Hacker News Reader

Having been a teaching assistant for intro programming classes targeted at non-CS majors, I disagree. You don't need to understand what a 'stack' or 'heap' is to understand what's going on and for this to be useful.

And even if it's too complicated to be useful for people on their own, being able to use something like this as a teaching aid would be very helpful. The number of people who have trouble grasping even what most of us consider very basic concepts like iteration over a list is astonishing. Trying to explain something you find trivially easy to someone who doesn't understand it at all is an exercise in frustration for both people. I usually resorted to doing a manual step-through on a whiteboard or piece of paper, but this is much nicer.

I would discourage people from using this constantly, just because I think having a step-through debugger handy constantly will prevent you from developing necessary debugging skills. (The concept of wrapping something in print statements is another thing I take for granted that's not obvious to some people.) But I still don't see how something like this could be anything but a net positive.

> But I still don't see how something like this could be anything but a net positive.

The student will construct their own knowledge of programming by some learning process. This tool has an effect on that process, as has every tool. It could, for example, let some students construct an understanding of a variable that makes it harder to start learning about, say, memoization in dynamic programming. (This is just an conjectured example, mind)

I don't say it will, and I do have to say that the visualization given is quite nice and sound. But because we, as experienced programmers, like a tool because it visualizes how we think about programming and program execution, that does not mean that this is transferable in a similar way to novice programmers. As a high school computer science teacher I have been growing more and more worried about so called anti-didactic inversion in programming education. Especially at lower levels of education.

In programming education, we often use professional programming tools with professional programming languages and professional measures of programming quality. When students are learning to become professional programmers, this is a good idea. But is it as good an idea for teaching programming to those who do not want to become professional programmers. Or for those who are learning programming as a basic skill (like math, language, etc)?

Using this tool, a student would get a visceral sense for what the stack and heap are, from experience (even if nobody had mentioned those words before). e.g. "Pointers point at stuff on the heap."

Teachers and students have been drawing pictures like this on the blackboard, or on paper, for a long time. Many experienced programmers visualize these pictures in their imagination (unless they're implementing a familiar pattern). That can be tedious and error-prone. Why not let the computer show you what it's doing?

Many debuggers already show some of what this tool does, but I've never seen one quite like this.

Can you give an example of a "more complex programming structure" where this would be detrimental to understanding?

> Can you give an example of a "more complex programming structure" where this would be detrimental to understanding?

It is difficult to imagine what kind of knowledge novice learners will construct while using this tool. I could imagine, for example, that their operational meaning of a variable becomes that of consecutive boxes with values in them. Given that knowledge, how would such a student start to understand a variable in a closure? Will it fit their existing understanding of variables as boxes? Maybe it does, maybe it will not. Maybe they have to deconstruct their understanding of variables first to connect it to their budding understanding of a closure, building a deeper and more widely understanding of variable. Maybe this will be not too much of a problem. Maybe this becomes a hurdle. We don't know unless we try it out, of course.

Learning isn't an exact science. I think that dynamic representations like this one are very useful in teaching and learning. However, I would also argue to use these tools with care and conscience. Although it seems to fit our operational view of a program, that does not mean it is a good fit of a novice learner's operational view of a program. Whatever tools we use will influence that operational view. What I want to ask teachers is to evaluate and reflect on the best way and place (in space/time) to use these tools to make learning as optimal as possible.

I think if you tried to teach programming to two groups of people who had minimal programming experience, one using say the normal python interpreter and one using this tool, the latter group would acquire a better understanding of what is going on in less time.

The diagrams used here are similar in style and content to the environment diagrams used in SICP (Structure and Interpretation of Computer Programs), which is an introductory (and quite comprehensive) CS text. At Berkeley at least -- and I think MIT as well -- SICP is taught in a course taken by both majors and non-majors are taking CS courses.

MIT did away with SICP in its intro class a few ago. Quite a shame, but that's the subject of another post.