I told my friend at work about this thread. He isn't on here so I am ghost posting for him for fun and perspective.

He did his undergrad in CS at UCLA '78-'82.

Intro to Programming => PL/1

Problem Solving using Computers => Algol 68

Operating Systems => MIX pseudo assembly

Data Structures => Mostly theory/test based

Programming Languages => COBOL, Fortran, APL, and ALGOL 68

Software Engineering => C

Simulations => GPSS (General Purpose Simulation System)

Graphics => GDDM (Graphical Data Display Manager)

Very cool how diverse the language selections were.

Also interesting to that C hadn't really caught on yet.

Your friends sounds like he has the "Right Stuff" and can join the Algol68@linkedin group ...

http://www.linkedin.com/groups/Algol68-2333923/about

Intro to programming => Java

Data Structures => Mostly java, a couple projects in C

Computer Organization: pretty sure this one was entirely in c.

Programming Languages => Whatever the most recent version of Ada is, python 2.7, prolog, haskell, c#, java, "language of your choice, suggested choices are ruby, python, or perl" and most people chose Ruby, and I believe that was the gamut. I may be forgetting a few, and I know that course has switched to using Ocaml instead of Haskell for the functional language section. The course is all about how languages are implemented and what makes one language different from another, so obviously it bounces around a lot. Super interesting class, one of my favourites.

Networks: Java or C; at least one project was mandated to be in C.

Software design: Ruby, and a tiny bit of Haskell

Operating Systems: C.

Human-Computer Interaction: Mostly javascript.

Almost all grad level courses (except for the intro programming), taken circa '12/'13

I started my undergrad in 2008. At the time, my department's intro sequence was C -> Java -> C++. Essentially, intro to programming -> intro to OOP -> data structures.

After that, professors used whatever they wanted. Most electives let students use whatever language they wanted so long as it ran on the department's Linux machines and you provided build instructions for the professor.

Scala became the intro language the year I graduated with C and C++ following for data structures. Other courses use everything from Scheme to Java to Haskell to Python, depending on the specific course the professor.

My undergrad thesis mentor actually wrote an intro CS textbook using Scala and from what I hear it's worked quite well.

http://www.programmingusingscala.net/

I graduated in '08 (wow that's 6 years ago already!). We used C++ for all the core courses except Data Structures, which used Java. C++ wasn't too bad as an intro language, with a very encouraging teacher. Java was a disaster because there was way too much boilerplate when you're just trying to write a toy data structure for an assignment. At the time I left, they were considering moving to Python for the intro courses, but there didn't seem to be much enthusiasm behind it.

And we used Access for our database course. Sigh.

That said, it wasn't as monolingual as it sounds. Even though the courses were geared toward C++, several of our teachers were enthusiastic polyglots (actually one of them spoke four human languages!), and we were encouraged to explore.

OP here, all my C courses had the extra requirement that they compile under GCC on a Solaris box; not for our education but for the prof's benefit of using an automated "turnin" program for grading. Thank god though, I had one cool professor that let me use Visual C++ while everyone else used GCC. The productivity boost allowed me to beat everyone in getting the regular projects done and then give me extra time to code up extra credit stuff. Not a language progression but a tool progression at least - got me hooked on IDE's.

Oh yeah, I should mention that we used an old (but still quite usable) version of VS for the C++ courses. That made it easier to code, but the huge and uninformative error messages put a lot of people off.

Started my graduation in 99, finished it in 04, at Brazil.

1st year: Intro to programming in Prolog, and data structures in Prolog or C (student's choice).

2dn year: Everything in C, except for system level courses, in MIPS and x86 assembly.

3rd year: Mostly C and MIPS/x86 assembly, a very interesting discipline in programming paradigms teaching Lisp, Prolog, and Java.

4th year: From tis point on, the course starts to lose structure, my choice of disciplines used mostly C/C++, with specialized languages for compilers, and VLSI design. (Have you ever tried to do network programming in C? Strings are funny.)

5th year: About the same as 4th year.

In retrospect, the official list of languages teached in graduation is ridiculously small near the list of languages students were unofficially expected to know at its end.

Wow, an intro class teaching Prolog, what was that like?

Oops, wrong language. I meant Pascal.

I graduated in '08, although my major was IT and not CS. All the CS courses I took (pretty much all the required 100- and 200-level classes, a couple of 300-level electives) were in Java (although in one class we used Prolog for some stuff). Other coding classes for my major included Computer Architecture in which we used C and MIPS assembly, some web programming class that was JavaScript and PHP, Systems Administration that was Python, Information Assurance and Security used a lot of C (mainly for demonstrating various flaws). In most other classes were given a lot of freedom in the language because we were graded on functionality, not code. I generally focused on C, Python and Java.

Class of '04, Computer Science

- Programming I in C

- Programming II in C++

- Data Structures in C++

- Theory of PL rotated languages every semester and project had to be in a language you didn't know coming into the class. (C#, php, pl/sql)

- Software Engineering divided into groups, each group assigned a stack to implement (mine was LAMP)

- Databases pl/sql

- Compilers C/lex/yacc

- OS projects in C and assembly

- Parallel projects in C, python and mpi

- Python language class

- Scripting languages survey was always python and ruby, but rotated in something new or interesting each section.

- A COBOL section with old mainframe

- Assembly class was in MASM

No FP for undergrads. No one had to learn Java or C#, you were given the opportunity to be exposed to them through User Groups or electives, but directed classes in them were reserved for the Information Systems people over in the Business school.

--- edit: formatting

I've not graduated yet as I started in 2009 and just take courses every now and again instead of doing it all at once, I'm completing my last term this fall.

First year with C++ and C. The C++ usage was C-style code just used cout/cin/booleans.

Second year was C, Forth(had to write an interpreter) MIPS32, Java, and Objective-C(Elective in iPhone dev[pre-iOS days])

Third year: C, Java, Haskell, Prolog

Fourth Year: Matlab, C, whatever you want. Most 4th year courses are either fairly specific or you're free to use any language you want. Ex. the Computer Vision course uses Matlab, but the AI course you could use whatever language you wanted provided you supplied steps for running it that the marker could follow.

I studied in Hamburg, Germany. We started our first programming course with Ruby, the second was Java. We did some Prolog and Erlang later on and I took an optional course on the the basics of FP in which Scala was used. Oh, and there as a Software Engineering project where we could choose from either Java or C#. And we did some Assembly/C in an OS course as well.

All these were undergrad courses. My graduate courses were mostly either theoretical or project work where we could choose our own language. The only exception was Maude [1], which we had to use.

[1]: http://maude.cs.uiuc.edu/

Undergrad 1999 - 2004 (IU-Bloomington)

I can only speak for the classes I took

Intro to Programming => Scheme

Object Oriented Programming => Java

Assembly Programming => 68k assembly

Intro to Data Structure => Java or Scheme (depending on Prof.)

Operating System => Technically C, though I did some of it in Java

Compilers => Scheme

Programming Languages => Scheme

Distributed Programming => C and MPI

Web Programming => HTML, Javascript, Java, PHP, Apache & Perl

AI => Scheme

Software Engineering course => whatever was required or wanted, we chose Perl

IU-Bloomington at the time barely touched Java, preferring to do most of the teaching in Scheme or C. I would have prefered they had focused more on C (as I still can't program a C program without segfaults galore.) and less on Scheme, but that's how it goes.

Soon going to start my last year in my CS master at Linköping, Sweden.

The overall trend appears to move towards Python and even some functional languages like Haskell, but Java is still very common.

Core

Intro to Programming => Common Lisp (Now changed to Python)

Intro to Data Structures => C++ and Java

Intro to Object Oriented => Java

Embedded => C/C++ and 68k assembler (possibly some other architectures as well)

Operating Systems => C

Elective

Some of the subjects have been touched on in other subjects, like logic programming.

Compilers => C++/Flex/Bison

Advanced Data Structures => C++

SICP (course follows the book fairly closely, not sure what to call it) => Scheme

Database => SQL (probably python/Java)

Web programming => Python

Logic programming => Prolog

Design patterns => Java

Artifical Intelligence => LISP and Java

Parallel computing => C and C++

From what I hear, java is the big one.

2007-2010 undergrad dates here.

I graduated with a degree in Computer Information Systems. CS was not offered at my school which was a relatively smaller university with focus on general business classes or accounting. Finance/accounting/economics/marketing/management were the more popular majors (25 graduated with my major)

The more development oriented classes were Intro to Java & Intermediate Java. We also had an intro to web development class that focused on HTML/javascript and another that used C++. There was also a DB class that used Access and the next level DB class used mysql.

1st year CS @ ETH Zurich here

Intro to Programming => Eiffel (Betrand Meyer was our Prof)

Algorithms and Datastructures => Java (Pseudocode in PASCAL)

Parallel Processing => Java

Design of Digital Circuits => Verilog/MIPS Assembly

and in the next courses there will be some Haskell and more Java.

Graduated in 2013, started in 2008.

C was used for 101, Systems programming, Operating Systems, and Networks. There was an elective HPC class which taught CUDA C. C++ was another elective class.

Java for 102, Algorithms/Data structures, software engineering, and oddly enough Compilers (along with ANTLR for the parser).

Programming Languages was Racket or ML depending on the teacher.

There were also elective HTML/CSS/Javascript/Ruby on Rails classes but I think they counted for 2 credits (instead of 4) and were only offered online during breaks.

We used MIPS and some other teaching assembly language that I forgot the name of for computer architecture.

You went to Cal Poly huh?

Interesting to see all the answers. To put things in perspective, these were the languages I used at MIT from 1969-1975 (except for PL/1, we didn't have courses on programming per se, they just gave us the manuals and it was sink or swim):

Fortran -- Engineering classes

PL/1 -- Intro to Programming EE/CS

APL -- EE (network analysis, etc)

360 Assembler -- EE/CS systems course

PDP-8 Assembler -- EE/CS Project

PDP-9 Assembler -- EE/CS Project

Lisp -- EE/CS AI class and structure and theory of Programming languages

CLU -- EE/CS Research

Pascal -- grad school

I'm sure there were some others in there. I didn't really learn C until I started working on the Unix kernel after grad school.

I graduated in 2011 and my sequence used:

Alice/Java => "101"-type class

C/Perl/Shell => Intro to Systems

C => rest of the systems branch

Java => Data Structures

Standard ML => functional and logic classes.

Many of the more esoteric electives used their own thing. For example, I used Serpent in Computer Music Systems.

The curriculum changed in my final year. The new students now do:

Python => "101"-type classes and basic data structures and algorithms

Standard ML => parallel data structures and algorithms and other functional and logic classes

C0 transitioning to C => Systems courses.

I do think our distributed systems class was experimenting with Go at some point.

'10 from Imperial College London, we did:

Haskell Java Prolog C and C++ NASM assembly

Then depending on the optional modules you chose you might also do a couple of more specialized languages like Matlab.

There was also a mandatory course involving building a multiplayer networked game with total flexibility on language, but predominantly people did browser based games with one of PHP/Python/Perl/Ruby and JavaScript (although NodeJS wasn't around in 2008 when I did the project, but I'm sure people are using it now).

Not exactly "these days", but hey, perspective, and non-US.

1998-2001 (Curtin, Western Australia)

Intro to Programming => Pascal (switched to Java in '99)

Intro to OS => C and an x86 assembly variant I don't remember much about

Comms => C

Database Systems => PL/SQL

Systems Programming => C++

Design and Analysis of Algorithms => C

Scientific Computing => C

AI => Lisp

Graphics & Visualisation => C

(Looking back over my transcript, I was a really terrible student :/ Just as well I had a pretty decent grasp of C before I went to uni really.)

Pascal! First mention I've seen on this thread.

There is a required C++ course and then a required Java course. Later classes use one or the other language, these were the main two languages used in CS.

There was a course on logic gates etc. where we learned MIPS assembly.

The database course used SQL.

A course on algorithms used Python so we learned that as well.

Then we had a course on languages. Half of it was devoted to Common Lisp, but it also touched on languages such as Java and Prolog.

Started CS at my university in 2011.

Intro to Programming => Java

Intro to Scientific Programming => Python

Data Structures => Java

Computer Organization and Design => C & MIPS Assembly

Programming Language Concepts => Java, Prolog, Haskell, Python

Operating Systems => C

Bioinformatics Algorithms => Python

I would have loved to have been introduced to a Lisp somewhere in there. Had to stumble upon that one on my own, and it's my go to language family for side projects now.

I'll be a senior in college next year.

We use Python for our introduction course (still 2.x due to a library incompatibility) and Java for the next level course.

After that, it's about 90% Java, with C++ for certain courses. Only exception I can think of is Databases, where we use MySQL and write programs to interface with it in mostly PHP (but also some Java at the end).

hola

Grad was 2010. Mostly was Java for everything, except

- C for an OS course

- ARM ASM for a CPU course

- creating some C# lite language for a compilers course.

- SML for a languages course

- SQL in a databases course

I was pushing to use python for the first programming language class since Java had too many magic words that confused people, but they didn't go for it anyway since internship employers still wanted java in the first years even.

Current student here. 90% is C++. Other 10% is various other languages used to show different programming paradigms. My university solely teaches C++ for the first two years (and after that, its class/professor dependent) because it has partnerships with a couple major engineering companies that give the school a good amount of money.

Current Oxford student:

Functional Programming: Haskell Imperative Programming: Scala Object Oriented Programming: Java Concurrent Programming: Scala Concurrency: CSPm Intro Algorithms: Haskell Compilers: OCaml Digital Systems: MIPS Assembler Networks: C Graphics: Java Databases: SQL, PHP (apparently...) Principles of Programming Languages: Haskell

Currently still in school (senior graduating in 2015) I started my degree at Georgia Tech and I'm finishing it at UCR.

---------------

Intro to Programming => C (GT) / C++ (UCR)

Intro to Data Structures => Java (GT) / C++ (UCR)

Advanced Data Structures => Java (GT) / C++ (UCR)

Compilers => C (GT) / C(++) (UCR)

Systems Software => ? / ?

Operating Systems => C (GT) / Java (UCR)

Database => ? (GT) / SQL (UCR)

---------------

Minho Univ. Portugal

Functional Programming: Haskell

Imperative: C

Object: java

Computational Logic: Prolog

Graphical Computation: c + opengl

OS: c

Concurrent: Erlang, java

Compilers: c+yacc+flex

Program Calculation: Haskell

I've notice very few places teach program calculation. It is an interesting trend and you can learn more about it here: http://www3.di.uminho.pt/~jno/ps/pdbc_fm.pdf

For me two years ago it was still C/Java/Sql and also a course on 80x86

The hard part was the Advanced Algorithms and Data all in C where you can fuck up in the algo implementations AND also in the memory management of your algo implementation. A fuckup on a malloc/free could cost me the failure of an entire exam

I graduated this past spring. A good chunk of the classes were primarily in Java. I only took 4 or 5 classes that the utilized C/C++.

However, there was a revamp in the curriculum in that the core courses are not being taught in C. It's not till they are in their Junior year that they now encounter Java or C++.

Class of '09, computer engineering.

1st year:

Intro to programming: C (& bash to compile & run programs)

Intro to datastructures: C++

2nd year:

Digital Systems: 68k assembly

Design Project: PIC microcontroller assembly

3rd year:

Prog. Lang: Python, Scheme, Prolog

Databases: SQL

Comp. Org: Verilog, NIOS assembly

Operating Systems: some weird custom language for this one course

Control Systems: MATLAB

4th year:

Compilers: C

Compilers2: C++

Distributed Systems: Java

Computer Networking: Java

Computer Security: C (& learned to use gdb)

Also used bash & java to do my thesis

I'm in my second year in Computer Science, so far we've used: Java - Programming Lab 1 MIPS assembly - Computer Architectures Lab C - Programming Lab 2, Operating Systems, Algorithms and Data Structures Lisp/Standard ML - Programming Lab 3

Intro programming = python Data structures and algorithms = python Intro OO = Java Concepts of Computer Systems = C/C++/mips/x86

Those are the names that the school gave the courses it's basically CS1-4

Those are the current courses I took CS1-3 in java and CS4 in C++.

A friend of mine is teaching an introductory course in Clojure. It is perhaps still at an experimental phase, but so far the experiment has been a notable success, judging by the students' performance later in college and after the college.

I took two grad courses this Spring:

- Networking used Python with Mininet

- Software Development used Java with Eclipse (Android, Swing, JUnit, Google App Engine, GWT, etc.)

I finished my undergrad in 1995 and used C and assembly (RS6000, Spark, x86). C++ started to be an option when I left.

Graduated with a CS degree in 2004. The breakdown of the primary languages I used were:

75% Java 25% C

With some smalltalk, SQL, and C++ sprinkled in for some of the more specialized classes

Asking a friend who graduated 2014:

60% C++ 40% Java

Some C#, Python, PHP for some of the specialized classes

I’ll start the last year of my M.Sc in CS in Paris, France next October.

Intro to Programming => Java

Intro to Data Structures => Java

Advanced Data Structures => Java

Compilers => OCaml

Systems Software => C

Database => MongoDB, PostgreSQL

Web => PHP

Logical Programming => Prolog

Functional Programming => OCaml

OOP => Java, then C++

Scripting => Python

I would have loved to use Ocaml for my compilers course, writing one in Java was a less than ideal situation, especially since the spec we were implementing was a strict subset of Java. Not much of a wow factor when you create a language that can't do anything the implementation language couldn't.

I Just finished my undergrad and am starting my masters. University of Utah

Intro to Programming => Java/Racket

Software Design 1: C++

Software Design 2: C#

Intro to Data Structures => Java

Compilers => Racket

Systems Software => C/x86

Operating Systems => C/x86

Database => dunno

Electives

Programming languages: Racket Advanced OS: C

Most of the (non-systems programming, which use C) classes offered at my university are in Java but a few of them are taught in O'Caml (The programming language and compiler ones).

When I went to Uni' in like 2006, it was all Java (end to end) except electives in Visual C++ (ick), some web stuff in PHP/SQL, and then the maths requirements had MathsLab.

I'm about to graduate in December. We've used almost entirely Java for the core classes. My algorithms class used python and we had a single class devoted to C/Unix.

I'm going to a technical college, but (in order of exposure so far) C++, Java, VB, C#, SQL, Javascript. Haven't touched python yet, unfortunately.

Looks like you received more variety than most of the other commenters.

So I left university in 99 (Cal Poly SLO) and am considering going back in the Fall to finish. From what I understand most courses are still using Java.

I graduated ~7 1/2 years ago and we had a class with Prolog and SML/NJ. SML/NJ wasn't even new back then, but it was pretty sweet.

Class of 2016 undergrad

Intro to CS: Java

Data Structures: C++

Systems: C

Programming Languages and Compilers: OCaml

Numerical Methods: Python

Programming Studio: Java + Ruby/Python/Perl + PHP/Any web framework + Language of your choice

Current undergrad:

Intro: Java

Data structures/algorithms : java

Advanced data structures/algorithms: java

Programming languages: C/scala/javascript

web development: php/js/sql

databases: sql

logic: prolog

networking: C

Comp. Organisation: x86 asm

electives:

Operating systems : no code at all

embedded systems : C

digital systems : VHDL

Introduction: C# (WinForms)

Data Structure: C#

Patterns: C#

Web client: HTML/CSS and jQuery

Web server 1: Java

Web server 2: ASP.NET (WebForms)

Database 1 & 2: SQL Server 2005 & 2008

Project: ASP.NET MVC 4 + Entity Framework

Wow, where did you go that used .NET? I've only ever seen that in specific .net courses available in some places.

Just finished 1st year. We used Python for the introductory class, then Java for the intro. to OOP class.

Programming Paradigms (aka Intro to Programming):

- 1st semester: Haskell (functional)

- 2nd semester: C (imperative)

- 3rd semester: Prolog (logic)

- 4th semester: Java (OOP)

That's very interesting. Where is this?

I had a semester long class but with Scheme, F#, and C#.

My impression is that Python is much more common now, but Java still dominates.

I'm about to graduate and I learned almost entirely Java. I hear that some of the intro classes are switching to python however.

FWIW, I'm a year from graduation and have been taught 90% C++.

I currently teach high school math and science, but I'm looking to switch over to CS in the next year or so, still at the high school level. If I make the switch, I'm going into a school that has no meaningful programming classes. I am currently outlining a four-year plan to build a good high school CS program, that would set students up well for jumping into a competitive CS undergrad. I'd love feedback from people in this thread, about how well this would set people up for their undergrad work:

--- Year 1 ---

[few students in the entire school program at all] Offer multiple sections of an Intro to Python class. Focus on Python, because people can start to do meaningful projects in a relatively short period of time, while still learning meaningful fundamentals. Focus on intro classes, to build a broad base of overall programming competence in the school. Focus on games, visualizations, maybe delve into some robotics.

Also offer some web-focused classes, focusing on basic html and css, getting into Bootstrap and Wordpress as well.

Support other topics such as 3d modeling, graphic design, etc.

--- Year 2 ---

Offer an intermediate Python class for students who have taken the Intro class, and who have continued to build their own projects. Expand projects to include web apps, focusing on full frameworks such as Django and more modular frameworks such as Flask.

Start to offer other languages. C for students who want to understand how things work at a lower level. Go for students who want to work in a newer language? Maybe Java for students who want exposure to a statically-typed language, without dropping all the way to C?

Start to bring students to a conference or two, probably starting with PyCon. I took one student to PyCon last year, and it was a great experience for him, and continues to be a guiding experience in his life.

--- Year 3 ---

Offer an advanced Python class. Refine the C/ Go/ Java offerings. Focus on helping students build portfolios of finished projects.

Offer a class focused on databases? Support students in learning Rails? Maybe refine an independent learning class, where students who have learned Python develop a plan for learning a second language or building a specific project. Focus on teaching students to use the appropriate support channels such as StackOverflow, IRC, mailing list archives, etc, more than teaching directly.

--- Year 4 ---

Have a clearly articulated set of pathways for students who just want some exposure to programming, for students who want to build specific projects, and for students who know they want to go fully into CS. Work closely with teachers in the math and science departments, letting students do CS projects that focus on a content area in another class.

---

I could write an essay on this, so I'll stop there. Many of you are now professional programmers. If you could influence a nascent high school CS program, is there anything in here you would want emphasized, or want to steer me away from?

[edited slightly for formatting]

I'm teaching an intro class for 5th-7th graders that already have some experience with Scratch (visual block based programming). I think Processing, especially in its static mode, does a good job at helping make the leap to actual programming (typing in code) without exposing the novice to as many real programming language constructs like Python does. Since it so trivial to get drawing, animation, and interaction going with Processing, I also find it is more fun for the first timer, especially the ones who don't have a natural geek bent. I'd say go with Python for year two, when you know you have the ones that cared enough to return for more.

Matthias Felleisen, one of the co-authors of 'How to Design Programs', contends that Racket is a gentler, kinder introduction to computer science and programming for high schoolers (actually, for beginners in general).

There's less emphasis on syntax (since Scheme is so minimal), and more on concepts - which cover all the mainstream paradigms. In addition, starting with functional programming demonstrably better complements and reinforces learning in other subjects such as Math.

The 'standard' text is HtDP (http://www.htdp.org/); it's being used in high schools as well as colleges. A second, revised edition of HtDP is in development (http://www.ccs.neu.edu/home/matthias/HtDP2e/). There's also 'Picturing Programs', by Stephen Bloch (http://picturingprograms.com/), an alternative to HtDP, perhaps more suitable for high schoolers.

(Incidentally, DrRacket is an excellent IDE, with all 'batteries included'!)

Conversely, his colleague Shriram Krishnamurthi has carried out extensive research into learning, and is now of the opinion that Racket is actually too minimal syntactically! Hence the development of a new (and rather cool) teaching language called Pyret (http://www.pyret.org/). (It's been discussed in thrilling detail on HN in the past.)

Lastly, it was found that beginners who started with Scheme actually did better when continuing later to Java than others who began with Java. There are some rather blunt testimonials (from students) that reinforce this point...

'Matthias Felleisen often teaches a programming languages course, and reports that near the end of the semester, students (particularly the stronger ones) ask why they didn't learn Scheme first, before Java. At least one top student disagreed:

Make sure you always teach assignment and bad programming first. They must go through hell before they are allowed to program in heaven.'

(A lot more here: http://home.adelphi.edu/sbloch/class/pbd/testimonials/)