JetBrains

I think it comes down to what you're trying to teach. Every language has pros and cons. Let's cover three things that beginners absolutely need to know.

1. General Language Design
2. Build systems
3. Package management

Ideally you choose the simplest language that accomplishes all of these things.

Let's start with build systems. Many languages have good build systems, many have very bad build systems.

Some examples of good build systems:

• Rust
• Elixir
• Ruby
• Java (this is probably the most contentious point I will make)

Some examples of bad build systems:

• Python
• Javascript (this is probably the second most contentious point I will make)
• C
• Scala

What makes some systems 'good' and some 'bad' are the amount of effort required to get even the simplest project running. With rust, elixir, and ruby (all built either completely based on or inspired by Ruby's Bundler build tool) it's a single command to get started. You get one file you have to manage. You get a single command to build. A single command to release.

With the others it's either piecemeal, or even multistep. JS you're building your own commands, depending on which package manager you've chosen and which build tool you're using. You have to understand both package management, your package manager, your build tool, how that build tool works, and how that build tool interacts with every other part of your system. There's no "1 right way". Same with Python, even though it claims to have the Zen of Python, there's over 15 build tools you can use (and that's just the popular ones). C has CMake and make and maybe another one, I can't remember. Actually, if all you wanted to learn was build tooling then C is probably a great choice. Same for language design. But trying to learn both at the same time is just not ideal for someone already overwhelmed by how different programming is to 'real life'. Scala's build tooling is just bad. It is built on gradle or maven, but because it is essentially a processor on top of those it's just not enjoyable to use. There's plenty of other examples here, I'm just giving ones that popped to the top of my mind.

Now package management. Most languages have fine package management. There's different ways of managing these 'artifactories', 'repositories', etc.

All JVM languages pretty much work alike, so you get a very consistent base with that. Almost any library written for Java will work for any other JVM language: Kotlin, Clojure, Scala, JRuby, Jython, etc.

Ruby, Python, and Javascript have a very similar method of package management, but Javascript has some bad things around node_modules depending on which package manager cli you use. This is the most annoying thing about JS and something a bunch of newbies have no business worrying about.

Rust's package management is very good, but has to deal with linking libraries and so can be confusing for anyone that doesn't already understand what is happening.

General language design: What are you trying to teach? Are you trying to teach object oriented programming? Are you trying to teach enterprise related architecture and design? Are you trying to get someone ready for a real life job in the "real world"? Every one of these can have a different answer, not just based on what industry that person eventually wants to go into, but on what the course is trying to teach, what the student is trying to get out of it, etc.

I have biases, just like everyone. I'll list off my favorite languages in order (this means languages I like even if I don't ever program in them):

1. Kotlin
2. Ruby
3. Elixir
4. Rust
5. C#

I would never use Kotlin to teach an entry level 101 course, because I think the prerequisite to using Kotlin is to understand Java.

Elixir is the same way, you really need to understand Erlang to do so. Rust is also not really on that list, because getting a compiling program for a beginner is nigh impossible. They wouldn't understand any of it.

I think scripting languages are really well suited to teaching a beginner 101 course, which really leaves only a few popular options: Ruby, Python, and Javascript. Ruby and Python come installed by default on almost every linux and mac distribution (I think mac might not anymore as of very recently, can't remember). Javascript is a great language for programmers to learn, I just don't think that it gets out of your way enough to actually teach. Ruby is my choice, this is how easy it is for a beginner to get started (after install):

gem install bundler # explain what bundler is
mkdir mynewproject
cd mynewproject
bundler init # working gemfile displaying package management

I've actually been helping a friend with his python stuff and they just avoid the concept of build tools entirely. Essentially just teaching individual files and then just make file or python blah.py. This is fine, but then you start teaching that whitespace matters and students are confused why there isn't any sort of delimitation between areas. The friend I'm helping got confused because he couldn't tell when whitespace mattered and when it didn't. Also, I think that teaching list comprehensions (which aren't used in 99% of languages) is just a waste of time. Teach 'normal' functional paradigms like .each.

I wouldn't stick with Ruby past a certain point of teaching language structure and a few simple scripts. Don't try to build anything large in it. Switch to C# or Java for that, where the student can start to learn the importance of types and managing many modules and libraries.

But of course all of this is just my opinion. I learned Ruby and Python in the same semester by two different teachers in different courses when I was in school and it was vastly easier to learn Ruby for everyone in my class. I think Ruby is great for teaching the basics, including build and package management and even creating and debugging libraries. It will fall short in many ways for more advanced stuff though (same with Python).