Hcfyk

Actually I am of the opinion that you should not present your own code, but rather get the students to implement the algorithms you teach them, which you give in pseudocode, and give them the freedom to choose any one of a fixed set of languages that you are familiar with, such as C++/Java/Python. Really, the only way students can truly understand an algorithm is when they face the real task of implementing it, but the key ideas behind an algorithm can be sufficiently conveyed via pseudocode.

I understand your dilemma, but from a general pov it's better to present content through pseudocode. This actually gives students the freedom to explore multiple languages. When you present your code in a particular language you are making them comfortable with that language alone and they might find it hard to shift to other languages later on. The main purpose of learning algorithms is to know how they work rather than implementing them in a particular language. Regarding resources, I would suggest looking up books like Introduction to Algorithms. You can also refer to CodeMonk which is an online portal which has a collection of all known problems and algorithms to look into.

One of the key points here is that you are teaching to future engineers, even if at academic level. The very nature of engineering is solving problems by implementing a solution.

Therefore I think that presenting the pseudocode is useful to give your student the correct theoretical POV to frame the problem, BUT showing them an actual, working implementation is key to make them develop their engineering skills.

Much better would be to show them the pseudocode and make them try to come up with an implementation first, then show them yours. But this requires honing their skills first, probably.

As their skills improve, you may also dare show them more than one implementation, possibly in two or more languages. Of course this depends on their actual knowledge of the languages you are going to use. If they know only, say, Java, showing them an additional implementation in another language could backfire and confuse them more.

Of course, I'm assuming that it's not your duty to teach them another computer language, otherwise, it could be a useful approach: start with pseudocode, show a reference implementation in a known language (e.g. Java) and finally show them how to reimplement the algorithm in the new language they must learn.

When I took algorithms, my first professor used a pseudo-code of his choosing. It may have been clear in his mind, but in was pretty opaque in they eyes of his students. It was a much dreaded class, and hard to get useful knowledge from. Then he had a heart attack.

New professor (let's call him "Finkle"), discarded the previous class notes and textbook. Finkle wrote new notes (replacing the book) and explained algorithms using Pascal (it was the 1980's). Pascal was much more clear than the pseudo-code AND IF YOU DID NOT UNDERSTAND HOW SOMETHING WORKED, YOU COULD RUN THE CODE AND LEARN.

That class ended up being the most valuable class in my whole undergraduate education.

1. Pseudocode helps a lot by removing anything unnecessary, and focusing entirely on the algorithm, which can already be hard to understand as is. It's also faster to express ideas : if a student wants to write a different algorithm than the one you taught them, it can be really cumbersome if they have to deal with every details of Java.




2. As others said, it's good for students to come up with their own implementation in code of the pseudo-code algorithm. They need to really understand it, while if they just paste code or learn it by heart they won't necessarily understand every subtlety.

I think most universities do this already (mine did), but I think the best is pseudocode for the course, and real code for practical exercises.

Neither alone is enough for a good dish.

I'd go with pseudo code in the lecture, and use homework to give students practice in turning pseudo code into real code.

Using pseudo code in the lecture has the pragmatic reason that pseudo code is, by nature, somehow vague. You want to use it as a tool to be able to concisely state ideas that still contain all important details, but abstract as many of the unimportant ones away.

Because of this, it takes some time to gauge, as a student, how pseudo your pseudo code actually is allowed to be:

As an example, at the start of the course, pseudo code shouldn't involve a (merge-)sort, but once you're done with that chapter, there's no harm in adding the line "sort the array A" without further explanation.

Therefore I'd say that the easiest way for a student to learn what is, and what is not, allowed in pseudo code, is by getting a feel for it, simply by osmosis over time.

And if some students have problems understanding your pseudo code, then they still have enough resources (books, or even interactive coding sessions of the algorithm) showing them how the algorithms would look like in an actual programming language.

On the other hand, to understand the design and working of an algorithm, it helps immensely to have coded it yourself, at least partially, once.

Therefore, by letting your students program the algorithm (or letting them finish a partially programmed algorithm) and then tasking them to "play with it", they'll get a good look on the other side of the medal as well.

Writing from a students point of view:

I had a course regarding algorithms and data structures two years ago.

The first exercise consisted of implementing a program with a certain behavior (Search in a sorted array, etc.).
In the next lecture we would discuss an algorithm in pseudocode which fulfills the requirement of the previous exercise, only in a more efficient manner. The next exercise consisted of another goal to achieve (sort an array, ...) and a implementation of the pseudocode we discussed earlier in the lecture. We could freely choose the language for implementation.

These assignments made every student give their best since we compared the runtimes of our algorithms among ourselves.

The course was well received among all of the ~30 students. For myself I think I learnt a lot since you can also focus on optimization instead of only making something work.

I think the best is to do a comparison. The algorithm may be a cooking recipe that may be written in many languages but produce always the same cake.

Pseudo-code is like describing the recipe with pictures. There is not a unique grammar or way to "talk" in pseudo-code but anyone should be able to interpret it. By reading the pseudo-code written by someone, one may often guess what is his favorite language. The main rule is to forbid the language specific keywords.

Teaching an algorithm in a specific language is not a problem in my opinion as long as anyone understand it. But if you want someone to master this algorithm, you have to make him try it by hand. Make him do the different steps of the algorithm on a small example. In fact it is again like cooking the cake... You can remember a recipe much easier if you actually have cooked it.