The Pitfalls of Java as a First Programming Language – A Response

Two computing practitioners from an Ada shop in New York, Dr. R.B.K Dewar and Dr. E. Schonberg, who are also professors emeritus at New York University, have recently slammed Java as a first programming language. Their article has received quite a bit of attention and created wide discussion.

I think they are completely barking up the wrong tree.

Dewar and Schonberg report some observations, and than jump to conclusions that are not in any way supported by the observations or their argument.

Specifically, they state that today’s students are lacking certain skills (low level programming and formal methods), and then go on to blame the use of Java as an introductory language for this problem.

To state my conclusion upfront: They describe a badly designed curriculum, and then blame one programming language for the education’s problems.

The fallacy in Dewar and Schonberg’s argument is mainly that they imply that the use of Java means that low level programming, such as pointer arithmetic and runtime complexity, is not being taught anymore.

While it is true that this is the case in some institutions, and when present indeed represents a problem, it is not necessarily connected with the use of Java as a first language. True, Java isolates the programmer from direct pointer manipulation, so this is an area that is not practiced in introductory Java courses. However, I have never seen anyone arguing that this means that this material should not be taught anymore.

In many good institutions that I am familiar with, including my own, this material has been moved to other, often second year, courses. It seems from what they describe that this may not be the case at NYU. That is then indeed a hole in the curriculum. But blaming the programming language on bad curriculum design is a simplistic and misleading argument that lacks real insight.

Dewar and Schonberg complain that “the Java programming courses did not prepare our students for the first course in systems”. Well, tough luck. If they expect C programmers, a Java course indeed would not prepare them well. Nobody said that teaching Java would magically produce C programmers. If we want students to be competent C programmers (and we certainly want that for our computer science students, but not necessarily for the multimedia students) then we need to teach C as well.

They are essentially complaining that, now that we don’t teach our students C anymore, they don’t know C anymore. Well, then teach them C before you expect them to use it. But this still does not make any reasonable argument why Java should not be the first language. Java as a first language has many advantages over C (or Ada, which the authors, somewhat desperately, try to present as a necessary modern mainstream language).

The authors state that “Because of its popularity in the context of Web applications and the ease with which beginners can produce graphical programs, Java has become the most widely used language in introductory programming courses”. Here, they fundamentally fail to understand why so many educators have adopted Java as a teaching language.

The truth is, it was neither because of the web, nor because of graphics, but because Java represents a reasonably clean, manageable, nicely designed and very well supported implementation of a modern programming paradigm: object orientation. It certainly represents object orientation, which educators decided they want to teach, better than C, C++, or the authors’ favourite: Ada.

Java allows discussion of the most important concepts of programming, such as abstraction and professional quality program construction, to be done first, so that low level details can be filled in in later courses with other languages.

Java clearly was and is a much better choice of language for introductory teaching than C, C++, or Ada, from the late 90s, when most schools switched to it, to the present day (despite a longish number of detailed criticisms that I might have).

Dewar and Schonberg want us to custom train students for their little niche of applications: security sensitive real time applications. Sure, that is an important field, and computer scientists need to be trained for it. But this is not all there is, as the authors seem to think. The field of computing has grown significantly since Dewar and Schonberg’s view of it seems to have solidified.

The fact is that introductory computing courses are now taken by people from what are (or should be) different disciplines: computer scientists, software engineers, multi-media experts, electronic engineers, applied computing students, network computing students, and a lot more, with differing degree names in different parts of the world. The field has developed.

Some institutions still try to squeeze all in a single degree, but that does not really work anymore. It has passed breaking point. The field has grown so much, we really need different degrees. Everyone of those needs a first programming course. Clearly not everyone of those needs Ada. Or even C.

Blaming the first language for a failure to design a good curriculum where other necessary languages are taught appropriately is a naïve argument that misses the point and isn’t helping anyone.

14 thoughts on “The Pitfalls of Java as a First Programming Language – A Response

  1. Pingback: » “Failure of Java as a First Language” issue continues Guro

  2. Hi Michael,

    I would have come to the same conclusion that you did as soon as I heard about the complaints. Why I’ve not is due to what I believe to be an interesting experience during my undergrad years.

    My experience was with the CS program run at Carleton University at a time when they were switching from Pascal to Smalltalk as a first year teaching language. This was one of the first Universities to use Smalltalk in a first year course. I started the yeear prior so my first year was with Pascal with some Smalltalk and assembler. The following years the first year students did Smalltalk and C. They missed out on Pascal.

    Without getting into why, I ended up working on a group project in a systems course with the students that had mostly only seen Smalltalk (with the C course). The project required the use of a data structure that I had previously implemented in C. So I passed the code along for some C&P reuse to the responsible team member with a small explanation of what I though needed to be changed which amounted to altering a struct and changing a few “get” functions. We had a good team. Everyone on it was above average so there was no warning for the troubles that were on the horizon.

    The team member was completely incapable of working with the data structure (an AVL tree). At the root of the problem was a total lack of understanding of pointers. So the facts in this antidote;

    1) Smalltalk was mostly used the by the students
    2) the student was an above average
    3) C/pointers had been presented prior to the systems course
    4) The CS program was exceptionally forward thinking in what is was presenting so I don’t think one could say that is was poorly put together.
    5) dealing with pointers was still a problem
    6) this guy wasn’t alone.

    It was a real eye opening experience for myself. It says that one cannot easily dismiss the curriculum unless you’ve had a good look at it.


  3. This is a brilliant counter argument. We need different degrees for different career paths. The most important part of computing related degree, however, is the ability to learn. In my degree, Physical Sciences with Scientific Computing, 1990 was never taught Object Oriented Programming. It was too new! But I was ready to learn and motivated to learn this new way by Coad, Bud, Rumbaugh, Stroustrup and Gosling and countless other. The ability to learn is all or nothing will be achieve by any student.

  4. Pingback: Vinny Carpenter’s blog » Daily for January 14th

  5. I saw this article and hoped you’d have something to say on it. One might surmise that Java is becoming a scapegoat for poor teaching or even poorer planning.

    I daresay that’s true for other languages too.

    Or maybe bashing Java has just become cool.

    I’m in the middle of my second Java module… there’s plenty to think about without pointers, which I’m sure I’ll come to later but for now it’s nicer to know they a) exist and b) are handled automatically by Java. The rest shall follow.

  6. Pingback: Noticias externas

  7. Pingback: Computer Science Teacher - Thoughts and Information from Alfred Thompson

  8. I’ve been a high school “computer teacher” for six years. I teach two levels of programming, AP, a game development class and an opengl class (all in java). I also, however, teach more art based classes (photoshop, digital photography, 3D/Maya, etc) and I was a software developer for seven years before that.
    I agree with you. Java is not to blame for the problems they are seeing. Bad curriculum design is, well, bad. Blame the cook, not the ingredients .
    At any rate, I would like to point out more importantly that they are championing the idea on “bottom up” teaching (in a matter of speaking). They assume that it is always better for learning to start from the minutia and build up to the whole (how left-brain . . . even procedural of them). They fail to see the opposite way of teaching: “top down” (again, in a matter of speaking). Start with the big picture, right brain view of the problem/application/task/etc. and drill down to the nitty gritty.
    This “top down” approach is crucial for a more organic approach for a student to map his/her way through their studies. eg: I get students who think they want to program computer games. They start into things and realize that what they are really interested in is 3D computer graphics creation (as an artist). Kids will sometimes come in as math/science and leave as artists. Sometimes the opposite happens. This would never happen if I started by focusing on pointers, factorials, asymptotic analysis, etc.
    I think the authors failed to see that they need to change to a top-down approach. They are teaching students who are educationally making their way down to the minutia, not on the way up to the big picture. Maybe they are the ones that need to adapt.

  9. I completely agree with what Michael has to say on this topic. I am a first year student at the University of Kent and spent the first term under Michael’s tutelage.

    Now unlike most of the other people on the computer science course, I have not been interested in computing from a young age nor had I ever studied IT or Computer Science before starting my degree. Essentially all I knew about computers was, when you’re buying one, the higher the numbers on the specifications the better (this is no exaggeration)! Computer Science was quite a fluke to be honest, I chose it because I thought that it might be interesting and also very useful as a career.

    As it turns out, choosing computer science as a subject has been the best decision i’ve ever made. I was spellbound by our lectures on programming and never missed a lecture or a seminar. I was/am fascinated by what goes into a computer program and there is nothing better than the rewarding feeling that comes when your program works the way you want it to. I know that this love of programming is in no small way due to Java as a first programming language.

    As a programming language Java is pretty air-tight. What I mean by this is that the syntactical rules you get taught are the ones you follow without exception. Everything has been clearly thought out and whilst there were concepts that were initially confusing to me, such as: Interfaces and abstract classes, once you’ve put the effort in to understanding these concepts everything clicks. You can suddenly see how everything fits together and why things like multiple inheritance can only be achieved through the use of interfaces. As a student who knew nothing about programming at the start of university I had to work bloody hard to try and catch up to those who already knew multiple languages and could program competently. Suffice to say that at the end of first year I am still a long way off this level, but I was one of the highest achieving “newbies to programming” on my course.

    Java, as a language, was exactly at the right level for not just me but alot of my friends. Java, at times can be extremely challenging without having to think about pointers and the real nitty-gritty low-level things like that. Object orientation is a very easy concept to get on board with, especially if you do not come from a mathematical background. At this moment in time I can’t even conceive of how to write a program without object orientation.

    Luckily I’m also very fortunate that the course was run extremely efficiently and that it covered all the bases that we needed to know. I now program for fun in my own time. My girlfriend, who studies classics and archaeology thinks I’m crazy and constantly says, “I don’t do classics in my own time for fun, why are you programming?”

    In short, I will be studying C in my second year module and have already purchased and started reading textbooks on it. I agree that the ‘top-down’ approach has been the best way to learn programming as I can assure you if we had to deal with pointers and memory allocation in first year alot of people would have shot themselves.

    Thanks Michael for really starting my passion in programming!

  10. I disagree with this article.
    Personally I learned low level languages first and while learning them I also learned OO programming with Turbo Pascal & Borland C++ so good that when starting to learn Java OO was not a problem for me.
    Still it’s arguable if my opinion that it’s better to learn low level programming first is correct, but worked for me. But there are better high level languages than Java, which worst problem is not even that OO is the ONLY way you can program with Java, like Guy Banister stated: “At this moment in time I can’t even conceive of how to write a program without object orientation.”. Is that good?

    For high level languages Perl would be my suggestion – it has impressive OO programming implementation, yet you can also learn non OO or even mixed coding with it at same time. Also it lacks the huge number of bad flaws in Java not related to this article.

    When a student knows only language where all is written as OO it’s not the best starting point for learning suddenly procedural programming. With Perl and many other options he would, with good teaching given, already have good base for OO and procedural programming – also he could know pointer-like things and other stuff that would ease learning pointers and other low level things.

    And the language he had 1st learned would not be useless or at least dying for common applications programming.

  11. You sir need to learn how to read. What the authors of those arguments is advocating for is introducing lower level languages before moving on to higher level languages like Java. The bottom-up approach makes more sense. It’s easier to transition from a low-level language to a high-level language than vice-versa. You’re better off knowing about dynamic memory management and garbage cleanup before learning Java, and even if you don’t end up using it in Java, you’ll still have it for every other programming language that requires it to be done manually. If you start in Java and then move to C++, it’s difficult to change your ways and have to learn how to do garbage cleanup manually. The authors are saying that starting with Java teaches people how to do something, but not how it works.

  12. my 2c is this: I started with C, was too hard so I went to Java, The Java book really annoyed me so I tried python. I got all the way to classes and GUI, both of which I wasn’t really able to understand or do so I went back down to C. Now because of python C suddenly made allot more sense and it didn’t have the nasty OOP and GUI focus that Python had(and java have even worse). Then after going up all the way towards Files and GUI I went back to python, now The OOP started to make a little more sense(yet not too much), so I went down to C++ and now this makes unbelievable amount of sense(The OOP aspects that is).

    So from my perspective I have to say that the whole OOP “fad” causes too much confusion, and the focus on GUI programming(and especially introducing it too fast) causes allot of confusion. I found it easier to learn the basics from a high level langauge(python), then relearn those basics and some low-level stuff(C) and then go back to the high level langauge to try to catch that I had problems with(OOP, python), and then Go back to a low-level langauge to re-learn that again(c++). After going trough all this I feel ready to try myself on Java again and hopefully progress past GUI programming on Java, and then revisit in on C or C++ for the API(or wxWidgets, haven’t decided yet).

    The biggest problem with everything however is that everyone learn differently, so blaming a language isn’t really right, the curriculum doesn’t take into account that many people can’t learn trough the “standarized method”.

Leave a Reply

Your email address will not be published. Required fields are marked *