MAA Mathfest is in Madison this week — lots of interesting talks about mathematics, lots of interesting talks about mathematics education. Yesterday morning, David Mumford gave a plenary lecture in which he decried the lack of engagement between pure and applied mathematics — lots of nodding heads — and then suggested that two-column proofs in plane geometry should be replaced with basic programming — lots of muttering and concerned looks.

But there’s something to what he’s saying. The task of writing a good two-column proof has a lot in common with the task of writing a correct program. Both ask you to construct a sequence that accomplishes a complicated goal from a relatively small set of simple elements. Both have the useful feature that there’s not a unique “correct answer” — there are different proofs of the same proposition, and different programs delivering the same output. Both quite difficult for novices and both are difficult to teach. Both have the “weakest link” feature: one wrong step means the whole thing is wrong.

Most imporantly: both provide the training in formalization of mental process that we mathematicians mostly consider a non-negotiable part of general education.

But teaching coding instead of two-column proofs has certain advantages. I am not, in general, of the opinion that everything in school has to lead to employable skills. But I can’t deny that “can’t write five lines of code” closes more doors to a kid than “can’t write or identify a correct proof.” People say that really understanding what it means to prove a theorem helps you assess people’s deductive reasoning in domains outside mathematics, and I think that’s true; but really understanding what it means to write a five-line program helps you understand and construct deterministic processes in domains outside a terminal window, and that’s surely just as important!

Computer programs are easier to check, for the teacher and more importantly the student — you can tell whether the program is correct by running it, which means that the student can iterate the try-check-fail-try-again process many times without the need for intervention.

And then there’s this: a computer program *does something*. When you ask a kid to prove that a right triangle is similar to the triangle cut off by an altitude to the hypotenuse, she may well say “but that’s obvious, I can just see that it’s true.” And she’s not exactly wrong! “I know you know this, but you don’t really know this, despite the fact that it’s completely clear” is a hard sell, it devalues the geometric intuition we should be working to encourage.

You can’t see that a program is correct by running it, you can merely observe that it for that particular execution generated an output that satisfies your expectation.

Having TA:d a bunch of introductory and less introductory CS courses, people program by happenstance all the time and it’s a problem that needs to be properly handled.

The skills needed to write good proofs are indeed close to the skills needed to write good programs, but the skills needed to write mediocre proofs are quite different from the skills needed to write mediocre programs. Given that the median teacher and the median student are more likely to pick up the latter than the former, I don’t think the two subjects are perfectly exchangeable.

I’m down with most of your argument, except this: “…which means that the student can iterate the try-check-fail-try-again process many times without the need for intervention.”

I actually really don’t like this piece of it, because (at least the way you’ve said it) it teaches students to rely on external authority to know if their answer is correct.

The beauty of proof is that if it’s right, you should KNOW it’s right. You shouldn’t need the teacher or the answer key or anyone else to check it for you. It makes sense; you can see the logical flow and understand how one step follows from the previous. It sounds like you’re advocating teaching proof writing as a glorified version of guess-and-check, and I think that rather misses the point entirely.

When I teach proof, I will question students about various steps or point out places where I don’t understand their logic. But (except on tests) I never tell them if I think they’re right. I keep asking them if *they* think they’re right and why. I would hate to get “because the program runs” as an answer to that question.

Your title on this post is a bit misleading. I followed a link here all in a bother about the idea of eliminating plane geometry and see that actually it’s only the business of “two column proofs” that is on the chopping block – and those I would actually be happy to dispense with.

I valued the inclusion of Euclidean proofs in my own education and would be loath to see the concept eliminated entirely, but I don’t think they are by any means essential for everyone and the very label “two column proofs” has always annoyed me for its emphasis on layout over content. If the concept of “proof” is going to be transferable in any useful way to other contexts then it needs to be dealt with in a much more fluid manner where the emphasis is on logical connections rather than the way things are laid out.

If you had to choose whether graduating seniors would be able to write mediocre proofs or mediocre programs, which would you pick?

Hmm, to be honest, neither skill is of much use in isolation at that level of mediocrity. But of course even a weak amount of experience with proofs is going to help with any mathematics-intensive discipline, and a weak experience with programming is going to help with any computer-intensive discipline. (The broader benefits of being able to think abstractly and precisely would, unfortunately, not become significant until a high level of understanding of either is reached.) So it would have to depend on the general area the graduate is planning to work in…

I would vote for mediocre geometric proofs. At the very least it exercises some geometric/physical intuition, and I’m not sure that simple procedural programming does much to develop any sort of intuition except perhaps for simple algorithms which are relevant only if the student would go on to become programmers or software engineers. If the programming involved classes and methods and functions to the extent that their usefulness becomes obvious, then it’s a different matter because this is a doorway to abstraction not totally unrelated to math, and particularly so if programs are complex enough in architecture to match the scale and complexity of a math paper. But I don’t think we are talking about this at that level. I also think that too much focus on this sort of computer syntax and architecture before exposure to math proofs may be a hinderance because mathematical discourse and intuition involves a higher level of natural language absent in computer programming, and the earlier the student learns it the better, as with languages such as French of Russian. I think that less is lost if programming is encountered at an older age than when math is encountered at an older age.

I should say though that I did not see this talk, and maybe I’m missing something here. As Terry pointed out, it’s not clear what kind of students we are talking about here. I also had plane geometry in the 1960s and don’t remember “two column” proofs.

Somewhat related, I have to add that I sat through three hours of presentation by Tom Hales a couple of years ago regarding computer proofs, and although it was impressive in a way, it left me feeling cold. I would never have studied mathematics if it were presented this way. The beauty and intuition is lost.

Frankly, it makes no difference because the number of people qualified to teach basic programming in high school and willing to do it at wages and working conditions anywhere near what schools are able to provide is so small as to be statistically zero.

Addendum: a fun lab course in simple analog electronic circuits would be a much better substitute than programming. There is much more physical intuition involved in that than programming, and is a good gateway to applied math.

A modest proposal: Replace paragraphs in English class with two-column subject-verb tables.

Over the years, I’ve learned to be more patient with the educational system, simply because it’s too easy to criticize everything without actually having a viable alternative. But I *still* think that two-column proofs are bad, no better than education simply for the sake of education, and not for the sake of learning something important. They’re beyond mediocre. They are a failed successor to a failed legacy, learning geometry directly from Euclid.

I do not know how I would replace it. It’s true that computer programming is sorely missing from the standard curriculum, and I guess it’s as good as anything else.

Geometry is a beautiful and interesting subject, and doing the two column proofs is a way of learning about geometry and at the same time learning to think logically. Not that there’s anything wrong with computer programming; some people consider it to be beautiful and interesting as well. But keep in mind that future programmers will have numerous opportunities to learn programming in college or even later in high school. There really will not be another chance to learn plane geometry in another class, and you do use some aspects of it in future math courses. Certainly doing a fair amount of it in high school will be helpful in future math courses.

I think one very useful meta-lesson is that programming will teach students to follow instructions exactly and unambiguously. This skill will come in useful later in life, for example when filling out tax forms.

When I was in school, they tried to teach us this skill in other ways. I distinctly recall being tortured with the MLA format for bibliographies: semicolons go here, colons go there, and don’t forget the city where the book was published! I quickly learned that I could write mediocre papers as long as my bibliographies were written in exactly the format we were told. My respect for my teachers went through the floor.

In computer programs your semicolons and colons again must go in exactly the right places, but it doesn’t feel like some contrivance that gives the teachers something easy to grade.

Since you mention tax forms, I think it is appropriate to share this link “If the IRS had discovered the quadratic formula”:

http://www.cs.amherst.edu/~djv/irs.pdf

which also, incidentally, gives a glimpse as to what other parts of mathematics would look like if forced into a two-column format.

How about geometry proofs which are NOT in two-column format? Can’t believe nobody’s suggested this yet!

I am a mathematician who teaches programming to engineering students. While the level is higher than that discussed in the post, some general observations probably transfer.

Programming has the virtue that the student can see, at the most basic level, if he/she has “gotten it right” – either the program works or it doesn’t. For students with little intellectual autonomy this is a valuable aspect of programming which is not shared, for example, by calculus – a beginning student without much confidence or independence can tell on his own whether he has done things correctly.

Programming courses reward mule-like stubborness better than do math classes. Perhaps counterintuitively, precisely for students who need to learn to reflect more, and depend less on mule-like stubbornness, this can be a good thing – they at least get to the level of basic competence and begin to see what is necessary to go further.

Programming and mathematics course X appeal to overlapping but distinct sets of students. There are always students who have failed calculus who do well in programming, and students who have done well in calculus who struggle badly in programming. At the basic level, many students rely too much on “talent” – a reasonably able student can, in most high schools, get A’s in math simply doing his homework in class and paying attention in class. Programming classes punish such students severely – one has to spend time to master the basic syntaxis and one cannot learn programming by listening to someone else – and this latter aspect is much more obvious to students than it is with math classes.

In a beginning programming course, even at the university level, the thing on which most students founder is simply writing loops and conditionals. That is, learning programming obliges learning some careful logical thinking, albeit in a very concrete context.

Programming forces care with syntaxis – this is one of the things the old two column proofs sought to teach, albeit in a terribly artificial way – in programming it is not artificial – one simply has to have the semicolons in the right places, and one has to learn how to find syntactical errors, and to use strategies to avoid them. For old-fashioned teacherish goals of making students punctuate properly and the like I can’t think of a better vehicle than programming because the formal correctness is actually necessary (until one discovers that compilers are quite permissive …). (Frank says something about this in another comment).

Programming has to be taught in a lab setting. This requires smaller classes or more teachers, and uniformly functional computers with a competenet maintainer. These are not resources available in every institution, particularly at the primary level. Instead of a blackboard, one needs a room full of computers and two or three times as many teachers per student – this is a serious problem in practice.

The idea that teaching programming is teaching an “employable skill” is probably misguided. One or two introductory programming courses are about as useful as one or two years of French classes when it comes to finding employment. They perhaps demonstrate readiness to learn more. In practice, passing a basic programming course aimed at general students amounts to being able to write a program to multiply matrices …

To me it makes sense to teach programming to school students (I was taught programming in school), but it does not make sense to substitute it for plane geometry, in particular. When teaching calculus I have often the sense that the biggest weakness in the preparation of my students is that they have not learned any geometry, and have very poorly developed geometric intuition.

I had to google for “two-column proof” to learn what they are. I don’t know about other countries, but this is something I have never seen in France, although there certainly was an emphasis on geometry with proper proofs at the time I was in school (I don’t know of the current level; my children will fairly soon be old enough for me to see what happens today…)

There is something which I believe that programming can teach or at least influence positively: creativity. It is much easier to take a simple computer program that works and tinker with it to change and improve it, than it is to take a proof of a statement in euclidean geometry and generalize it interestingly.

Arguing for the replacement of a classical Euclidean plane geometry course with a beginning programming course requires attention to issues of collateral learning. Both writing effective programs and proving new theorems are creative acts. The median successful student in either course would not have that level of competence. Even if the rare student wanted to, an extended apprenticeship and many more courses would be needed before becoming either a productive programmer or a mathematician.

The important question is what generalizable skills might come from either course. As taught or at least as I remember them being taught not so much. The content, the facts of plane geometry and syntax of various programming tools would certainly be there. The beauty of the axiomatic approach to mathematics and the structure and operations of digital computers might be given slight notice. The programming course may end with a project and the geometry class move toward increasingly sophisticated proofs. Both demonstrations are designed to show just that, that a student can write a program or prove a theorem, skills that most of them will never use again.

A reoriented pedagogy would make a big difference. After a set of preliminaries, students could be taught to read a program or a proof. Start with a fully remarked program and an annotated proof (The column method would work fine for this.) and have students answer a series of questions like how many iterations does this loop perform or why is the line segment bisected. Then give a series of unremarked programs or unannotated proofs and ask the student to provide the remarks or annotation. Then spend plenty of time debugging programs and finding flaws in proofs. Along the way discuss various program structures or methods of proof. In either case students will spend their time developing close reading habits and critical thinking skills.

Couched this way both courses have similar ends. For the general student, a programming course makes more sense. The variety of problems could be much broader (graph theory, probability, etc) and computers are ubiquitous. Also, somewhere somehow we also need to be teaching high school students the fundamentals of system theory.

[…] This is a comment I wrote on this cool blog – Quomodocumque. […]

It amazes me the way that our general education system is set up. There are so many none real world classes that are mandatory, yet we teach nothing about personal finance, personal credit, and quite a few other things that could actually help in day to day life of an adult.

THEN I think about how little opportunity there is for someone wanting to know more about IT and technology. It is almost a joke. No wonder our education system is lagging behind every other 1st world country.

[…] of geometry, Brown University professor David Mumford gave a talk at MathFest in which he said schools should switch out plane geometry for programming. And hey. I’m all for that. […]