Teaching other teachers how to teach CS better
cacm.acm.org
cacm.acm.org
In my own academic studies the teachers that were the most valuable to me were ones who nudged me in the right direction, and then mostly stayed out of the way and let my hunger for knowledge and results do its thing. But now I perceive a fundamental shift in higher education, one towards spoon-feeding in order to satisfy a strict curriculum, and I worry strongly that this sort of model is very dishonest and doesn't produce good graduates.
The biggest problem that I see in present-day academia is the bureaucratic desire to quantify and measure things, which might be reasonable if you see universities as trade schools, but is in my opinion doing irreparable damage. I'm sure there are some bad teachers out there, but the bigger problem I see is institutions that prevent good teachers from doing their thing, until only the bad ones remain.
I don't know about the solution of this problem, but giving programming challenges to students (in groups of two) is extremely effective. Ideally, forcing the students to use a different language each time. The evaluation is automatic and both the correctness and the speed of the solution over large inputs need to be evaluated. I've seen groups of otherwise passive and uninterested students spent weekends working really hard on a problem to try to beat the challenge.
I wouldn't doubt there's good research showing pair programming is a great way to learn, but anecdotally/observationally I really have trouble believing it's effective. In my experience, in at least half of pairs there will be one more skilled programmer and one less skilled programmer and the better one does the lion's share (if not all) of the work -- this is doubly true if the partnerships are randomly assigned. Even if the worse one is trying their best to stay engaged and follow along, it's just hard to do if the other person is faster than you, and you might even feel like you're being a bit of a useless nuisance by asking questions when the other person is clearly capable of working on their own. (I've been on both sides of this in different contexts, BTW.)
But I imagine my intuition must be wrong since this is such a popular teaching method -- interested to read any research/counterpoints on the subject.
As a student, many years ago, I have been in both situations: the more skilled of the group who taught the other, or the less skilled that was taught (and worked really hard because I was ashamed to be a "useless nuisance"). Both experiences have been very positive in my case.
Right, I get that that's the theory, it's just that I've never personally seen it work out so well in practice.
I can imagine how it's extremely useful and rewarding for both partners if you have two very motivated people, and the better one is keen to teach and even genuinely open to suggestions from the "worse" one, and the "worse" one is keen to learn. That's the model for a good partnership that most people probably have in mind when they propose doing a project like this. I've just never actually seen a partnership work out like that -- it feels like it requires both members of the parternship have top ~quartile motivation/empathy/communication skills (which as you could imagine might end up being pretty rare among randomly selected CS students...).
In any case thanks for sharing your experience -- good to know that it actually can/does happen!
> There's often other work to do
IMO there needs to be somewhat of a give and take situation (which can also work on other angles with pairs that already like each other for whatever reasons).
When finding a balance is just hard, straight rewarding the more knowledgeable/faster half of the pair could work too, provided there is a reliable way to identify them and how much they helped their counterpart.
IMO you can't say you really understand a thing until you've taught it to someone else. Your teachers gave you the opportunity to hone your own teaching skill, something you will use your entire CS career. Just wait until you are a senior dev holding the hand of someone more junior than you. If you think there is a skill gap between you and your peer in the same class, imagine the experience gap between you and someone 20 years younger than you.
If I wanted a lesson in teaching, I would take a class in it. Teachers should teach the subject as advertised.
In the ways you describe, academic group work is pretty similar to being a professional developer, unless you're in a solo project. The experience of dealing with people would have been more instructive (for me) than whatever ostensible subject material we were covering at the time.
I've always loved teaching peers because it reinforces my knowledge of the concepts being taught and gives me a sense of satisfaction. On the flip side, I feel small and maybe a bit ashamed if I'm less skilled than my partner, but if my partner's nice enough to explain things to me, then I come out with a better understanding of the concepts and a good relationship with my peer. Either way, it's a win-win situation, even if it doesn't feel that way in the moment.
Nothing will expose the gaps in your own understanding faster than trying to teach another person. Just being forced to verbalise your own understanding helps you remember things better, even if you already had a good grasp of the material.
> or I’m the less knowledgeable in the pair, and instead of listening to a professional I’m stuck being tutored by an amateur who doesn’t know how to explain anything.
If they understand what they're talking about you can ask questions until you understand as well as they do.
As a university lecturer in CS, I agree this would be a great thing for a lot of students. The thing about CS though is a lot of students hear that programming is a path to a high paying job, and they are really not motivated to learn the subject in the way that people who frequent HN might be. They don't want to self-learn, they want to be told what they need to learn to achieve an end-goal of earning a high salary when they graduate in 4 years. If you sit them down and ask them about their curiosity, interests, or ambitions related to CS, they give you a blank stare. They just want to get paid.
This perception also means that our program is the biggest at my institution. Students from every college want to take our classes. Our department is not so big (in terms of faculty, fewer than 20), so our class sizes are huge. My PL class last year was 200 students. My systems course last semester was 160. What this means is that I can't offer the kind of guidance for self-learning. Maybe if my class sizes were 30-40 students, but not for classes of 100+ students.
And then there's the issue of what students imagine a self-guided education looks like. They want to do things like mobile app development and AI. Most students don't self-guide themselves into fields like compilers and operating systems in my experience. They just aren't interested. Hell, I wasn't interested in these topics, until I was forced to take these classes as part of the standard curriculum. Now compilers are pretty much the only thing I'm interested in! I guess that's where the "guided" part comes in, but the point is that if students are left to their own devices, I worry we'll end up with a generation of programmers who are experts at making predictive AI models and iPhone apps, but have no idea how an OS or compiler works. Then who is going to teach the next generation how to make an OS? Already we have problems hiring people in these fields. 90% of the tenure track applications from our last round of hiring were from AI/ML type researchers, with only a few systems people (2-3 if we're lucky). I even have trouble getting TAs for my PL class, because all of our available grad students only know Python and C++ for their ML research. I see this only getting worse in the future.
I think you're spot on here. You don't see people flocking to the English department because they had heard the ability to read and write is essential to landing a high paying job.
The same will be true for programming in the future; programming will be to the CS curriculum as reading and writing is to the English curriculum. No one is teaching English majors how to read and write English at my university. But we have 4 semesters devoted to reading and writing programs, because we can't assume any student knows these things like the English department can.
Many countries have specific exams in place for each university degree, and it is expected that the basis are already in place from the highschool.
Learning is easy, you just sit down and you engage with the material in earnest. Whether that's course material or research papers doesn't matter too much. Figuring out other people's perspective without them explicitly telling you is way more difficult.
Fixed it for you. What is true for you is not true for all.
Instead the article was more about why student reviews are not a good way to evaluate the teacher. It’s like letting your toddler decide what’s for dinner… “ice cream and candy, again?!?!”
Students and parents view our CS department like a trade school. They are very focused on us teaching "practical" skills that students will use when they enter the work force. I think that's something we should do, but that's not all we should do. But any time we try to teach more theoretical CS concepts, there's always a lot of push back like "How will I use this thing when I'm at FAANG, and if I won't then why am I even learning this?"
Then there are employers, who have in the past come to us trying to get us to teach their tech stack so they don't have to. They wanted us to convert our entire curriculum to .Net, because that's what they use. Would that ever happen in the math department? I don't think so.
Maybe college has changed since I went there, but a similar question was asked and the professor responded with "you are free to drop the class." It was a required class for a CS degree and when the student pointed this out, the professor said that it's still freshman year, feel free to switch majors and that they should shut up because they were interfering with everybody else who (unlike them) were actually trying to learn something.
It's actually got a table of teaching practices, which they presumably want to see. I went through them and it looks like good stuff to me. I do a lot of it, though some wouldn't fit my (non-CS) discipline well.
One thing they mention that I think is a problem with CS is:
> connect with student prior knowledge and beliefs
I do not know how do do this in a group larger than about 6-8 (I'd say 2 pizza rule, but you need more than 2 pizzas to feed 8 college students :)
In particular since much computer related learning prior to joining a college level CS class is some combination of: informal, self-taught, and/or poorly taught. This leads to a very wide variety of prior knowledge and beliefs, most of which are subtly wrong in important ways.
In a small group it's trivial to address these as they come up, but I can't imagine trying to anticipate them for a larger group.
I switched to CS from Physics and immediately noticed this difference. At first I just thought it was because physics classes were smaller, but I had no classes with less than 10 people. Then I realized that there just wasn't that much variety in the misbeliefs my physics peers held; partly because we had fairly similar backgrounds (most had taken AP Physics in High School, and had read a selecton from a fairly small pool of pop-science physics books).
I'd actually be interested in seeing a taxonomy of specific misbeliefs in CS (or really any field). Such a summary would probably aid teachers as well; most good teachers will have an intuition for the categories, but organizing and naming things can help one think in a more structured way about them.
I think that taxonomy is a great idea. Maybe it's something that could be developed inside a department with a wiki?
Anyone who opened a 1980s PC mag could be shown how to implement basic FOR or WHILE or if/then/else expression logic in BASIC and achieve huge outcomes: playable games, interesting solutions.
Learning how to craft code so its "better" is really hard. Abstraction is a distinct skill.
The mathematical underpinnings of code lie in things like logic, and group theory, higher order functions, recursion, you name it. These are not things to acquire by asking your kid next door to show you how his mod-scene ASM works.
I studied CS over 40 years ago. I think I'm still deficient, at the end of my career. CS is hard.
Understanding the implications of code on memory, performance, critical paths, safety, provability, type-safe all come with rules of thumb (engineering) which can often be acquired by the kid-next-door path, and fundamentals in their theory which really cannot.
FP is at the extreme end of hard-to-acquire, especially if your entry was imperative hacking.
Name one system you worked on in your career that was “abstracted well” and built to the quality uncle bob thinks is good. I bet you can’t. Because they don’t exist. Not in the framework that this industry now measures “abstract well” in.
It’s a square peg in a round hole. Writing software is more like composing music than it is an engineering or maths discipline no matter how much people really want it to be. (Hardware is a different story)
Come at me bro :)
Music is a sub-arc of Maths. You know that, right?
void get_coffee() { /* ... */ }
void move_away_from_obstacles(auto what_to_move_away) { /* .... */ }
void place(auto object_to_place, auto to_be_placed_on) { move_away_from_obstacles(where_to_place); put_object_on(to_place, to_be_placed_on); }
void sit() { place(butt, seat); }
void prepare_mind() { get_coffee(); sit(); }
void get_opinion(int on_whom) { /* .... */ if (on_whom == UNCLE_BOB) { return create_opinion("too many short functions"); } }
void get_opinion_of_uncle_bob() { prepare_mind(); opinion my_opinion = get_opinion(UNCLE_BOB); return my_opinion; }
void get_opinion_of_uncle_bob() { prepare_mind(); opinion my_opinion = get_opinion(UNCLE_BOB); return my_opinion; }
void prepare_mind() { get_coffee(); sit(); }
void get_opinion(int on_whom) { /* .... / if (on_whom == UNCLE_BOB) { return create_opinion("too many short functions"); } }
void get_coffee() { / ... / }
void sit() { place(butt, seat); }
void place(auto object_to_place, auto to_be_placed_on) { move_away_from_obstacles(where_to_place); put_object_on(to_place, to_be_placed_on); }
void move_away_from_obstacles(auto what_to_move_away) { / .... */ }
void get_opinion_of_uncle_bob() { prepare_mind(); opinion my_opinion = get_opinion(UNCLE_BOB); return my_opinion; }
void prepare_mind() { get_coffee(); sit(); }
void get_coffee() { / ... / }
void sit() { place(butt, seat); }
void place(auto object_to_place, auto to_be_placed_on) { move_away_from_obstacles(where_to_place); put_object_on(to_place, to_be_placed_on); }
void move_away_from_obstacles(auto what_to_move_away) { / .... / }
void get_opinion(int on_whom) { / .... / if (on_whom == UNCLE_BOB) { return create_opinion("too many short functions"); } }
I feel like I'd be a much better programmer had I studied CS, but it's difficult to also self study when working so I'm trying to find some balance to learning. Like, easy reads that will show immediate improvement to keep me interested, instead of picking random dry textbooks.
> In computer science, we often have a model of teaching that is heavily focused on content matter knowledge—if you know your CS, you'll likely be a good teacher. But all our evidence about quality teaching says that that's wrong. There's a lot of knowledge involved in teaching computer science well, and perhaps the most important is pedagogical content knowledge.
Basically, its not enough to understand your CS, you have to understand how to teach the CS.
To teach in aviation in the US, you need a Chief Flight Instructor (CFI) rating, where you demonstrate to an examiner how to teach the various maneuvers.
IT could learn a lot from regulated industries like aviation.
but software engineers? definitely.
The parent comment called it IT, so I called it IT, but if use the more specific term "software engineer" I'm still going to say that most software engineering projects aren't likely to injure people when they fail.
Software engineering just doesn't seem to fall in the category of jobs where you'd want to mandate ongoing training... jobs like pilots or psychologists.
a lot of them even in their free time.
You could spend years at a company working with internal frameworks or internal forks of old open-source projects, and when you change jobs, you realize that everyone's using React and all of your experience is with some half-baked alternative to Rails that someone at your last company cooked up in 2008.
Or you could even be a bona fide OS/360 wizard who hasn't touched anything else for the past thirty years, who suddenly finds themselves looking for a new job--not that there's zero demand for OS/360 experts, but it can be very tough to find positions.
You can either have a dynamic field or a mandatory curriculum. Once the curriculum is fixed, the field advances at the speed changes can be pushed into the curriculum, which is at best annually.
Not googling how to teach, but skipping the entire "teaching" process altogether.
> It's easier to pick a good teacher than to train one: Familiar and new results on the correlates of teacher effectiveness
> Neither holding a college major in education nor acquiring a master's degree is correlated with elementary and middle school teaching effectiveness, regardless of the university at which the degree was earned. Teachers generally do become more effective with a few years of teaching experience, but we also find evidence that teachers may become less effective with experience, particularly later in their careers. These and other findings with respect to the correlates of teacher effectiveness are obtained from estimations using value-added models that control for student characteristics as well as school and (where appropriate teacher) fixed effects in order to measure teacher effectiveness in reading and math for Florida students in fourth through eighth grades for eight school years, 2001-2002 through 2008-2009.
https://www.researchgate.net/publication/227414368_It's_easi...
http://www.hks.harvard.edu/pepg/MeritPayPapers/Chingos_Peter...
For intermediate classes force students to use some type of version control, as in they need to submit assignments to a branch, and the branch will be graded.
those who can do
those who cannot do teach
those who cannot teach teach teachers. those who cannot teach teach gym"Those who can, leave"
Those who can, do; those who understand, teach.Thus teachers must be creators first. Out of 100 teachers I had, that applies to... 3?
The process of getting stuck and figuring out how to get un-stuck is where the learning actually happens.
I can't visit bit.ly links.
ERR_CONNECTION_CLOSED
- 2019 Harvard study of active learning (https://bit.ly/3uQnXh4): https://news.harvard.edu/gazette/story/2019/09/study-shows-t...
- students have implicit bias (http://bit.ly/3e3UzOe): https://www.insidehighered.com/news/2019/05/20/fighting-gend...
- Computing classes often have a defensive climate (https://bit.ly/3qizsdH): https://www.researchgate.net/publication/2920892_Defensive_C...
- students get messages that they don't belong (https://bit.ly/3sEBsOT): https://depts.washington.edu/sibl/wp-content/uploads/2017/10... (PDF)
- on formative assessment in K-12 CS (https://bit.ly/3sHAAJd): https://csassess.org/wp-content/uploads/2021/01/Final-Submit... (PDF)
- on effective design of formative feedback (https://bit.ly/3qaF8Gz): https://www.researchgate.net/profile/Qiang-Hao-15/publicatio... (PDF)
- treating teaching innovation as action research (http://bit.ly/3efbyxl): http://www.ascd.org/publications/books/100047/chapters/What-...
git and HTML and Linked Data (and Reproducible Containers) should be requisite: https://learngitbranching.js.org/
Pedagogy#Modern_pedagogy: https://en.wikipedia.org/wiki/Pedagogy#Modern_pedagogy
Evidence-based_education: https://en.wikipedia.org/wiki/Evidence-based_education
Computational_thinking#Characteristics: https://en.wikipedia.org/wiki/Computational_thinking#Charact... (Abstraction, Automation, Analysis)
Learning: https://en.wikipedia.org/wiki/Learning
Autodidacticism: https://en.wikipedia.org/wiki/Autodidacticism
Design of Experiments; Hypotheses, troubleshooting, debugging, automated testing, Formal Methods, actual Root Cause Analysis: https://en.wikipedia.org/wiki/Design_of_experiments
Critical Thinking; definitions, Logic and Rationality, Logical Reasoning: Deduction, Abduction and Induction: https://en.wikipedia.org/wiki/Critical_thinking#Logic_and_ra...
Doesn't this all derive from [Quantum] Information Theory? It's actually fascinating to start at Information Theory; who knows what that curriculum would look like without reinforcement and [3D] videos: https://en.wikipedia.org/wiki/Information_theory
Stone, James V. "Information theory: a tutorial introduction." (2015). https://scholar.google.com/scholar?q=%22Information+Theory:+...
It used to be that we had to start engines with a turn of a crank: that initial energy to overcome inertia was enough for the system to feed-forward without additional reinforcement. Effective CS instruction may motivate the unmotivated to care about learning the way folks who are receiving reinforcement do: intrinsically.