First off, let me admit to heavily salting the previous post with hyperbole. I wanted to contrast the article writers assertion that accreditation was education. This is an issue I run into constantly, because I'm just slightly older than most graduates, so I'll take some time to answer you fully.
When I said that I'm only starting to deeply grasp introductory CS topics, note the 'deeply' part. Everyone in CS learns that a computer is a turing machine, but that in of itself is merely a useful analogy. Getting an intuitive grasp of what a turing machine was took me a few classes in relatively advanced mathematical logic (I went back to school part-time in philosophy recently). Yes, CS includes a great deal of mathematics (although rather aenemic logic as compared to philosophy, oddly), but it was the synthesis of the math with a great deal of programming knowledge and experience that made the whole thing really stick. (Often people just axiomatically accept that mathematics is reproducible using basic logic, but actually playing with doing such things is a much more powerful epiphany)
Likewise, while I would call myself a true programmer, and one that is talented at OOA/OOD, I readily admit to only having a very limited understanding of that subject. While I'm well read in OO stuff, have programmed more code than I can remember in a number of object-oriented languages, and pride myself on having a pretty good grasp of the wierd subtleties of C++, I still don't have that intuitionistic grasp of object oriented design that is the mark of a true pro. If you hang out on the Cygus STL developer list for a while, you'll understand what I mean.
My beef with CS education is the way it's being approched. I've had to sit down and explain to a CS grad that C was a subset of C++, he had never taken a C class. As a matter of fact, he had never really done any procedural programming, just OO. This seems to me like a medical resident performing surgery without ever taking anatomy. Industry pressure has made CS curriculums focus more on 'modern' technologies, but at the expense of teaching things in a sane way. At the same time the heavily academic focus remains strong. Academic computer science is useful, but gets rather a lot easier with practical experience. Universities should get people into code fast, make them write a hell of a lot of it, and supplement this with computation / information theory instead of the other way around. In experience, the result is CS grads who have a great deal of potential, but typically do not have enough knowledge to appreciate where their knowledge is lacking, a terribly hard person to work with or train.
Here's a little platonic anecdote (which actually occured, mostly):
CS Intern: Why aren't we using C++ for everything?
Me: Because it's rather inappropriate for what we're doing (writing a linux kernel module)
CS (sceptical): C++ is better.
Me: Well, sometimes.
CS: But everyone knows object oriented programming is the way of the future!
Me (sceptical): I agree, some people wouldn't.
CS: So why don't we use C++.
Me: Why don't you write OO code in C?
CS (looking at me like I'm an idiot): Uh, C isn't an object oriented language.
Me: Well, no. But an object oriented language isn't the same as object oriented design.
CS (confused): I think your wrong. [I learned in class from an expert prof] There are a few languages for OO, smalltalk, Java, C++, and older languages aren't.
Me: Well C++ was originally a pre-processor that emitted nothing but C code.
CS (adamant): But C doesn't have objects!
Me: It has structs...
CS: Yes, but we we're told not use those. Just classes.
Me: Uhm, and you can have pointers to function in a struct.
CS (confident that she has me licked): Yeah, but those are really bad to use too!
Me: Well, but you use both of those in C++ all the time. C++ just makes it easier by calling them things like classes and virtual function tables. You can use the principals of C++ in C without any real trouble, it's just a bit more time consuming, but for code that needs to perform well it can actually be a big advantage to know exactly what's going on. For kernel-mode programming it's an even bigger advantage, since performance is really important, especially in a network stack.
CS: Well, I guess we'll have to agree to disagree. Do you know a good book on C, I never took any classes on it...
If you like that one, I'll recount the time I had to explain to another CS grad why 'assfucker' was rather a bad choice for a variable name (nobody had actually ever read their code, in classes the grades we're based solely on output), or why O(logN) searching to find a TCP/IP port number for a incoming packet was a much better way of doing things than O(N) (didn't seem to really matter, and it was more work).
If you fault the grads you must necessarily fault the system that produces them.
[ Parent ]