These are some questions we commonly encounter from teachers and parents. If you need additional information, please contact us by email at the address scmfaq@teach-scheme.org.

• Is your curriculum only about Scheme?

  No! Our curriculum is (at the collegiate level) a year-long effort that takes students through both Scheme and Java. At the end of the year, students have learned not only the syntax of Java but a proper understanding of object-oriented program design using Java.

• Is Scheme a “real” programming language?

  Scheme supports most of the standard real-world programming protocols: ActiveX, COM, ODBC, SMTP, POP, NNTP, HTTP, IMAP, XML, and so on. Scheme programmers use these protocols daily to develop real programs that see worldwide use. Several companies make their living out of selling Scheme products. Does that count as “real”?

• But how about jobs? I don't see job advertisements for Scheme in our local papers. Does anyone actually use it?

  Scheme does see active use at numerous companies, sometimes even stealthily. See, for instance, Paul Graham's Beating the Averages. And, related languages are used for diverse real-world uses ranging from building popular graphical games to controlling international telecommunications networks.

  In any case, a discussion of jobs is irrelevant because industrial practice should have virtually no bearing on what we teach in the very first semester. First, most professions introduce students gradually to the tools of the trade. They do not expose students to tools that are complex, difficult to control, and possibly useless by the time students enter the profession (say six years later). Would you want to start your daughter on sledgehammers before she has ever seen a screwdriver? Second, most beginning programmers are in no shape to do anything industrial beyond weak, fragile, and faulty programming, say for Web pages. Ask yourself:

  • Do you really want to hand over your personal information to a Web site designed by a high school student with one course on programming?
  • Would you trust your money to software written by a programmer with nothing more than a high school course on programming?
  • Would you fly in a plane whose software was written by your first-year programming class?
  Finally, the trend in the software industry has been to change the dominant language roughly every seven years (COBOL to Algol to Pascal to C to C++ to Java to Visual Basic to ...). So how do we know that the currently new thing is the right thing for six years from now when it matters?

  Indeed, we regularly invite leading managers from leading companies to address this issue. Every one of them tells our students to study more than one language paradigm and to study the relationship between design paradigms. They insist that programmers must switch languages every few years. Because of these warnings, our students learn Scheme in the first semester and Java in the second (a very natural transition), thereby being much better prepared for a wide variety of challenging jobs than even students who have had Java alone.

• But students like fun things like games, graphics and animations! How am I supposed to sustain their interest with Scheme?

  How about with games, graphics and animations? You can do all this, and more, with Scheme. In our courses, within four months students write several graphical games, generate entire Web sites from programs, and build a basic compiler. This pace is of course much more intensive than the average high school course would follow, but even in high schools teachers have reported great success with graphical and game exercises.

• Why not just teach them flowcharting?

  The trend over the past 30 years is away from control-centric programming to data-centric programming. This new paradigm places data, not control-flow, in the center of all design activities. That is, the programmer carefully designs the classes of data that the program is to process and the legal operations on these classes of data. Flowcharting has no place in this world. What is needed instead is training on reasoning about data. This is why object-oriented design patterns have made a huge splash in industry over the past few years. Our curriculum introduces these (and other related design techniques) to students, but in a way accessible to beginners. If you wish to understand what we do, read the first part of our book. It's on-line and free and will remain so.

• Does anyone else think Scheme is a good idea?

  Sure. Scheme won its author the ACM's Grace Murray Hopper award, which is given to a computer scientist under the age of thirty for a significant achievement (a rare and remarkable honor). The person is Guy Steele, better known as one of Java's principal designers. Study Java carefully and you will find Scheme all over it. Guy continues to serve on the Scheme language design committee.

  Scheme also inspired perhaps one of the finest computer science textbooks ever written: Structure and Interpretation of Computer Programs, by Abelson and Sussman. Educators and researchers alike hail this as one of the most influential texts ever. The book won its authors the ACM's highest award for educators a few years ago.

  Numerous universities and high schools worldwide use Scheme in various parts of the curriculum. In short, there is universal acknowledgement that this embodies some of the great ideas of computer science. If you don't want to teach universally recognized great ideas, what do you want to teach?

• All languages are pretty much the same anyway; can't I use C++ or Visual Basic to teach just about anything?

  They say that when your only tool is a hammer, every problem looks like a nail. Likewise, it's true that all languages look equal when the languages you know are C++ or Pascal or Visual Basic. If you've missed out on languages like Scheme, ML, and Haskell, then you've missed (some of) the counterexamples to this claim. This deprives you of a significant portion of the innovations that computer scientists have made in programming languages. Students deserve to have access to this knowledge --- especially because it facilitates the teaching of programming.

  This isn't the place for a full analysis of programming languages, so we'll just offer a few examples. First, Pascal, C++, and VB force teachers to spend an inordinate amount of time on input and output operations, which rapidly change and which contribute nothing to students' problem solving skills. Scheme, in contrast, permits students to manipulate all forms of data directly (structures, lists, trees, graphs, stacks, queues, and so on). I/O is introduced if time permits. Second, Pascal, C++, and VB force students to understand a plethora of arcane rules of syntax (the language's grammar) and semantics (the language's meaning). The teaching-relevant subset of Scheme, in contrast, consists of five constructs and has an extremely regular set of rules. Finally, Pascal, C++, and VB are batch-oriented languages, which means students must test entire programs. The Scheme compiler, in contrast, is interaction oriented, which means students can freely experiment with all parts of a program directly (functions, expressions, definitions, etc).

• Why don't you like C++?

  The syntax of C++ is baroque and arcane. There are so many operators and so many layers of precedence that even most teachers are unable to understand the language they're trying to teach. (Don't believe us? Hang out on the AP COMPSCI list sometime.)

  The programming environments are heavy-weight and, as such, not designed for beginners at all. They produce indecipherable error messages that only a professional could make sense of. Don't believe us? Have you never seen one of your beginners type in

  price * number_of_items = total_cost

  after a week or two? We have been observers in many C++ classrooms and that's what we see. Explain the error message to your average student. Or, how about controlling a run-away program? Why is there no break button in your environment?

  The language offers no safety features, so students often don't find out about errors except in obscure ways, and sometimes don't find them out at all.

  Most textbooks fail to teach object-oriented programming properly (if at all). They miss the idea of data-centric programming. Even when they try to, the problems with the language make it impossible to separate the study of this from low-level details. In short, it's an educational abomination.

• Why don't you use Visual Basic?

  Some of the complaints about C++ — especially about the programming environments — also apply to Visual Basic. The real problems are, however, with the curricula. Most VB textbooks are so taken up by the GUI-related opportunities in the language that they fail to provide any sort of coherent basis for programming. Teachers try to compensate for this with concepts such as flowcharts, which are effectively outmoded (as described above). Again, monitor the VB list: most questions reveal either an obsession with GUI minutiae or deep misunderstandings about program design. We haven't yet seen a VB textbook that comes close to resolving these issues.

  Added to this is the problem of choice. VB is a proprietary technology with implementations only on limited platforms. Say an enthusiastic high school student hears about Linux and wants to use it. This is the sort of student we should try to encourage. But the lack of VB support for Linux means she cannot use it for her work, and has to choose between working for class and learning for fun. Is this fair? In contrast, Scheme runs portably across all major platforms. Even programs that involve graphics run without change (and without the annoying #<include> declarations that pepper C++ programs) on all these platforms. We routinely use this portability to develop assignments: start one evening at home on Windows, continue the next morning at work on Solaris, then release the assignment, which a student can solve on his Macintosh, and that the grader can evaluate on Linux. Isn't this how it should be?

• So is your curriculum mainly about Scheme?

  No. First of all, our curriculum combines Scheme with Java. Even within the Scheme portion, it is not primarily about Scheme. Rather, it is supported by three distinct, but related, pillars:

  1. A design method that helps everyone (especially weak students) proceed methodically from problems on paper to well-designed programs.
  2. A student-friendly programming environment that introduces the language as a series of layers, so that students are not inadvertently affected by advanced features. The environment runs on all major platforms, and programs written in it behave identically on all platforms, even when they employ sophisticated graphical and other operations.
  3. A syntactically simple, highly expressive, programming language that serves as an ideal introduction to other languages like Java, and reflects the current state of computer science.
  Scheme is only one part of this trinity. Furthermore, we don't even use all of Scheme; we teach only a smattering of it.

• So why Scheme at all?

  Our choice of Scheme is governed by our experience and expertise: unlike most authors of introductory programming books, we are both educators and researchers. As educators, we have seen the quality of high school curricula, as evidenced by students in our classes. As researchers, we have spent several years building up our material to address these problems using our in-depth understanding of computer science principles. Scheme, when properly harnessed (as explained above), is the best language we have found to provide this kind of understanding. We know lots and lots of other languages in great depth, and no other language fits our bill as well.

• If my child takes this curriculum in high school, what will she do when it comes to taking the AP Exam?

  The AP Exam currently uses Java. Because our curriculum covers both Scheme and Java, a student who goes through this curriculum should be very well prepared for the exam.

  We can actually say more than just that. Teachers who have used our material, building up Java upon a basis of Scheme, find that their students end up knowing

  • as much Java as they knew at the end of a year of just Java
  • the basic concepts much better than they did with just Java
  The reason for these findings is that students have learned the concepts in the low-overhead environment of Scheme, so they have spent more time mastering the details. Then, they learn to translate their ideas into the syntax of Java, rather than mastering both Java and the concepts at the same time. All our teachers who have tried this are extremely satisfied with this approach; some have found that their deeper understanding of concepts from our material has helped them present even Java better. Many are willing to communicate with other teachers interested in exploring this option.

  There are two subtle, more long-term benefits of this kind of composite curriculum. The first is that there is growing realization in industry that students who have been trained in many language paradigms are much better prepared to adapt to the Next New Thing than those who haven't been so trained. Combining our curriculum with an AP course gives students this advantage early on. Secondly, students who go to a leading university — such as MIT, Berkeley, the University of Chicago, Rice, Brown, and so forth — will anyway have to confront Scheme (or something very similar) immediately upon arrival there. These students would be much better prepared to handle the rigors of college with a broader curriculum.

  There is actually much more material in our curriculum than would fit even a year of high school. It can therefore be split into two parts: a pre-AP material, to prepare students for the AP course, and post-AP material, for advanced students or in schools that have free time available to study computer science after students have completed the AP requirements.

• Isn't Scheme a version of Lisp?

  Yes and no.

  Yes: Scheme has a strong syntactic resemblance to Lisp. Some people who have seen Lisp's syntax on paper are concerned by this. In reality, editing Scheme on a computer is much easier than editing most other syntaxes. Students take about one day to learn the syntax, and can then move on to learning real concepts. How many teachers of other languages can make this claim?

  No: Beyond this, Scheme shares very little with Lisp. Don't be misled by the syntactic similarity; Elvis look-alikes are not, despite their appearance, the Kings of Rock'n'Roll! In fact Scheme is a fairly different language with a much more refined and modern philosophy. If you have prior Lisp programming experience, it will only help you on the first day of our five day workshop.