Programming really hasn't changed much fundamentally in the last 20 years. I think its a good thing university doesn't chase the current trend. The knowledge would be quickly outdated. They should teach the stuff that isn't flavour of the week but common to everything.

Some things do change, though, and courses which involve specific technologies should at least be up to date to a point where people aren't required to use Windows XP when every laptop runs Windows 10.

I kind of get what you mean, but you don't provide a good example. The first question is what are the specific technologies and why are they involved? If you take some outdated version of Java, this could be interpreted as teaching you to be a Swing developer, or how to apply Java for user interfaces and learning some fundamental design patterns.

Whether it is the former or latter matters a lot. Oftentimes the people taking the course don't appreciate which it either which is problematic. In your example, someone could be given a really good desktop programming class on Win32 whether they used Windows XP or Windows 10. The success of this is orthogonal to the tools at hand really. It is what the professor and/or students make of it.

In general, I find that many fresh college folks (new hires and interns alike) struggle with Java streams. Streams and stream adjacent things like Optional remove a lot of tedium and footguns from older Java code styles, and unfortunately learning them tends to be a speed bump for anyone onboarding to the code base from college, because it’s just not covered, even in a Java algos course where I believe they’d be fairly relevant.

Had a similar thing with a guy who taught Android programming and was stuck on Android 2, while Android 5 or so was out. He did not know about specifying button handlers in the XML of the view and all kinds of stuff. They did not manage to set up the IDE properly for the exam, so that logging and installing the written app on a phone did not work either. Got out of it with a bad grade, because he did not see his Android 2 shit in my solution.

This is why courses should focus on fundamentals not flavour of the month stuff.

Learn assembly, then learn C, then code up a small OS and learn semaphores and stacks and how a computer actually works.

> even though it was EOL and Java 8 had been out for a while,

What's wrong with that?

You're supposed to cover the basics in intro to programming courses, and typically Java is not outright taught in college, and instead it's object-oriented programming using a random OO language, which more often than not is Java. Do you need to use Java20 to learn inheritance?

Also, unless you expect to work exclusively on greenfield projects, the bulk of any developer work is maintaining legacy applications. I still see an awful lot of projects in java 8 and only a few in java 11. Insisting on the latest and greatest java release makes as much sense as pressing to cover Lombok or Kotlin.

I mean, Java 8 had the lambdas and FP which I would argue are pretty important in modern Java.

But like, that’s the rule. I took a web class in college and the professor was teaching how to use <i> and <b> tags, which are no longer supported as part of the standard. (Not to mention that these days it’s not really helpful.)

> I mean, Java 8 had the lambdas and FP which I would argue are pretty important in modern Java.

What role do you believe lambdas and support for functional programming play in object-oriented programming courses?

To prove two points: First that forcing objects everywhere makes things really complicated compared to FP, second that under the hood everything can be shoehorned to object model.

> First that forcing objects everywhere makes things really complicated compared to FP

Pointless. They are OO courses, not FP courses. You have FP courses already covering that.

> second that under the hood everything can be shoehorned to object model.

You do not need lambdas or FP for that.

So, what's the point of lambdas and FP in a OO course?

Frankly if you want to teach object oriented languages, you should be teaching Smalltalk or Objective C, not things derived from C++. Message passing is the defining feature of object orientation.

If the intent is actually to teach polymorphism and encapsulation, both of those can be done in raw C.

The question is then, why should object oriented languages be taught? It seems to me that for last 25 years or so the true object orientation has been a historical curiosity that inspired polymorphism and encapsulation and only interest for people who want to argue that this and that language aren't true object oriented languages.

Indeed: I wouldn’t bother. Teach procedural and functional programming to undergrads as primary focuses.

However, polymorphism and encapsulation have existed for much longer than “OO” languages. What is stdout? Seems pretty polymorphic to me. How does one gain access[1] to a variable declared in a .c file that is not exposed via the header. That’s encapsulation…

[1]: there are of course ways, but they are often also true of private members of class instances too.

Good point. I was thinking about the C++/Java meaning of the words because that way of doing things has proved to be useful but they're not the only way indeed.

Aren’t lambdas implemented as objects with common interfaces in Java?

I don’t just see this behavior in OOP style courses.

Most algos classes would probably benefit from streams, and there are many of them being taught in Java for reasons unrelated to OOP. Universities often stick to one language for much of the programming curriculum.

As an aside, they are once again part of the standard.

https://webmasters.stackexchange.com/questions/27693/should-...

> Do you need to use Java20 to learn inheritance?

Do you need to prohibit Java 20 to teach inheritance? Working with an outdated version as basis is fine, not accepting newer versions for no reason is something different imho.

> I still see an awful lot of projects in java 8 and only a few in java 11.

Sure, but that doesn't mean knowledge of newer features should be discouraged.

> Do you need to prohibit Java 20 to teach inheritance?

Java20 did not introduced inheritance, nor did it introduced any OO concept. Java20 adds no value to those learning OO. If you're writing java code but are not using any Java20 feature, you are not writing Java20 code.

> Working with an outdated version (...)

It is not outdated. You are not using any feature. You're just succumbing to the misplaced belief that new means more value. It doesn't, specially when the only thing that you get is more complexity.

> Sure, but that doesn't mean knowledge of newer features (...)

Repeat after me: Java20 adds no OO feature. You do not have to use Java20 to learn OO. OO courses are not java courses. Do you understand this?

> It is not outdated. [...] You're just succumbing to the misplaced belief that new means more value

Sure, technically you can still teach HTML in Internet Explorer 6 and OOP in Java 7 or something, but that has no added benefit and is actually more difficult to set up nowadays. And you can't deny that old versions are outdated when they don't even receive security updates anymore.

> the only thing that you get is more complexity.

What part of OOP basics got more complex in Java? And why teach Java at all if simpler OOP languages exist? Not to mention that avoiding complexity can actually be counterproductive for teaching. As an example, I got more than 5 years of Java-focused programming education and afterwards I still didn't know what a classpath is and couldn't write a single line outside an IDE because nobody wanted to expose complicated stuff to the students. Instead of forbidding students from using a newer Java version one should focus on the actually important part.

The reason is it creates extra work for the teachers (having to keep up with newer features, bigger diversity of solutions they receive) without much benefit regarding the substance of what they need to teach.

Some universities choose a more “exotic” but more stable programming language for that reason (like SML or Scheme or Smalltalk), but then also get criticized because it’s not a major industry standard.