The College of Computing at Georgia Tech is considering a proposal to remove Smalltalk from our Objects and Design course in favor of C++. It’s reasonable to teach a course on object-oriented analysis, design, and programming in C++ rather than Smalltalk. I’m more disappointed that we will have a curriculum that is all about C. After this change, our required courses will be in Python (first course), then Java, C, C++, and C#. Students will not see languages like Smalltalk, Lisp, or APL.
Richard Gabriel has been thinking a lot about the C-ness of our discipline. If you have not read Richard Gabriel’s articles on “Worse is Better,” I recommend them. Dan Weinreb has a nice overview, and there’s a list of all the various pieces in Gabriel’s debate (some of which was with himself!). Gabriel has been trying to understand why Lisp, despite its many measurable benefits over C (e.g., Lisp programmers are more productive and generate fewer bugs, Lisp environments are amazingly powerful, Lisp code is small and runs fast), has so clearly lost the battle over hearts and minds.
Gabriel contrasts two design philosophies, the MIT/Stanford philosophy (which he calls “the right thing“) and the “New Jersey” C/UNIX philosophy (which he calls “worse is better”). In short form, the MIT/Stanford philosophy (which he associates with Lisp, and which I also associate with Smalltalk) is that correctness and consistency are the most important design quality. In Lisp and Smalltalk, we have S-expressions and objects consistently. The C/UNIX philosophy places simplicity in interface and implementation as the most important design quality.
Python is a mix of the two design philosophies. Yes, you get lambda and map/reduce and objects and classes. But you lose the consistency and syntactic flexibility of Lisp and Smalltalk. What’s interesting is that Python, being the least C-like of the popular languages in computing education today, is mostly seen as a language for the NON-computing major. It’s like faculty are saying, “Oh sure, those simpler and more conceptual ways of programming are fine for people who won’t be real programmers. For our students, it’s C all the way.”
I don’t dispute that Unix/C philosophy has won the marketplace. I worry about only teaching that to our students. I think it’s important for Computing majors to understand Gabriel’s debate, to understand what’s valuable about Lisp, Smalltalk, APL, and other high-power, lots-done-in-few-lines-of-code, flexible languages and environments. We want our students to be thought leaders, to think about possibilities that aren’t currently in vogue in the marketplace. They should know about lessons of history, to avoid repeating mistakes and to resurrect old ideas when technology and opportunities fit.
The political forces are lined up to make the Georgia Tech change likely. In comparison with the departments that I had contact with this summer, we’re late. The C-only train has left the station. Few departments teach surveys of programming languages anymore, and I don’t know of any department that teaches a required course in history of computing. I worry about what this means for our discipline. Are we really going to tell students that the peak of human expressibility for computation was in 1973? That all programming language research from here on out is wasted energy? That simplicity is all that we can ever hope for, and correctness and consistency just aren’t worth working on? Are we forever stuck with 30+ year old ideas and don’t even teach that anything else is possible?
Perhaps we don't need to teach "ancient" programming languages (Ada, APL, BASIC, Cobol, Fortran, Lisp, Posix little languages, regular expressions, Smalltalk) any more than university placement offices request. It seems negligent however to completely omit "modern" equivalents (Haskell, J, LaTeX, Perl as a cautionary example, Plan 9 little languages, Python as a cloud-computing language, SQL, structured regular expressions). I think it is especially important for students to at least understand that each language family offers affordances that make certain problem types much easier to solve.