What makes a programming language good for you?

Having in mind this topic:


I started to think what are the most important things which allows calling specific programming language “good”.

For me there are lots of things:

  1. Syntax
    Some people could not be sure about this point, but after mentioning really exotic ideas like Whitespace language everything is changing. It’s definitely not a good time for Assembler and generally low level languages. Everyday life from day to day is faster and faster and if there is no really important use case then there is no time for some type of things. Fast developing, fast consumption and heart attack at end. :077:

  2. Code readability
    Related to first except that there is no need to have source code with only whitespaces to make code not readable. Of course lots of cases depends on developer, but language which does not helps in code readability at all have a big con for me. Please notice how important Elixir pipes |> are. You can find them almost everywhere. Also look that while Bash has also pipe support | there is still lots of other places to improve like associative arrays syntax.

  3. Modern programming
    X server is of course not a programming language, but it’s perfect example. It was designed 35 years ago and it’s really problematic for today’s use cases. Therefore it’s slowly going to be replaced by Wayland (lots of distribution already made it default). It looks really similar in programming languages except one case …

    Of course some old, but popular languages would still be used as for business one of important things is LTS (long term support) releasing. Some apps would not be so easily replaced in just few days. In contrast to business, market hates stagnancy.

    As soon as some solutions would be well tested and would be considered as stable lots of people would give them a try. I believe that Elixir already passed the test of its first time i.e. since 1.0.0 version was released. I can see on my own case how much more offers are coming (even if you are already employed).

    Elixir have really lots of pros here which were already well described on forum. Simply instead of solving some old problems it’s focusing on current problems which actually Ruby-like languages have right now. Of course it’s based on Erlang which is not a new language, but look how much it’s usage were increased in years. Erlang were ahead of its time, because really specific part of market requires something which now is really desirable in much more places than originally.

  4. Number of remote job offers
    Language without enough job offers as well as without enough big community would not survive really long. Of course even in really less popular languages you would always find some job offers, but most of them would be onsite and really often you would need to take costs of relocation. On the other side big amount of open remote job offers says that there is a real interest in specific language and it’s not going to be forgotten by market in just “few days”.

  5. Community
    Programming is like endless cooperative game. Sure with enough experience you can find a workaround and rush alone, but it’s really bad practice. Working with team in which you can trust each other makes in our case a huge difference.

  6. Regular good updates
    Elixir is the first language I just can’t wait for next release! I’m really often taking a look at GitHub issues, milestones and pull requests. Every new release gives something interesting and many new discussions/proposals are really awesome ideas which I would like to see in Elixir ASAP.

  7. “Fake reports” (especially based on unfair statistics) :slight_smile:
    If somebody tries to cut off reaches not by mistake then taking a look on “censored” things could be actually at least interesting for some people. Is somebody worried that JavaScript is going to die sooner or later? That’s just awesome conspiracy theory!

and many more …

Those are only examples and really generic rules. I found lots of awesome pros in Elixir, but describing everyone would take for me probably few days. :smiley:


To add on to your list,

  1. Packages.

I use R over Python most of the time because of the packages. Hands down R have the most bleeding edge statistical packages out there.

  1. Complexity

I also like small languages not too overly complex. I’ve come from Scala and C++ and I think those languages are too overly complex.

  1. Clear documentation on language behavior. I really like Python’s Data Object Model, it is basically an API/Spec on what all Python Objects will have. So there is no surprises and you know what to expect.

  2. Explicit no black magic. I really dislike javascript implicit type conversion.

  3. Package manager from the get go. This is a modern thing and I hope newer languages will continue the trend. Elixir have mix. Rust got something (no clue but I’ve heard it have a package manager). Javascript/NodeJS got npm.

I didn’t include TDD in there because I think dynamic languages need it more than type language.

Nice to have a language specification. Python have one and Ruby used to have one until the drama. Where if you implement your own Ruby language on JVM and you run all the test cases and pass it. Your implementation of Ruby is really Ruby. I think Java have TCK and Sun system was supposely going to give it to Apache for their implementation of Java but Oracle took over and kill that and the project.


I quite agree on complexity and black magic. Keeping it simple and explicit wins in the long run.


Here’s the one thing that makes a programming language good for me:

Can I get things done without fighting the language?

That’s all that matters. Syntax, paradigm, etc. are all sprinkles on top of the ice cream. Without being able to get things done with the language none of the other stuff matters at all.

A well designed type system does wonders for me :slight_smile:


Documentation: Probably the most important thing, most of the relevant and modern languages are very well documented, but it’s worth to point it out.

Syntax: Not too verbose (like Java), not too crazy simple (like Go), and with no weird and inconsistent names for functions (PHP I’m looking at you!).

Modern features: Concurrency, pattern matching, pipe operator, errors for humans… Also modularity is love.

Tooling: Things like testing, documentation, package manager, linter, formatter… included out-of-the-box.

One language to rule-them-all: It’s a very attractive feature, but not mandatory. You know, one language for mobile, web, desktop… I think C# and JavaScript are the most advanced languages for this kind of things.

Ecosystem: It’s nice to have a big ecosystem, but I’d rather prefer something more minimal and focused, not going crazy with libraries that do pretty much the same. The community feels divided when multiple choices are available, e.g. Typical flame wars (or should I say frame wars?) in the PHP and JavaScript communities.

Community-friendly: It’s true that most of the development have to be internal with core team and recognized contributors, but it’s also nice to ask the whole community its opinions and suggestions, also this helps to increase the commitment of the community with the project.

Nice to have: Automatically uninstall the tool-chain when someone tries to compile foo bar.

I feel that I’ve just described Elixir with the things explained above.

I don’t know if any of you have used HLA (High Level Assembly), I liked it a lot, it’s like a mix of Pascal, C and Assembly. Sadly Randall Hyde only wanted to use it as a tool for teaching purposes.

Already in my further plans for Elixir + Scenic fork + WebAssembly, but of course it would not be started soon. Basically I plan to write one front-end code and compile it using unified API to different targets.

╰─➤  typeset -A blah

╰─➤  blah=(                                                                                                                                  130 ↵
array> key value
array> a 1
array> b 2
array> )

╰─➤  vwoop='a'

╰─➤  print $blah[$vwoop]

Doesn’t seem bad at all (though excepting that variables are ‘called’ with $ of course)? :slight_smile:

However, overall a ‘best language’ for me needs to be:

  • Expressive: Ease to write unexpected algorithms in.
  • Readable: How easy and unambiguous the syntax is to read.
  • Terse: How short the syntax is (important while also being expressive and readable, few languages get all 3 well)
  • Maintainable: If you come back to it a year later and check something, how likely will it be that it is not breaking something somewhere else, especially if you don’t have tests covering that part, strong static languages have a huge leg-up here.
  • Proper build and packaging systems: Is there generally 1 and only 1 way to build it for a given architecture, cross-compiling, etc… Is it easy and reliably to acquire packages without worry of them breaking in weird ways in certain compiles.
  • Safe: How the system handles failure, and there can always be failure, so how well does it handle it.
  • Fast: Raw speed.

Some examples:

Haskall is terse, though not readable.

OCaml is expressive, readable, terse, maintainable, has a great build/packaging system, safe, and fast in ‘most cases’, however it has a lot of old cruft, which thankfully you can ignore for newer libraries (like core to replace the stdlib).

Rust is expressive, mostly readable, not terse, maintainable, has a great build/packaging system, safe, and fast.

Elixir is expressive, mostly readable, not terse, not very maintainable, has a great build/packaging system, safe, and fast in IO but not much else (great for web servers!).

C is kind of expressive, mostly readable, not terse, not very maintainable, has too many building and packaging systems (a huge problem), not safe, and it’s fast.

C++ is expressive, kind of readable (I know it Very well and template work still looks like magic even though its hard functional, the syntax hides that…), can be terse or not, kind of maintainable, has many build systems (which is a huge problem), has way too many packaging systems (almost all do things sooo poorly, like vspkg is a horror), can be safe (or not, depending on the libraries and such used for type safety), and it’s fast.

Go is not expressive, it is ‘simply’ readable in that is doesn’t have much but that also means that most code that would be a single readable line in most other languages ends up being 40 so it is not overall readable, absolutely not terse, about as maintainable as C (so only kind-of… not really), great build system, has a package system (with issues, I can’t even call it decent…), not safe, and it’s fast.


I think you wanted to say “can be safe”, totally agree!

Since I watched the talk Simplicity is Complicated by Rob Pike, it changed my mind and I’ve to agree with him, old languages only evolve by adding new features, and at some point they will do pretty much the same thing. This is hard for beginners and old users; A decade ago I did a lot of C++, but nowadays with all those new additions in C++ 11, C++ 14… I’m not in a position of saying “I’m a C++ programmer” anymore. It’s true that I’ve been stopped its development process and forgot most of the things, since I can’t be up to date with a “secondary language”, but it would be more pleasant to me relearning it without most of the new and sometimes not useful features. Go promises to be different by just adding the right stuff, so you extend it with packages if you want to implement some kind of functionality, and this is something that I appreciate a lot, even if I don’t like the language per se.

Relearning stuff is something awful for me, because you’re tied to old practices, and it’s hard to adapt your mind using those new additions. The same applies to C# for example, I did started with C# 3, and now C# 8 is here, the language changed a lot in these 5 versions, and I think if I had never used C#, these days it would be hard to me learning it from 0, on the other hand, some new additions make the code more concise and pleasant to read, so adding the right stuff is definitively worth it, and I’ve to say that for me the right stuff is the one that makes your code concise and shorter.

I wish I had discovered Elixir before, this new generation of programming languages (Elixir, Go, Rust, Kotlin…), are learning from others programming languages mistakes, specially Elixir and Kotlin reusing the well-crafted BEAM and JVM, sometimes is better to reuse battle-proven software rather than building it from scratch.

Great catch, fixed! ^.^

OCaml does it a LOT better if you like that style, it’s just a lot older, it really needs a refresh too… ^.^;

LLVM is awesome for that too!!


So you really love OCaml, uh?

I’ve never used it, this functional programming land is very new for me, and I think there are no jobs available in Spain, here the skills enterprises ask the most are Java and C#. But I’m a bit interested in ReasonML, since I write a lot of React and I did some F# in the past, so OCaml should be easy to pick up, thanks!

1 Like

I really like OCaml. ML languages may seem weird at first but it is all for specific reasons of clarity, speed, and safety. I consider it a “Better Python” overall (faster, safer, better code, etc…). And yep, ReasonML is just a skin over OCaml and F# is just ‘part’ of OCaml on .NET (it’s missing the fantastic First Class modules system, which is really what makes OCaml). :slight_smile: