"Are pointers and recursion the Latin and Greek of Computer Science?" Joel Spolsky has an insightful article
on his "Joel on software" blog about computer science curriculums and
recent changes. He equates teaching of concepts like pointers and recursion
to the teaching of Latin and Greek in the early 1900's. These things aren't
taught because they have great practical purpose outside of school. They are
taught because they train the mind to think about hard things. They are also
taught because they help to weed out the students that aren't going to make it
later on. In Scouting, I've had an opportunity to counsel quite a few people
that were starting to look at colleges and wanted advice on a career in
programming. My advice has always been that the best schools are those that
care more about teaching theory than teaching languages. Languages change.
When I went to school, c++ was all the rage. Now, its Java. Who knows what it
will be in 10 years? If all you know is Java, you're useless when Java goes
away (just as programmers that only know Fortran are pretty much useless now).
On the other hand, if you know the theory behind programming languages, then
you are able to pick up new languages quickly and you are much more
valuable. Recently, I've been allowed to establish some of the criteria that is used
to evaluate potential recruits for the programming team at work. For me, my
priorities are on picking somebody that can be taught new things quickly, and
that already has a concept of working with and maintaining big code. Sadly,
that's just doesn't seem to be what schools are teaching. Applicants seem to
want to wow us with their familiarity with XML and Java skills. But when I
start asking about the projects they've been working on, things crumble. Most
of them don't have experience maintaining things beyond a single homework
assignment. Some of them have taken semester-long project courses, but even
those courses have been boiled down to the point where they've been robbed of
the process that goes along with the software life-cycle. Theory seems to be
an up and down thing. Some people get it, where others seem to have missed
it. I wonder if its one of those things that gets covered once and then
forgotten by most. My advice to people looking for a programming job: Knowing how to pick the
school is critical! If you get sucked up going after the big names just for
the name's sake, or if you go after the curriculum that seems the most
exciting, you can be sure that in the end, you'll have a resume that contains
lots of buzzwords but very little substance. You'll find yourself getting
picked for lots of first interviews (the HR folks will love you), but you'll
also find yourself getting called back (the non-HR folks will see right through
you). Eventually, you'll find yourself a job, but it will be something like
"systems analyst 1", which pretty much indicates that you know just a little
bit more than the secretary does and will not be moving up any time soon.
Instead, look for schools where the focus is on theory. These types of
schools usually make you wait a few semesters before letting you program in a
language you've actually heard of before. They give courses dedicated to
nothing but data structures and discrete mathematics. One final piece of advice: Don't look to your courses to give you all of
the education that you'll need. Just as important is what you do outside of
the curriculum. Join a CS club. Or, start writing your own software. Or,
pick an open-source project you like, and just start hacking away at it.
You'll be surprised just how much you can learn by trying to get somebody
else's software to compile on your platform.
posted at: 18:44 | permanent link to this entry | Comments: