Computer Science Education: Teaching the Machine

Zusammenfassung

For most of computing’s history there was no agreed way to teach it. Programming was learned on the job, from manuals, or not at all. Building a discipline of computer science education meant answering two stubborn questions at once: what should a child learn about computers, and what should a professional? The first thread runs from Seymour Papert’s Logo and his 1980 manifesto Mindstorms — the radical idea that children should program the computer rather than be programmed by it — through Scratch and the global “everyone should code” movement. The second runs through formal credentials: the Advanced Placement Computer Science exam (first given 1984), university curricula, and then the explosion of alternatives in the 2010s — coding bootcamps, MOOCs, and Code.org’s Hour of Code. Across forty years the field swung between two visions: computing as a liberal art that teaches thinking, and computing as vocational training that produces employable programmers.

Papert and the Child Who Programs the Computer

The intellectual foundation of computing-for-children was laid by Seymour Papert, a mathematician who had worked with the developmental psychologist Jean Piaget before joining MIT and co-founding its Artificial Intelligence Laboratory.

In 1967 Papert and colleagues created Logo, the first programming language designed for children. Its most famous feature was the turtle — first a floor robot, later an on-screen cursor — that children commanded to draw by moving forward and turning. A child writing FORWARD 100 RIGHT 90 four times discovered they had drawn a square, and in doing so had learned something about geometry, angles, and procedure by building rather than being told.

Papert’s 1980 book Mindstorms: Children, Computers, and Powerful Ideas turned this into a philosophy. He attacked the prevailing model — what he called “the computer being used to program the child,” drilling facts through software — and argued for the inverse: the child programs the computer. His theory, constructionism, extended Piaget’s constructivism with the claim that people learn best when actively building something shareable in the world. Debugging a program, Papert argued, taught a healthier relationship with error than school did: a bug is not a failure to be punished but a problem to be understood and fixed.

Powerful Ideas

Papert’s phrase “powerful ideas” captured his goal. He did not want children to learn to code so they could get jobs. He wanted coding to be a vehicle for big transferable concepts — recursion, procedure, systematic debugging, thinking about thinking. This framing — computing as a way to learn how to think, not a vocational skill — would resurface decades later in the term “computational thinking,” and it remains the central tension in the field.

The Formal Track: AP, Curricula, and Pascal

While Papert pursued computing as childhood epistemology, a parallel and very different project built formal credentials for older students and professionals.

In the United States, the College Board introduced Advanced Placement Computer Science, with the first exam given in May 1984. Its choice of teaching language tracked — and lagged — industry:

Pascal, 1984–1998 — the language Niklaus Wirth designed expressly for teaching structured programming.
C++, 1999–2003 — following industry’s move to object orientation.
Java, since 2004 — reflecting Java’s dominance in enterprise software and its memory-safe, object-oriented design.

The AP CS sequence later split. AP Computer Science A remained a rigorous Java programming course. AP Computer Science Principles, launched in 2016 and developed with support from the National Science Foundation and a Berkeley curriculum (BJC, “The Beauty and Joy of Computing”), deliberately broadened the scope to algorithms, data, the internet, and impact — explicitly designed to attract students, especially women and minorities, who were put off by a pure-programming course. The split institutionalized the discipline’s two faces: programming craft versus computing as a broad literacy.

University computer science, meanwhile, professionalized through shared curriculum standards (the long-running ACM/IEEE Computing Curricula recommendations) and a canon of foundational courses — data structures, algorithms, operating systems, theory of computation.

Scratch and the Return of Constructionism

Papert’s ideas did not stay in the 1980s. They were carried forward by his student and colleague Mitchel Resnick at the MIT Media Lab.

In 2007 Resnick’s Lifelong Kindergarten group released Scratch, a free visual programming environment in which children assemble programs by snapping together colored command blocks — eliminating syntax errors and letting beginners focus on logic and creativity. Children build animations, games, and interactive stories and share them on an online community, an explicitly social, constructionist design. ScratchJr (2014) pushed the idea down to ages 5–7, replacing words with pictures.

Scratch became the default first programming language for a generation and one of the most-used educational tools in the world. The programmable LEGO robotics kits LEGO Mindstorms — named directly after Papert’s book — extended the same philosophy into physical building. Papert’s bet that children should be makers, not consumers, of computational artifacts had become mainstream.

The 2010s: Bootcamps, MOOCs, and “Everyone Should Code”

Around 2011–2013 the demand for programmers outran the supply that universities could produce, and three new institutions appeared almost at once to fill the gap — bypassing the traditional degree entirely.

Coding bootcamps first appeared in 2011: short, intensive, vocational programs (typically a few months) that promised to turn beginners into employable web developers. Schools like Dev Bootcamp, Hack Reactor, and General Assembly sold a sharp contrast to the four-year degree — fast, job-focused, expensive, and explicitly transactional. They embodied the vocational pole of the discipline in its purest form.

MOOCs — Massive Open Online Courses — exploded the same moment. In fall 2011 Stanford’s Sebastian Thrun and Peter Norvig offered their Introduction to Artificial Intelligence free online and enrolled over 160,000 students worldwide. The scale stunned everyone. In 2012 — “the year of the MOOC” — Thrun founded Udacity, Stanford colleagues Andrew Ng and Daphne Koller founded Coursera, and MIT and Harvard launched the nonprofit edX. Harvard’s CS50, taught by David J. Malan, became one of the most popular courses on earth, online and on campus alike.

Code.org, the advocacy nonprofit founded by Hadi and Ali Partovi, launched in January 2013 with a viral video arguing every student should learn to code. That December it ran the first Hour of Code during Computer Science Education Week — a one-hour, drag-and-block tutorial (built on Blockly, a Scratch-like system) aimed at demystifying programming for tens of millions of students. The campaign’s deeper goal was political: to get computer science taught as a core subject in K–12 public schools, the way math and science are.

Two Visions, One Field

The 2010s wave exposed the discipline’s permanent fault line. Bootcamps and “learn to code for a job” rhetoric pulled toward vocational training: computing as a ticket to employment. Code.org’s “CS for All” and the AP CS Principles redesign pulled toward broad literacy: computing as something every citizen should understand, like reading or arithmetic. Papert’s original vision — computing as a way to think powerful thoughts — sits underneath both, claimed by neither completely.

Dead End: Logo’s Unfulfilled Promise

For all his influence, Papert’s most ambitious claim largely failed in practice.

In the 1980s, fueled by Mindstorms and cheap school microcomputers, Logo swept into classrooms. Papert believed that immersing children in a programming environment would transform how they thought — that the cognitive benefits of debugging and procedural reasoning would transfer broadly to other subjects. Schools bought turtles by the thousand.

The transfer mostly did not happen. Influential studies in the mid-1980s found little evidence that learning Logo improved general problem-solving or planning skills outside of programming itself. Critics argued that simply giving children Logo, without carefully designed teaching around it, produced little — exposure was not enough. The grand claim of automatic cognitive transformation collapsed, and Logo faded from classrooms in the 1990s.

But the dead end was instructive, not total. The failure was attributed to how Logo was deployed — dropped into classrooms with untrained teachers and no curriculum — rather than to the underlying idea. Scratch’s later success drew the lesson: the constructionist tool needs a designed community, social sharing, and pedagogical scaffolding around it. Papert’s vision survived; the naive 1980s version of it did not. The question he raised — whether learning to program makes you a better thinker, or just a better programmer — remains genuinely unsettled.