The Continuous Watering Down of Computer Science

Posted on March 13, 2011



As anyone that churns code for a living knows, it is incredibly difficult to find job candidates that can demonstrate a modicum of CS and engineering common sense. We would suspect that the perils of Java Schools are painfully clear and visible. And yet, in typical fashion, CS schools and CS instructors keep missing on the fundamental reasons (which are many) for the cause of this. Perhaps it is a sign of our culture and its fascination with turning education into a caricature, I don’t know.

As reported in Slashdot, there are CS professors that actually argue against the teaching of Calculus in a CS curriculum:

Are these CS professors serious?

Though it is open to question the depth and nature of the mathematical teachings required for a good CS degree, the fact that something as basic as calculus is open to question, that is something indeed troubling. I mean, who the heck believes that? And a CS professor to booth???

Seriously, what the hell?

Seriously, what the hell? Are we going to water down the discipline even further?

I won’t quote what it is said in the slashdot’ linked story. I’ll let the reader check it out and make up his own mind. After all, either we get the need for Calc in a CS degree or we don’t. That’s the conclusion I’ve arrived after many years of tiresome discussions and arguments. So, this is my line of thought on the subject.

Do you need Calculus to perform programming of barely functional applications (that compile and kind of run)? Of course not.

Do we do integration and differentiation at work? Of course not.

But neither we write poetry nor analyze the works of Twain, Shakespeare, and Hemingway  at work either. I would love to hear an argument that we do not need English Composition 101, 102 and Advanced English Composition 2xx in our curriculum… and in our line of work.

I would love to see you attempt to build a logical argument against the teaching of Calculus in CS. Why? Because we do not directly use the Calculus exercises we did in school in our lines of work, then you also must, logically, apply the same argument with every single thing that is in a typical college curriculum.

How far are we going to go? Are we also going to remove Pre-Calculus and Trigonometry, all the way into devolving into nothing more than Intermediate Algebra (if we are lucky) or something that does not include Matrices?

Why not go further and remove anything that is beyond quadratic equations – how often do we find root of second order polynomials at work? Let’s not stop there and remove polynomial division, too!!!!

I would argue the opposite, that we need more math, in addition to more exposure to multiple programming languages – compiled, interpreted, dynamic and statically typed, procedural, OO and functional and assembly – before a CS student is even allowed entry into a 3xx level course in data structures and algorithms. Industrial evidence suggest that we have more than enough everything-is-a-hammer programmers out there without the minimum analytical skills needed for coding without doing horrendous damage to their employers.

Just look around. Look at the crap quality of code that exist out there. Look at all that shit! We are literally drowning in an ever flowing sea of software shit!

We know how to build software, and yet a large number of the people that do a living in it continuously fail at it, continuously oblivious (or incapable of understanding) the things we know about building good software.

Software development and engineering is more than programming. Programming is just the set of mechanical steps for building an executable representation of a model of a system. The actions that continuously precede programming assist in build a suitable model. And by “suitable”, we mean a system that not only runs, but that is also economical, effective, maintainable, changeable, with a low defect rate  (low as dictated by the specific business context, urgency and availability of resources), a open system that allows continuous change without requiring disproportionate efforts in controlling the (systems) entropy of its structure.

Whether we like it or not, there are mental capabilities that are required for building those systems that are not confined to programming, the mere usage of programming languages and tools. The teaching of Calculus, Chemistry and Physics in any science curriculum act as

  • a filter or barrier of entry- indeed, ever discipline (science or not) requires a filtering criteria. Despite what we like to believe in our culture, not everyone is cut to be a computer scientist, or a doctor, or a lawyer, a writer, a musician or artist.
  • a field for developing analytical and scientific maturity. This is another one of those you-get-it-or-dont, and as such won’t argue any further.

Yes, you don’t need a CS degree to exhibit the analytical skills to achieve what we must when building (responsibly) systems people depend on (with their lives or economically). Those skills can be either innate or explicitly cultivated in one way or another by most science and engineering degrees. But those skills exist, they are undeniable, and the continuous unfounded denial of them in industry and – sadly now – in academia is the ultimate culprit of the decrepit, cost and operational ineffective state of software and the software industry and profession.

I’ve never done any integration or differentiation, but for sure as hell I’ve relied on discrete mathematics, set theory, logic and automata theory for getting my work done consistently, even in IT! Not much so that I build something, but to stop people for attempting the building of things that are impossible, or computationally expensive under production load. There is no freaking way in hell that one can go through those mathematical disciplines without having the knowledge and mathematical maturity that you get through differential and integral calculus.

Good software engineers, good computer scientists (not just coders) ultimately rely on these skills day after day, in manners both implicit and explicit, for building models of systems, and for efficiently capturing those models in code. And there is no way in hell that you can do so without a formal, Calc-based education…

… unless you are a genius and which case none of this applies to you.

The current model of software work that plagues the industry is nothing more than an assault of a horde of monkeys flinging shit at their monitors, bundling what sticks and deploying it to their (typically unsuspecting) users, economical costs and consequences be damned.  No amount of senior, capable engineers can counteract that. We must move away from that model.

The industry needs rigorous methods for building software, not the shit-flinging code monkeysm that we have been flagellating ourselves for too long. And by rigorous I do not mean formal verification and validation, but evolving, adaptive practices that are build on formal skills and foundations, on good mathematical understandings and models of software, hardware, computation, systems, science and engineering, however implicit and indirect their influence might be.

Watering down the mathematical underpinnings of undergrad Computer Science curricula is a step in the wrong direction. There is nothing in the 60+ years of Computer Science, software building and industrial evidence that could even remotely suggest, in any logical manner, that this is a good idea.

It not only a bad idea, it is ill-advised, plain stupid and ultimately dangerous, incompetent and cost-ineffective.