What are the axes on which different programming languages differ? So far, I have evaluation - eager or lazy abstraction mechanisms - classes, modules etc types - static, dynamic, strongly, weakly (I know first 2 and last 2 are different categories🙂) syntax primitives What else?

Perhaps paradigm, exceptions, or expressive power? (As measured by some formal heuristic, such as statement ratio or line ratio, often compared to C)

Size? There’s a lot of languages, i.e. Lua, where a major feature they espouse is being small in size and embeddable, for example

I mean something concrete that’s a property of the language not just what it affords. Like you can do functional programming in the broad sense in python for example but Haskell affords it better so I want to keep paradigms out since the programmer can decide to use different paradigms. I remember something Phillip Wadler said(I think he is the one who said it) that Haskell is the best imperative language. like a friend pointed out Memory management - Garbage collection. Though I wonder if garbage collection is going a bit into the implementation vs. what the language actually is.

scope and name resolution!

(There needs to be a sigh reaction)

Instead of "mutable variables", I prefer 'pure functions and referentially transparent expressions' vs 'shared mutable state'. Curv is in the former category, but it supports mutable local variables and a

while

loop. Curv wants to be a better imperative language than Haskell.

In my experience: • automatically garbage collected vs. not • statically vs. dynamically typed • inheritance-oriented vs. composition-oriented The three most useful high-level axes for comparing languages.

The method by which garbage on the heap is collected affects what language primitives are available, what is efficient, and how you write code. There are multiple choices: tracing gc (most languages but originally Lisp), C, Rust, Swift, etc.