[Edu-sig] An somewhat stale article about using Java for introductory programming; what can we as Python educators learn from them?

[Danny Yoo]

Hi everyone,

[Warning: I guess I ramble and rant here a bit.  My apologies!]


I picked up an interesting (if outdated) article on the "Use of Java as an
Introductory Programming Language":

    http://www.acm.org/crossroads/xrds4-4/introjava.html

It's written in the 1990's, so some of the comments are not relevant, but
a surprising number of them are still quite pointed.  Here's the jist of
the article:


Georgia Institute of technology switched to Java for their courses
because:

    1.  They were concerned that Pascal wasn't up to date with current
        programming practice.

    2.  Java provided OOP, garbage collection, and exceptions.

    3.  Java was more marketable.


They ran into the following problems:

    1.  Input and output routines in Java were hideous.  They got
        around this by providing their own library.

    2.  Java error messages weren't helpful.  They rewrote the error
        messages themselves to suit their students.

    3.  Students found it easier to plagerize, given the popularity of
        the language.

    4.  Introductory books were scarce at the time.

    5.  The division between primitive types and the other data types
        was difficult to explain to new users.

    6.  There was a high initial overhead due to Java's scaffolding
        code.  (public static void main(String[] args) { ... })


The authors argue, finally, that the particular programming language
chosen really isn't a factor, but that:

    1.  Teaching good design (modularity, coupling, abstraction, etc.)

    2.  Showing iterative program construction in the classroom

were really more important.  This I agree with, and thought the mention of
Eductional Software Process (ESP), to use industry best practices, sounded
very relevant, much like the introduction of unit testing as an
educational technique.


Yet...  I know I shouldn't think this, but the tone felt a little
half-hearted, considering that the author had just finished describing the
factors that they said hampered their student's understanding of the
system.  I just found it sad that the majority of the article focused on
all the problems Georgia Tech instructors ran into, but then again, it's
easier to point out failures than successes.


A lot of the cons in the problem section above are points in favor for
Python, but there are some things that Python could benefit from.

In particular, I thought Problem 2, on customizing error messages to make
erroneous situations easier to understand, was a very interesting one. As
I understand it, many of Python's error messages are hardcoded into
modules and binaries.  Would it be worth it to allow for easy error
message customization through some external file resource?


Last of all, I took a look at Georgia Tech's CS 1321 web page, just out of
curiosity, and came with:

    http://www.cc.gatech.edu/classes/AY2005/cs1321_spring/

So perhaps language matters after all.  *cough cough*