Do We Need A New Kind of CS Degree?


Joel Spolsky suggests that we should have something called a BFA in Software Development.  That is, a Bachelor’s in Fine Arts focused on creating software.  I think he’s onto something.  I’ve called for something similar in the past.  Presently there are two sorts of degrees that seem to be offered in the market.  There are what I call IT degrees that are designed to help a person operate in the information technology field.  They teach database programming, visual basic, web design, etc.  They don’t generally teach hard-core programming.  There are also the traditional CS degrees which are geared toward doing research in computer science.  Their roots in the math departments of old show and there is a strong emphasis on proofs and mathematical modeling.  There is a need for a 3rd option.  What Joel calls the BFA in Software Development and what I called Software Craftsmanship is a degree that teaches someone the art of programming.  The graduate from a CS school knows how to prove the correctness of a for loop and can characterize an algorithm as NP-complete, but doesn’t have much practical experience.  There is a certain class of person that shys away from the math required for a CS degree today but who would make a great programmer.  Mot of the time these people take a few classes and then quit school to fend for themselves on the open market.  If we offered a program that taught better programming techniques focusing on different sorts of languages, longer-term projects, more design patterns/oo, debugging, testing, etc., I think we would find the uptake to be solid.  There are a lot of people that want to program but don’t want to do research.  They also don’t want to be a DBA in the back end of some giant corporation.  Today, there is no program at the college level for a person like this.

As a counterpoint, several professors are claiming that today’s CS programs aren’t mathematical enough.  I see their point.  There are places that need more formal methods.  The lack of a BFA in Software Development is probably partially at fault here.  CS programs are becoming watered down because students don’t want the formal methods.  Perhaps splitting the CS degree into CS and SD would help create a pipeline of those who are trained in formal methods and also create a pipeline of those who are trained in creating working software in an efficient manner. 

The authors also attack the use of Java as the first programming language.  Joel also wrote an excellent post about this a couple years back.  This is something I can support.  Java is too easy.  It’s a fine language for writing production code, but it doesn’t force the programmer to understand the underlying computer.  It hides too much of what is really going on.  This means that when the abstraction leaks, those who have only learned Java don’t know what to do.  They don’t understand pointers and memory.  They haven’t had to write low-level programs of their own and don’t understand how those parts might be doing things.  They don’t interact closely with the OS and don’t understand what it might be doing which is causing problems.  Anyone who learns to program in C or C++ can learn Java (or C#).  The reverse is not true.

Comments (5)

  1. Greg Miskin says:

    An SD degree?  I would have been all over that.  It was what I did for myself.  I was in a CS program for a year but was waaay to ADD to deal with the math requirements.  

    However, I had been teaching myself C++ for a couple years. When I had to write assignments in Pascal I was doing stuff the TA’s didn’t know you could do, not to mention adding features beyond the class requirements.

    I dropped the CS and pursued a degree from Addison-Wesley, buying up as many programming books as I could afford.  

    Although I have gotten this approach to work it hasn’t been easy and the lack of a degree is a mark against me in interviews.

  2. Mike Borozdin says:

    Hey Steve!

    I think this is a good idea.  CS degree is more like a doctorate and an SD degree would be like a nurse-practitioner.  It’s really just a matter of what people want to get into.  Right now the "nurses" in software really don’t have a validating degree.  The nurse-practitioners could also take on some additional requirements such as using photoshop, doing technical writing etc. The CS degree would be all about OS-level development, mathematical correctness and maybe even involve exposure to chip design.  The CS degree of that sort is what UW teached when I got my degree there.  The SD/nurse degree is what Business/IT department taught.

  3. SteveRowe says:

    @Mike, I think you have the SD degree wrong.  It’s not what is taught at Business/IT departments.  It’s hard-core, but about programming, not about formal models.  It would be OS courses and Database courses and Compiler courses, just not computational theory courses.

    Let’s take an example from UIUC.  The security courses there teach a lot of formal proof methods.  They don’t teach about buffer overflows or cross-site scripting.  Yet most people doing real security work today are worried more about implementaiton problems than provably correct algorithms.  We teach people to invent AES in a CS program, but unfortunately, we aren’t teaching people to implement it.  We need to do both.

  4. Maurits says:

    I have to bring up the Latin analogy that Joel did to death (and that Paul Graham did to death before him) because I think it’s unintentionally apt.

    Despite what Joel and Paul have said, the virtue of Latin is not that it’s hard.  If that was good enough, there would be Sudoku courses.

    The virtue of Latin (and to a lesser extent, Greek) is that it is a common source of much of "intellectual" vocabulary… that it is very close to an intersection of English, French, German, Italian, etc., etc.  If you learn Latin, you will have a tremendous head start in learning a whole plethora of other languages… including, perhaps, some English words that would otherwise have been too, um, sesquipedalian.

    Why do I bring this up?

    Because I see a tremendous pitfall in the path advocated by this blog post and by Joel’s blog post.  

    I agree that the only way to learn programming is to, well, program.  Granted.  Any CS curriculum that teaches exclusively proof methods is too esoteric for its own good… it will produce students that can /read/ code, but will be totally at a loss when it comes to /writing/ code.  It is critical that a person with a CS degree should be able to write a program like "given two strings, find the longest common substring" and have it "just work" within, say, an hour.

    But I argue that heading too far in the other direction has its drawbacks too.  A curriculum where students do nothing /but/ program will produce programmers that cannot do analysis… whose idea of performance testing is buying faster and faster test machines.  It is equally critical that a person with a CS degree should be able to look at a program like the one just generated and be able to say "that’s O(n*m)."

    But anyway, the reason I bring up Latin is because Latin is to spoken languages as math is to computer languages.  The tools used to do analysis are independent of the chosen language.  You can do analysis of a Java program using the same math that you use to do analysis of a C++ program or a Ruby script or a Perl library or …

    So learning math may not get you all the way towards being a Ruby on Rails programmer… or a Python programmer… or a C++ programmer… but the skills you learn in math will serve you well no matter what language Fate may dump in your path.

    Which brings me to the pitfall.

    In your OS course you’ll have to choose an OS.  And you might spend a lot of time talking about, oh, say, BSD.  And you’ll learn a lot of BSD-specific behavior… /some/ of which may translate to other OSes… and some of which may be totally misleading when attempting to apply to other OSes.  You’ve just learned French.

    In your Database course you’ll have to choose a database.  And they all use some flavor of SQL, and that’s good, because your SQL knowledge will serve you well almost everywhere in DB-land.  But presumably after you’ve learned SQL you’ll learn about the implementation of an RDBMS and you’ll learn about how indexes are built and how database engines like to do raw reads to the disk and bypass file systems and whatnot, which is very specialized knowledge indeed.  You’ve just learned Hungarian.

    The compiler course has a little more value because you’re learning how to translate one language into another, and you can’t help but discuss concepts of grammar in the large.  So good.

    But all-in-all, if you take a bunch of specialized courses, you’ll end up speaking a bunch of specialized languages.  Which is just what the employer wants, if you have the /right/ specialized language… but it doesn’t do you a lot of good if your specialized language of choice takes a dive (like Mac OS 9 did) and all that knowledge which cost you years of your life becomes useless.

    So learning math is a form of insurance as well.

  5. Tom Hunt says:

    I’d say the original point of having a 3rd option alongside "hardcore" CS, and IT (what was called CIS at my school) would be beneficial.  The Doctors-Nurses analogy doesn’t really frame it completely right, IMHO.  

    There is something missing from university CS programs that vocational schools, such as the many game schools popping up around the country, are addressing, if at the expense of the rich social environment that universities offer (non-CS classes, non-CS majors).  In CS, we learned about coding and how computers and software work.  We didn’t learn so much about Software Engineering.  At LHU, this was a special topics class where there was one project, and we were only expected to have a PPT prototype and some documentation for our project by the end of the semester.  Great for an introductory class on software engineering, however, there needs to be more.  

    A lot of people go through and come out of college thinking too big by default.  While this is great for fueling wide-eyed-bushy-tailed startups with fresh meat, this mostly has the tendency to cause new grads (including myself) to have ideas that are way too big for them to actually pull off.  It’s important to learn how to dream within one’s own abilty to complete.  Promise and deliver.  While I did take a couple of open-ended project-oriented independent studies in college that were a step in this direction, I’ve had to gradually learn how to do this on my own.  I still am (sometimes painfully), through the work I am doing now.  Thankfully, I’ve been getting some great guidance on the topic here at Microsoft.  I just wish that I could have been better prepared on this in school.  Perhaps a more project-integrated CS program could have done this.

    My $0.042,

    ~tom