I came of age in the 1980s, programming personal computers such as the Commodore VIC-20 and Apple ][e at home. Going on to study computer science (CS) in college and ultimately getting a Ph.D. at Berkeley, the bulk of my professional training was rooted in what I will call "classical" CS: programming, algorithms, data structures, systems, programming languages. In Classical Computer Science, the ultimate goal is to reduce an idea to a program written by a human—source code in a language like Java or C++ or Python. Every idea in Classical CS—no matter how complex or sophisticated, from a database join algorithm to the mind-bogglingly obtuse Paxos consensus protocol—can be expressed as a human-readable, human-comprehendible program.
When I was in college in the early 1990s, we were still in the depths of the AI Winter, and AI as a field was likewise dominated by classical algorithms. My first research job at Cornell University was working with Dan Huttenlocher, a leader in the field of computer vision (and now Dean of the MIT Schwarzman College of Computing). In Huttenlocher's Ph.D.-level computer vision course in 1995 or so, we never once discussed anything resembling deep learning or neural networks—it was all classical algorithms like Canny edge detection, optical flow, and Hausdorff distances. Deep learning was in its infancy, not yet considered mainstream AI, let alone mainstream CS.
Of course, this was 30 years ago, and a lot has changed since then, but one thing that has not really changed is that CS is taught as a discipline with data structures, algorithms, and programming at its core. I am going to be amazed if in 30 years, or even 10 years, we are still approaching CS in this way. Indeed, I think CS as a field is in for a pretty major upheaval few of us are really prepared for.
Programming will be obsolete. I believe the conventional idea of "writing a program" is headed for extinction, and indeed, for all but very specialized applications, most software, as we know it, will be replaced by AI systems that are trained rather than programmed. In situations where one needs a "simple" program (after all, not everything should require a model of hundreds of billions of parameters running on a cluster of GPUs), those programs will, themselves, be generated by an AI rather than coded by hand.
I do not think this idea is crazy. No doubt the earliest pioneers of computer science, emerging from the (relatively) primitive cave of electrical engineering, stridently believed that all future computer scientists would need to command a deep understanding of semiconductors, binary arithmetic, and microprocessor design to understand software. Fast-forward to today, and I am willing to bet good money that 99% of people who are writing software have almost no clue how a CPU actually works, let alone the physics underlying transistor design. By extension, I believe the computer scientists of the future will be so far removed from the classic definitions of "software" that they would be hard-pressed to reverse a linked list or implement Quicksort. (I am not sure I remember how to implement Quicksort myself.)
AI coding assistants such as CoPilot are only scratching the surface of what I am describing. It seems totally obvious to me that of course all programs in the future will ultimately be written by AIs, with humans relegated to, at best, a supervisory role. Anyone who doubts this prediction need only look at the very rapid progress being made in other aspects of AI content generation, such as image generation. The difference in quality and complexity between DALL-E v1 and DALL-E v2—announced only 15 months later—is staggering. If I have learned anything over the last few years working in AI, it is that it is very easy to underestimate the power of increasingly large AI models. Things that seemed like science fiction only a few months ago are rapidly becoming reality.
So I am not just talking about things like Github's CoPilot replacing programmers.1 I am talking about replacing the entire concept of writing programs with training models. In the future, CS students are not going to need to learn such mundane skills as how to add a node to a binary tree or code in C++. That kind of education will be antiquated, like teaching engineering students how to use a slide rule.
The engineers of the future will, in a few keystrokes, fire up an instance of a four-quintillion-parameter model that already encodes the full extent of human knowledge (and then some), ready to be given any task required of the machine. The bulk of the intellectual work of getting the machine to do what one wants will be about coming up with the right examples, the right training data, and the right ways to evaluate the training process. Suitably powerful models capable of generalizing via few-shot learning will require only a few good examples of the task to be performed. Massive, human-curated datasets will no longer be necessary in most cases, and most people "training" an AI model will not be running gradient descent loops in PyTorch, or anything like it. They will be teaching by example, and the machine will do the rest.
In this new computer science—if we even call it computer science at all—the machines will be so powerful and already know how to do so many things that the field will look like less of an engineering endeavor and more of an an educational one; that is, how to best educate the machine, not unlike the science of how to best educate children in school. Unlike (human) children, though, these AI systems will be flying our airplanes, running our power grids, and possibly even governing entire countries. I would argue that the vast majority of Classical CS becomes irrelevant when our focus turns to teaching intelligent machines rather than directly programming them. Programming, in the conventional sense, will in fact be dead.
I think CS as a field is in for a pretty major upheaval few of us are really prepared for.
How does all of this change how we think about the field of computer science? The new atomic unit of computation becomes not a processor, memory, and I/O system implementing a von Neumann machine, but rather a massive, pre-trained, highly adaptive AI model. This is a seismic shift in the way we think about computation—not as a predictable, static process, governed by instruction sets, type systems, and notions of decidability. AI-based computation has long since crossed the Rubicon of being amenable to static analysis and formal proof. We are rapidly moving toward a world where the fundamental building blocks of computation are temperamental, mysterious, adaptive agents.
This shift is underscored by the fact that nobody actually understands how large AI models work. People are publishing research papers3,4,5 actually discovering new behaviors of existing large models, even though these systems have been "engineered" by humans. Large AI models are capable of doing things that they have not been explicitly trained to do, which should scare the living daylights out of Nick Bostrom2 and anyone else worried (rightfully) about an superintelligent AI running amok. We currently have no way, apart from empirical study, to determine the limits of current AI systems. As for future AI models that are orders of magnitude larger and more complex—good luck!
The shift in focus from programs to models should be obvious to anyone who has read any modern machine learning papers. These papers barely mention the code or systems underlying their innovations; the building blocks of AI systems are much higher-level abstractions like attention layers, tokenizers, and datasets. A time traveler from even 20 years ago would have a hard time making sense of the three sentences in the (75-page!) GPT-3 paper3 describing the actual software built for the model: "We use the same model and architecture as GPT-2, including the modified initialization, pre-normalization, and reversible tokenization described therein, with the exception that we use alternating dense and locally banded sparse attention patterns in the layers of the transformer, similar to the Sparse Transformer. To study the dependence of ML performance on model size, we train eight different sizes of model, ranging over three orders of magnitude from 125 million parameters to 175 billion parameters, with the last being the model we call GPT-3. Previous work suggests that with enough training data, scaling of validation loss should be approximately a smooth power law as a function of size; training models of many different sizes allows us to test this hypothesis both for validation loss and for downstream language tasks."
This shift in the underlying definition of computing presents a huge opportunity, and plenty of huge risks. Yet I think it is time to accept that this is a very likely future, and evolve our thinking accordingly, rather than just sit here waiting for the meteor to hit.
Figure. Watch the author discuss this work in the exclusive Communications video. https://cacm.acm.org/videos/end-of-programming
1. Berger, E. Coping with copilot. SIGPLAN PL Perspectives Blog, 2022; https://bit.ly/3XbJv5J
3. Brown, T. et al. Language models are few-shot learners. 2020; https://bit.ly/3Eh1DT5
4. Kojima, T. et al. Large language models are zero-shot reasoners. 2022; https://bit.ly/3Ohmlqo
5. Nye, M. et al. Show your work: Scratchpads for intermediate computation with language models. 2021; https://bit.ly/3TLnfMY
The Digital Library is published by the Association for Computing Machinery. Copyright © 2023 ACM, Inc.
Agree. But even "The bulk of the intellectual work of getting the machine to do what one wants will be about coming up with the right examples, the right training data, and the right ways to evaluate the training process." might be more than what will be needed. Why wouldn't future systems largely automate this?
Also that sounds more like engineering that computer SCIENCE. Maybe a good fraction of future computer science researchers will be focussed on figuring how these systems work by analysing the behavior of small subsets of their neural networks.
Remember Ed Yourdons prediction in 1992 (see https://en.m.wikipedia.org/wiki/Decline_and_Fall_of_the_American_Programmer). Matt Walshs prediction may or may not be accurate, but the timeframe isnt always clear.
I dont think that AI means the end of programming, but I do think that it will change the way we teach computer science.
Already it is clear that we need to be teaching all kinds of new skills, such as prompt engineering and the theory and practice of data annotation. We also need to teach how to use AI to build more complex systems. Just as todays computer science students dont need to know how to implement a language like Python but need to know how to use it, CS students of the future will need to know how to use AI effectively, and that will sure be improved with formal education.
Its also clear that computer science departments will need to be at the forefront of socio-technical issues, including understanding and counteracting systematic bias in AI systems, improving access to these systems, and making sure that the benefits of AI are shared by all. These may seem like soft social science issues, but over the past decade, weve learned that its simply not possible to address these issues without a firm grounding in computer science.
Improving cybersecurity and developing approaches for respecting privacy while making use of private data are two other areas where the need for strong education and research will continue. Yes, cybersecurity defenders make use of AI, but so do attackers: we will need the combination of human-AI teams to stay ahead of attackers. In terms of privacy, it seems unlikely that AI is likely to develop fundamentally new technical or legal approaches for protecting privacy, but we will certainly need them to keep up with the technologys challenges.
I am confident that AI will only increase the demand for CS graduates.
When FORTRAN was introduced, the authors claimed that it would "virtually eliminate coding." Did it? No, but it changed what the term "coding" meant. AI tools will similarly change was "programming" means. Is that the "end" of "programming," though? Highly unlikely it is.
(See https://www.softwarepreservation.org/projects/FORTRAN/BackusEtAl-Preliminary%20Report-1954.pdf -- "Since FORTRAN should virtually eliminate coding and debugging, it should be possible to solve problems for less than half the cost that would be required without such a system.")
I agree that AI models could very well displace humans as authors of simple and complex software components. However, I would argue that already today writing the actual code is only a small part of my daily work as an software engineer. Much of it is indeed spent discussing (and also finding) the correct requirements (or stories), devising the architecture, writing documentation and generally thinking about how to keep the code base maintainable. Thus, I think that "the bulk of the intellectual work of getting the machine to do what one wants will be about coming up with the right examples, the right training data, and the right ways to evaluate the training process" is probably very true, but I would say that that is already a large part of what I do as a software engineer - although maybe in a different form.
The alternative is to use speech, which is certainly an information bearing medium, as a Turing Complete mechanism, by embedding an orthogonal boolean signal (Ok, . or Sorry, ) to act as a conditional, and to create loops by recursion. This follows the symbolic logic of C. S. Peirce as applied by Ogden and Richards in 1923, and the Pragmatic linguistics in the 1950s. More detail on how this works is further detailed in:
However, what this solves is the age-old problem of software engineering: the need for a written artifact. Even the above article alludes to writing a program and neural-nets requiring a few keystrokes, it comes so easily! The inductive process the creation of meaning can be described, or programmed by voice, by what an utterance implies. This too is simple science and so is evidenced by open experiment: a simple demonstration, currently with 504 unit test examples, is available at https://bitbucket.org/martinwheatman/enguage/src/develop/ (and at a similar location on github!)
It took 100 years to get from the idea of Babbages Analytic Engine to Turings idea for the Universal Machine. Perhaps it is fitting that Ogden and Richards published their Meaning of Meaning in 1923? It is here, it is now. Enjoy.
Having used ChatGPT to help me writing code for a complex project, not just some toy CS intro examples, I found many cases where ChatGPT provided some amazingly great support beyond other resources such as StackOverflow. But, as others have found themselves, it can also produce answers that are simply wrong and do so with great confidence. In some cases it took me a long time to debug. My more general insights are these:
1) New Skills. CS competence models of the past have focused on the ability of students to ANSWER QUESTIONS. In the post-GPT era competence may need to be reconceptualized as ability to POSE QUESTIONS. The quality of an answer produced by ChatGPT is somewhat proportional to the quality of the question posed. And to ask meaningful follow up questions. Making effective use of tools such as ChatGPT develops a modern form of dialectic. This is a good thing. Entering the workforce and working in teams, past students will have to be able to master this kind of dialectic to work with fellow humans as well as with AI. In the long run, this kind of competence is likely to be more important than knowing some detail regarding a certain algorithm or specific programming language.
2) Shift in CS University Education. Working on real projects professional programmers already find value added by current AI programming support systems such as Copilot and ChatGPT. This value will only go up over time. It makes no sense to hide or forbid these systems in (not only CS) education. These systems provide new kinds of affordances that we do not fully appreciate yet. Our current mechanisms of CS skill assessment will not work well in the post-GPT era. Like it or not, students will use these new tools but in contrast to Google/StackOverflow-based approaches, there are no anti plagiarism tools to support educators. Tricky times ahead. A shift towards more project-oriented, higher level skills could help. Project portfolios instead of low level coding exams. If you want to become an architect you would not be judged how well you can hammer in a nail either.
3) Shift towards Explicative Programming in K-12 Education. Maybe The End of Programming will come to K-12 education as long as programming is only considered a recruiting mechanism for the CS education pipeline. To this day, programming is still not well received in K-12 education mostly because it does not provide measurable benefits towards non-CS subjects relevant to schools. In the post-GPT era K-12 programming with this career oriented focus, will become an even harder sell. Explicative Programming (), in contrast, is about the use of programming to develop the understanding of powerful ideas in other disciplines such as STEM, music and art by building interesting artifacts. Programming as instrument of thought is about thinking WITH computers. This kind of programming is will not end. It is about to begin.
Practitioner's experience and comment
"I'm a pretty decent programmer. Good enough that I've made a career out of it and none of my code will (likely) ever make it to the Daily WTF. But there are programming concepts that I've always struggled to understand because frankly, the documentation is obtuse and hard to parse, and it wasn't really worth my time.
For instance, the Wikipedia entry on monads is frankly just obnoxious to read. I program in elisp a bit, so trying to understand monads is mostly about satisfying some curiosity, but something about the article just doesn't click with me and I have to move through it really slowly.
I've also asked it to document some elisp functions that I've always thought were poorly described (emacs' documentation can really be hit or miss) and it really did a great job.
I'm not so arrogant as to say that these models won't one day generate a lot of good, usable code, but I honestly think that this ability to collate a tonne of data and boil it down to something understandable could fill in the gaps in a lot of documentation. The longest, most tedious parts of my job very often boil down to research for some engine-specific feature that I need, or some sort of weird platform quirk. For publicly available engines like Unreal, this will honestly improve my productivity quite a lot."
I'm not ruling out the idea that traditional programming might one day be replaced by AI, but I think there's a much bigger hill to climb than this article would seem to indicate. As I see it, there are two major jobs of a programmer:
1 Designing a program (including gathering requirements and writing the code)
2 Ensuring that the program works as intended (including not only testing, but troubleshooting issues as they arise)
Even if we fiat that AI will one day write clean, efficient code for any task assigned to it with little or no programming involved, that still leaves the second of those tasks to be accomplished in its entirety. I'd argue from an epistemological standpoint that doing so necessarily requires human input on some level; there will need to be a human with the domain knowledge necessary to verify that the program is behaving as intended.
Perhaps not the end of programming but programming as we know it today. Moving away from coding to "true" software engineering to solve problems and build solutions more economically, faster, and at higher levels of productivity and quality, while producing a powerful developer's experience.
Having been in this industry for over 50 years at one time this would have been nirvana and pie in the sky but at this juncture, it is quite refreshing and exciting to still be in the industry as this becomes reality. This a good article that opens the door to new possibilities and feeds a mindset for growth.