No. Java and Python and Scala are not improvements. Why? They're too easy. Pointers are hard (relatively). Compiler design is hard. Complexity theory is hard. A loss in any one of these sections is a loss to the degree as a whole. The ACM ICPC helps a little in promoting intelligent problem solving (every CS student should be able to write a program to use Dijkstra's algorithm in under 20 minutes from memory), but it's the university's fault in the end. Fortunately in the United States, some of our top universities seem to have (thus far) escaped the treatment that other ones did. Stanford, Yale, Caltech, MIT, CMU, et al. all continue to teach very much the same curriculum that they taught intro CS students 10 years ago. Systems is a required course and taught in C. Intro programming is a required course and taught in Scheme/LISP. Unfortunately, many schools did not fair so easily and now teach Java or some-such exclusively. I think that this is partially to blame for the number of unfortunately bad computer science students with degrees. How to change this, I have no idea.

About pointers being difficult...I don't think that pointers are difficult to understand. To me it was more the syntax C uses that got in the way.

You have got to be kidding us. But I don't really get it - what is difficult in & and * operators?

I do teach programming, and most of the time I see both the concept of pointers, and syntax is pretty understandable.

The real trouble begins when you expect students to use them to their advantage - but it really is beyond syntax.

Unfortunately I'm not. I tried learning C as my second language after VB and the syntax seemed unnecessarily complicated to me (like '->').

As a newb, you get bogged down in the details and knowing the cases for when to use &,* seems like an added complication.

See? This syntax trouble is already lesson #1 you learn from pointers: The _address_ of some value and the _value itself_.

If you have a pointer (that is, the address), then you need to prefix it with a * in order to get the value in order to do useful things. If you have a value, you need to prefix it with & in order to get the value's address in order to pass it around more efficient (at least it will be more efficient if it is some large data blob).

Did anyone ever mention addresses and values and their difference when looking at Java from a users point? Not to me, to be honest.

Pointers are easy. I thought several people in our CS program how to use them in ~2 hours. What's hard for most people is thinking abstractly between what the code looks like and what happens when you run it.

Pointers are simply the first thing that forces most coders to consider that split. But, a reasonably competent JAVA developer moving to C can pick them up in little time. The problem is reading other peoples C code that looks more like line noise than structure. But, pointers are a tiny step along that path.

Sadly, you are not entirely correct. Stanford's intro course uses Java (though learning C is also required) and MIT just switched from Scheme to Python.

I would agree that low-level programming should be taught at some point. But one course is sufficient and it could be one that is taken in second or third year.

Low-level memory issues should be avoided whenever possible by using a higher level language. There's a reason why garbage collection was invented.

Depends on what you're studying. System programming is and should always be done in C/assembly. Personally I am doing virtual machine design in C at the moment.

Yes, the hours upon hours of instruction in basic CS courses that were devoted to the various mundanities of Java abstractions drove me nuts.

I'd much rather have spent that time learning the more-useful mundanities of memory management in C.