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.