I'm constantly being inundated with articles and people talking about how most of today's Universities are nothing more than Java vocational schools churning out mediocre programmer after mediocre programmer.

Similarly, Alan Kay, a famous Computer Scientist (and SO member) has said this in the past:

"I fear ? as far as I can tell ? that
most undergraduate degrees in computer
science these days are basically Java
vocational training." - Alan Kay (link)

If the languages being taught by the schools are considered such a contributing factor to the quality of the school's program then I'm curious what languages do the "top-tier" computer science schools teach (MIT, Carnegie Mellon, Stanford, etc)?

If the average school is performing so poorly due in large part the languages (or lack thereof) that they teach then what languages do the supposed "good" cs programs teach that differentiate them?

If you can, provide the name of the school you attended, followed by a list of the languages they use throughout their coursework.

Edit:

Shog-9 asks why I don't get this information directly from the schools websites themselves. I would, but many schools websites don't discuss the languages they use in their class descriptions. Quite a few will say, "using high-level languages we will...", without elaborating on which languages they use.

So, we should be able to get a pretty accurate list of languages taught at various well known institutions from the various SO members who have attended at them.

I'm constantly being inundated with
articles and people talking about how
most of today's Universities are
nothing more than Java vocational
schools churning out mediocre
programmer after mediocre programmer.

They have always churned out a lot of mediocre programmers, a handful of good ones, and a few brilliant ones. Only the language has changed.

MIT

MIT used to teach its intro CS course (6.001) in Scheme (the textbook is still online), but that course was last taught in fall '07. The entire CS curriculum was restructured around then. Now, the new intro course (6.00) in Python. Other languages taught/used in various courses include:

Everyone is saying that Java has opened the floodgates to mediocre code monkeys. This is true, but not for the reasons being cited here, that it is too easy and thus unsuitable for teaching CS.

I would argue that Java is too similar to the last generation university teaching language: C++ (Look at Java generics and C++ templates for example). And this is not a coincidence.

Java is first and foremost made for the industry which has lead to its widespread adoption. Here are some points to consolidate this fact:

Java was designed to have similar syntax to C/C++ to woo the older generation while making it easy for the new generation to replace them.

Heavy emphasis on contractual black-box programing with interfaces. This makes it easy to fire the person who finished his module and then outsourcing the rest of the work to India or fresh college graduates.

Sun wants to make money.

Who is to blame for the influx of idiots? Industry. Industry is responsible for the commoditization of CS majors/programmers.

You have all heard ever so often on the news and Slashdot how there is a perpetual lack of programmers that they even need to hire foreigners on H1-B visas.

Colleges then teach Java because their students need jobs in order to donate or even pay for school.

When I was at Cornell (#6 on your list), ~8 years ago, they didn't "teach" any programming language, except maybe at the 100-level. They mostly just used a language, and you were expected to pick it up to do the work. The languages they used were:

Java (almost everything)

C++ (databases course, because the db guy thought it was necessary for dbs)

Scheme? (some advanced 200-level CS course, if you happened to go through that part of the program in a semester when they offered it; sadly, I didn't)

Gofer (a Haskell-like language; used for a couple weeks in the standard 200-level course)

Matlab (numeric computation and some graphics work)

MIPS assembly (computer architecture)

The programming languages I learned there were basically useless. Nobody's ever heard of Gofer. Nobody uses MIPS assembly. I've never used Scheme or Java 1.1 on a project outside of class (though I have used Common Lisp and Java 1.[2-4]).

But the point of the courses wasn't to teach me the language. When I'm staying up till 3am every night writing a compiler in Java for class, the point is not to learn Java, but to learn to write a compiler. The fact that they gave us a mission and we had to do the footwork to get there was better than teaching a language.

Being given the task of "write a compiler", you learn to teach yourself not just the programming language, but version control, error handling, refactoring, and so on. While Joel laments graduates who only know Java, I find that merely a symptom of not having learned how to learn, which is the true purpose of a university.

If you study physics and happen to use English when doing so, the point isn't to learn English well, but to learn physics. I don't think anybody would confuse physics with English. Would you ask what language top-tier universities teach physics in? ("I studied at Heidelberg, and we used German!")

Cornell also used Windows NT 4, but that's also completely irrelevant.

Undergrads are introduced to Scheme first. Many of the principles and problem solving methodologies learned during that course are applied to the later Java courses.

First year Master students take a mandatory course in Programming Design Paradigms.
Students are exposed to functional programming through small subsets of Scheme Language(Beginner Student Language ...). In the Second half of the course, the students are exposed to Object Oriented Programming through a language called ProfessorJ.

Other graduate courses at Northeastern are language agnostic. For example, in the Algorithms course, the students are encouraged to use languages like C and C++; but many choose to use Java and similar OO languages like Ruby.

Good developers will not limit themselves to what a University teaches. The kind of developers I want to hire are the ones that spend their free time writing programs that interest them, learning the languages they need to get those projects done and basically pushing the boundaries. The kind of developer I don't want to hire are the ones that got a 4.0 in their CS program, but didn't write a single line of code that wasn't graded in four years.

That said, my undergraduate University, the University of Missouri-Rolla (now the Missouri Institute of Science and Technology) still teaches C/C++ to first year CS students and continues that throughout the degree program. Second/third year students take "Computer Organization" which introduces Assembly and low level architecture. It's not until third/fourth year that elective classes introduce other languages, like Java, as part of classes like User Interface Development, etc.

I found Oxford (http://www.comlab.ox.ac.uk) didn't really teach languages per se, the course taught actual computer science -- algorithms, data structures, a healthy amount of relevant mathematics, that kidn of thing -- with very little focus on the specifics of language. Where necessary, though, we got a little tuition in (and pointers to where to find more) Haskell, Oberon, and a fictitious MIPS-like language called "SPIM" -- pretty sure we ended up writing a C -> SPIM compiler in OCAML, eventually.

Nottingham (http://www.cs.nott.ac.uk) on the other hand seems much more focussed on producing Computer Science graduates who are already trained software engineers / programmers -- so there's a lot of focus on Java early on, with more 'exciting' languages like Haskell only taught in optional modules later in the course.

I don't believe the actual language being used really matters. After all, its really only a bunch reserved words (syntax).

If you take language X away from developers and suddenly replace it with language Y, you will be surprised how well they adapt and how short the learning curve actually is. My point is that its not the language syntax that needs learning, its the actual concepts... design patters, object-oriented programming, design & architecture, best practices, etc, etc. You can learn any of those concepts with any (OO) language.

Since today, most companies will choose to use a successor to C/C++ that is fully OO, that doesn't leave most Universities with much choice:

a) Spend millions of dollars for Window OS (a must, and limited to x86 only), spend millions more for their .NET tools & platform. Ultimately limiting your students to ONE platform, or

b) Spend close to nothing on Java, reuse existing platforms (don't need only x86), also teach them about a full range of OS's (Linux/Unix/Mac/Windows) and architectures that are non-x86 based.

As for your second part:

churning out mediocre programmer after mediocre programmer.

That is pretty much unavoidable... regardless of school or programming language. The reason for that (IMHO) is that programming is an ART contrary to common belief that it is a science.

You can give 1000 people a brush, some paint and a canvas. Just like you can teach 1000 people how to code and give them a computer.

The end result is that although everyone painted on their canvas, only a few were a master-piece, some where visually appealing, but most were just simply awful. The same is for the code... a few were extremely efficient and well written, some where just standard, but most was just poor unreadable/unmaintainable code.

So why do we hire most of these 'awful' students then? Because there is just too much damn demand for software programmers! That simple! And companies are raising salaries by stealing them away from their competitors, thus enticing another round of students to join up.

I think the school was careful to teach the concepts behind the language (hence the use of Ocaml, whose presence in the industry is homoeopathic at best). The courses on testing and the courses on compilers, which were not based on any programming languages, were probably as useful in making us good programmers as the other language courses.

I'm studying at University of Copenhagen, Denmark. It's not quite Ivy League, but the best university in Denmark, and been rated in the top 50 worldwide a few times, so pretty decent at least.

In the first semester, we were taught SML, a functional language, as a general introduction to programming.

This has the fun effect of leveling the playing field. All the cool kids who think they've been clever and learned Java or C++ before enrolling have to throw it all out and start over on a completely different language. It usually turns out that those with no programming experience actually grasp it easier.

Second semester, we were taught Java as an introduction to object-oriented programming.

On second year we were taught MIPS and Alpha assembler (the former as the target architecture in the compiler class, and the latter because we had to implement a simple OS kernel running on an old Alpha).

And that's basically all the language-specific classes we have.
Depending on which classes you take past these, you'll probably learn C, C++, Haskell, Lisp, Prolog, Python, SQL and a few others. But in general, specific languages tend to take a back seat. They're something you occasionally have to pick up pretty much on the fly because you need it for an assignment or project.

(In the years since I enrolled, they've reshuffled some of the classes, so the exact order in which we learned these, and the amount of time spent on each is no longer accurate. In writing the above list I just stuck to what I knew. In particular, they've butchered the kernel project and with it, Alpha assembly. The latter isn't a big loss of course, but you really learned a lot from the kernel project)

I think that's the correct way to teach CS as well. It is not a programming degree as such. Individual programming languages are just tools to be used as necessary.

And without reading Joel's or Kay's minds, I think that was their point too. A CS college shouldn't just teach today's fashionable language. Whatever languages they teach should basically be incidental to the real meat of the degree.

I graduated from Michigan Tech, which, while not a top-tier CS University (top 50 in Mechanical, Civil, Environmental, and Materials engineering, FWIW), is supposedly regarded as having a fairly decent CS program.

The intro courses (CS 1 and 2, Data Structures) were in Java. Next was a "C++ for Java Programmers" course which introduced C++ and some GUI programming with QT. Operating Systems was taught in C++, and Systems Programming used C, though we were pretty much just expected to teach it to ourselves (K&R was a "recommended but optional" textbook). In all of these classes we used vim and Makefiles on Linux and Solaris machines. In Computer Architecture we learned MIPS assembly, and in Programming Languages we used Scheme (and a very tiny bit of Prolog, pretty much "This is Prolog, it's nifty but you won't see it again unless you take AI").

As far as electives go, I took a databases class where we were taught SQL (MySQL specifically), though most of the class was more concerned with theory (relational algebra, normalization, ACID, storage, etc.) We also touched on accessing databases with JDBC and Perl's DBI. Our final project, which was pretty much "do something neat that makes use of a database", could be written in whatever language we wanted. Other classes were similar; use whatever language we feel suits the problem best, just as long as we provide instructions and everything needed to build and run it on the lab machines (Linux). System/network administration classes used a fair amount of bash scripting. In addition to C, C++, and Java, I decided to turn in a couple of assignments in PHP, several in Perl, and a few in Python, when they were appropriate for the job.

I studied Information Engineering and Management at the University of Karlsruhe, Germany. IE+M is actually only 40% economics and 20% law, so only 40% CS as compared to a pure CS degree.

The standard language used for demonstrating programming in general, as well as OO was Java. In my case that was before Generics, so generic programming was demonstrated using Pizza, which is a superset of Java adding, among others, generic programming.

In one course we had to implement a simple CPU, then write some micro-ops in binary code, some assembler ops in microcode and some simple programs in assembly. However, this was all done on paper, there was no simulator for the CPU.

We had to write some simple programs in lambda calculus, and for a universal Turing machine, also solve some problems with Semi-Thue systems, Markov systems and µ-recursive functions. There were some minimal Turing-complete languages, like the WHILE language, which only has the WHILE-statement, the constant 0, the SUCCESSOR function and one single variable. There were also some not Turing-complete languages, like the FOR language (you can probably guess).

In our databases course, we used SQL and OQL, and also some XML query language (I don't remember if XQuery existed yet).

In some course we had to write XSLT.

In some of the courses I didn't take there is C and x86 assembly. Also, the Sather-K language is designed in Karlsruhe, so some profs use that. One chair has a cooperation with Microsoft, and used an early preview of C#.

We did some Prolog.

All in all, I think there was a good mix from pretty much every paradigm except language-oriented programming / metasyntactic abstraction (IOW: Lisp was missing).

As Joel says "A sure sign of my descent into senility is bitchin' and moanin' about "kids these days," and how they won't or can't do anything hard any more." Bitchin' indeed.

It's as absurd as Montgomery Scott bitchin' that they don't teach the internal combustion engine at Starfleet Academy anymore. Surely you can align those dilithium crystals without knowing how to construct a rotary engine.

If code-monkey jobs didn't require a bachelor's degree, perhaps the degree program would retain higher standards and lean more towards continuing education than vocational training...but, it's what the market demands.

The first semester one is taught Python if one is going to have a lot of math courses later in the grade if not one gets to learn Java.

All courses after that uses laguages, but do not use much time (or none) learning the language it self. One can then take classes that use Java, C, C++, Python, Common Lisp, Prolog, ML, ASM and matlab.

Java is the introductory language, but after Intro to Object Oriented Programming, it doesn't come up very often. There are about 3-4 CS courses that require Java in our curriculum. Many upper division courses require C.

We learned the basics of Imperative programing using C++. The next course intorduced us to Object Oriented programming still using C++ (I believe it is currently taught in Java). After that it didn't matter what language we used.

The professors I had at UT focused on understanding the underlying paradigms and not so much the language you used to implement a solution. Once you understand the underlying principles, it doesn't matter what language you use: just pick up a hand reference to see if you should end your statement with a semi-colon or not.

Which language(s) you know doesn't impact how good of a programmer you are. Having exposure to the various paradigms (object-oriented, functional, imperative, declarative, logic,...) will certainly help round out your tool set, but that won't make you a great programmer. What I'm trying to say is that a good CS program doesn't teach "languages", it teaches "concepts" and let you use whatever tool needed to demonstrate your understanding of those concepts.

I imagine that the programming language that universities would teach would be the programming language that you write the same programming language in.

Pedagogically speaking, I also imagine that universities would teach how to learn how to learn, and teach how to teach how to learn how to learn, and teach how to implement learning processes as mathematical functions.

Ohio State University

RESOLVE/C++ - for the intro classes, it's kinda like a bastardized easy version of C++

SPARC Assembler - which is actually used to write a simple software emulator of a 8-bit RISC computer

Year 2 and beyond

You learn whatever the class needs.

For Language Theory and AI classes you pick up Lisp or Scheme, for Numerical Analysis classes you will probably use C or C++, for Systems classes you will pick up something with good libraries, etc.
OSU tends to make sure you know how the computer works from the hardware up to the highest level constructs and languages, and the rest is up to you.

I agree with everybody that said that "They have always churned out a lot of mediocre programmers, a handful of good ones, and a few brilliant ones. Only the language has changed."
The things that really matter the most are their incoming skill level and their passion for CS, those things will really drive the skill level of graduates.

C++ for first semester, C++/C for second semester/data structures
Flex/Bison for Programming Languages (plus exposure to several others)
C for Operating Systems/System Software
There are optional C#, Java, Python, and VB classes
Higher classes are in anything - primarily C/++

posted 2009-03-13

0

McGill University.

I've done the Computer Engineering program there. The following list were the programming languages used for these classes:

Intro to computer engineering: C, ASM

Intro to computer science: Java, SML (functional programming)

Microprocessor Systems: C, ASM

Intro to software engineering: Java

No visual basic, no c# (although project teams were allowed to use them. They were simply not thought directly). I know some computer science students learn python, perl, bash scripting... In computer engineering, learning them was a plus, but not officially thought. They assume you should learn it yourself I guess...

The first four languages were taught in classes considered part of the standard required CS curriculum. There were some optional elective CS classes that had you use other languages like VB.NET and PHP. Once you got to the higher-level classes, most of the teachers would give you a project and let you choose how to do it (i.e. you can pick the language).

Some sort of assembly language for the computer architecture/engineering course

Along the way I also remember having to briefly use prolog, tcl/tk, html, VB, and C++ for various class projects.

I should also mention that the languages were never the focus of the classes. Instead they would teach us concepts (algorithms, data structures, language design, etc.) and we would be required to learn the specifics of the language on our own.

Anyway for a university with more business and computing students than computing students I've found that they have a reasonable selection of Languages:

First year: Two modules of Java programming with a bit of assembler in Systems Architecture and a bit of prolog in Computation and Reasoning. (That includes the business students)

Second Year: everyone has bit of UNIX shell scripting in Networks and Operating Systems, people doing computer science had a module of Haskell including stuff like higher order functions (our lecturer is on the design committee for Heskell' ) and Java/JavaCC in langauge processors, other branches of Comptuer Science do diffent stuff, the Games-Tech people are doing C++ I'm not sure about others.

In a typical Software Engineering track, languages will be encountered in the following order:

Java (Basics)

ASM

C

C++

SQL

Back to Java

PHP (optional -- web development elective)

At this point, students will be involved in a Software Development Laboratory course where they are challenged with real-world client projects. The languages learned/used here are subject to the requirements of the project.

After this are the Senior Design projects; languages learned/used are again subject to the requirements of the project.

As an MSOE graduate, I just wanted to add that in many courses, the labs don't require you to pick any one language. You're fairly free to implement your projects in whatever language the professor is willing to accept. This allows them to focus on concepts rather than languages.

They teach a bunch of other classes as well, this may not be a top tier university, just what I am currently going through for my Software Engineering degree. If you want more information, their website is actually pretty good, just look past the fact that the Software Engineering degree is now known as Advancing Computer Science degree.

Often, whatever language we want. A few classes force Java, but also MATLAB, Python and C. I hear some classes use Lisp, and we offer at least one class on C++. That said, there are many students that only seem to know Java and then they struggle when they encounter one of these new languages. I guess I was fortunate to learn C++ as my first language in highschool. Oh, and my computer architecture class forced assembly language. So, I guess it's pretty hard to get a degree here without at least touching Java, C, and Assembler. The rest sort of depends on what you take.

In the early 2000s, intro to CS was focused on C programming. The next course in the chain introduces shell scripting and them moved to teach C++. Later OOP courses focused on C++ and Smalltalk. There was a programming languages course that taught Pascal, Prolog and primarily ML. Our AI course used Lisp.

At the time, C# or Java were not used, at least not formally, students were expected to learn these languages themselves for certain projects.

Data Structures (Allowed to use any language that runs on any of their servers)

Operating Systems (C)

This is very well dated but I was impressed with them allowing you to pick and chose what to use for the Data Structures course. The best programs should provide an opportunity to make choices about the languages that you learn.

University of Texas at Austin (was ranked 9 or so, not sure where it is now):

Java for Intro classes and data structures/ADTs. I think the introductory classes used to use Scheme, but I think that scared too many people away from the program.

Haskell/C/C++ for the Programming Languages class

Java for Operating Systems

An assembly language class

Many of the electives used C and C++.

They also have one hour classes for each of the other big ones (Python, C#, Perl, LISP), but unfortunately I didn't take any of those.

There was plenty of theory in the required curriculum as well (discrete math mixed with programming proofs, automata theory, etc.).

I remember one professor speaking of a "departmental catch-22", where although 95% of the people graduating went straight into industry, they still geared the program to the 5% going to graduate school.

They were (and probably still are) really anti-Microsoft - mostly Linux labs, no VB classes, and no C# for quite a while.

At its inception, Transylvania University had a bit of history with Carnegie Mellon's CS department, though things have changed in the last 50 years naturally. I was pretty happy with the teaching style there.

Logic and Problem solving - C++

Data Structures - C++

Computer Organization - MIPS assembly

Theory of Programming Languages - LISP, C, Prolog, Java

Operating Systems - C++ required for programming NachOS

Other than those requirements, you can pretty much hack in any language you please. Most students stick to C++ however, since it is the language taught in the first two programming courses. My adviser, however, would probably have heckled you if you wrote in Java. Especially anything math intensive. Though the curriculum has gotten easier since I graduated, (allowed students to opt-out of two of the more difficult classes and cut two semesters of discrete math to one) it's still primarily a school that teaches computer science as science, not a vocation.

Imperial College London teaches Haskell for the first six weeks, an in-house imperative version of Java called "Kenya" for the next four, and then in the second term, Java and Pentium Assembly. These aren't the only languages you need to know to get through the course, but you're expected to pick up anything else on your own. Everything after the first year either requires you to know a language, or teaches concepts and lets you pick the way you implement them.

It was Haskell for quite a while, then they changed to Java, but that lasted only a couple of years, and now I think they're back to Haskell (along with various other languages for specific courses, such as Ada, PHP, Korn shell, etc.).

Otago University Computer Science taught Java at the 100 level and half of the 200 level. This was basically programming and problem solving basics.

In the second half of second year it moved onto algorithms and data structures in C.

In 3rd year they didn't seem to lock you into any particular language, you could pretty much use what ever you wanted. With the exception of a few - OO was C++, A.I. was prolog, lego mindstorms (:D).

I believe they now have a Python type paper.

At the time while I was studying I was a bit pissed off because we were never really taught how to use a particular language. I remember being particularly annoyed that they didn't teach PHP and feeling like I just wasn't learning anything. If I ever tried to code anything in my spare time I would use Java as that's the one I was most comfortable with.

It wasn't until I actually left Uni and started working that I realised how beneficial their way of teaching was. The majority of class time was spent on learning how to program effectively rather than the ins and outs of a language. I started to realise how beneficial this was when I would see people who had gone through other courses only to become C#/Java masters and it's almost like they are locked into a world of business system programming.

Introduction to programming principles and more advanced (but still fairly basic) stuff is essentially following the "Java vocational school" approach. The advanced programming course also introduced C/C++ as a single language, mixing concepts from both in a rather messy and error-prone way. That course needed serious rethinking around the time I took it a couple of years ago.

Functional programming principles is covered in Scheme.

The operating systems course focusses almost exclusively on the implementation of a FAT12 driver in raw ansi C.

Engineering principles for software was taught in UML using Java as the base language that everyone is assumed to understand.

Databases were dealt with by using SQL connectors from Java.

There was also a very basic HTML requirement that had nothing to do with the technical disciplines, but was more about personal professional image.

Compilers is handled by fiddling with JFlex.

Formal specification is done in the B method and language, as most of the staff prefer it over Z, at least for teaching.

I think it is pretty obvious from this list that "employability" is the most important buzzword at my university.

Despite many courses in the first two years having very strict requirements for languages (nearly all Java), we are constantly encouraged to experiment with any other languages/tools or technologies that seem interesting to us. This is essentially the reason I moved to .NET a year ago, and am currently playing with the D language against bare hardware.

CS is generally not primarily for language instruction/learning. They are merely tools for learning CS topics.

At Columbia I learned scheme in the SICP course, C in the OS course, C++ as a language course.

Prior to 1989 I think some CS courses used pascal for an intro language (before SICP was adopted.)

I think they use Java now for some CS courses

The AI classes let you use whatever Lisp variant you wanted.

C was pretty common for the higher level classes. It was a one point elective as well. Which supports the contention that learning a language is not a priority in a CS curriculum

posted 2009-07-10

0

The University of Alberta has traditionally taught intro computing science in Java. In '07 or '08, a new line of introductory courses were created based around the theory of computation rather than the engineering of programs. These new courses use Perl, though there isn't much programming. (Ironically, I think this is the best way to teach "programming".)

While Java is still the main language taught at the U of A, most senior courses are not programming language-specific, in that the professor allows students to choose their language. This is a huge plus, though it does depend on the professor.

Note: The Technion is considered Israel's best engineering school and one of the 30 best technological instutions world-wide. I consider that top-tier, and hopefully I'm right - I'm deeply invested in it already (3 years down, one more to go).

When I was an undergrad in 97/98/99 I started and finished with C (without the ++) and taught myself Perl and Java on the side. Now they are starting people off with Java but then you have to learn C and C++ to take many of the 4000-level courses (Computer Graphics, Operating Systems, etc). You will do some sort of assembly programming when you take the low-level classes such as Comp Org. Some AI courses are being taught in Lisp. There was a class taught in OCaml last year I believe.

The Carnegie Mellon answer here shows the languages taught by the Computer Science department. I'm an Information Systems major, and the languages are pretty different:

Introduction to Information Systems - HTML CSS Javascript

Information Systems Milieux - PHP SQL

Application Design and Development - Ruby on Rails

Further courses are largely project based and the choice of language is left up to the students. There has been some discussion of teaching Python, but as far as I know that has not materialized into a course yet. Information Systems courses also tend to be divided into advanced and basic sections based on prior coding knowledge.

Also, importantly, we had a few
classes learning to use a library,
the MFC. Now which will be replaced
with .NET. But the point is to get
practical experience building big
modern, GUI applications.

I happened to be there at a good time when the SoftE program emerged, and we already had CS. My class was the first of 4 schools in the nation to get ABET accreditation for SoftE, and the only one to get the full 6 year approval. And yes I was one of the best programmers in my class, and went right into industry as a programemr during a recession.

At the second rate state school I started at, we learned C++, but we didn't even learn basics like linked lists or classes. I transferred to the first rate state school, and they teach some pretty intense Java here for freshmen. Shell programming (bash, awk, perl, etc) in a few classes. There's of course, a class on MIPS. Even a fourth class where you design your own language.

Having taught at top-tier schools, I don't think that the problem is the languages. The problem is that people don't get any real-world software engineering education and skills. At best, this is left for optional electives.

This is part of a philosophy that CS is not about programming and that you don't go to a top-tier CS department to become a software engineer. Unfortunately, while that should ideally not be the case, few people go for the Ph.D. (and many end up as engineers anyway, as happened in my case), and most end up as software engineers.

You don't see this problem as much with EE departments, where it's understood that it is completely acceptable for graduates to work as engineers, and there is therefore an attempt to make them understand that circuits are more than just pretty lines drawn on a board but rather quite a messy thing.

Each of these courses is required before degree specializations kick in. Intro to CS for non-CS majors, however, is in Matlab =/

Many of the higher level courses allow the student to choose a preferred language, as long as the TA and/or professor know it. In courses like software engineering and senior design, the choice is absolutely up to the project group. Courses with domains tied heavily to a language usually use it - the intro to AI course is taught in Lisp- but that is beginning to change (the languages, computational theory and compilers course allows Java).

Despite the freedom, Java is definitely the lingua franca, and most students don't really break out of the C/C++/Java family. Web technologies are never taught- aside from tangent to a databases specialization course- though sometimes professors expect students to know a bit of HTML. I don't know of any course that focuses on Javascript (you would think the into to UI class, right?), or any server-side technology (PHP, Ruby, J2EE, .NET for the web, etc) other than the last project in the intro to databases course. From what I've seen, a lot of students decided to give the web a first or second try for their senior design project, or learn it on the side.

The further out of the norm your course choice is, the better chance you have to be exposed to cool languages. AI, web development, and HPC are all great areas to try something new, and it seems like I'm always learning something that I can apply to the rest of the field.

So long as the language is fairly modern and widely used (e.g. C, Java etc), then it doesn't much matter - the skills being taught are more important.

Saying that, IMO it is very useful to learn at least one low level language (e.g. C, Assembly), as that makes you appreciate what is going on under the hood, which is useful for most serious programmers.

I'm not studying computer sciences, but our informatics prof wanted us aerospace engineer students to code in VB.net. One of the reasons was, that the IDE sharp-develop is free of any charges ;). and in my opinion he can code it, because it is similar to basic, that he learned when he was a student. So he is used to it.

Formy diploma thesis I coded in Java, because it has nicer code than vb.net (sometimes it's butt ugly! :)) and a friend of mine is a informatics students and they codein java, so he was able to help me, when I had questions how to solve my problems.

Portland State University(not a top school)-Note this is what I was taught in although its similar for new students especially for the 161-202 and compilers part I, II classes.

161,162,163,202- Intro classes procedural->data structures->basic OOP
Taught in C++ w/ a tiny! bit of Java at the end of the last class to try it out.
C++ is taught mostly c style to start out with. Using iostreams for i/o and c style strings(char arrays). Then you learn pointers ->recursion->data structures->C++ OOP (inheritance/protected/friends/operator overloading)

200/201(they might have turned this into one class now- C and a bit of x86 gas assembly(figuring out what it means not writing any programs with it)-teaches a bit about how a c program works-binary representations of int and float,how structs fit in memory, the stack,loops, some optimisation stuff.

250/251/3?? -Logic/languages/NFA/DFA/turing machine/for all/some/boolean algebra/proofs,ect.-mainly theory but when I did it hw in language instructor decides on prolog/maple/Standard ML

386-Intro to databases-sql (postgres I think,plus theory, plus one short php script)

Other classes were instructors pick(Java is popular especially for the compilers class)

Usually its some basic instructions plus pick it up on your own-unless its Java

Also although higher level classes aren't supposed to just teach programming languages have 2 cool elective classes called OOP and Functional Languages, which teach Smalltalk(Pharo) and Haskell respectively although considering how idiomatic those languages are to those programming paradigm its understandable.

I can just talk for Blekinge Institute of Technology in Sweden. Here, most of the Computer Science programs starts out with 7.5 credits with the foundations of c++, and follow ups with Algorithms and data structures. After that, you have 7.5 credits with Java.

Other computer science ourses often handles different languages, it all usually depends on what the teacher like. But the mix is kind of big. It handles all from C, IA32 assembly to Java.

Also, in different project courses any language could be an option, depending on the customer needs. For example, for my graduation project I learned objective-c.

The best approach is, according to me to start out with C++ and from there, go to Java and C. You might say you could start out with C but you also want the object oriented languages as c++. I believe this worked and still works good. It was much better than before, when all Computer Science programs started out with Java, and then follow upped with C++. Many people had huge problems getting getting a hand of C++ when they've started out with Java.

I am a grad student at RIT. Well, first and foremost RIT gives bridge courses to almost all the grad students, which I feel are very important for a strong base. The bridge courses are Programming languages JAVA and C++, and a course in Computer Theory.

The language cluster in the CS department has various programming skills courses.

I am glad to discuss why I created the Contra Costa College community college CS degree I did for my students. I have only 2 years, in general, to suitably warp their minds.

Intro to Programming: C++

Data Structures and Algorithms

Computer Architecture

Intro to Programming: Scheme

Calc 1 and 2

Finite Math

Linear Algebra

The real issue right now is parallelism. College students have computers with multiple cores, yet are typically unable to do parallel programming because it is not taught. The scandal to me is that industry is often hiring non-computer scientists to do what should be the work of computer scientists. We will be a hiring manager from Adobe soon on our "Teach Parallel" show and it should be interesting. Alan Kay, mentioned above, is another person we interviewed. My page http://about.me/wolfmurphy has links to my parallel related activities.