Continuing on from last time, this time, I want to focus on what could be done in colleges. What courses could be taught, and what is wrong with the industrial approach as well. Again, all of these are my opinions, formed from my experiences, so yours might differ.
Why can’t there be a course which teaches you how to write maintainable software ? Concepts like separating your concerns, reducing your coupling. Using interfaces as and when necessary to abstract out unnecessary details. How about a semester or two semester long class which gives a student a chance to develop something in the first semester and maintain, add new features to it in the second. The only times I have heard of this happening is with independent studies.
And how can we forget about unit tests? This concept was rarely (if at all) touched upon during my four years in college. The only reason I had even heard of the concept was because I had participated in the Microsoft Imagine Cup and the Top Coder competitions. It sure wasn’t mentioned or required in any of my courses. Looking back, I just wonder how much easier a lot of my projects would have gotten if I had just written unit tests instead of trying to trace and debug it manually. But instead, I don’t remember it as more than a honorable mention in my Software Engineering class.
Why is such a fundamental cornerstone of software development not given more focus in college? Ideally, there would be a dedicated course talking about testing, the various aspects and kinds and when and where it could be applied. Along with practical examples and usages and projects where different kinds of tests were required. In addition, each class like Algorithms, OOAD and even Database Design would require testing of some sort of the other. Professors and TA’s could just run the submitted code against some unit tests to check for validity and only have to manually look at the code for stylistic errors or for problems.
How many fresh graduates actually get to work on something completely new and exciting? Instead, most end up joining companies which have a large and existing code base. And let me tell you, working with legacy code is rarely, if ever, fun. But guess what, this is again not touched upon in college? Working with legacy code? You are on your own again. Why? This is such a fundamental aspect of being a software developer, yet its not a skill which is even touched upon in colleges. Even letting students loose on open source projects and asking them to contribute a patch or two is good experience, but we don’t do it.
Even the industry seems to be misleading in that sense. In most of my interviews, I was asked algorithmic questions. Sure, they were nice and tough to chew on, and they give a nice, contained question that the interviewees can code up. But think about it. When was the last time a developer had to write just one method? Isn’t the requirement more often than not developing a system or contributing to one? Why don’t we ask questions which test for this? I myself have started asking design questions which test, say, a candidate’s understanding of polymorphism by asking him to design a class structure to represent mathematical operations like addition, subtraction with two methods, evaluate() and toString(). Does the candidate understand how to use inheritance, or does he end up using conditionals and switch cases instead.
It just seems to me that colleges have, to an extent, lost track of what the industry needs, and the industry doesn’t seem to be helping its cause. Introducing some of the courses I outlined above, or even incorporating it into existing coursework would give prospective graduates a leg up when they look for jobs. Its setting them up for success, and we all want them to succeed.
#1 by Mike on July 28, 2009 - 8:52 pm
What’s interesting about your post is that everything you mentioned is being covered in the Master’s program that I’m currently taking. You essentially covered the first year of coursework, while the second year will cover project management, software architecture, and some other interesting courses.
What’s frustrating is that I agree with you–it seems that much of this knowledge would have been far more valuable as an undergrad, before I had plenty of experience to draw on.
Still, at least some colleges are making strides in the right direction. I think this also shows that you’re on the right track…as computer scientists, we need to push at least some of this information down to the undergrad level.
#2 by Allen on July 30, 2009 - 11:11 am
Very insightful article. But I would like to point out, undergrad classes that cover some of these things do exist. In the new MIT EECS curriculum, the foundation class 6.005 (Principles of Software Development) focus very heavily on interfaces, decoupling, maintainability, unit testing and extensive documentation.
However, I do think it is difficult teaching testing in undergrad classes. Imagine that you’ve finally finished a huge project and can go to sleep, the Unit tests that are required would certainly seem like an annoyance and be written as an after-thought.
#3 by Anil on September 2, 2009 - 12:04 pm
Two things I think I missed in my Masters degree (and being a kernel developer now) is:
1. Lack of inception into debugging tools like gdb, kdb or OOPS. If a student gets introduced to something like this, I am sure his productivity would increase a lot. This usually isn’t the case with app layer dev with java / web-dev, but talking at the arch layer, these small tools make your life easier.
2. Many of the projects would be group projects. Most of the times, the group either does not have a common scratch space and if they do, they are not utilized in the best way possible. Having a source controller like git would help them be “industry-ready” and help coordination and again .. debugging easier !!
#4 by Shyam on September 16, 2009 - 10:27 am
Git does rock. Probably a great topic for another blog post