A NATURAL SENSE OF ALGORITHM
Children should learn computer programming as a basic skill
by Hunter Ellinger — last revised 10 Sept 2003

 

 

PART I — Can computer programming be a foundational skill?

A.  Why Spend Time Teaching Children Computer Programming?

The basic educational task for our society is ensuring that people in general have the tools they need to construct successful lives on dignified terms.  This implies that children need to learn to use the communication/control tools that can originate power and enable expression of unique talents, not just the tools needed to receive standardized instruc­tions and/or entertainment.  Artistic design, expository writing, and public speaking are such emancipatory tools. 

So is computer programming.  Failure to have children learn to teach computers how to do things (which is what programming consists of) is both a direct disservice on a par with not teaching children composition (not as bad as not teaching them to read, I admit) and an enormous missed opportunity (since many of the enabling skills most needed for successful adulthood are natural results of the task of acquiring such competence).

Among the important lessons learned during mastery of computer programming are (in alphabetical order) abstraction, adaptation of prior work (both one's own and that of others), coordination, design skills, error analysis, flexibility, independence, interdependence, invention, modulariza­tion, organization, perfectibility, precision, robustness (anticipation of possible errors), and self-criticism.  While there are other paths to these lessons (any authentic project usually addresses several of them), most are less available to children now than a generation ago both in school (due to the standardized-test-driven dominance of sterile academic material) and in general cultural experience (due to the displace­ment of self-reliant home-based activities [e.g., cooking, car repair, carpentry, sewing] by specialist-supplied ones).  The opportunities to learn to do precise work in a meaningful context suited to one's talents and interests have diminished at the same time that the career opportunities such learning provides have increased. 

People who know what it means to be useful and skilled are well situated to build successful lives for themselves and to share that success with their children and communities.  And note that this is not a matter of competition -- there's only one valedictorian, but everyone can become experts in an area that suits their talents and interests.  Since great diversity in people's roles and styles is one of the most pronounced features of adult life, a major theme in schools should be appreciation for specialization and for finding/building an effective individual style, as well as skill in working with people who have different roles and styles.  Learning to program computers promotes these lessons in a particularly clear way, especially when combined with other project-based instruction.

The creation of meaningful and flexible school contexts has also become more important as our society attempts to make schools successful in dealing with a wider range of people.  Children like those who soon abandon (or stop paying attention to) schooling will not be well served by diluted versions of the methods that drove their older brothers and sisters away.  New approaches are needed, with computer programming one of the best candidates.

In some ways I am urging a revival, under more favorable conditions, of the earlier efforts exemplified by the children’s programming language Logo.  But programming skill is now an important general-education goal in its own right as well as a bridge to mathematical competence (since many more people will have occasion to write computer scripts than to factor trinomials).    We also need to supplement the traditional Logo “turtle graphics” emphasis on geometric construction with more attention to text-related applications, especially HTML and its kin, data-oriented spreadsheet applications, and user-interface questions such as those that arise in game design.

A "basic" skill is one that persists, in elaborated and often specialized forms, into adulthood.  Such skills are thus particularly well suited for instructional strategies that make use of adult activities as motivation and examples.   Because computer programming is fast permeating the adult world, instruction in programming is now well suited to such a connect-to-the-world strategy.  This was not true at the time the initial Logo effort was launched.  Thus a new opportunity is available for teaching programming: one that builds on Logo's connections with the skills children bring from their pre-school experiences by adding new connections to adult and secondary-school skills. 

B.  The Programming Experience

While it may be attractive to think of having a marvelously complex and powerful machine at your command, the actual process of teaching something to a computer is challenging in several ways.  These challenges can be minimized by good programming languages, a well-constructed set of initial projects, and appropriate support from teachers and peers, but the basic experience is novel and profoundly educational for most people, even when the barriers to starting are removed.

Programming is meticulous.  Because computers are too stupid to understand their instructions if there are any errors or ambiguities in them, the mechanical nature of programming forces unprecedented precision and consciousness in planning and expression.  The computer is nonjudgmental but unforgiving.  When programming, a student can see that misspellings, omitted steps, punctuation errors, or inaccurate diction just don't work – there's no point in arguing about it.  Students have to abandon the “you know what I meant” excuse that is so often directed at teachers.

Programming teaches self-criticism.  When students are working on projects where they understand what action is desired from the computer, they are able to detect errors themselves – if the program doesn't make the computer do what was intended, there's an error somewhere.  But in this context (unlike usual school experience) the error is not recorded as a failure in the teacher's grade book, but is corrected.  This will usually take several tries, but that is educational in itself – correctness is constructed by sustained effort, which may include some ad-hoc investigation but has little to do with luck.  No one – novice or expert – writes programs without making mistakes.  Being good at programming just means being able to correct your mistakes efficiently and to plan your work so they are easy to find.

Programming teaches responsibility.  One of the biggest challenges novices face in programming is not so much cognitive as emotional.  It takes quite a while to accept that the mistakes in the program you write are your own, rather than those of some aspect of the computer.  This process of taking responsibility is very challenging (driving many adult novices to fits of anger), but is of great value in developing effective work, school, and life skills.

Programming is creative.  Programming has similarities to human-language composition (we talk of "writing" a program), and the activity offers great scope for design and invention in both the "specification" (what external effect the program is to accomplish) and the "code" (what internal instructions are used to produce that effect).  One can even make a case that the clarity of effect and limited vocabulary of a programming language can enable an awareness of the creative process not available via composition in regular language, whose very naturalness keeps people unconscious of the wide range of alternatives they are choosing among as they construct their expressions.  In this sense of making it clear where one is free to choose and where one is not, as well as in the attentiveness required to punctuation and syntax, programming is preparation for writing as well as for mathematics.

Programmers communicate.  While programming is generally perceived as a solitary activity, this is misleading in several ways.  For example, the choice of a goal for a program is usually the result of a discussion with peers or sponsors or both.  If a program has significant user interaction, conversations between programmers and users become a central element in the polishing phase, with users providing a form of authentic but nonauthoritarian criticism that strongly stimulates creativity.  The program design is almost always discussed with peers (in part because they will have to write or modify related programs), and peer suggestions are invaluable in discovering programming errors (they look right to the author or they wouldn't be there).

Programmers collaborate.  Typical professional-programming organization is into small programming teams that divide up the work of a project in accordance with specializations naturally adopted by team members.  This teamwork pattern is a good fit to the educational situation, where the consciousness-raising aspects of the conversations about the projects are particularly needed. 

Programmers share.  A different aspect of programmer collaboration stems from the fact that programmers constantly use the work of other programmers.  Programs are built with extensive use of named modules with specific functions (e.g., draw a hexagon) that require a limited set of inputs (e.g., position, size, color, tilt) but hide all the other details of how the effect is produced.  A typical programmer starts as simply a user of such modules (a basic set is supplied with the program­ming language, and the mentor or teacher will supply more), but then progresses to reusing modules she developed for earlier projects and finally to supplying modules to others.  The competition in usability driven by these exchanges is a major unifying force in programmer cultures.

It is because the relationships of students to such issues as these (precise expression, sustained effort to produce error-free results, taking personal responsibility for one's work, acceptance of criticism, creativity, specialized collaboration, and pride in usefulness) are of great educational importance that early experience in computer programming can reasonably be urged as a foundational skill.  Instructional time invested in this sector could be more than regained by the use of these skills in areas, such as writing and math, where they are urgently needed but not generally learned.

 

PART II — What can we learn from the failures of the Logo movement?

C.  Mindstorms -- The Logo Manifesto

            The foundational classic for this topic is Seymour Papert's 1980 book Mindstorms , which explained both his vision of the possibilities (natural communication with computers, computer-driven changes in learning methods) and his experiences in working with children in the context of the Logo language he helped develop to pursue this vision.  Mindstorms lays out an analysis of the nature of learning and programming whose central theme is that computers permit a concrete approach to formal knowledge, thus finessing several developmental difficul­ties.  While clearly rooted in the constructivist tradition based in Jean Piaget's work, Papert (who early in his career worked closely with Piaget) goes beyond Piaget's position by seeing the cultural and physical context in which a child is raised as providing important constraints and supports for learning.  One of the main goals declared for Logo is providing a "Mathland" in which a child will, by constant exposure to experiences and discussions of patterns and logical thinking, learn mathematics as naturally as she would learn French if raised in Provence.  In his 1993 followup The Children's Machine: Rethinking school in the age of the computer , Papert reinforces his original analysis and extends it by a more detailed critique of current schools.  The biggest additional factor he identifies is the "love affair" with computers that has become a major element of the lives of American children, creating new opportunities for educational reform.

While presented as a prep­aration for mathematics (or, more precisely, as a bridge from naturally-learned skills into mathematics), the subject matter of the Mindstorms curriculum is not fundamentally either computer programming or mathematics, any more than the subject matter of a literature course is grammar.  The higher-level picture is indicated by Papert's (1980, p. 54) "constructionist" principles for standards that educational topics should meet:

Continuity Principle: The mathematics must be continuous with well-established personal knowledge from which it can inherit a sense of warmth and value as well as "cognitive" competence.

Power Principle: It must empower the learner to perform personally meaningful projects that could not be done without it.

Principle of Cultural Resonance: The topic must make sense in terms of a larger social context.

Although offered in reference to mathematics, these ideas constitute a coherent philosophy with which any current or proposed instructional method or set of topics can be assessed.  One might characterize these principles as guidance for connecting to a student's past, present, and future, respectively.

            Via his "continuity" principle, Papert directs attention to the great extent and ease of acquisition of early non-schooled learning accomplished by young children in such areas as mastery of physical movement, language use, and social interaction.  This "Piagetian" learning is presented as relevant in two ways: Such learning provides the foundation for all subsequent learning, with the effectiveness of subsequent instruction primarily dependent on articulation with skills developed through natural learning processes.  The ease of early learning also indicates that school learning should meet comparable standards of ease, enjoyment, interest, and proficiency -- a proposal whose seeming impossibility reveals the pessimism with which scholastic instruction is generally viewed.

            Papert also attacks the common scholastic image of mathematics as memorization and mechanical symbol-manipulation skills.  He advances the image, much more in accordance with the experience of successful practitioners, of mathematics as the ability to generate, explore, generalize, and communicate patterns -- that mathematics is about thinking rather than computa­tion.  A related point is that there are many varieties of mathematical skill, and that no particular method or style is essential for success.

            Working from these premises, he asserts that provision of appropriate environmental supports (Logo programming in this case) that are designed to enable children to build on natural competencies can make the acquisition of complex and abstract skills, such as mathematical proficiency, as natural and compelling as preschool learning.  Further, the heightened consciousness about learning provoked by such experiences can profoundly expand a person's learning capabilities.

D.  Logo as a Language for Learning

A critical element in realizing the potential of student interaction with computers is use of an appropriate computer program­ming language.  One of the major accomplishments of the first few decades of modern computer programming was the development of programs that can automatically generate an appropriate sequence of hardware-controlling codes (like the holes in a player-piano roll) from precise but human-oriented descriptions (like musical scores).

The most effective computer languages are designed so that their modes of expression match the needs and natural style of particular sectors of users, within the current limitations of the software that converts the instruction lists into actual internal computer commands.  There are languages for engineers, accountants, lawyers, statisticians, musicians, artists, and mathematicians (among others), as well as ones aimed at particular tasks (such as HTML for web-page definition).  While almost all programming languages are able to implement procedures that produce identical results, differences in their styles of expression create differences in their appropriateness for instruction, just as the logically-equivalent Arabic and Roman numeration systems produce great differences in what arithmetic operations are actually mastered by those who use them.

The Logo programming language was designed for learning.  This is true in two senses: it is intended to be both easy to learn and easy to learn with.  The goal of its creators was a system with "a low threshold and no ceiling", suitable for use by elementary-school students but containing features that make it possible to construct programs of great power.  While some shortfalls from this goal can be pointed out, the Logo language remains an outstanding example of learning-oriented design. 

Logo's most famous element is "turtle geometry", which will be used here to illustrate how Logo can be used to support a sequence of cognitive development.  A half-dozen programming commands with obvious meanings (forward, back, left, right, pen up, PEN down, repeat) suffice to enable sophisticated exploration of several areas of mathematics (and of programming) via drawings made on paper or the computer screen.  A trail-leaving graphic "turtle" (starting at its last position and direction) moves around the computer screen in response to sequences of instructions, which are carried out as soon as they are entered, thus enabling children to figure out their meaning without trouble.  For example, the direction commands are followed by numbers giving the amount to turn in degrees (e.g., "RIGHT 45" or "LEFT 90"), but no one needs to explain degrees to the students, since they can quickly see the effects of various numbers.  A similar informal investigation calibrates the FORWARD and BACK commands, which are followed by the distance to move.

The turtle is an example of an "object-to-think-with", an educator-constructed object "in which there is an intersection of cultural presence, embedded knowledge, and the possibility for personal identification" (Papert 1980, p. 11).  Because the children are learning to tell the computer how to do something (move around and leave a trail) that they themselves already can do quite well, they are able to develop and debug their programs by "playing turtle" and observing their own actions as they either create or follow a "Turtle Talk" script.  Even simple scripts can produce significant effects: REPEAT 6 FORWARD 10 LEFT 60 END will draw a small hexagon. 

A higher level of thinking is naturally introduced by the definition of procedures that can be invoked from different portions of a program (or even from different programs).  This is described to the students as "teaching the computer a new word".  A simple example would be this definition of a routine to draw an L-shaped elbow (the initial "TO" tells the computer that it is being given a definition for later use rather than immediate execution):

TO ELBOW

            PEN DOWN

            RIGHT 90

            FORWARD 10

            LEFT 90

            FORWARD 5

END

This routine can then be invoked anywhere by simply typing ELBOW .  It (or similar routines for other patterns) might be very useful in construction of parts of the drawings that are typical early Logo projects.  Once the use of such procedures is well established, a very natural (but mathematically momentous) extension is made to permit the size of the longer line to be supplied as a variable, which is referred to symbolically in the definition but has an explicit value supplied when the routine is invoked (see below--the colon before the name indicates a variable).  The resulting routine could be invoked as "ELBOW 2" (for a very small "L") or "ELBOW 50" (for a large one).  Thus a major element of algebra is introduced as an immediately-useful tool that actually makes the definition clearer (because suggestive names are chosen for variables).

TO ELBOW :SIZE

            PEN DOWN

            RIGHT 90

            FORWARD :SIZE

            LEFT 90

            FORWARD :SIZE/2

END

Students are thus naturally led into refinement of higher-order intellectual skills, ranging from effective self-critique in the debugging process to design of concepts and their expression as program modules.  Students are also well positioned to ask (and answer by either experiment or insight) such questions as What if I change the "LEFT" to a "RIGHT "?  Change the first "90 " to something else?  The second one?  What do I need to add if I want to draw a staircase made of elbows?  How could I change such a staircase to a mountain range?

In addition to the obvious relevance for learning about angles and lengths (and the numbers used to denote them, which are now being used by the students rather than on them), programming the turtle provides an excellent context for learning about symmetry, proportionality, iteration, and symbol-denoted variables.  It seems to live up to its design goal as a bridge from naturally-learned skills (move around and mark your trail) into mathematics.

Logo supports advanced programming constructs such as iteration ("REPEAT ELBOW 10"), conditional execution ("IF :HEIGHT > 100 STOP"), and recursion (in which a procedure calls itself) in addition to procedure definition and turtle graphics.  It can evaluate mathematical expressions in numerical terms, and can process and display text expressions.  In these senses, it is a full-grown programming language capable of being used to address almost any task, although generality is no guarantee of popularity since most computer languages have specializations for particular areas of work. 

E.  Critique of Logo

Logo still seems modern and accessible compared to its contemporaries (such as Basic), and includes brilliant educational design features.  Its creators were based in the premier U.S. university for computer programming (MIT).  Pa pert had worked closely with the educational theorist who became the leading intellectual authority for U.S. precollegiate education.  It was launched just as the computer industry was beginning its astonishing history of developing cheaper, faster, and easier-to-use small computers.  It is hard to envision a more favorable set of starting conditions.

But the results have been disappointing.  The following twenty-five years have abundantly verified Papert's projections (deemed rash at the time) that computers would become cheap enough to use extensively in schools.  But his vision of the transformation of mathematics learning through widespread mastery by elementary-school students of the essential elements of computer programming has not come true.

If Logo's failure were due to discernable weaknesses in Papert's analysis, to displacement of his proposed reform method by some other effective way of producing the same broad mathematical competence, or to the curriculum never having been seriously tried due to lack of champions among the elementary-school leadership, then it would be of interest only to educational historians.  But both Papert's diagnosis of the weaknesses of traditional "School" and his prescription for transformation of it still seem (alas!) all too accurate and timely, and the Logo-based curriculum had substantial establish­ment support and enrolled a cadre of teachers with missionary zeal. 

Logo is not dead.  Updated versions making use of modern graphical user interfaces have been developed, resulting in substantial improvements in conceptual clarity (due to having separate program, graphics, and variable-trace windows) as well as in ease of use.  There are now "multithreaded" versions that can have thousands of turtles acting (and interacting) at once, providing a fascinating context for simulations and examination of emergent effects.  Logo has been adopted as the scripting language for one of the leading school-level multimedia programs; each button or menu entry can be provided a Logo routine from which multimedia components and effects can be invoked.  Limited uses of Logo (focused on turtle geometry) have been incorporated in several textbooks.  But all this adds up to keeping the dream alive for a limited group of enthusiasts, not to the revolution planned by the Logo pioneers, although clearly that revolution is still needed.

What has kept Logo (or a variant or successor) from becoming a major element of elementary education?  While no doubt the perils of the typical reform trajectory (oversold, under­supported, co-opted, misunderstood, forgotten) have taken their toll, the primary causes seem to me to stem from a failure to fully address Papert's "cultural resonance" principle -- the "larger social context" of secondary school and adult life is neglected.  While the connections of Logo to children's previous experiences are excellent, its connections to their later experiences in school and the world are weak.  How might they be strengthened?

 

PART III —  What approaches might bettter promote children's programming?

F.  Escaping the Turtle Ghetto

While turtle graphics is a marvelously useful tool for introducing programming, drawing pictures is only a minor element in subsequent work in school or life.  Even when pictures are to be drawn, the differential geometry of the turtle is less common than other methods: analytic geometry, raster graphics, lists of geometric primitives, or the use of presentation-graphics utilities.  Analytic-geometry methods are particularly relevant for school, since the graphing of mathematical relationships is one of the great pedagogic opportunities to integrate different modes of description.

One natural connection between turtle-type drawing and analytic methods would be the support of parametric equations, where a student could specify the position of the turtle as a function of time, with a separate equation for each coordinate.  One very attractive feature of this approach is that it is easy to support a variety of coordinate systems: cartesian, polar, cylindrical, or spherical (also differential or absolute) -- the user just types the appropriate coordinate symbol in the coordinate equation.

Since it is the foundation of much subsequent work, graphing of cartesian functions needs to be particularly well supported, with mechanisms for finding intersections of graphs with each other and the axes.  A variety of good interaction and presentation methods have been worked out in different graphing-calculator programs; what is needed are appropriate commands in Logo (or at least in a middle-school variant of it) to use them.

Euclidean geometry has its own set of issues that need appropriate support in the software.  The target here is to provide transitions from naïve drawing commands to systems such as Geometer's Sketchpad.  This might be provided either by extensions to Logo that would permit users to define graphical entities and relationships between them or, probably better, by adding a scripting element to Sketchpad for which Logo is a good preparation.  Since the balance among design elements shifts with different applications and different levels of programmer sophistication, installing a Logo-similar scripting capability in a higher-level software package will often be preferable to adding substantially more capability to Logo itself.  But, where feasible, it will help students if some precursor of a feature has been encountered in an earlier language.

G.  Words Can Be Worth Thousands of Pictures

Most of school is about concepts, propositions, assertions, deductions, commentary, and arguments that are expressed in words, not pictures.  This is rooted in the fact that thinking mediated by language usage is the preeminent human skill.  While the initial emphasis of Logo on geometry is soundly based in the sequence of children's cognitive development, verbally-expressed knowledge increases in relative importance as socially-constructed scientific concepts are learned to connect and organize the natural concepts and skills learned earlier.  Care needs to be taken that the uses of programming are not seen as limited to geometric applications.

This is all the more true because a deep understanding of programming itself requires a transition from the quasi-continuous model appropriate for movement or drawing to the discrete entities and states required for truly exact processes.  Text-oriented procedures (e.g., alphabetical sorting, comparison of text strings) clearly lie in such a discrete-state world.  While simple text applications seldom have the drama of turtle graphics, wordplay of various kinds can be engaging.  The most natural text-oriented computer programs are automated generation of messages, typically in conjunction with a simple information-storage mechanism of some kind.  Because commercial text-oriented programs (e.g., word processors, relational databases) are so advanced (although easy to use) that their mechanisms are not at all obvious, students will benefit from encountering some understandable programs that produce simple results of the same basic type.  The best exemplars here are the various scripting languages (e.g., Tcl, Perl), but for instructional use it would be best to have a more restrained subset of the features in most of them.  This is a case where extension of Logo itself is an attractive option, since it has decent text capability and the database references could fit into the existing syntax.

One of the most compelling illustrations of the power and characteristics of text is the computer program itself.  Here one has a set of symbols causing dramatic action by their effect on a complex machine, but this occurs in a context where the student can define the meaning of some terms and get a complete description of the effects of the others.  This provides an example for the idea that words can have exact meanings in some contexts, an excellent preparation for many areas of study.  Because they come to school having already mastered talking, it is easy to underestimate how much students still have to learn about language (and thus the need for instructive models).  Vygotsky (1962, p. 99) makes the point that writing is "as much harder than oral speech for the child as algebra is than arithmetic".

Note that algebra itself is fundamentally linguistic, but has a variety of idiosyncratic usages that do not reflect the patterns of other writing.  While it may seem perverse to add yet another syntax (that of math-oriented programming), its more regular and limited pattern actually makes computer math much easier to use consistently for most people than standard college-algebra and trigonometry notation.  However, more attention needs to be paid to providing smooth transitions from programming syntax to traditional algebraic notation.  While it is to be hoped that pressure from programming usage will cause some rationalization of mathematical notation (although its compactness is a great virtue in professional use), for at least the immediate future students will need to learn the correspondences.  Computer algebra systems such as Mathematica address this by supporting both "input" and "traditional" modes; they also support the use of specialized symbols and constructions such as square roots and complicated fractions.  Students will need ways to achieve similar effects in programming languages they use, at least for the cases that are common in school-level problems.

H.  Moving From the Playground to the Town Square

While connections from elementary-school programming to secondary-school instructional areas are among the most urgent needs, it is important that the impetus to connection not stop there.  This is not only because school is a staging area rather than an appropriate final destination, but also because the battle to connect schools to reality (of which the Logo movement is part of the "lower", elementary-school front) is also being waged from above.  What will truly anchor elementary-school programming as a fundamental element in the curriculum is showing that it can advance the time at which full-strength adult-world work can be successfully done.  While many of the programming-inspired cognitive benefits discussed earlier should advance students even along paths that require little further use of computers, a payoff can particularly be expected in the many paths where there is substantial adult-style interaction with computers in a context where programming is useful.

One example is spreadsheet programs.  Due to their focus on simple numerical relationships and the clear mechanism for attaching procedures to individual cells, these are among the most accessible places for serious programming.  And such programs, by handling issues such as missing data in an appropriate way, can make great differences in the quality and utility of the results.  Automation of heuristics can be of great value, as well (use red text for all past-due accounts, blink if more than 30 days overdue).  T he ability to do customization is much of the difference between being in control of your activities and being a cog in a computer-controlled machine.

Another area where it is programming that makes the tool really useful is database analysis.  The proliferation of computer-based information has been rapidly expanding the haystacks in which various needles are hidden.  If you are doing a political mailing, you want to be able to specify that you want 2000 general-election voters (don't waste money on confirmed stay-at-homes) who didn't vote in the 2002 Republican primary (not your type) or the last two Democratic ones (don't preach to the choir) unless they are close to 65 years old (your opponent wants to raise the retirement age) or within a mile of a railway (you support tougher chemical-spillage safeguards).  This particular choice will not be presented as a check box.  Real programming will be even more necessary for analysis of less structured information such as search-engine results.

The final and most important example is HTML programming, which includes dynamic and data-specification forms as well as the static pages like this one.  Anyone who can use a word processor can publish to the entire world via the Internet.  Perhaps most of them will (sometimes it seems like that already).  All of these pages are expressed in a programming language that is clearly going to be one of the major areas of cultural development for decades to come.  Knowing how to use, extend, and correct statements in this language will help people participate in this [insert awestricken superlative of your choice] phenomenon on their own terms.  The web is all the more important because almost all other software applications will soon be embedded in it.  This means that mastery of whatever script languages, graphical-interface widgets, and communication protocols serve the web will provide the keys to many doors.

It will not be necessary to force students to participate in these activities.  In fact, most of them will be substantially engaged with computers in any case.  But both they and the rest of us will be better off if that engagement is at least in part on terms in which they can express their own talents and pursue their own interests, helping them build high-quality specializations.  Using computer programming to blaze a path from preschool enthusiasm to adult right-livelihood could well be the wisest investment available in educational reform.