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?
That's because many Scheme jobs are hired through networking or
are listed by other names (well-trained Scheme programmers are ready
almost immediately for jobs that use Erlang, Dylan, Common Lisp, and
with a little more preparation, Smalltalk and Java). Scheme does see
active use at numerous places including Intel, Motorola, Silicon
Graphics, Microsoft and Disney's animation studios. 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 programmer managers from
IBM, Texas Instruments, and other software 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:
- A design method that helps everyone (especially weak
students) proceed methodically from problems on paper to
well-designed programs.
- 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.
- 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 mislead 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.
|