My opinion on this is split between
Scheme and
Python, these days. Both are primarily interpreted languages which can be compiled to native executables. Both have interpreter prompts/listeners, which means that a you can easily test out a section of code without having to write and compile a whole program. Python (under Unix) also allows you to run programs as shebang scripts, in the same way that most Perl programs are; some Scheme implementations also support this (e.g., Guile) but most do not.
Python has one highly portable and consistent bare-bones implementation; Scheme has a multitude of implementations of varying quality, and while there is an excellent standard for the language, it is both difficult to implement in places and relatively limited in scope (though the introduction of the SRFI libraries has help in that last regard), with the result that many incompatibilities exist between implementations. The default user interface for both is disappointingly primitive; while there exist the IDLE and PythonWin GUIs for Python, IMAO neither of them measure up to the best Scheme GUI,
Dr. Scheme (then again, neither do any other Scheme or Lisp GUIs I know of except Franz Allegro CL).
Scheme is a relative of Lisp, and shares its most salient features: parenthesized lists as the primary data structure, list-based prefix functions, the interchangeability of code and data, the use of higher-order functions, lambda functions, etc. It differs from Common Lisp in many key (and controversial) ways, however, including the use of a single namespace for both code and data, the use of continuations, the 'hygenic' macro system, the absence of standard systems for module control or OOP, and the vastly smaller core language. It is extremely flexible, and the language itself can be easily extended. While it is primarily designed towards functional programming, it easily supports iterative programming, and object-oriented extensions are easy to add (but not standardized). Over all, it is a very clean language that can be used to teach virtually any aspet of programming in a straightforward manner. However, it is radically different from conventional languages like C or Pascal, and can be confusing to programmers used to a richer syntax (and fewer parentheses), though this is not a serious stumbling block.
Python has a structure that is similar to, but not quite the same as, most conventional iterative languages, and has a rich syntax of iterative structures. It is a natively object-oriented language, and also supports some functional programming features such as lambda functions, higher-order functionals, closures, and continuations, but none of them are a key part of the language. There is no standard macro support, and the syntax itself cannot be redefined. It is a very clean language with a well-defined module system. The only really confusing aspect is that indentation is used to indicate nesting; however, most programmers adjust to this quickly, as the indentation more or less matches the conventions that are used in other languages.
Many books have been written using Scheme for teaching programming; the most common flaw in these is that they tend to write at too abstract a level, and tend to concenrtrate too much on re-inventing the wheel, often present only a subset of the already small core language and then going through recreating those aspects of it in the text. Relatively few books exist for teaching with Python, but some have begun to appear recently. For a beginner, Scheme is almost certainly the easier language to learn the basics of (most of the core language could be taught in a single session, or, as I did with my
tutorial, in a single message board thread), but it is more difficult to develop great proficiency in. Python is definitely going to be more familiar to anyone with previous programming experience in a conventional language; even for novices, the basics of the language should be readily understandable after only a few classes.
My choice? To be honest, if I really had my way, I'd teach both, though not at the same time. Which you teach first is more or less arbitrary, I think, though it is probably easier to go from Scheme to Python than the other way around. I'd still teach C, and eventually C++ and Java, but only after at least a year spent laying the groundwork in those two languages, and a semester of assembly language programming (trust me: an understanding of assembly programming makes a lot of things in C much clearer). If there is time, I'd interpose a semester of Pascal and/or Perl as well; there definitely should be a semester of Perl at some point, simply because it is unavoidable in the Unix world in a way even C is not.
