University of Waterloo and introduction to programming

It has been reported that the University of Waterloo dropped Java in favor of Scheme for first year students. A lot of discussion revolves around whether this is a good choice.

I would argue that introducing CS students to programming through Scheme rather than through Java has a lot of beneficial side effects.

• REPL: The first thing that Scheme has that Java doesn’t is a REPL, a read-eval-print loop. This is a program that is available in a lot of languages, and only the C-family of languages seem to be lacking them. A REPL allows the user to input expressions and get an immediate answer. REPLs are great for exploration, testing and just toying around with the language. And because the result is instantaneous, students are more likely to try different things than they are to make modifications to a program and keep compiling and running it.
• Small core: Scheme is unarguably a simpler language than Java. The entire R5RS standard is 55 pages (which I assume is the revision they will use, since DrScheme has no plans to move to R6RS as far as I know. I was misinformed regarding R6RS, PLT-Scheme will in fact support it. Thanks John and Jeremy. I wonder if the classes at Waterloo will use it or R5RS.) The book Java in a Nutshell is over a thousand pages long! There’s just a lot less stuff to learn in Scheme than in Java.
• Simpler syntax: Some people argue with this claim because they get lost in a sea of parentheses and claim that Java has a more “natural” syntax. Nevertheless, in terms of simplicity, Scheme’s syntax wins. You don’t have to remember if a semi-colon goes after this particular line, you don’t have to remember that if there’s only one statement in your if/while/for/etc. you don’t need the braces, etc. A lot of anecdotal evidence suggests that students who learn Java are confused by syntax errors and that they represent the majority of the questions asked in class.
• Dynamic typing: Without saying that static typing is harmful, I think that the constraints it imposes, while beneficial in the long run, significantly complicate a programming language. If I take Haskell as an example, there are a lot of concepts such as type variables, type classes, monads, etc. that exist solely to satisfy the compiler. In a large production program, this can help the programmer, but to the student, these will get in the way of comprehension.

  You want a tree in Scheme? Just use a list, there’s no need to define a new recursive type.

• Functional paradigm: Although Scheme is not a strictly functional language, it supports this paradigm much better than Java. Programmers who grew up with BASIC, C, C++ and other imperative languages will tell you that functional programming is a lot harder, but I believe that it is easier for a student to reason about a functional program than about an imperative one. As they show in SICP, all you need to do is expand your function call. For instance, to understand the function map:

  (define (map f xs)
    (if (null? xs)
        nil
        (cons (f (car xs))
              (map f (cdr xs)))))
  
  (define (plus1 n)
    (+ 1 n))
  
  (map plus1 '(1 2))
  (cons 2 (map plus1 '(2)))
  (cons 2 (cons 3 (map plus1 '())))
  (cons 2 (cons 3 '()))
  (2 3)
  

  With imperative programming, you need to keep track of all the variables that get mutated in your program. This is harder.

• The students learn: With Java, students learn to program in Java. With Scheme, students learn to program. Because the Scheme language is so simple, students can quickly be introduced to more complex topics. In Java, the static typing, the complex syntax and the lacking means of abstraction and combination hinder this fast progress (try writing a general, simple map function in Java.)

Some people voiced concerns over the practicality of showing Scheme instead of Java; those concerns are unfounded in my opinion. First of all, a person that knows programming well shouldn’t have any problems picking up Java. Once you know the fundamental concepts of programming, learning a new language is learning new syntax, idioms and libraries. That is not to mean that it is a trivial task, but the transition is easier. Next, the job of the university is not to teach the currently popular technologies, it is to teach the fundamentals of the discipline. Technologies come and go, but the core of computing changes much more slowly and is applicable to many technologies.