Java or Kotlin for beginners (procedural programming knowledge is existing)?

I've been using Kotlin for two years now on an introductory course on imperative programming (bachelor's first semester) and I'm very happy with this decision. Before Kotlin, I was using Java for the same course.

Here are some of the benefits:

• No need to explain what are classes on a imperative programming course, since Kotlin programs can only have a main() top level function (like C)
• It is a "safe" language in the sense that it prevents most novice mistakes at compilation time (uninitialised variables, type conversion errors, etc.)
• For simple interactive programs (e.g., ask two numbers and compute their sum), you don't need all the complexity of the Scanner/BufferedReader classes, just use readLine() and println() (without the System.out). This makes the initial learning curve much more pleasant.
• It forces the students to think about the little things that are essential when you are taking the first steps in programming: mutable vs immutable variables, nullable vs non nullable types, mandatory variable initialisation, implicit vs explicit types, conditions as expressions, etc...
• It is easy to jump to Java in later courses (than say Python or Javascript)

Most of all, from my experience students find it more motivating to learn to program in Kotlin than Java, since they have to write less to accomplish the same things while at the same time feeling protected about runtime errors.

My advice: go for Kotlin.

My preferred curriculum is to teach relatively few languages explicitly, but require others in projects, even large projects. Then draw it together in a principles course.

Most students in the US come to a CS program knowing some imperative programming, even if they think of it otherwise. But their background is usually very weak and they don't write effective or maintainable programs. They write too few, too large functions, for example with deeply nested logic structures that are hard to unpack. They need to be taught how to write differently. It can be a struggle for many to not just build deeper and deeper logic structures, with lots of badly named flags, etc., hacking a more or less workable solution.

So, in my view, the curriculum, as it relates to programming, focuses on abstraction and how to use it effectively in the different programming paradigms.

Ideally, three languages are sufficient to cover (most of) the ground. A low level language in which you can write things that need to be close to the machine. An object-oriented program in which you can discuss the various kinds of abstraction and encapsulation. A functional language in which you can discuss higher level constructs (first class functions, etc). If that is followed by a language principles course in which you can take a meta level view of the language paradigms, it should be possible, in theory, for a student to learn any new language (until a new paradigm comes along). Paradigms are, by their nature, hard. The principles course can dip a toe into several languages other than the ones the students know, just to give them the flavor of the range of possibilities. This is separate from any compiler course, though.

My preferred method is to start with the OO paradigm as it is sort of mid-way between imperative and functional. I don't start with low level constructs (int, float, if, while) however, but with OO features programmed in a prepared simulation that allows Turing Complete programming without any of the low level detail. The "primitives" of the simulation are much higher level, constructed objects with well defined behavior. From that base you can introduce both higher and lower level ideas.

The German system, however, has much more opportunity to do various things as there are more courses in the curriculum.

However, actually teaching both Python and Java seems to be a waste of resources to me. Teach one and in another course, do a project in the other. The ideas are nearly the same and the differences can be learned by osmosis.

I don't know Kotlin, actually, but brief examination suggests that its benefit is in concurrency. That is actually a different paradigm, of course, to the "big three". But if they know Java or Python, a project based course focusing on concurrent programming in Kotlin might be feasible, with relatively little emphasis on the other features of the language. I wonder a bit if the language is stable enough currently to make it a fundamental part of a curriculum. Hence a project rather than a full course.