Followup On Java As "Damaging" To Students

hedley writes "A prior article on the damage Java does to CS education was discussed here recently. There was substantial feedback and the mailbox of one of the authors, Prof Dewar, also has been filled with mainly positive responses. In this followup to the article, Prof. Dewar clarifies his position on Java. In his view the core of the problem is universities 'dumbing down programs, hoping to make them more accessible and popular. Aspects of curriculum that are too demanding, or perceived as tedious, are downplayed in favor of simplified material that attracts a larger enrollment.'"

Comments

@_@

[Ojuice]

I started with Java and I turned out just fine.

Re:@_@

[rmdir -r *]

I started with Java and I turned out just fine.

His point is less that Java as a language causes brain damage and more that the switch to Java is symptomatic of a move to liquor-up and lacquer-down University Computer Science curriculum.

Re:@_@

[ushering05401]

While this point may be valid, it's not like CS degrees were assurances of any level of competence anytime in my recent memory (I've spent about 15 years in IT).

About all I can suggest is that students who are inclined to supplement their educations through their own creative pursuits will continue to surpass those who treat CS simply as a profitable skill set. If anything, simplifying CS courses will assist potential employers in identifying those who aspire to excellence in the field and those who are merely pursuing a career.

Re:@_@

[M. Baranczak]

Exactly. If I recall, he was mainly talking about the fact that low-level system concepts aren't being taught. Java was only incidental to the argument, but the /. summary made it seem like another stupid language flamewar. Java is a high-level language: of course you won't be using it to write kernel code.

Re:@_@

[jayp00001]

Personally I'd rather have the high school grad that likes to mess around with programming and would like an internship than the same kid after 4 years of college. The intern is grateful that he's getting paid to learn. The college kid thinks he should now be ready to start paying off his student loans, bu thinks he know enough to get a job. The college kid spent 4 years learning java and c at a base level (meaning spending half of that time learning syntax and idiosyncrasies rather than working on actual challenges Worse case scenario with the intern- I lose an entry level employee- I can fire and hire those as needed. With the college kid, worse case becomes a question from the CIO: why didn't I just outsource the projects instead?

I do not blame the professors on this issue. America sends completly unprepared kids from high school to college so they can get a job afterward. For an example see:

http://www.youtube.com/watch?v=Tr1qee-bTZI&NR=1

Re:@_@

[smilindog2000]

That video you linked to is one of the scariest I've seen in a while. Sorry if I lost your sarcasm... I would post this as an example of how incredibly stupid parents ruin school systems by forcing us to ban evolution, or any other modern thought from the classroom. I hope that's how you meant it. That bitch on the video pushing monkey-see-monkey-do education is partly responsible for our dumb high-school grads. I've never seen the "Turk" math she's talking about, but from the presentation, it's clearly a major improvement over the old stupid memorization techniques taught when I was in elementary school.

Sorry about being so acidic over a stupid parent. I spent eleven years of my youth in hell in a backwater Georgia school system where original thought was the enemy of the school. I don't blame professors on this issue. I blame the stupid backwards hicks.

Re:@_@

[AKAImBatman]

It would be amazing if people actually read the article every once in a while. :-/

I make a living as a Java programmer. I enjoy the work I do and feel that no other language/platform can even touch Java's capabilities in team and enterprise development. Even for single-programmer development, there are a lot of situations where Java is the solution to end all solutions.

That being said, I agree with the article.

As the author tried to explain, programmers need a solid foundation in data structures and algorithms before they should even begin looking at Java. The specific problem he calls out (which I actually feel only scratches the surface) is that Java offers such a featureful API that the programmer isn't forced to learn the basics. He is able to simply use a Hashtable, a Sort, a LinkedList, or whatever he needs without understanding why it works. Which is a very dangerous thing for someone training to be a Computer Scientist.

A much better approach is to force the student to work through lower-level programming before ever reaching a modern layer that abstracts everything away. Otherwise the student is liable to shoot himself in the foot at a much later date. (Primarily due to a lack of knowledge.) This is very comparable to many sports where expensive, advanced equipment can be an asset to a well-trained athlete. But in the hands of an amateur, the attributes that make the equipment powerful becomes liabilities - and even barriers! - to the athlete's success.

Re:@_@

[wellingj]

I don't know about that. I work on an embedded team of 4 people, and we enforce OO in C. We get along just fine. Most days.

Re:@_@

[s4m7]

Ah a fellow Article-reader. we must both be new here.

The thing that drives me nuts about this article is that I have been making this very argument for more than 10 years now, since my family tried to push me into CS school. The simple fact is that I was already writing in assembly in early high-school, and C shortly after that. As a manager and later, as a small-business owner, I've interviewed dozens of people with CS degrees who claimed they were programmers, only to find out quickly in an interview that they haven't the foggiest clue what a compiler does, or any relevant understanding of how a data structure manages to exist. Pointers? what are those? Why did you laugh when I said GOTO? Garbage collection? That's on Thursday.

I don't know that there will be no call for the type of programming CS programs teach today, in the future... in fact the way I see it, 70% of the apps that business runs on can be done in the "plumber at the store" style. Many of these require intimate understanding of the problem domain, which is one thing that CS used to be fairly lacking in prior to the "Java Shift". But when it comes to serious applications for big iron, Java just ain't it. I guess what I'm suggesting is that Java is a great language for non-programmers to learn to get a task done quickly and painlessly. I hope you don't take offense at this, I'm simply pointing out where the language's strengths really apply.

Re:@_@

[AKAImBatman]

But when it comes to serious applications for big iron, Java just ain't it.

You'll have to forgive me, but I must raise an eyebrow at this. While the (generically speaking) Java Platform has many potential homes, it has found no better home for its technology than on big iron. Its straightforward design allows for the Virtual Machine to automatically adapt to memory, processors, and optimize away sections of code at runtime in ways that a static compiler will never be able to match. In addition, Java's natural fault tolerance allows for complex multiuser applications that provide logical firewalls between each user. Except in cases of poorly designed code (extremely poorly!), no single user can take down the entire application.

If anything, Java is the ideal solution for Big Iron usage. Which is why I must ask you to clarify. There are certainly super-computing applications where Java is a poor fit. This is due the non-standard low-level design of the hardware that requires a completely different toolkit to take advantage of. (Like it or not Cell is a prime example of this environment.) Other than that exception, though, I have a hard time imagining where Java would be ill suited for Big Iron work.

I guess what I'm suggesting is that Java is a great language for non-programmers to learn to get a task done quickly and painlessly.

I vehemently disagree with this statement. I deal with the incredible task of training amateurs on a regular basis. (Some are even degreed-idiots.) VB is friendly to these amateurs. PHP is friendly to these amateurs. .NET is friendly to these amateurs. Java is anything but friendly to someone who can't figure out how to setup their classpath. Even worse, the APIs are ripe for extremity destruction. Nothing says "I don't know what I'm doing" like a coder not using a data structure when it's available, using the wrong data structure (Ouch! My memory! Ouch! My CPU time! Ouch! My I/O!), or simply developing a massive megastructure of code to replicate (badly) something that should take 10 lines of code for anyone who bothered to read the JavaDocs!

As I said, Java is a wonderful tool in the hands of an experienced programmer who knows what it is capable of. In the hands of an amateur or (sometimes worse!) an old hand who's not used to the tools that Java offers, using Java in your project is like asking for your company to be nuked from orbit.

I hope you don't take offense at this, I'm simply pointing out where the language's strengths really apply.

I'm not offended. I'm merely perplexed. You sound like the type of fellow who should have a solid understanding of the platform. So perhaps I am merely misunderstanding your statements?

Re:@_@

[Lally Singh]

I see where you're coming from (at least I think I do -- you're the ultimate judge on that), but I respectfully disagree.

The advantage to java is that it's safer to make errors there. Screw up with a reference, and you get a nice stacktrace. In C/C++, your program just dies (you can get a debugger on there, sure, but 1st year students are rarely taught debugging skills).

That said, Java's good for getting someone into the proper habits of programming. Let them cut their teeth there - make their typos, basic logic mistakes, etc in a safer sandbox. Teach them how to print out debug statements early to understand what's going on, and to identify what mistakes they often make. When they know how to properly type in a loop construct and declare/invoke a function, then let them play with pointers.

And then you let them use C++. Not the big scary version of C++ everyone in /. is afraid of (IMHO unjustly so), but just the C with classes version. Let them use that for their data structures course. People still have to take a data structures course and write their own implementations of the basic data structures! It's what we do here and it's not too bad an idea -- the kids should get trained on more than one language.

Re:@_@

[s4m7]

(sometimes worse!) an old hand who's not used to the tools that Java offers

This is probably where I fit. :)

Re:@_@

[AKAImBatman]

Fair enough. :-)

Re:@_@

[AKAImBatman]

a CS prof can require assignments to NOT USE Hashtable, Maps etc.

An excellent point, which does indeed refute the authors' argument. To furhter back your comment, I've done advanced algorithms in Java before; sometimes as just a learning experience. There are no barriers to going low-level if you want to. However, I did mention that I felt that their argument only scratched the surface. ;-)

My own argument tends to go farther down the line to the point of obtaining an understanding of how to code in the first place. What I have found is that a new programmer rarely knows how to put one line of code in front of another. (Yes, the mere logic of ordering statements often escapes them.) Introducing a new programmer to an object oriented environment at an early stage forces them to think in terms of "magic".

"Yeah, don't worry about that 'public class HelloWorld' bit. We'll get to that later."

"Trust me. You need to have that import in your code. Otherwise it won't work."

"We'll get to that main() method later."

"Why System.out.println? Don't worry, you'll understand that once you understand objects and fields and methods. For now we're just compiling a simple [ed: *cough*] Hello World program."

If these barriers were truly debilitating to a student, then we wouldn't have a problem. They'd learn what they needed to know along the way. Unfortunately, these barriers are far more insidious than that. The student knows this magic works without understanding how it works. So he's able to coast through a variety of tasks without ever worrying about it. Then when he gets to the real world... oops. You mean that wasn't actually magic? I needed to know what that did? But all I ever learned was some control structures! My professor didn't even make me format my code properly!

*sigh*

That's the scene I see far too often. A good programmer can't do a good job unless he knows why he's doing it.

"But AKAImBatman," you say. "Won't most kids going into school these days have prior exposure to programming?"

You are correct! Which makes teaching them the basics that much more important. Once again, when they muddled through as teenagers, they focused on WHAT they could do and not WHY they could do it. Code snippets and tutorials and IDEs abounded! They didn't need to KNOW what they were doing. Just fiddle enough and it will work!

If you take things down to a low level, the majority of the students will be forced to learn or find an easier major. If they already know what you're teaching, then great! They can help with the rest of the class. But if they don't, then they're learning something priceless. Either way, the knowledge is KEY to data structures. One cannot truly understand the intent of most algorithms and data structures until he's visited the metal of the machine and tried to work with the likes of strings, memory allocation, and low-level hardware control. That's when he truly "gets it" and 40+ years of computer science suddenly SNAP into place.

"Ohhhh, I get it! I really do! Hey, I had problem X a month ago that I could have solved if I had just..."

Best. Sound. Evar. ;-)

(P.S. In case you're wondering? C++ should NEVER be taught in school. Worst drain bramage you can do to a poor kid. Especially as his first language!)

Re:@_@

[AKAImBatman]

While I understand where you're coming from, I think you need to understand how Java got where it did. Coders of the 80's and 90's were faced with a variety of problems on a regular basis. Problems that were wasting their coding time to the point where they spent more time trying to track down the issues than they did writing the software to begin with. Even the most experience programmer was regularly bit by these issues!

What were they?

• Manual memory handling lead to leaks
  
• Mismanaged pointers would dive into the wrong memory by accident
  
• Compiled software was difficult to debug (particularly for low-level DOS software where the debugger rarely worked)
  
• Chaging a base class (C++ specific) would require a recompile of all related classes. Which invariably meant a clean and compile. (This issue was actually the origin of Java. ;))
  
• Software rarely compiled across multiple platforms, much less shared binaries across platforms. Write, rewrite, #IFDEF your code like a Christmas tree, compile/test regularly least you break some other platform, yo-ho-ho it's a programmer's life for me.
  
• Pay $5,000 a pop for a TARGA decoder or write your own? (Again and again and again.) Yup, that was life as a C/C++ programmer.
  

Java solved these problems by looking to the most advanced technology in the industry, and packaging it in a way that was so straightforward and simple that it was the DEFINITION of the KISS principle. What were these wonders?

• Garbage Collecting
  
• Complete lack of manual memory management
  
• Stack-based design
  
• Easily implemented, reversible bytecode
  
• Objects/Classes (there's a difference which I won't expand on here) as first-class citizens in the language.
  
• Separation of Classes into dynamic code files
  
• Portable bytecode
  
• Abstract libraries that implemented common data structures and functionality similar to that proposed in STL
  

The productivity gains from these changes were astounding! But it didn't completely replace low-level coding in C/C++. Why? Because sometimes you needed to get down to the metal to make things work well.

Today, the JVMs have been optimized like crazy. They can automatically make a program run faster as long as you know how to work with the GC and data structures that it provides. If you fight it, your performance drops like a rock. If you don't know how to use it, you might as well be fighting it.

Yet how is a student supposed to know what the JVM is doing if he's never had to scrounge for bytes? If he's never had a practical need for a linked list? If he's never had to implement memory management? If he doesn't have the first clue how to balance a tree? If he can't understand how a garbage collector works? If he doesn't know what a circular reference is? If he can't explain what a pointer is and how a reference is related but different to a pointer? If he doesn't even know what "Turing Complete*" means?

Java as a tool can be sharper than any other blade. But it is a double-edged blade. If you swing it wildly, it will cut you. If you wield it like a master, it will allow you to attack your problems with precision and vigor.

As a side note, I wonder if it isn't time to start teaching students using virtual machines that replicate the limited environments of yesteryear? Not only would it force them into solving the low-level problems, but it would also provide them with the ability to visually inspect the state of the virtual processor, memory, and I/O. Much better than a simple stack-trace, wouldn't you say? ;-)

*Imagine a computer scientist with no knowledge of what "Turing Complete" means being assigned to design the future of computers. Frightening concept? Very. Perhaps Quantum Computing would already be here if we had a greater number of qualified scientists?

Re:@_@

[Plaid Phantom]

As the author tried to explain, programmers need a solid foundation in data structures and algorithms before they should even begin looking at Java. The specific problem he calls out (which I actually feel only scratches the surface) is that Java offers such a featureful API that the programmer isn't forced to learn the basics. He is able to simply use a Hashtable, a Sort, a LinkedList, or whatever he needs without understanding why it works. Which is a very dangerous thing for someone training to be a Computer Scientist.

As a current "IT" student, I have to wholeheartedly agree with this. Just last week, I was in a Data Structures class and we were sorting our first array. The guy beside me, instead of writing the bubble sort that we'd been using in previous classes (the intended solution), nearly the first thing he did was pull up the Java documentation and find the Arrays.sort() method. I asked him about it, since we were working on a team. His answer? "Why write out a sort when Java provides it for you?"

To be fair, Java is far from the only language susceptible to this. The C++ STL has sort methods, and I'm sure most other languages have similar features. The real problem is that programs are moving away from programming fundamentals in the interest of getting to the advanced things that employers want. I took the AP Programming classes/test back when it used C++, and I learned things there that we *still* haven't gotten to after two years in the degree plan.

I don't know that it's the specifics of the algorithms that is really what is missing, though. I think the real loss is that students aren't spending time reading through the algorithms and learning how to analyze code, leaving them less able to step through their own code when their Java Servlet won't start up or their Bean disappears. One thing I run into when helping others is that they really can't say what the code they just typed is actually doing either algorithmically or under the hood.

But then, I do hail from a small(er) former community college. YMMV, I suppose.

Re:@_@

[Lally Singh]

1st year students are rarely taught debugging skills

WHY NOT?

Only so many semester-hours in the first year, and plenty of them go to non-CS materials. And frankly, when the kids are still learning to set up a basic for loop, debugging won't help you much. Worse, it'll make kids learn to depend on a debugger for problems that they should learn to figure out themselves. I *shudder* at the thought of students single-stepping simple for loops and method invocations.

Here's my personal history of learning to program.

Yeah, congrats. Think of this: if you had your basic programming skills down pat before switching to lower-level techniques like pointers, linked-list implementations, etc. wouldn't it be an easier learning methodology than jumping in the deep side of the pool early?

Yeah, some self-motivated, self-teaching programmers will go through all of it happily (you and I both did), but this is mainstream education. If we only catered to the innate hackers, we'd have a small fraction of the already-insufficient graduating CS majors we do now. Like 1/10th, easily.

The 2nd year involves building digital circuits and programming raw-metal asm on machines without an OS.

By the 3rd year, those same students who were spoon-fed java are writing kernel code as part of their OS class. I'll happily submit that most self-taught programmers who jumped in the deep end of the pool can't speak to that kind of advancement 2 years after writing their first line of code. The training wheels come off, but they definitely help getting the students up & running.

Furthermore, I know plenty of kids who taught themselves to program at an early age, only to get turned off by it /because/ they got bit too hard by the stuff Java can prevent. I submit that making it easier to learn to program is a better thing than making it harder. Just b/c you make it easier to start with doesn't mean the kids are suddenly weaker for the rest of their life. More often, you end up stunting their long-term growth.

Re:@_@

[sydneyfong]

The advantage to java is that it's safer to make errors there. Screw up with a reference, and you get a nice stacktrace. In C/C++, your program just dies (you can get a debugger on there, sure, but 1st year students are rarely taught debugging skills). "Safer"? Unless the student is going to write any mission critical programs (during the course), there's no "unsafe" errors. Sure you'll get quite a few SEGV (I ran into these more often than not when learning C), but it provides a more rigid foundation than the "safer" Java which sometimes hides away problems that one might otherwise be able to spot with C/C++. Printing a stacktrace with a debugger isn't really that hard. And it's a bit shorter than your average Java stacktrace, which is a plus. (And if "debugging skills" are not taught in the first year... when should it be???)

That said, Java's good for getting someone into the proper habits of programming. Let them cut their teeth there - make their typos, basic logic mistakes, etc in a safer sandbox. Teach them how to print out debug statements early to understand what's going on, and to identify what mistakes they often make. When they know how to properly type in a loop construct and declare/invoke a function, then let them play with pointers. I think Java actually makes it hard to do these things. Print out debug statements? When I first saw Java code I almost screamed at "System.out.println"... wtf? Besides, from what I know most Java programming courses provide a "friendly" GUI Framework, which has its own obscure classes and methods of doing I/O. Compare that with printf/cout, and you get what I mean.

Besides, the problem with Java is that it has a very rigid (i.e. inflexible) programming paradigm. There are many programs which are not best modeled by OOP, and this includes the procedural iterative programs that a student will most probably begin with. I've always wondered how instructors were able to explain away "public static void main(String args[]) { ... }". Some magic incantation?

I agree that C/C++ is too heavy on pointers and SEGV happy, but at least you can hide away those problems if you choose the right subset of C++ to teach.

Re:@_@

[Weedlekin]

""Yeah, don't worry about that 'public class HelloWorld' bit. We'll get to that later."

"Trust me. You need to have that import in your code. Otherwise it won't work."

"We'll get to that main() method later."

Whereas the standard C "hello world" example will of course be perfectly obvious to any rank programming beginner due to the fact that people are born knowing all about functions, header files, and libraries, whereas objects and classes are something they have to be taught.

Re:@_@

[daem0n1x]

I had a great microprocessor teacher at college. He would use the Socratic method, not telling people how things are done but asking people and slowly building knowledge using the answers.

His classes were great. He would start by drawing some components on the board and then asking people how to connect them for some purpose. Some students would suggest things, he would ask the others if they could find a flaw, and so on. Many times he would follow a wrong idea on purpose so that the students could find the flaw by themselves some steps ahead. Then he would erase everything back to the bad idea and start again from there.

In the end of each class we would have a full circuit drawn and the greatest thing was, the teacher didn't explain it to us, we created the solution by ourselves.

I loved his classes but almost every one of my colleagues hated the teacher's guts. They preferred to be spoon-fed with information, and that teacher committed the worst of sins: make them think.

Re:@_@

[Sam Douglas]

Personally, I would go for a language with an interactive REPL environment, preferably one that allows/encourages functional style (Scheme, Python, Lua, etc.) to learn the concepts of computer programming. Not many programming languages can teach you that faster than a good Lisp dialect. C would be a distant second.

Re:@_@

[Etyenne]

I am one of those passionate about IT (incidentally, I am also self-taught). While I recognize that those for whom IT (not just programming) is a passion are, in general, much more competent than those for whom IT is just a source of income, the reality is just that there are simply not enough of us. As such, I recognize that I cannot expect most of my colleagues to get excited about their job as I do, and it is all good anyway. It's really just too bad for them, I hope they have fulfilling hobbies.

After all, the situation is not really surprising. I know very few people (if any!) that are *passionate* about accounting. Yet, millions of accountants worldwide reliably make the numbers add up. These unpassionate accountants do good services on average and make our economic system run smoothly; without them, it would collapse. I am grateful someone else is willing to do it, because I could not stand having to do it myself. Why would IT be any different?

I am sure someone will try to invalidate my point saying the IT-as-income people have negative productivity, and hence we would be better off without them. Well, considering how few of us there are, I doubt we could make up for the horde. And I am already overworked as it is ...

Re:@_@

[smilindog2000]

Spoken like someone without much math experience. Until you get *past* diff-Eq, virtually all useful continuous math is wrote memorization (except perhaps proofs...that's mostly covered in geometry). Further, it's pretty much all memorization of algorithms. If you're not teaching algorithms, you're not teaching kids to understand math.

Well, I see we'll just have to agree to disagree. Math was my favorite subject at Berkeley, and even though I got an EECS degree, I took a math course ever semester. I was part of the math club, and frankly just love it. I have a patent on super-fast simulation of diff-eqs using backwards trapezoid with direct computation of the future point. I was the first person to ever create a commercially usable version of asymptotic waveform analysis - AWE (which is not as good as the patent I linked to). I dabble in high-frequency transformer design because it uses cool 3-D optimization techniques. Anyway, trust me, I like math, though I'm just an engineer.

If China and India and Singapore want to churn out clones who can mimic smart people well enough to repeat their work, let them. To continue leading, we need creativity, not the arts/literature kind, and it needs to be nourished in children. I strongly disagree that prior to diff-eqs, math should be mostly rote memorization. Math can be fun and creative starting in Kindergarten. My kids go to Montessori school, where they teach the why's before the how's. It's not for everyone, but it certainly is for me in my family. Unfortunately, with "No child left behind", our country is headed in the exact wrong direction, focusing on the how's rather than the why's.

Re:@_@

[smilindog2000]

Yep, that's how I do it, too. I like to say I took way too much math to ever learn how to multiply, but if you show me the numbers, I can usually guestimate quickly and move on. In your example, I'd just say it's something between 4,000 (40*100) and 4,500 (45*100), and in most cases move on from there. Especially as an engineer, I almost always know my required precision when doing math. Computing run-time or memory usage I only do within 20%. Even if I need 6 significant digits, I do the simplified calculations and make sure my final answer falls within my precision error from my guess.

Once in college, the Electronics 101 professor handed out a really tough equation to solve. However, our standard practice was to only write out the answer to six significant digits. I realized in about 30 seconds that only one term in the sums on either side could contribute any significant digits, and I had the answer in a couple of minutes. The rest of the class thrashed out a solution over multiple pages of computations, and only a few of them got it right. I thought the professor was going to give a valuable real-world lesson on how real engineers do things, but no... the next lecture was entirely about solving the math the hard way. He sucked as a professor... completely lacking in creativity (he was a French visiting prof... most profs at my school were quite good).

Re:@_@

[homer_s]

I saw the multiplication part in the video you linked and I don't understand why she is against the second method - the one where you split up 31 x 20 into:

30 x 20 + 1 x 20

Her complaint that it takes time and does not make the students proficient and quick in calculations. But that method teaches place values and shows that the product can be found by addition.

The traditional method that she seems to advocate just teaches a rote way of getting the result without making the students understand how they ended up with the result - kind of like the 'lattice method' which she rightly criticizes.

Re:@_@

[imgod2u]

"Computer science is no more about computers than astronomy is about telescopes."

For those who will be dealing with low-level programming (and certainly every college will have plenty of courses to teach them), there is a curriculum to teach it to you. But, and as one of my professors stressed, computer *science* is a *science*. The ability to debug pointers is hardly the de-facto starting point of computer science. Linked lists, stacks, queues, etc. are. And you can teach that in any language and really, it's better to start with Java (or some other language with a GC) and just require students not use the API data structures.

You then get into all sorts of nice things like theory of automation, neural-p systems, algorithm scaling, etc. *NONE* of which requires intimate knowledge of low-level programming.

If one chooses to go the route of programming, by all means, most CS programs offer that tree of study. But the idea that somehow, those skills are the "core" of CS is very narrow.

Re:@_@

[electroniceric]

After all, the situation is not really surprising. I know very few people (if any!) that are *passionate* about accounting. Yet, millions of accountants worldwide reliably make the numbers add up. These unpassionate accountants do good services on average and make our economic system run smoothly; without them, it would collapse. I am grateful someone else is willing to do it, because I could not stand having to do it myself. Why would IT be any different?

I think you're pretty close the nub of the argument. What Prof. Dewar is upset about is a broad trend away from university as an apprenticeship of those deeply and philosophically (why do you think they call it a PhD?) interested in the subject, with the elitism that entailed, towards university as essentially job preparation. This issue crops up all over academia, and the notion of any sort of quality standards (much less regulation) for post-secondary education is just in its infancy.

I happen to agree with the good professor that the best thing you can do in college is to learn to think deeply and critically as well as communicate, though to my mind that speaks more strongly to a good liberal arts component of education than to the specific language choice within a CS major. You might not think think learning history or economics or English make you a better programmer, but they do. By learning different modalities of thinking, you become more aware of the strengths and weakness of your own methods. Not to mention that good engineering nearly always involves communication in the form or requirements and design. But I digress...

I don't know how you tackle this make the courses hard vs. make them accessible issue. The reality is that a demanding course will in fact turn off a lot of students, and that does represent in some way a failure of the university's mission. On the other hand a demanding course (especially math) make a much, much, much better programmer/engineer/computer. Think of all the hollering software pundits do about how a good programmer can be 10 times as productive as a mediocre one - this is true and a lot of the skill of that star programmer comes down to grasp of deep algorithmic and mathematical concepts. So what do you do about the fact that most people are neither prepared nor dispositionally inclined to deal with those demands when they are 18 years old and just entering college, particularly if their family and friends are not that academically inclined and can't help them keep faith and slog through hard and sometimes tedious preparation? What's most fair to the students? It's not all that clear to me.

I started with C/C++

[KermodeBear]

When I entered college I was started on C/C++. I learned a lot about memory management, pointers, low level system calls, using system libraries, etc. Two years into college they changed everything over to Java.

God damn, what a difference.

To this day I am happy that I was able to have those two years of C, letting me get close to the guts of the OS, forcing me to think about what I was doing every step of the way. There is no question in my mind that it made me a better programmer in general, regardless of the language.

I feel sorry for the people that start - then never leave - a much higher level language such as Java.

Re:I started with C/C++

[StarvingSE]

I don't think it matters what language a university teaches their 1st years. Any decent curriculum will include an operating systems class which should have the low level programming assignments. My uni taught us data structures and OOP concepts with java our first year, and then we reverted back to C/C++ for the system calls, threads, etc. And any CS program that does not teach algorithms, well I don't know how they get accreditation (referring back to TFA).

Re:I started with C/C++

[mcrbids]

To this day I am happy that I was able to have those two years of C, letting me get close to the guts of the OS, forcing me to think about what I was doing every step of the way. There is no question in my mind that it made me a better programmer in general, regardless of the language.

Reminds me of the debate I often see in aviation: "tricycle gear" vs "tail draggers". Tricycle gear planes have a steering nosewheel, and two main wheels under the wings. Tail-draggers, the "old" way, have two main wheels in the front and 1 small wheel (the "tail dragger") on the tail.

It's considerably easier to land/takeoff in a tricycle-gear. But there are plenty of pilots who are dead-set on flying tail draggers because it makes them "a better pilot". Which, then, sparks another debate about whether or not new pilots should be taught on tail-draggers or tricycle gear.

In short, it all comes down to whatever the student wants. They can choose which way they prefer. Myself, I learned in a tricycle gear Cessna 172, and I don't regret my decision. Flying is fun!

Re:I started with C/C++

[giminy]

You know, I started thinking the same thing a few months ago. I learned to program with Pascal, then BASIC (basic sucked, but it's what they taught in high school), then C, Scheme, C++, and finally Java/C# (these two only in the last year or two). I've been primarily a unix guy in the past, but I actually had a job interview at Microsoft, maybe a year ago. I asked my interviewers technical questions, too. One question that I like asking is, what does an object method look like in memory versus a static method? Most of my interviewers at MS could not answer the question, which I found telling. They're certainly wizards with algorithms and code optimization, but hadn't gone into much depth in how what they're doing actually works in memory. I find a lot of OO programmers don't know what a function pointer is, even though they use them with every new line of code.

I definitely think that learning low-level languages first is the way to go. I do learn a lot of new stuff every day from my younger coworkers who have been using Java since day 1 (mostly programming paradigms and weird stuff in the libraries), but I find myself teaching them a lot as well -- and quite basic stuff too, like what thread an event fired by hardware will run in in their .net code ;-).

Re:I started with C/C++

[samkass]

My Math/CS program didn't have any class that taught a particular language. Most of the classes had some primary language, but you were expected to learn it yourself outside the coursework. In various courses I used C, C++, Lisp, Scheme, SML, Prolog, and a few others. Everyone's biased towards how they chose to learn, but I think it's the breadth that taught me the most rather than just some low-level C hacking.

As for Java, I think it's one of the most advanced languages in its balance between functionality and the ability to debug and maintain the code. The simple syntax feels a little limiting at first, but after maintaining some code for a few years you grow to love it. Parsers are trivial and thus all the IDEs have powerful analysis and refactoring tools, and it's very easy to see what's going on. The object model is simple and operators almost always do the same thing all the time. I really don't miss slugging through dozens of obscure .h files mentally parsing macros.

However, I honestly don't know what learning CS is like in Java, as I went to school just before the "big bang" of Java, WWW, ubiquitous e-mail, etc. I could imagine it being a little harder to learn some of the data structures and algorithms, since the ones included in the language are so rich. And threading and concurrency is so much easier in Java than almost all the languages that came before it I'm not sure whether current CS students even know what dilemnas philosophers faced at round eating tables.

Re:I started with C/C++

[poopdeville]

To this day I am happy that I was able to have those two years of C, letting me get close to the guts of the OS, forcing me to think about what I was doing every step of the way. There is no question in my mind that it made me a better programmer in general, regardless of the language.

This is dumb. Very dumb.

A programmer needs to think about what he is doing every step of the way, regardless of the language he is using. You know, to implement an algorithm (the steps). On the other hand, memory management is an implementation detail. If the problem at hand isn't about memory management, having to think about it is in fact a handicap. I know that I would rather focus my mental powers on solving the problem at hand than wrangling pointers, or allocing and freeing memory. If I'm learning about recursion, I don't care what the kernel is doing, or how the compiler and linker resolve memory addresses, or function pointer syntax. In fact, I want all that implementation crap abstracted away, a la Lisp and Scheme, or Ruby and SmallTalk, or even Java.

Granted, there is a time and place for things like C. College isn't it, unless it's for a course in operating systems, compilers (though I'd prefer Scheme for this purpose), or some kind of electronics engineering, where stuff like memory management is actually relevant to the subject. And even then, the essentials can be taught in less than a week. Assembly programming alumni at your school probably decried C's introduction to the curriculum. Too dumbed down. Access to system libraries and "low level" (ha!) system calls and powerful APIs is too easy. Etc ad nauseum.

Me? I started with Perl, of all things. My first project was a data analysis tool for a friend's Linguistics thesis as a college senior -- rather fitting. Moved on to Ruby (with ATLAS C libraries) for research in data mining algorithms. Later moved on to Scheme for an introduction to functional programming, and Erlang for more work in distributed data mining algorithms. Picked up some C and PPC Assembler somewhere. I'm not even defending Java in the classroom. I don't have any particular opinion about it, except that I dislike statically typed languages. Mere preference.

Turn turn turn...

[TheLazySci-FiAuthor]

I think there is a difference between dumbing-down and simplification.

Really, when has a tool ruined the skill set of an industry? The worst a tool does is eliminate certain roles or industries altogether - and those who filled those roles will always complain (and sometimes revolt).

From the study of C and Java I can say that for 90% of the tasks I've taken on I've needed no more than Java (and Java would in fact be overkill).

This reminds me of the controversy when Feynman diagrams were first shown. These diagrams were a much simpler way of expressing complex summations - but the old-school (some pretty impressive names) felt that these diagrams were a dumbing-down and that the historical mathematics were the proper way to express these systems.

Always a new tech will simplify something and those who have had to trudge through the complexity will shoot-down its simplicity - this happened with the GUI, and I have a feeling about 84% of you are reading this statement on a GUI desktop.

There will always be benefits to be had from the classic way of doing things, but new tools enable people to climb to new heights. The brain only has so many cycles, If they don't need to be wasted with pointers and bleedingly-effecient machine code then save those brain cycles for algorithms and interface design.

Re:Turn turn turn...

[Secret Rabbit]

You're arguing that what goes on at College should be going on at Universities. This is very very wrong.

Java is fine to learn at College because of the reasons you cited i.e. the purpose is to get people actually building things that is relevant to industry.

Java is a horror at University because learning to code is NOT its primary (or secondary, or...) purpose there. The purpose of a University is to get people to be able to go onto a Masters and PhD and be able to do actual research. In this case, research in Computer Science. For this context, a programming language is just a tool to be used to really dig into an idea. And one cannot do that with Java when one is dealing with such low-level things as OS's.

Your example of Feynman diagrams is also false and misleading. There it was about notation and practicality thereof. People will stick to what works for them and those "big names" that you mention already were "stuck in there ways" with the "old" notation. They PREFERRED to use the old one because they were used to it. Feynman diagrams stuck around because they conveyed the necessary information in an easier to understand way.

Here we are talking about function. Basically, there are many many many things in the CS curriculum that require a low-level language to properly describe. This does NOT include Java. There is also a level of detail of thinking that one acquires when one programs in a lower-level language like C that one cannot get with something like Java.

Basically, while Java makes business apps and such easier to write, it is counter productive with regards to the goals of a University CS program. But, if I'm wrong, just go ahead and show us an OS that was written in pure Java.

Re:Turn turn turn...

[Skreems]

There will always be benefits to be had from the classic way of doing things, but new tools enable people to climb to new heights. The brain only has so many cycles, If they don't need to be wasted with pointers and bleedingly-effecient machine code then save those brain cycles for algorithms and interface design.

The point isn't that you should spend all your development cycles on pointers. The point is that even when you're using a language that handles that junk for you, you should have some idea of what it's doing. I've seen good programmers, people I would consider to be way better than me in many respects, tripped up by the way managed languages abstract away the concept of pointers by making all objects automatically act as references. And I remember in my own Java courses in college, that not only was it strange trying to wrap your head around the language implicitly treating objects as pointers, but not a single person, student OR teacher, could explain that internal memory system properly. Pointers and memory references are still there in Java and C#, you just don't use C++ style notation for it. But if you don't understand it, it's going to bite you.

Re:Turn turn turn...

[jadavis]

From the study of C and Java I can say that for 90% of the tasks I've taken on I've needed no more than Java (and Java would in fact be overkill).

The point of academia is that new problems are rare, and old problems are common but take on many forms. Java does automatic garbage collection for many objects correctly.

But what about when your resource is something other than a few bytes of memory? What if your resource is shared among many processes, like a file, shared memory, some kind of protocol state, database connection, or session data? It's no longer good enough to just use a garbage collector, because that was only intended to collect certain types of garbage. You need to write your own, which is simple enough if you already know how existing systems work, but you are likely to make many mistakes if you go at it alone without understanding the trade-offs involved in the different garbage collection strategies.

So just because someone writes a library, tool, or what-have-you doesn't mean that the entire class of problems disappears, it means that one manifestation of the problem has disappeared, but it will probably resurface in another form somewhere else. If you have the education to back it up, you will quickly recognize the problem and solve it. If not, you will surely make all the mistakes that people have already made in the past, and from which you never took the time to learn.

"Core stack"?

[mrami]

The older worker suggested that the young engineer check the core stack to see about a problem, but unfortunately, "he'd never heard of a core stack."

Core stack? What the heck's a core stack? Does that mean get a backtrace out of a core dump?

Get that college credit

[snappyjack]

It doesn't help that the only Advanced Placement computer science courses in high school are based on Java. If it's really a problem, it should be addressed here first. Never really did see why they moved away fro C++.

Re:Get that college credit

[sneakyimp]

Java runs on a virtual machine, isolating the programmer from the details of the OS. Write once, run almost anywhere, right? Seems if I was a teacher I'd want to teach that rather than wasting time on some specific OS which won't even exist when they get out of college.

C is overkill for most people

[kemushi88]

At the University of Washington, where I am a student, the introduction programming courses teach Java. These courses seem to serve two purposes. A number of majors outside of computer science require them for the general background knowledge of how computer languages work. They also are prerequisites to entering a CS major, so they serve to weed out people who really don't belong in a technical major. Although I don't care much for Java itself, there are a number of benefits to using it in these introductory classes. First of all, when you're working with a bunch of noobs, it is really nice to have the platform independence that Java offers. Secondly, all of the libraries, at least from my experience, are extremely well documented. But most of all, most of the people that take an introductory programming course won't ever reach the level of sophistication that C requires, so teaching C would be kind of overkill. And those of us who really will continue on to work requiring C, really shouldn't have a problem learning it.

Re:C is overkill for most people

[beckje01]

At my undergrad during my last year they completely redid the structure of the CS program, and looking at it now I very much like it. I am currently a CS PhD student and a software engineer doing everything from medical device programming to web development, so I've seen the gambit of the low level coding to the high level all the way to the CS research. When I see entry level classes taught in C and Java I think its just wrong. What are you trying to teach in the first 2 semesters? How to compile code and get things to work or are you trying to teach data structures and problem solving? My undergrad has moved to teaching the first two semesters in Python and I think it was a great move. Not only is it quick and easy to get into those people who would like to learn a little CS to help out in basically any science now get a tool that they can easily pick up and use later in life. (Also forces proper indenting.) After the two starting classes the 3rd course in the entry series is Java and all kinds of things you should know in CS that fall through the cracks. The profs went around to the seniors and asked what things were lacking in the current classes, so things like regular expressions, version control, and other very useful but overlooked items were added into this new class. I think its a good plan I'm not 100% as the first students should be coming out soon so we'll see how they turn out. After seeing the vast differences in low level programming to high level programming I almost see a need for a separate degree but all I'm seeing is companies hire EE people for embedded programming and hire CS for the higher level tasks. All well eventually schools will work it out and there will be a real distinction between Computer Engineering Degrees and Computer Science Degrees. Also to make it a bigger headache don't forget there are both Computer Science BAs and BSs. I actually have a BA which makes job interviews interesting sometimes but it hasn't seemed to hurt me yet.

Re:C is overkill for most people

[TheCount22]

I have to disagree C is not overkill and isn't hard either. It is a shame that people are getting CS degrees without knowing what is really going on at the machine level. I got news for universities teaching only JAVA!!! Your Students better know that computers aren`t magic. They should know why and how things work inside their computer or they will be flipping burgers before you know it.

Truth

[p0tat03]

I'm in one of Canada's biggest CS schools, and though I'm in engineering, I really do feel sorry for them. Many of the toughest courses in that program are now optional, and one can cruise by and get a degree only knowing the most basic algorithms (quick sort?) and data structures. Naturally, the only people who take the original challenging courses are the alpha geeks who live for that kind of stuff anyway.

Meanwhile people come out of the doors of this school knowing only Java and .NET, and then complain that the world of programming was not as interesting as promised. Hmm.

On the other hand, I'm in an electrical engineering-like program, and we only deal with assembly, C, and maybe C++ on the odd occasion. I love it. IMHO any self respecting programmer needs to at least KNOW how to operate close to the metal, if only so it makes them a better coder at the higher levels.

Re:Truth

[ScrewMaster]

IMHO any self respecting programmer needs to at least KNOW how to operate close to the metal, if only so it makes them a better coder at the higher levels.

Well, a lot depends upon your eventual focus. Me, I started out in life on a Rockwell PPS-4 4-bit micro, eventually graduating to an 8080 and then the 6502, 6800, 6809 ... didn't get much closer to the metal than that. I agree with you that, as a general principle, knowing the low-level stuff can make you a better programmer. With C/C++, I'd say that knowing assembler (several assemblers) is a definite plus, really a prerequisite, especially if you do embedded systems work with limited resources.

However, given the level of abstraction in more sophisticated programming languages (Java and .Net in particular), knowing how to use pointers and memalloc probably doesn't buy you all that much. You'll never use them directly, and you're so far from the underlying constructs you're better off just learning the best practices for the language of your choice. Otherwise, you're just guessing at what's going on under the hood.

Two things

[zanderredux]

C/C++ gives a nice inside view to the core of the machine and you have to learn all the good stuff you mentioned, but I still think the best way to understand programming as an abstract exercise is through some Lisp variant. It forces you to think about data structures and exposes to a whole different way of programming, which is quite useful.

Then you mentioned you feelt sorry for those who started with Java, but then I really feel sorry for those who started with VBA...

Does the language really matter?

[HauntedCrown]

I got into University during the change from C++ to Java. The reasons that the professors gave was that they were wasting so much time with concepts that weren't critical to the class. They claimed with Java, they were able to focus on algorithms and data structures.

In a way, they were correct. Java was used, but we didn't learn Java. It could have been any language. We went over addressing memory quite extensively, and how objects are stored 'behind the scenes'. We could have really substituted any language and had the same results. Unfortunately, the results *were* the same: some students 'got it' while others just couldn't come to terms with any of it. I suppose now they are coming to the realization that there is no good way to make a difficult subject easier. Perhaps that is why they are coming up with an IT program...

With all that said, my university had yet to make the transition from 'everyone should know C and pointers by now' in the upper division classes. Perhaps that has been remedied now, but made things pretty difficult for those who weren't willing to put in the time. But the university is supposed to make you work, so I guess in that sense everything worked out fine.

What a "BS" degree really is

[bradgoodman]

The curriculum in a BS program, as I have always understood it - isn't designed to necessarily prepare you to enter the workforce with all the "hands-on" technical skills - no matter what discipline its in.

If you're to learn "hands-on" skills to apply towards work, that's what an associates degree, or trade-school is about

Look at it this way - if the world went post-apocalyptic tomorrow, and everyone "knew Java", we'd all be screwed, because no-one would understand all the theory and crap behind compiler design, OS design, carnal maps, finite automina and all the other "fundamentals" on which everything is built. Just like if everyone got their ACE automotive technicians certificates, we'd have no one who knew how to design the cars.

Now I'm not saying that universities don't try to balance out the BS curriculum with real-world, practical stuff - of course they do - but that's the idea.

In my view, school gives you the foundation, and it's up to you to apply it. Reality is, once you get out there, any specific tools, languages, etc. change so fast anyway - a BS degree teaches the foundation, and its up to you to build on it

Disclaimer: I'm an EE drop out - basically completely self-taught - the same rules apply - know the foundation - and your own your own from there.

Re:What a "BS" degree really is

[GregAllen]

I'm assuming you mean Karnaugh maps. Although I'll be the first to admit that carnal maps sound pretty intriguing to the lonely engineer type. :)

Its not 42?

[LaskoVortex]

CS should be made as difficult as possible to keep the numbers of graduates low. This may not be what CS department officials want to hear, but it would be the right thing to do. Right now, the biomedical sciences suffer from a serious glut of highly trained PhDs that find they need to extend training by 4 to 8 years as "post-docs" without solid prospects for long term employment.

While this may be great for the advancement of science, it makes for a pretty bad professional situation for scientists who still looking for work in 2-year appointments at the age of 35+. Moreover, average biomedical post-doc salaries are less than what a fresh BS in engineering would make. Biomedical sciences have suffered from an overabundance of training funds and from a drive for departments to have cheap labor in the form of hard working grad students chasing the carrot of a PhD. So they (1) outsource lecturing to part time lecturers, (2) train more biomedical scientists, (3) shrink the size of permanent faculty. Moreover pressures from tightening NIH funds exacerbate these problems.

In short, training should not be easy or overly encouraged. Colleges should provide training based on market needs and discourage weaker students from saturating highly technical fields.

If CS departments can weed out potential programmers by making their curricula tougher, they should really do it. This would ensure that CS people were actually talented and devoted to the trade and that compensation in the future would remain commensurate with training, unlike in the situation in the biomedical sciences.

Authors have a vested interest

[ZombieRoboNinja]

They're pretty up-front about it, but it's worth noting that the authors here work for AdaCore and have a vested interest in getting people to use their language. (Notice how they keep talking about the importance of teaching "languages like C++ and Ada" and the section about why Ada is the best programming language ever.)

Duh

[cvd6262]

Aspects of curriculum that are too demanding, or perceived as tedious, are downplayed in favor of simplified material that attracts a larger enrollment.

Let me be the first to welcome you to higher education.

Re:Duh

[digital19]

I think the best teachers in many universities learn to dumb their courses down. Professors that give easy A's have full classes and get great reviews. The one's that push for you to actually put in the hours and don't give out A's are avoided at all costs.

No!

[EmbeddedJanitor]

He means checking the actual magnetic core. You can do this with a magnetic compass from your Boy Scout kit.

Not mutually exclusive

[compupc1]

I don't see why students can't learn both Java (or C#, etc.) and C. I first learned Java in my undergraduate days, then in the second year we learned C++. After that we were pretty much expected to learn whatever language we needed with minimal instruction. It's not like CS programs need to do only one or only the other.

High-Level != Non-Innovative
I don't know why some people think that something can't be innovative if it's high-level. I frankly don't care whether something's written in assembly or JavaScript. It it brings something new and useful to the table, it's innovative in my book.

Different Skillsets, Different Challanges
Constructing a low-level system utility and architecting a large enterprise web-based application are two fundamentally different types of problems. It's true that students need to understand memory management and low-level OS concepts. But quite frankly students who come out of Universities understanding only this type of development consistently demonstrate a complete inability to design an enterprise web application using OO design patterns, SOA, and reusable components. There are significant technical challanges involved in this type of application development. They're just not the same as when you're living in the low-level world of systems programming.

Ever heard of reuse?
I don't know whether this guy seriously believes that students shouldn't be leveraging libraries in their code, but I've got news: that's the way the world works. It's true you should be able to dive into the low-level code if there is a specific need to, but nobody's going to pay you to reinvent the wheel (anyone who insists on implementing their own sorting algorithms in the real-world is probably a fool.) Reuse is something software engineering strives for, so why should we be painting it out to be something evil?

Besides, where do you draw the line? I know some people in the supercomputing industry that feel C is "too high-level and bloated". They would like to see students spending most of their time in Fortran and assembly. So...do we expect students to write all their software in assembly? Should students be designing everything using sequential circuits and skip the software alltogether? My point is that what's considered "high-level" is very relative, and there's no good justification to sitting exclusively any any level or another. Part of being a good engineer is knowing how to select the right tool for the right job. Sometimes that's assembly, and sometimes that's Java. As long as you're proficient in multiple styles of programming, you should be able to handle most anything you need to.

nonsense

[j0nb0y]

I was taught how to handle pointers in QBASIC when I was in junior high.

The assignment was to implement a linked list. The instructor had us initialize an array which represented our memory block. The program then had to perform all the standard linked list operations, handling memory allocation and all that crap.

The choice of language may seem odd, but consider that QBASIC is what we had available. All our DOS computers already had QBASIC on them, and we could use it without having to shell out the big bucks for a C/C++ compiler (none of us was aware of DJGPP at the time, though I later used DJGPP to teach myself C++).

Now, if the problem is that students aren't being taught memory management, then that is obviously a problem, no matter what language is being used.

Give 'em a good mix

[EmbeddedJanitor]

I would recommend that one thing people need in an introductory course is to be able to quickly figure out if they're interested in the stuff. To achieve this needs a good mix of programming etc..

Sure, some link lists etc in Java/whatever are fine, but also introduce them to some assembler etc.

If the kids are going to make a career of programming then an appreciation of what is going on under the hood is valuable.

Everything is getting dumbed down

[MikeRT]

It's not just Computer Science. When it's not being dumbed down, it's often falling victim to tenured professors who are incompetent. That's what happened to us at my alma mater. We had some brilliant professors who were tenured, couldn't communicate, and frequently were so slothful that you couldn't practically learn from your mistakes. We'd get homework from the first few weeks back halfway between the midterm and final in some cases.

I graduated with a 2.8 GPA overall, and about a 2.5 GPA in my major. That was mostly because projects were usually 10% to 20% of our grade. One exam was usually worth all project work combined. Our valedictorian, a girl who could regurgitate raw data on exams, but could barely write hello world in any language, had a 4.0 in Computer Science.

A big problem that I saw was the hand-holding. Professors don't feel confident because of the crop of students they have, in just telling students that figuring out their development tools is their problem, not the professor's obligation to teach them.

Programming is different

[Weaselmancer]

This reminds me of the controversy when Feynman diagrams were first shown. These diagrams were a much simpler way of expressing complex summations - but the old-school (some pretty impressive names) felt that these diagrams were a dumbing-down and that the historical mathematics were the proper way to express these systems.

Feynman diagrams are just another way of looking at things. It's another viewpoint of the same thing.

Java and C don't map so well. There are some things for which only C makes sense currently, such as driver development. Java is a virtual machine. Although it's possible to beat, mangle, and force java into submission and make it do those things, that's not what it's for. All those JNI libraries that Java needs to actually talk to your machine - they're written in C. AFAIK, nobody is writing an OS or even drivers in Java. I'd even bet that the first few implementations of Java were written in C/C++.

When Java is the first thing you learn, you learn sloppy IMHO. You just assume there is a garbage collector. You can allocate whatever you want, whenever you want, and not have to think about scope. If you ever do have to do some system work later on in your career - all of these notions will be new. You'll have to think about pointers, and the size of an object in memory, and how long you should hold on to it before you free up that memory. You'll suffer serious setbacks when it's time to program down to the wire.

Java is a beautiful language - my personal favorite - for application development, but application development isn't all there is.

Re:Programming is different

[starfishsystems]

Java and C don't map so well. There are some things for which only C makes sense currently, such as driver development. Java is a virtual machine.

To be precise, Java is a language specification. It's typically implemented as a virtual machine, but there's no fundamental requirement to do so.

Let's consider Lisp instead for a moment, since Gosling, Steele, et al used it as a conceptual basis for Java. It has an extremely rich history. Lisp predates Java in being implemented as a virtual machine. The dialect was Interlisp.

The Xerox model 11xx AI workstations used Interlisp as the system language. Lisp device drivers and network stacks were also implemented for the MIT Lisp Machine and its commercial derivatives based on variations of MIT Lisp and later Common Lisp. Note particularly that Lisp is running in silicon on these systems. There is no virtual machine.

These systems were not a great commercial success, because they entered the market as very exotic and very expensive research workstations at exactly the same time as commodity microprocessors were experiencing exponential growth. The various Lisp systems just couldn't keep up with commodity growth effects on price/performance. There was nothing functionally lacking with them, and I can say from firsthand experience that it was a pleasure to work on their operating systems.

I'm not convinced that I would enjoy working with an operating system written entirely in Java, but there's no reason such a thing couldn't exist. If a JVM can perform acceptably on top of a foreign processor architecture, it should only perform better without the virtual machine overhead.

The usual, yes and no.

[jd]

Yes, computer science is massively dumbed-down, needlessly. Yes, this is to bolster numbers. Quite stupidly, as you could get the same results by making CS courses cheaper to take. Computer scientists make more money, so get taxed more, so some of that surplus could go back into funding the courses. Cheaper courses, more people taking them, even if they are hard. It's simple market forces.

The "no" is with regards to comp sci being for a certain kind of person. It's for a certain kind of perspective, but anyone can learn to see things from any perspective they choose. It's not equally easy for all people, so the more people you want to have that perspective, the more appealing you need to make it. But that is very different from changing the perspective, which is what fee-driven universities tend to do. No. Leave the perspective alone. Then how to make it more appealing? After all, everyone hates numbers, right? Wrong. In fact, up until about the ages of 11 or 12, you'll find something like two to three times as many people absolutely love numbers, algebra, equations, algorithms and problem solving. (This is based on the fact that the number of boys who like maths stuff remains unchanged, but girls go from outnumbering boys as geeks younger than that to being virtually non-existent soon after.) If you ask people (and I have) over the age of 18 about their experiences in learning maths or science, guess what! You rarely hear complaints about the subjects themselves - it's almost invariably the teachers.

So? So, if you want to double the number of CS students and revert to a tough, purist syllabus, all you need to do is replace all the middle school teachers with people who have an interest in the subject and a passion for educating the students, rather than an interest in the paycheck and a passion for the students. Doesn't seem too tough.

(Of course, it's easier if the teachers are payed a living wage, or better, so that you can recruit talent rather than whoever is on the scrapheap of life.)

And this is why...

[theJML]

This is why things are getting more and more bloated. I learned in basic and was quite glad when I got to c that I was learning something closer to what actually goes on. I had 3 Pascal classes in HS and shortly into them I found out just how powerful Assembly really is. Luckily I had a teacher that let me use that knowledge with inline statements on assignments. Things just worked, and worked quickly.

There are trade offs to be made. Sure you can probably hack something together using less lines in Java or .NET, but I know for a fact, there's no GOOD reason to have to install a 120MB .NET install for some of the simple control panels and apps that are out there (ATI, I'm looking at you...). I remember when people tried to make their programs smaller and more efficient, finding ways to both put it on a floppy, and run quickly on slow hardware. Now these young whipper snappers use some high level interpreters and say screw the extra cycles, Proc's are cheap. Corps aren't worried about running quickly, or taking up small amounts of memory with elegant programs. They just want it released. Now. No time to dilly-dally on making "good" code, just gotta keep cranking it out. If it's slow, just up the requirements. I long for the days of assembly and low level programming...

Re:And this is why...

[TheMCP]

Corps aren't worried about running quickly, or taking up small amounts of memory with elegant programs. They just want it released. Now. No time to dilly-dally on making "good" code, just gotta keep cranking it out. If it's slow, just up the requirements. I long for the days of assembly and low level programming...

Okay. Let me give you an example from my career a few years ago.

I was running an IT group in a small university. We needed a new help desk management application. It had to store various data and produce various printable reports, some just of regurgitated data and some of statistical analysis thereof. It had to have interfaces which could be used by the support technicians to log data, and by the customers to view the status of their requests and make comments. These interfaces had to be useable via the internet from several campuses, in a mixed platform environment. Commercial systems for the purpose ran at about $250,000 for the cheapest suitable application I found, and that one would require additional consulting costs for configuration (which would take a month or two between waiting for a consultant to be available and actually doing the installation and configuration) and didn't tie in with our existing relational database or single signon solutions.

How long would this take you to program in assembly? (Hint: if your answer isn't measured in man-years, I'll laugh at you.)
What would the cost be for all that programmer staff time? (Hint: too much.)
How long would my team have had to go without the new application? (Hint: we would have needed it long before you'd finish.)

It took my team of programmers one calendar month to write a java/jsp/jdbc/sql web application that met all requirements and played nicely with our existing systems and was ready for use the minute it was done. If I was doing it again today, I'd use a higher level language and probably have it working in two weeks or less. The staff time cost $10,000.

So, the university saved $240,000+ because we had a high level language available to us. So why should I have wanted to do it in Assembly, or even C ?

Java not the problem

[mandelbr0t]

I agree with the professor's statements -- mostly. The fact is that Java is not to blame, a lack of rigor and mathematics is. I love Java, not because of all the wonderful graphical fiddling, but because J2EE is a great server-side environment. I have taken the trouble to understand all of the server-level stuff before abstracting it away into an EJB; I understand what work the server is doing for me, and know how to fine-tune that behavior if necessary. Likewise, students should have to write GUI code in a text editor before learning how to use the IDE to save time. Anyone who expects to do any serious software engineering definitely needs to take a course in Algorithms. Math should not be ignored, as it is quite often the mathematics that is packaged up into a neat application, invisible to the end-user.

It's true, you can teach people how to use an IDE like a software application, and you will get "programmers" that can put together a basic program with no problems. Ask them to start debugging, add complex features, etc., however, and they have no idea how to begin. I've no problem with Prof. Dewar lambasting these people as they are a large problem in IT today. However to simply point the finger at Java (or .NET for that matter) misses the point entirely.

Re:Java not the problem

[John C Peterson]

As an educator, I see the other side of this a lot. For everyone who complains about the lack of formal math in the curriculum, I see students who would never survive 2 years of calculus and yet get good jobs in the IT community. There are many students who can't handle intense data structures or low level programming but do fine as network administrators. Over the years, I've seen computer science broaden incredibly. When I was in school, it was obvious what you had to study: low level programming (assembler and Pascal), algorithms (Knuth!), graphics, theory, numerical methods, computer architecture (Bell and Newall), operating systems, some high level programming language like Lisp, and that was it for just about everyone. We always look back to the "good old days" when things were so clearly defined. I'd like to teach a more rigorous program - some catagory theory (just kidding!), some formal methods, Haskell, low level C programming, serious software engineering, whatever. But I'd lose most of my students for no good reason. If I wanted to complain about something, I'd complain about lack of communication skills among CS graduates. That's something that we can address in higher ed that really impacts everyone with a CS degree, not just some narrow part of the field. Employers should quit whining and do a better job of looking at the experience and capabilities of their applicants. You can't assume a CS degree means programming. Don't expect us to put all the things you need in the core curriculum - look hard at the advanced courses that an applicant has taken. It's not dumbing down - it's a natural expansion of the field that keeps reducing the common core in CS.

Re:Java not the problem

[IWannaBeAnAC]

It is called Computer Science. What has gone wrong with the CS field that it is now turning out people to work as network administrators? What does that have to do with science? If you can't survive 2 years of calculus (or something of similar standard, it doesn't have to focus on calculus, perhaps group theory, algebra, statistics, discrete mathematics, etc), you shouldn't be doing any kind of science degree.

Computer science != software engineering != information technology. But it seems that computer science programs have lost their purpose. It was happening at the school where I was too, by third year it had become a haven for the lazy and less bright students that couldn't handle the workload at physics, mathematics, chemistry etc. This was 10+ years ago, so I expect it is even worse now. I can see the day when computer science gets thrown out of the science faculty, actually. Perhaps into business/commerce, or even away from the university sector completely, into a vocational training school.

Generation gap

[Mr2001]

I saw that too, and like the young engineer in the story, I also have no idea what a core stack is - despite the fact that I've been programming for nearly two decades, in environments from x86 assembly to .NET, and I know my way around a debugger. I assume he meant a call stack, maybe one saved in a core dump, but I can't help envisioning a pile of antique magnetic memory units.

This seems like an example of the "old people have funny names for things" principle, not "Java makes you a bad programmer". I bet the young engineer wouldn't know where to buy oleo or Prince Albert in a can either, but what the hell does that prove?

Re:Pascal

[Diordna]

Because no one teaches courses in C#...except for my freshman-level game programming course using XNA on a grant from MS.

The article is utterly ridiculous . . .

[mmell]

. . . my entire educational experience in college was augmented by drinking large quantities of java - I turned out just fine! Come to think of it, sometimes I had Dewar's in my java . . . ew.

Starting off easy

[Version6]

My son's high school programming class starts in Python and finishes the year in Java. In previous years, they have started in Scheme. His instructor says that since they switched, he sees much more experimentation and "programming for fun".

I started (over 40 years ago) with an Algol variant and proceeded to Fortran. (C hadn't been invented yet.) As a professional programmer with a computer science style background (as opposed to the engineering style of today--an improvement I think), Scheme appealed to my aesthetic sensibility, but especially at the high school level, making it fun is much more important. Plenty of time to "graduate" to the drudge work of Java (yes, I've been paid to use it) and the painful bugs of C (used it since 1976, sworn bitterly at it, defended it valiantly against all detractors and it's still the one I'm most proficient in).

Basically, when I started programming, a high percentage of computer users were programmers. These days, that percentage is vanishingly small. High school and introductory college courses should reflect that and focus on basic computer concepts well-learned by being fun enough to just fiddle around with.

Better to teach them English Lit.?

[PeanutButterBreath]

I am one of those "fake" programmers building web and database apps with VB, ASP, JavaScript and the like. FWIW, have I never referred to myself as a "programmer" of any type, as I suck at math and have no formal training in CS. I just use tools that are easily accessible and best allow me to make myself a more valuable to my employers. Every once and a while I get the bug to read-up on something like C++ or even Assembly but it is soon obvious that these are not relevant to the problems I was trying to solve and I would rather do other things with my time.

The author strikes me as a typical "You kids have it easy -- I used to walk to school in the snow uphill both ways" type who resents the fact that his formative experiences are no longer relevant. How does the field progress if everyone is forced to retrace the same steps from the same start point? That is not to say that his specific concerns are invalid. But it seems to me that the evolving state of software requires a broader range of programmers. If Java introduces people who will never become excellent programmers to programming concepts, why is that a bad thing? There are many roles to play, and hardcore math geeks can't fill them all. Rather than chase everyone else out of the field, perhaps the next step is for schools to adpot a more sophisitcated approach to organizing their CS programs.

I see an advantage in distributing programming skills as widely as possible. Being able to create my own tools makes me much more useful to my employers, and the combination of business knowledge and programming knowledge make my overall skillset more difficult to outsource. Win-win. Even a programmer who "only" knows Java is infinitely more useful to society than a technophobe with a Liberal Arts degree (speaking as a non-technophobe with a Liberal Arts degree).

Re:Computer Science

[Version6]

In my not especially humble opinion, you are completely wrong. Computer science is the mathematics of computers. It may indeed be mental masturbation some of the time, but again in my opinion, masturbation is sexual activity.

Analysis of algorithms, theory of computation, numerical analysis, syntax and semantics of computer languages . . . there is a long list of theoretical topics which sometimes aid in "practical implementation of complex concepts on limited physical computers" but which merit study even if they don't currently contribute directly to that end. Just like mathematics, there may be eventual applications which less limited computers will allow, or the process of studying these things will provide tools and insights into current problems.

Even in the "practical" world, the real question is "Which is the right tool for the job?" Interpretive languages are sometimes the right answer (though I'm not sure that Java is ever the right answer myself--I try to be open-minded on that). I think they are particularly the right answer in the early stages of learning computer programming and often in "exploratory" or prototype work. For a professional programmer it's important to have a repertoire. For a beginner or a non-professional, "Bus error: core dumped" is a little harsh. And no one should have to use the horror that is C++.

CS Degree Means Writing Javas, not Using Them...

[tjstork]

I'm thinking that a good CS Degree should give you the background in compilers, machine architecture and structures, languages (in the theoretical sense), so that, you could write your own cheesy VM + byte code compiler for a senior project.

Re:Could be worse

[ardor]

Imagine teaching closures, coroutines, true generics, conditions, pure functional coding, arrows, lambdas, etc. in Java.

See? Java has very limited expressiveness. People are taught what's hot today. Tomorrow, different languages are hot, with different paradigma. Or, they get a job where other paradigma are important. Now, see how hard the people have to try to adapt.

If all you ever got taught was to use a hammer for everything, you will have a hard time adapting to a scalpel.

the right tool for the right purpose...

[DrEasy]

Both C and Java have their purposes. I'd use C to teach pointers, memory management, recursion and maybe even complex data structures and algorithms. I'd use Java to teach OO. I would also go back to C when teaching operating systems, and to Java when teaching design patterns and software development methodologies. But I believe that neither should be used as an intro to programming.

The first course on programming is where you can turn off a lot of students if the language gets in the way (weird syntax, a compiler with cryptic error messages, a mammoth virtual machine, etc.). If all you want is teach variables, conditions, loops, and simple data structures in order to solve simple problems, why not use something like Python, Pascal or Scheme? Let's please leave concerns like the understanding of computer architecture and efficiency (C) and software engineering (Java) for later courses. The C-centric crowd needs to understand that Turing is not married to von Neuman: understanding of pointers is not necessary for computing and algorithm design (hello Lisp?). The Java-centric crowd needs to understand that, for some, programming is just a tool (for problem-solving) and not a discipline (software engineering).

And this does NOT mean I'm promoting the dilution of the curriculum. In fact, because students would get up to speed faster, you could solve more complex problems earlier, and actually hit those issues of efficiency and code reuse that C and Java are respectively supposed to solve. They will then be ready to enjoy and understand those courses that follow.

IDEs and EJBs

[Phantom of the Opera]

The java of today has a vastly different feel of the java of 12 years ago.
There are two major influences that has caused this change :
    * IDE's
    * EJB's.

IDE's are not for me, but here is what I'd say are the pros and cons.

  pro : easy code navigation
              saves time typing
              UI development
              debugging is easier

  con : leads to code concepts like MyAbstractFooBarFactoryFactoryBean
              debugging takes longer (_look_ at what you've written, dammit)
              gets you further from what the machine is actually doing

EJB's. I have yet to find a real live person who thinks these are a well thought out idea.
I won't shooting at this particular fish in a barrel, but I think its changed the java culture in the following ways

    * reliance of configuration files, with the express purpose of "making it easier so you don't have to code...just change the configuration". What do we wind up with? Logic that is spread far and wide and removed from the actual computer program.

    * layers and layers of 'ghost' classes that really don't do anything but pass the buck. Some call this a framework. I call it Kafkaesque.

    * XML, including the trifecta of embedding logic in configuration files in a language thats
                    > weak in human editing
                    > a horrible space hog
                    > poor in expressing trees
                    > overkill for 98% of what it is used for

I agree one thousand percent (long)

[WatersOfOblivion]

The CS program at my University is a joke and apparently it is as I have always feared: my University is on par with CS programs at other Universities. Partially you can blame the Universities, but mostly you have to blame the students. Let me tell you why:

I've been programming since I was 8 when my father (who has worked for IBM since before I was born) taught me C (I am now 25). My Junior year in high school (10 years ago), I stopped using Windows and started using Linux, and have never turned back because I immediately fell in love with Bash.

When I went to school, I started as a Music Major and actually stayed one for quite a while, but I was never very good at it since, instead of practicing my sax for three hours a day like I was supposed to be doing, I was coding about six hours a day. In my first three years of college, I taught myself Java, Lisp, Ruby, and OCaml, and not just the languages but the libraries as well. I read everything I could find about algorithms, data structures, software engineering (URL, Design Patterns, etc.), compilers, theory (FSAs/PDAs/TMs), and even some true graphics programming (ray tracing). All of this I learned from the internet, completely isolated from any direct contact with other computer science professors or students. I did it because I wanted to learn it because it was interesting, and not because anyone told me I had to.

When I realized I was going to starve as a musician I decided to get a minor in CS, since it was something I had always just done for fun, and it would look good on my resume. My first month into the minor, I was already tutoring seniors in their classes, and simultaneously laughing at how easy their assignments were and being horrified that they couldn't do them. I had done more complex projects for fun and threw away the code because I didn't think anyone would want such trivial junk. I quickly found out that I had essentially put myself through a CS degree on my own and completely by accident!

The next semester, I changed majors, was in senior level classes and was actively involved in a research project with one of the professors. Whenever I got an assignment due in two weeks, I would complete it in class, and then spend the next two weeks implementing it in other languages and extending it to something that isn't incredibly trivial. For example, we had two weeks to implement a Turing machine, and because the majority of the class couldn't do it, it got extended to almost a month. I wear shirts from ThinkGeek and my peers don't get the jokes. When I pull up a terminal their eyes glaze over, as if I'm performing some mystical black magic.

The point is that any and all the information for the CS degree is out there and publicly available, but the students are simply not willing to go out and find it. I think the only positive thing I have gleaned out of the CS degree is what they are stripping from the degree programs: being forced to take the advanced math classes. My math classes taught me how to think formally about something that has always been intuitive and have been the most enlightening classes I have ever taken in college!

Whenever I get frustrated with my University or my peers, I just reread theses and remind myself that there are others out there:
http://www.pbm.com/~lindahl/mel.html[The Story of Mel]
http://www.pbm.com/~lindahl/real.programmers.html[Real Programmers Don't Use Pascal]

Also, the point of the above article is by no means a new idea. Edsger Dijkstra said it over a decade ago in one of my favorite EWDs:
http://www.cs.utexas.edu/~EWD/transcriptions/EWD10xx/EWD1036.html[On the Cruelty of Really Teaching Computer Science]

Teaching Java - Prefer Python

[Hairy1]

A few years ago I taught a class in Java. I program in Java professionally, so I know it is a powerful language. In learning Delphi I developed Object Orientated skills which easily transferred to Java. The main principle of Java is protecting the developer from themselves, with strict typing and automatic memory management. The main problem with C/C++ is programmers stuffing up memory allocation. Right now I manage a project that has C++ code, and we still deal with unexplained fatal crashes and such like. Anyhooo....

I thought it would be good to teach Java. Problem is that you are forced to make everything a class. That means you have the choice of either teaching all the principles of objects in the very first lesson - even before variables, or telling your class to ignore all the cruft at the top while you try to teach the basics. Even then basic things like keyboard input and outputs require in depth explanations of the Java API. I spent most of my time trying to explain why everything was so complex in Java.

Bottom line; the best language to teach programming is Python in my experience. You can write a one line hello world easily and teach all the basic principles of programming. I don't agree that languages like C should be taught first, as they tend to overwhelm students with details of the language rather than the principles. Python certainly isn't an endpoint. A professional developer should know several languages, even if they are not 'commercially proficient'.

The problem with Python, to be brutally honest is the poor quality of the documentation. I'm not talking about core Python so much as libraries. Often I get libraries and then spend ages trying to find references about how to use them.

Java is suitable for teaching CS just as C/C++ is

[master_p]

There is nothing that makes Java unsuitable for learning algorithms and data structures. The fact that Java comes with a set of prefabricated components does not mean that it can not be used for such a task. C++ and Java have exactly the same algorithmic issues, because Java, despite what others may have said, is essentially C++ with a garbage collector and all objects allocatable on the heap. Java also has pointers; it's not possible to say "I know Java but not pointers", because even the language itself admits it has pointers: it throws a null pointer exception when a pointer is null. There is also a little bit of memory management thrown in, in the sense that pointers must be nullified as soon as possible so as that the collector clears unused objects.

Java has some advantages over C++ that are important for teaching programming: it has an established set of patterns that all libraries use, whereas in C++ there is no discipline, anyone can make anything in any way possible. For example, many Java libraries use the listener pattern.

Java treats exceptions correctly (despite of being boring to having to program around them), where is in C++ exceptions are not used, although they are available a long time now.

Another advantage of Java is its typing system, which covers a great spectrum of typing systems: it is strong, it is static, but it is also a little bit of dynamic when one uses interfaces. It's very important, and since OO is dominant these years and for the future, it's a very important aspect and Java is the best environment to teach and experiment on these issues.

Java is also suitable for teaching concurrent programming, due to its support for threads. In fact, a Swing programmer must already know threads, because a Swing application is already threaded right from the start.

So what is left? low-level system calls and system libraries are operating system-specific tasks, and have no place in the programming course, unless the course is about kernel programming. Manual memory management is a C/C++ specific task, so unless someone is required to program in those languages, it's not a requirement for today's majority of applications.

So, in conclusion, I believe that there is nothing wrong with teaching Java. I think the core of the problem is that they don't teach the fundamentals of programming (algorithms and data structures), not the language itself.

Tools != fetishes

[Simon Brooke]

It would be amazing if people actually read the article every once in a while. :-/

I make a living as a Java programmer. I enjoy the work I do and feel that no other language/platform can even touch Java's capabilities in team and enterprise development. Even for single-programmer development, there are a lot of situations where Java is the solution to end all solutions.

I have also made my living for the past ten years as a Java programmer. Before that I was a C programmer, and before that I was a LISP programmer. There's no doubt whatever in my mind that of those languages the most powerful, productive and expressive is LISP. However, there's equally no doubt in my mind that any high-level language is primarily a means to communicate with the programmer who has to maintain your code after you, and if it doesn't achieve that goal then it fails.

Many languages have strengths. Java was designed as a special purpose language for programming the low-power, processor and memory-poor devices. For everything else it is compromised by those design goals. But it has the great strength that it is now a lingua franca that many people in the industry can read and understand.

If you're fetishistic about your tools - if you believe that one particular language (normally the one you're familiar with) is somehow better than all others, then you are fundamentally a poor programmer. A good programmer can pick up any Turing complete language and produce good code - and, more importantly, can assess the strengths and the weaknesses of those languages. But in the end, any language is merely a tool, and every Turing-complete language can be used to achieve exactly the same results as any other Turing-complete language.

Me? The most interesting new language I've seen for a while is Scala.

That being said, I agree with the article.

As the author tried to explain, programmers need a solid foundation in data structures and algorithms before they should even begin looking at Java. The specific problem he calls out (which I actually feel only scratches the surface) is that Java offers such a featureful API that the programmer isn't forced to learn the basics. He is able to simply use a Hashtable, a Sort, a LinkedList, or whatever he needs without understanding why it works. Which is a very dangerous thing for someone training to be a Computer Scientist.

I, frankly, don't agree with the article. Firstly, Java has nothing to do with the case - it's a complete side issue. As a pedagogic language, Java has some merits; it's simple, reasonably orthogonal, and has very clear syntax for expressing structure. And it's just as easy to write a course using C++ which uses only very high level graphical toolkits as it is in Java. The issue isn't the language used for teaching (although I'd prefer to see students introduced to a range of languages); the issue is what is taught. A Java-based course, on the other hand, which takes the student through designing their own compiler in Java (not for Java) and then onto considerations of 'Just In Time' compilation will teach as much or more basic computer science as a course which teaches compiler design in C.

If you think you can stick with the programming technology you learned in college for the rest of your life then you're in the wrong industry, my son. The core skill of a programmer is learning new technologies, not rehashing things in familiar ones.

Load of Crap

[Heembo]

These guys are shills for the "Ada industry" and are not really crying about "damaging to students", but rather how difficult it is to find Ada programmers in support of their personal financial interests. And they do so hidden behind academic titles. Depressing. The world of programming for new grads is mostly about web development which is either Java, PHP or .NET. A CS program "rich in Ada" is not very beneficial to grads. OO Java Development is an excellent teaching language and is very pertinent for a bachelors of science in CS education.