In my understanding, that could help me avoid misconception by using proper visualization since the very first day and sticking to it all the time.

For instance, my very first slide was an extension to a visualization from Goodrich’s book I found modified on a data structure course where boys enters a machine and girls comes out (the website seems to have added a clock to remind of the importance of T(n)). You can find it here:

On the very first slide.

I extended it with some text notes from my former professor and some thoughts on what could visually codify the concepts and as a end result I got this for the computational model, code file, algorithms as functions (C is the used language here), data structures as boxes, a computational problem and solution.

In my case, teaching data structures is slight more complicated because students are on their second freshman semester, and were only taught pascal on the previous semester. Still, they are expected to use the concepts in C, perform all classic sorts and search on primary and secondary memories and know all basic data structures up to trees and associated searches. For a total of 68h class!

Thanks for the interesting post!

]]>First the student should know the basic C programming (data types, if-else, for loop, while loop and function creation and calling, Arrays and basics of Pointers and Structures)

For convinience I take first few days of class to get the students brush up these skill by doing some workshop sessions in same.

Then I start Data structures But I never say that I am teaching them data structurs (Stack, Queue,Linked List ,Tress or Graphs).

I just start by taking a real Life Example say ( to create a list of all students in a class) First I tell how to create the node structure and Importance of creating the node poninter inside the structure.

Then I tell how to keep adding the nodes to the first node by using insert function and using double pointer.

I keep doing the same with many other examples (like a Bank Accuount Conunter, Line of people in bus stop, list of Things to purchase from market etc.) same creating a node and adding the nodes again and again.

By this time the student is familiar with making the basic structure for any type of example and adding nodes to the end,Also understands the methods of manupulating the pointers to point to the next node.

Then I take same examples again but this time teaching to delete a node from the list (for all the eamples previously taken).

Then I take adding a node in between the two nodes and adding the node in front of the list. For same examples taken previously.

Keep practicing the same examples again and again untill each and every student understands the concepts of manipulating the pointers and nodes to acheive the tasks.

Repeating the same workshop again and againg for many days and classes actually enables the students to interact with each other. The Student who understands the concept tries to help other students in the workshop and hence improves his own skills as well as satisfaction levels. Other students get motivated and try to learn the same from others.

Slowly then I take more complex examples each time to give other real time problems to solve (making a pile of chairs(i.e Stack), making a queue in ticket counter (i.e Queue FIFO), making a Call Log of the mobile phone (i.e Linked List) Making family History Diagram (i.e Tree)etc.)

Since now the students are familiar with pointer and playing with pointer to making and creating links, They slowly able to understand that Every example I take was one of the data stuctures (Stack, Queue, Linked List or Tree).

Happy Coding. ]]>

As far as “down to the metal”: As a CompE, I did have to go down to the metal. In other schools, that’s just how Computer Science is defined.

The reason why I educate at all is because I want my students to be able to function and create things on their own. It doesn’t matter if it’s a robot, distributed system, or parallel algorithm. The goal is not to take what’s there and simply reuse, but advance. This isn’t a purely academic exercise. I’d hire people based on their ability to function and innovate on their own or in small groups (and recent job postings would agree with me on that).

Two stories:

– My last year as a student was TAing CS1332, which for the non-GT was pretty much new and the only dedicated Data Structures course we had in the into curriculum. It also served as the new merging point for the different intro CS tracks.

Most of the work went to breaking the abstractions that prevented understanding of the new concepts, rather than new concepts themselves. It’s harder to appreciate the difference between arrays and linked lists without knowing what memory is on some level. It doesn’t preclude you from “using” these structures naively, which is the beauty of an abstraction. But it is 100% blocking on how you “innovate” data structures.

Long term, the general problem becomes worse: How do you know what you don’t know, or where to find it?

As it happens, one of my old Scheme students who had to take medical time off was also in the class. He later commented that Scheme (not the class necessarily) ended up changing how he thought about programming completely and made the rest of the CS easier to grasp as a whole.

– My first experience with Linear Algebra was that the entire field is a square of numbers that you only do two things: Row reduce to get identity/inverses or eigenvalues/vectors. I went back to grad school in computational math specifically to learn the math that kept me from doing well in higher-level CS theory classes.

More importantly, this abstraction is 100% useless for real applications. In numerical computation, you never find inverses (They take too long and are numerically poor at best) and row-reduction as a general rule typically performs worse compared to other techniques. Just as important for growth: Someone else needs to be familiar with this abstraction.

One last note: I don’t think it’s necessarily a community question but an institutional one. One of the biggest distinctions you can make in a school is if you want your undergraduates to be practical engineers or academics, one trade-off being whether your students learn software engineering techniques/paradigms or mesh theory and abstract algebra.

What do your students need to learn such that, as an educator, you feel as if they are equipped for the challenges ahead? At some point you cut a line, and it probably isn’t one size fits all.

]]>I don’t anticipate that building a debugger will have much use later in their careers, or that their experience dealing withe the Java debugger API has any long-term benefit, but it serves as a fantastic tool for drawing out and fixing any misconceptions the students might have.

]]>Hi Alan,

Your question is exactly the one that I think (and the colleagues who wrote the linked paper think) that the community needs to be asking itself. All of these approaches, including our depiction of memory, is an abstraction for the students. We need to think about learning intentions, and determine appropriate abstractions — which may be “down to the metal.”

Cheers,

Mark

What is the actual intent here with regard to the students?

For example, are we selecting out of a population, or trying to educate all? (There is nothing complex about this subject for the 10% who find it obvious and easy)

Are we dealing with mathematics or engineering? (Before and after, butfirst and butlast, etc., are relationships and can be implemented many ways, including as definitions on paper)

Just these two dimensions give us 4 pathways.

For children, we give them visible active structures — e.g. “Holders” in Etoys — and they learn how to do things with them. This is the “learning to use tools before learning physics and engineering” approach. The concrete visible and manipulable nature of the structures puts them into the “real world with a little mystery, but real predictability” category.

For a general population where we are not selecting, I think the children’s approach is a good one. If the language/IDE allows all the “hoods” to be popped to (later) see how the mid-level tools are implemented, then one can contemplate a middle-out approach here:

— down to specific implementations

— up to more abstract definitions and uses

I think going “up” from middle first is a good one, because those mechanisms can be learned and will be understood as one goes “down”.

Another prejudice I have is that computing’s emphasis on data structures and algorithms is a bit of an artifact from the problems of the past on tiny computers and very little knowledge. So I think computing would be much better off being taught from the point of view of systems and architectures.

This argues that an “older children’s language” on the lines of Etoys or Scratch, would be a very good idea.

Cheers,

Alan

]]>Really interesting, Greg — I proposed something similar in my second talk at CMU. I’m interested in the problem of teaching high school CS teachers. Not clear we can use cognitive tutors for this. A worked examples approach is our best bet right now, and the folks at CMU agreed with that. I suggested that we could check the value of the worked examples by interspersing them with small exercises, then using credit/blame assignment to determine the most effective worked examples.

]]>