Is there a good reason Uni courses still use "academic" languages like modula2?

This question prompts me to ask - why do universities still teach in languages like Modula2, when improved modern languages are available for free?

Are there uni's that still teach Pascal, for example? I mean, it was good 30 years ago, but... now? Why?

Why not Jav开发者_StackOverflow社区a, C#, Haskell?

Related: Is it backwards to still teach LISP?

Is this a duplicate question? If not, I think it ought to be a community wiki topic.

The university's job is not to teach you a programming language, it's to teach you programming concepts. The language they use is only relevant in terms of the teaching material they have already generated or use from other sources.

I imagine that redoing a curriculum is something like rewriting a large application - something you do only if you have a compelling reason, and even then you think twice about it.

Improved modern languages (Java, C#, Haskell) are available for free?

So by "improved" you mean powerful, loaded with external libraries and frameworks, and insanely complicated? With a maze of twisty little features in which beginning students can easily get lost? And when they are lost, they get error messages that no beginner can possibly understand?

Good universities resist the pressure to teach the popular languages of the day because our job is to teach timeless truths and skills that will still be relevant in 50 years. (Today's university students can expect to work at least until age 70.) Our best tools for that are simplicity, simplicity, and simplicity. Modula-2 is a pretty good choice. (So is the Beginning Student language of PLT Scheme.

I love Haskell, use it heavily in research, have taught it in advanced classes. You couldn't pay me enough to teach it in an introductory course—I'd be cutting me own throat.

Why not Java, C#, ...

In the absence of requirements to interoperate with existing code bases, what advantage does Java or C# have over, say, Smalltalk? I'm a C# programmer by day (and former Java programmer) and there are some good things about it and some bad things, but one thing that really sticks out is how incredibly complex it is. Look at how many questions there are here about the finer points of C# syntax and semantics. You'd waste your whole semester or year teaching trivia. Modula-2 is much simpler and perfectly adequate for many problems.

You need to learn assembly, too, and going from Modula-2 to assembly is a much easier step than C# to assembly. I would not want to try to teach assembly to a bunch of students who only knew Microsoft's professional tools.

Related: Is it backwards to still teach LISP?

(There's about 50 different ways to interpret this...)

I don't see what's "backwards" about it, unless you're seeing it taught {before,after} a lower-level language and think it should be taught {after,before} instead.

Can you suggest another language that does what it does? (Smalltalk? Forth? Icon? Factor?) For example, if you want to see the design of a real OO system (and arguably a more powerful one than Java or C#), you can pick up AMOP and see the whole thing in a short book, including complete source code. (Common Lisp isn't the simplest Lisp dialect, but it's a lot simpler than C# or Java, and AMOP uses a relatively small subset of it anyway.) How would you teach metaprogramming, or even multiple dispatch, with Java?

Or: the original purpose of Lisp was to replace Turing machines as a construct for building algorithms. (It just happens to be really useful for writing real programs!) Are you suggesting that you'd rather using Turing machines for teaching algorithms? Or C# for modeling computation? A Turing machine is a 7-tuple -- I can't imagine how many components the C# computation model would have! Lisp bridges the gap perfectly, and I've only seen one or two other languages in this space -- Forth comes to mind, but for whatever reason it's not become popular in academia.

...Haskell?

I think it's a great idea. I learned it in school. Then again, I think any member of that language family would do fine. If you learn ML in school instead, I don't think you'll be any worse off. The concepts are the same.

It's like studying mechanical engineering in Berlin versus Chicago: the language may be different, but the concepts are the same. But if you don't know anything, not even a language, it makes sense to start with the simplest language possible. If you want to be an engineer in Berlin but speak no German, it makes sense to study engineering and to also study German, but the conventional thinking is that it's less effective to start with German-only engineering classes.

Two reasons I can think of, one good, one not. (And I was a prof.)

The good reason: to simplify teaching. Teaching intro students is like herding chicks on a diving board. If there's a way for them to fall off, they will. If I had to teach C, I'd be tearing my hair out, what with char, unsigned char, char*, char**, char*[], char[10]*, and so on all being legal and different, and that's just a few splinters on the tree. For a second or third course, it's a different story.

The bad reason: academic freedom. We had one person teaching some far-out interpreted language because he liked it. Another one insisted on teaching spreadsheet programming, because that was the "wave of the future".

Although this question seems to have been handled some time ago i wanted to add something (since i am the asker of the mentioned Question :) ) Why we learn Modula2 in our first year: Apart from all the already mentioned reasons, it is for getting a grip on how basic things (e.g. pointers) work before getting involved with something like Java where all that stuff is pretty invisible to the programmer :)

I realise this question is rather old and there are many good answers. Nevertheless, I'd like to chime in.

Most of the answers are variations of the "Modula-2 is simpler, thus easier to teach/learn" theme. Although this is correct, it isn't the this-disqualifies-all-else rationale why a university should choose to teach Modula-2.

The most important benefit of teaching Modula-2 to undergraduate computer science students is that it is good-habit forming and discipline instilling.

See also "What are the most important benefits of Modula-2?" at:

http://modula-2.info/m2info/pmwiki.php/General/FAQ

There are very few languages out there that teach strict programming discipline, adherence to engineering principles and good habits. Most modern, and especially popular languages actually do the opposite, they teach bad habits.

Among the strict languages, Modula-2 is the smallest one, and amongst the small languages, Modula-2 is the strictest one.

This combination makes Modula-2 the perfect choice for any university that doesn't merely want to be a vocational school for software mechanics.

This may sound harsh but if software developers aspire to be called software engineers, then they should be trained like engineers, think like engineers and most importantly, behave like engineers when they get to work.

Electrical, mechanical and civil engineers have an obligation to build things that are first and foremost safe and reliable. With few exceptions, software doesn't quite live up to that standard and lack of a classical engineering mindset is a major factor here. For example the popular notion of "release early, fix later" is diametrically opposed to engineering principles.

The matter of Lisp/ADA vs C/Java is the same as Informatics vs programming. One is a science, the other is a craft.