Java was chosen because it was seen as relevant by staff/students and industry. The connection with the Web was seen as positive and a way of motivating students. The language itself is reasonably simple (though not as simple as Pascal). It was seen as a good thing to start the students with an Object Oriented language, rather than having to move them to this way of thinking in the second year.

The explicit event model was seen as approximating more closely the way real user-centred applications are written.

It solved some of the problems with C++, especially garbage collecting, while making it easy for our students to pick up C++ if they need to. We have a Macintosh laboratory and most of our students have PCs at home, therefore the cross-platform aspect was also important, enabling students to work on their assignments outside of our lab.

HUGS stems from the split of our old courses into two half year courses. The course in which it is used tries to emphasise abstraction and functional languages have worked well in teaching data structures etc. Interestingly, we decided this morning to switch to Java for that course also! Students, often only with hindsight, did seem to appreciate an early introduction to a radically different paradigm.

Our main goals were:

- Move to a visual elements/GUI component language
- Be able to introduce OO concepts (use of properties, methods, objects in the intro paper, developing simple classes in the follow-on)
- Use a language that was an "industry standard"
- Use something that would appeal to more students

VB seemed to meet most of these criteria, although its OO implementation is incomplete (no inheritance). We also considered Delphi as this was Pascal based and handled the OO stuff butter, but it didn't seem as well know as VB. In addition, we use/teach some VB for MS Office applications in some of our other papers and this was a tie-in and advert for the intro programming papers.

I'm pleased to say that VB met the criteria we set and indeed was very well received by the students. It is our intention to switch the students over to a "proper" OO language in subsequent papers, eg Java or C++ or Jade (this has to be decided for next year).

The reason for choosing Modula 2 was its clean design, which we find good for teaching correct programming practice. We don't consider that its comparitive lack of "real life" use is important, though it is a PR problem.

Currently the issue is under review, and it is very likely that Modula 2 will be replaced in the next year or two. The most likely candidate is Java.

We taught C as the introductory language from 1992 to 1998. There was opposition,[...] but it was seen as a unit which gave access to what we wanted later in the course, such as operating systems, [...]

We reviewed the first course and went back to fundamentals. We felt that a lot of the purpose for learning languages in a command line environment could no longer be justified. We also knew we were spending our time teaching language syntax and semantics rather than understanding, learning and using programming concepts. [...] Most students, both off and on campus, come to us now Windows oriented.

We reviewed the environments and determined that Visual Basic was a way to connect with the students and focus on programming concepts most directly for the present. We have a chance to focus on programming concepts because we are not focusing on syntax.

Why VB? It connects directly with what they know about spreadsheets, word processors and so on. We can draw on already justified material, because they already know examples of techniques applied in real life. We can work through a series of exercises illustrating, using and exploiting programming concepts wihtout getting sucked in to the syntax of C or C++. [...]

Why not C++? That introduces more syntax.

Why not Eiffel? It is not close enough to the windows environment yet, but this language would be my long term preference for this slot.

The learning curve is gentler than for imperative languages. The functional style leads to better imperative programmers. Some students come in knowing Pascal or C or other imperative languages and just coast for the first semester or two, while other students struggle. Haskell forces students to gain a good understanding of types early. The experience helps with other subjects: mathematics, logic, logic programming, formal specification. The commonly used operators are (almost) a subset of the C operators.

We use C in CIT1104 because:

It is required in later subjects, on operating systems etc.

MIPS was chosen to replace ML (a home grown architecture and machine language). MIPS was chosen because of its simplicity and the relative simplicity of the underlying architecture + the availability of a reasonably working simulator (which didn't require too many changes to suit our needs).

- influence of a staff member [...]
- desire to penetrate a perceived market demand (this will go - we are in
progress of moving to Vis Basic as a first language, followed by C/C++), and
- (the real reason) we are a small university & the rationalisation implied required that we teach the first unit in C, since that's what the engineers want.

My own personal preference would be for a more abstract language - starting with Eiffel say - then using a systems programming language (C/C++) in 3rd year when required.

These three units are part of a common first year program done by all our students - the others are intensive lab skills in the first few weeks, mathematical tools, intro database (SQL/Access), intro information management, machine and operating system concepts, and intro data comms. Majors are chosen in second semester and commence in second year. Some students, particularly those planning to do the Information Management major, find the programming stream very difficult.

Our reasons for choosing Modula were those that recommended Pascal before it - small, well-structured, safe. We wanted the improvements over Pascal that were in most compilers as non-Standard additions, and we wanted a cheap, consistent environment on all our machines. That led us to develop gpm (Gardens Point Modula) which is available free to our students as the PC (DOS and Linux) versions, and also on our Faculty SPARC Unix server.

Those reasons still apply, but we are facing the market drive to integrated environments with good debuggers (gpm offers gdb, but that's a bit heavy for struggling first-years), and to the 'well-known' languages - C, C++ Java, ...

We have reviewed a wide range of options recently, and are likely to proceed with a small, cautious change option: change the Programming Lab unit to Java (this was the original plan at our last major course reconstrcution, but at that time Java was still changing too rapidly, texts were few/poor), evaluate that, and then decide about Software Development 1 & 2, with front-runners Java (just one language for all three units) or Component Pascal (better language, again local expertise and compiler products).

So, as I said above, a small change to meet the 'market expectation', and use that to guide further change; the Modula is not exactly broken, so no urgent need to fix it. It's an open question whether the motivation of an environment like Java will be sufficient to overcome the fundamental problems with software development that many students suffer.

I am now teaching the 4th subject in the sequence (all C++), meanwhile Java has been introduced in final year to Ada students as the language for the large team project.

We feel functional languages are good for rapidly teaching important concepts such as recursion and higher order programming, and students are able to develop large programs. It is also an advantage for all students to take a language they have not seen previously.

The second language is C. C is also used as the introductory language for students taking only one programming course.

Reasons against: pointers and assignment rules are difficult to understand without having a good understanding of the underlying hardware/software (should we teach computer architectures, then programming?); syntax is not well defined; ...

Finally, we decided to take the second course.

We are now reviewing the course again. This time it may be a debate between C and Java.

"Blue is an imperative, srongly typed, garbage collected object-orientated language similar to Eiffel....... The Blue language and programming environment were designed to present modern computer programming concepts to novices with minimum possible unnecessary complexity. The progrmming environment includes a very clean graphical interface, intergrated editor, complier, interpreter, debugger, and library browser."

We wanted Object-Oriented. C++ is dreadful and we feel Java is not nice and quite difficult for beginners. Eiffel is well structured (The OO equivalent of Pascal) and a good teaching language. We have now taught it for 10 years. We revisit periodically but can as yet see no reason to change.

Most students doing just a few computing subjects, (Business, Info Studies, Maths, etc) opt for Visualbasic which is OO, easier than Java and likely to be useful to them in industry.

[...] People argued for C++ as a better C, and that's what we chose. The introductory course tends to be procedual, even though we are using C++, with a progressive shift to classes and object oriented design in later courses. Of course our first year students have such a variety of programming experience, from nothing all the way to being competent in some language, that really no one set of lectures and programming assignments can do them all justice.

We have considered going to java as the first language but have so far resisted that, as the change to C++ has only now worked its way through our courses, it needs an evangelist to do it all again with java, and there is a lot to be taken on trust to get started in java.

One disadvantage I see with using C++ in that first course is that students may stumble over features of the language we have not explained to them. This simply reflects the fact that C++ is a big language. [...]

The purpose of our first year language is to provide a foundation for further studies in Comp Sci. However it is our intent to offer a language that has a strong usage base in the wider community. Thus C was followed by C++ and now we are contemplating Java.