Does the tech world need computer science? Not the computers or the chips, but the abstract collection of theories taught in universities with departments sporting that name. Not science in general, but the idea of thinking about programming with a theoretical lens.
The question becomes trickier now that AI will be quickly putting us all out of business. AI will be able to think deeply about computing ideas so we don’t need to. They can already keep track of billions of tidbits of knowledge. Is there any point to computer science as a discipline if we can ask the AIs to build something majestic while we nap?
It’s not that the field of computer science hasn’t delivered. There are petabytes of LaTeX files filled with brilliant ideas, like new programming languages, clever search algorithms, machine vision algorithms, and millions of notions in between. Many are even wonderful.
The problem is that few of us really need much of it. One friend confessed he’s watched a development team flourish by passing over CS graduates and hiring only physicists, accountants, or any other math-savvy person. These new employees are more practical about getting the machines to deliver, which is all most businesses want to do.
It’s not that pursuing a CS degree or hiring someone who has earned one is a misguided effort; it’s just that it may not be necessary for the problems most companies need to solve. Here’s a rather incomplete list of why IT hiring managers might be better off ignoring them.
LLMs are changing what programming entails
Some snobs call them “stochastic parrots.” Others claim they’re just clever compression mechanisms. But they’re pretty good at knowing how to program. They make mistakes and hallucinate API calls that don’t exist, but overall they save me hours of reading documentation.
When I use them — which is every day — I find I’m three to ten times faster. Not only that, I can forget entire courses. I needed a data structure the other day and the LLM suggested the right one. Then it wrote the code for that data structure in a language I barely know. Two complete semester courses replaced by machine learning.
No-code tools are proliferating
Computer scientists can pat themselves on the back for putting themselves out of work. The world is awash in low-code and no-code tools that do much of the work that kept programmers occupied even a few years ago. Now that LLMs are adding more leverage to these stacks, they’re more powerful than ever.
The solutions aren’t perfect. They still fail or fall short, but they keep getting better. And they dramatically reduce the need for heroic human efforts. We’re more caretakers and curators of a data assembly line than data-herding cowboys on a long, solitary cattle drive.
Theory distracts and confuses
Many computer scientists are mathematicians at heart and the theorem-obsessed mindset permeates the discipline. One theoretician told me all mathematical proofs are just programs and vice versa, at least in his mind. He’s not interested in delivering code that does the work as much as proving his code is correct. Okay.
It’s rare for a CS major to graduate without getting a healthy dose of NP-completeness and Turing machines, two beautiful areas of theory that would be enjoyable if they didn’t create bad instincts. A biologist once asked me to solve a problem in DNA sequence matching and I came back with the claim that it was NP-complete, a class of problems that can take a very long time to solve. He didn’t care. He needed to solve it. And it turns out that most NP-complete problems are fairly easy to solve most of the time. But theoreticians are obsessed with the thin set that confound the simple algorithms, despite being rarely observed in everyday life.
Turing machines present the same problems. Dutiful CS students learn nihilistic results like Rice’s Theorem, which shows that we really can’t analyze computer algorithms at all. But Turing machines are a pretty bad model for how regular machines operate and it’s relatively easy to create software that does smart things with our code. Any CS major who doesn’t take these theoretical results with a dose of salt risks giving up when a perfectly usable answer is close at hand.
Academic languages are rarely used
The academy can breed snobbery and a love for arcane solutions in every field. When I asked an MIT graduate his favorite language, he proudly told me he was sure I had no idea what it was. After I pushed a bit, he relented and said it was CLU. He was right.
There are many great ideas out there from those obsessed with languages, but sometimes these ideas create clutter and confusion. If one team member loves an odd feature and includes it in the code base, everyone is going to have to learn it. Just a few of these, and the time to get up to speed is brutal.
This is why Google chose the low road when it built Go. The creators insisted that the language should have few constructs and be simple to learn in the shortest possible time. That way everyone can know the core very well.
Many CS professors can’t program
One of the dirty secrets about most computer science departments is that most of the professors can’t program computers. Their real job is giving lectures and wrangling grants. They understand spreadsheets and grant proposals, not actually writing code. This is why god gave them grad students. The last time many of them actually programmed a computer was when they were in graduate school. Since then, bit rot and cobwebs have set in and the compilers on their machines probably won’t start.
Many required subjects are rarely used
Data structures are often the main topic for the students’ second course in computer science. But few of us use many data structures anymore. We plop things in object hash tables or push them into a database that does the thinking for us. It’s still useful to think about the algorithmic complexity, but very few people need to worry about B-trees or linked lists. Not only that, but many of us have realized we’re better off trusting a standard library. It’s too easy to make mistakes fiddling with data structures. Many organizations forbid roll-your-own data structures for good reason.
There are many other examples in the classic curriculum of subjects that aren’t important anymore. They’re used, but largely automated. Compilers are complex and essential, but the only people who write them are students forced to create toy versions in a semester-long course. Even Apple used stock open-source tools when it created the compiler for Swift.
Mathematical models take us down the wrong path
Anyone who’s learned database theory has discovered the cleverness of Boyce–Codd Normal Form, the way we break down an elaborate data structure into small tables. It’s very elegant and efficient — until you wait forever for a response to your SQL query filled with JOIN commands.
Most developer teams quickly learn to “denormalize” their databases to improve performance. They strip away all the cleverness and stick the data in one huge table. It’s ugly and wasteful, but often screamingly fast. And disk space is cheap.
Once they put their education into practice, many developers spend a few years unlearning all the mathematical cleverness from their CS courses.
Institutions breed arrogance
The very nature of academic degrees is designed to give graduates the ability to argue one’s superiority with authority. But even on the best days it’s hard to know what’s really right, especially in a fast moving field.
One person I worked with loved the “coding standards” he brought to the department, taking every opportunity to cite the standards during code review. These standards amounted to fussy opinions about where to place white space, but speaking of them with academic precision, he wielded them like cudgels. He would ding code with the ominous claim that it didn’t meet standards. And so we were all stuck counting white spaces so everything could fit some quasi-academic standard.
Many modern skills are ignored
Most modern skills aren’t covered in many CS departments. You’ll find very little Node.js, React, game design, or cloud computation in the typical curriculum. An average schools’ course list concentrates on the fundamentals — deep concepts like race conditions that will be part of computing well after words like Node.js or React are forgotten. That’s a noble goal, but 99% of what most programmers do is wrestle with the idiosyncrasies of the current buzzword du jour.
It’s common for computer science departments to produce deep thinkers who understand some fundamental challenges without any shallow knowledge of the details that dominate the average employee’s day. This is why companies find it just as worthwhile to hire someone from a physics lab who used Python to massage some data streams from an instrument. They can learn the shallow details just as readily as the CS genius.
The academic cutting-edge is long in arriving
Machine learning and artificial intelligence are all the rage and many are racing to experiment with them. But they’ve been studied for decades by CS departments. Does it make sense to investigate all the ideas emanating from the schools today — or wait patiently until they’re finally ready for general use?
Tenure can breed complacency
There are wonderful reasons behind the institution of tenure and most professors who enjoy its protections deserve all the benefits for their contributions way back when. The problem is that in fast-moving fields, today’s students have little need for the insights of even a decade or so ago. Yet tenure guarantees that many of the professors will be ten, twenty, even thirty years past the days when they had the greatest insights.
There are also the distractions that can lead professors away. One tenured genius seems to blog endlessly about poker tournaments and the bad beats that sent him home. Another has invested in a minor league baseball team and brags about hanging out with the ball players and shagging balls while they take batting practice.
Intellectualism rarely produces results
When I told one tenured faculty member that one of my students landed a job thanks to a few lectures on Angular and React, he smiled and said, “The last thing I want to do is turn this into a trade school.”
That’s fine, but there aren’t many who can justify spending close to half a million dollars on wondering whether polynomial or exponential angels can dance on the head of a pin. The liberal arts tradition is a wonderful thing, but it encourages a disdain for practical knowledge. It’s all about some deep, eternal truths. But when your company has to ship something next week by the deadline, no one has time to navel gaze and wonder about eternal truths.
Read More from This Article: 12 reasons to ignore computer science degrees
Source: News