Computing Education

Computing education is the study and practice of how people learn to program, design, and reason about software.

12 frameworks, from 1955 to today · Software Engineering · Computer Science

still a working view ended · each leads to its entry below

Overview

Computing education is the study and practice of how people learn to program, design, and reason about software. It matters because software is now infrastructure—banks, hospitals, elections, and schools run on it—and because the gap between what a beginner can do and what a professional must do is unusually wide. Unlike mathematics or physics, computing has no centuries-old school curriculum; its teachers have had to invent, decade by decade, what should be taught, in what order, with what tools, and to whom. That invention is the history below.

Programming as a Mathematical Discipline, 1950s–1960s

The first computing courses were taught to mathematicians and engineers who already knew how to think formally. Early programming was taught as applied logic: flowcharts, algorithms, and the careful transcription of a procedure into machine instructions. The dominant belief was that programming was a branch of mathematics, and that a good mathematician would become a good programmer.

A concrete expression of this view was the development of ALGOL 60, whose report (1960) introduced block structure and recursion in a notation meant for publishing algorithms, not just running them. The language was designed partly as a teaching and communication medium. In this era, "computer science" was often taught inside mathematics departments, and the first degree programs appeared in the 1960s—Purdue is often credited with establishing one of the first computer science departments, in 1962. The curriculum question was already live: was this a science, a mathematics, or a trade?

Curriculum Standardization and the Birth of a Discipline, 1968–1978

As departments multiplied, the problem became coordination: what should a graduate know? In 1968 the Association for Computing Machinery (ACM) published Curriculum 68, a recommended undergraduate program. It was followed by Curriculum 78, which organized the field into core and elective areas. These documents did two things: they gave new departments a template, and they asserted that computing had a coherent body of knowledge distinct from mathematics and electrical engineering.

The same period saw the first serious research on how people learn to program. In the late 1970s, studies of student programmers began to show that novices did not simply lack knowledge—they held misconceptions. A beginner might believe that a variable holds a value permanently, or that a loop runs exactly as many times as there are lines inside it. This line of work, later called research on novice mental models, reframed teaching: the teacher's job was not only to transmit correct rules but to surface and dislodge wrong ones. The classic demonstration came from studies of students learning recursion and assignment, where otherwise capable students built consistent but incorrect mental models of how the machine executes code.

Software Engineering Enters the Classroom, 1970s–1980s

The 1968 NATO conference in Garmisch, Germany, popularized the term "software engineering" and named the "software crisis": large systems were late, over budget, and unreliable. If software engineering was a discipline, it had to be taught. Through the 1970s and 1980s, courses appeared in requirements, design, testing, and project management, often built around the waterfall model and structured design methods.

The teaching problem was that these topics are hard to simulate in a classroom. A single student writing a 200-line assignment never experiences the coordination failure that motivates software engineering. The response was the team project course and, later, the capstone: students build a system in a group over a term, with milestones and reviews. This remains the standard way software engineering is taught, and it descends directly from those 1970s efforts to make process visible to students.

Constructionism and the Logo Years, 1967–1980s

A rival vision came from Seymour Papert, a mathematician and educator who worked with Jean Piaget. Papert argued that children learn best by building things they care about and debugging them—an approach he called constructionism. His vehicle was Logo, a programming language created in the late 1960s at MIT, famous for controlling a "turtle" that draws on screen or floor. A child could write a short program and immediately see a shape appear.

Logo's deeper claim was epistemological: programming a computer is a way of thinking about thinking. When a child's turtle draws a wrong square, the child can inspect the program, find the error, and revise their own mental procedure. Papert's Mindstorms (1980) made this case to a wide audience1. Constructionism never became the standard school curriculum, but it permanently changed the debate: it insisted that computing education is about expression and intellectual development, not just vocational skill.

Novice Mental Models and the Turn to Empirical Research, 1980s

Through the 1980s, computing education research matured into an empirical field. Researchers interviewed students, recorded their errors, and built catalogues of misconceptions. The influential work of Benedict du Boulay and colleagues (1980s) described common bugs and the "notional machine"—the simplified model of the computer a student carries in their head. If a student's notional machine is wrong, no amount of syntax correction will help.

This period also produced the "programming is hard" literature: studies showing that a large fraction of students fail introductory courses, and that prior programming experience predicts success strongly. The practical consequence was a search for better first languages and better first examples, a search that has never really ended.

Objects-First and the Design Patterns Wave, 1990s–2000s

Object-oriented programming became dominant in industry in the 1990s, and curricula followed. The objects-first approach taught encapsulation, inheritance, and polymorphism from day one, often in Java or C++, rather than starting with procedures and data structures. Its supporters argued that objects model the world naturally and that students should learn the paradigm professionals use. Critics countered that beginners cannot appreciate abstraction before they can write a working loop.

The debate was never fully settled, and later evidence suggested that the ordering of topics matters less than the quality of examples and feedback. A related wave arrived with design patterns: the "Gang of Four" book (1994) gave names to recurring object-oriented solutions, and educators began teaching patterns explicitly. The hope was that named patterns would give students a vocabulary for design. In practice, patterns proved easier to memorize than to apply, and teaching them well required realistic problems—which pushed courses back toward projects.

Outcomes-Based Curriculum Design, 2001–2013

In 2001, the ACM and IEEE Computer Society published Computing Curricula 2001, which shifted the organizing principle from lists of topics to learning outcomes: what a graduate should be able to do, stated measurably. This outcomes-based design spread through accreditation bodies and national quality frameworks. The curriculum volumes that followed—Computer Science Curricula 2013 among them—continued the pattern, and software engineering received its own guidance through the Software Engineering 2004 (SE2004) volume and later the Software Engineering Competency Model.

The underlying idea is simple and consequential: if you specify the outcome, you can assess it, and if you can assess it, you can improve the course. The risk, which critics noted, is that measurable outcomes crowd out harder-to-measure goals such as taste, judgment, and curiosity.

Computational Thinking and CS for All, 2006–2010s

In 2006, Jeannette Wing published "Computational Thinking," arguing that the concepts of computer science—abstraction, decomposition, recursion, separation of concerns—are valuable to everyone, not only future programmers. The phrase became a banner for a movement to bring computing into general education, from primary school upward.

That movement found institutional form in CS for All, a term used for a cluster of initiatives in the 2010s, including the U.S. Computer Science for All initiative announced in 2016 and the widespread adoption of K–12 computing standards. England's national computing curriculum, introduced in 2014, made computing compulsory for schoolchildren. The scale of the change was large: computing moved from an elective for the interested to a subject with national standards, teacher-training programs, and equity goals—particularly around the participation of girls and underrepresented groups.

Active Learning and the Evidence Turn, 2010s

Alongside the expansion of access came a demand for evidence about what works. Active learning—peer instruction, pair programming, live coding, worked examples followed by practice—was tested in controlled studies. A widely cited 2014 meta-analysis by Scott Freeman and colleagues, covering 225 studies in science and engineering, found that active learning improved exam performance and reduced failure rates compared with traditional lecturing. In computing specifically, peer instruction (students answer conceptual questions individually, then discuss in small groups) and pair programming were studied and adopted.

The same decade saw the rise of large introductory courses and automated assessment tools, which made it possible to give immediate feedback to thousands of students. The evidence turn changed the professional identity of computing educators: teaching was increasingly treated as a research-informed practice rather than a personal art.

Generative AI in the Classroom, 2022–Present

The arrival of capable large language models in the early 2020s—ChatGPT was released in late 2022—posed an immediate question for every programming course: if a tool can write a working function from a plain-English description, what exactly is the student being assessed on2? Educators responded in several directions at once: some banned the tools, some redesigned assignments toward design, testing, and explanation, and some taught the tools explicitly as part of professional practice. The debate is unresolved, but it has already forced a re-examination of what introductory courses are for—whether the goal is to produce code or to produce understanding of code.

Where the Field Stands

Today computing education draws on several traditions at once: the mathematical view that programming is formal reasoning; the constructionist view that it is expressive building; the software-engineering view that it is team practice under constraints; and the empirical view that teaching should be tested. Its main approaches—outcomes-based curricula, active learning, project courses, and increasingly AI-assisted instruction—descend from the turning points above. The open questions are the old ones in new clothes: how to teach abstraction before students can write working code, how to assess understanding when tools can generate solutions, and how to make computing education genuinely available to everyone rather than to those who arrive already interested.

References

  1. Constructionism (learning theory), Wikipedia
  2. Artificial intelligence in education (ChatGPT), Wikipedia

The frameworks of Computing Education

Each framework is a way of working the field has used: when it held, and the question it answers.

  1. 1955-1975
  2. 1967-1995
  3. 1968-Present
  4. 1970-Present
  5. 1978-Present
  6. 1993-2010
  7. 1994-2010
  8. 2001-Present
  9. 2006-Present
  10. 2010-Present
  11. 2013-Present
  12. 2022-Present
A city in Nousfarer: a red-carpeted stair climbing terraces to a crowned tower on an acropolis, more towers round it, forest and snowy mountains beyond.
A city in Nousfarer, the game played in the browser.

Computing Education is a planet in Nousfarer

Its city has a tower for each of these 12 frameworks. Land, walk in, and climb one concept at a time.

Land on Computing Education

Related fields

More in Software Engineering

See where Computing Education sits on the Map of Human Knowledge