If you are a software professional, you probably have a degree in Computer Science or a related field. Most likely, you also had some confusion early in your career as you were thrust into a lot of situations for which your education did not prepare you: instead of working with algorithms, you were working with customers, for example.
Since the dawn of this century, there has also been a push in our field to outsource work to cheaper locations such as China and India. Westerners with our university educations and high standards of living in locations such as the United States, United Kingdom, Canada, and Australia are expensive. Why pay a software professional in the West USD$50 per hour when Indians and Chinese will do it in the East for USD$3 per hour?
These problems may seem unrelated, however, they are inexorably linked.
Computer Science education teaches fundamentals of software: data structures, algorithms, discrete math, et al. There is even some programming thrown in. Software Engineering is a discipline which has existed for decades but relatively recently matured as a degree program in the 1990s. It overlaps part of Computer Science while adding rigorous methods for estimating projects, measuring quality, and generating and using metrics in general. At the graduate level, both disciplines focus on preparing students for research in academia rather than further enhancing “real world” skills.
However, a lot of software development is relatively easy grunt work. Knowledge of advanced algorithms is not required when a technical specification states how the software should be implemented. Looking back at outsourcing, much of the design work is performed by expensive Westerners while the implementation is farmed out overseas to cheaper locations.
The market tells us that there are two aspects to writing software: design and implementation. Design is worth spending money on, implementation is not. Yet our education system in the West does not reflect this dual requirement: there is no cheaper “implementation” degree or career. Instead, we rely more on the junior to senior progression where junior team members perform more implementation, while senior team members perform more design.
I propose a slight tweak to the existing degree paths, an addition of a new educational path, and a fundamental change to how we approach hiring and career progression.
Add a new “programmer” certificate
First, create a new “programmer” certificate. This would operate similar to the trade schools that produce electricians, plumbers, auto mechanics, and the like. They spend a few months in school learning about their trade, with some real-world hands on apprenticeships. Then they move on to the real world as journeymen, still attending classes but less frequently. Eventually they may take a test and become a master of their trade.
Programming should be the same. In-depth knowledge of B-trees and sorting algorithms is simply not required for the vast majority of modern software. When a programmer needs to sort some data, a language’s standard library often provides a black-box implementation that is highly-optimized and performs better than what 99% of programmers could concoct themselves. Programming in the modern world is all about abstractions and reusable components, and piecing them together to produce a finished product. Computer Science is overkill for this task.
This particular career path would not pay as well as the other two: it has lower entrance requirements, and by and large its constituents are replaceable cogs in a machine. Sorry if that sounds insensitive, but it is already true: this proposal is simply the aligning of our education with the reality of our profession. At least with cheaper wages we could hopefully employ more Westerners.
Focus on Software Engineering, not Computer Science
For those who currently have Computer Science degrees and work on design, I propose future students should instead take the Software Engineering track. If our Software Engineering programs were to add more classes on software design, this would produce well-rounded individuals who can work with customers, produce accurate requirements, good designs, and measure productivity and quality.
I also believe Software Engineers should focus on being real engineers: that is, take classes in the big three (electrical, chemical, mechanical) and take the Professional Engineer exam. This is especially important for Software Engineers who want to work on systems that may impact human life: medical devices, rocket guidance, avionics, et al. If I am a passenger in an airplane, I would feel better knowing that an actual Software Engineer approved the autopilot and guidance software that flies the airplane because the software was proven to meet requirements the same way a bridge design is approved by a Professional Engineer to meet requirements. (Did you know that modern commercial airliners can take off, fly, and land fully automated, using, of course, software?)
Computer Science still has a role
We still need Computer Scientists. These are people who would be at the same high level as the Software Engineers, but more focused on design, algorithms, and technical details of software: they would help bridge the gap between the programmers and the engineers. For those rare cases where we do need a highly-optimized and custom sorting algorithm, they would be the ones to identify that a new algorithm is required, do the math to show how existing algorithms could be improved for the specific problem, design the algorithm, then prove that the new algorithm has better performance.
Of course, specialized software would need a team of these people, just as they already do. I am sure Oracle employs many Computer Scientists to design and tune their flagship database engine, for example. Google likely employs teams of them to create new searching algorithms for their flagship search engine. However, as anyone in the industry knows, 99% of software developers do not work at these big, well-known companies.
Will this ever happen?
Will we see this shift happen? Probably not. Quite simply, there is an immense amount of inertia to keep the status quo of educating programmers in Computer Science, and outsourcing the grunt work to cheaper countries. Combine that with no union, guild, or trade organization that represents professionals, and there is no leadership to push in that direction. Programmers are notoriously independent, and we are unlikely to see any change here. Note: the ACM and IEEE are the closest we have to trade organizations, but they focus more on academia (ACM) and standardization of protocols (IEEE).