RC W4D3 - Categorizing programming languages with ChatGPT

In a prior post, I shared a quote from Chelsea Troy comparing expressiveness vs interpretability in programming languages. I thought it would be interesting to get ChatGPT to categorize other languages based on this measure.

We start with Ruby being expressive (there's more than one way to do it) vs Python being interpretable (there should be one obvious way to do it). We continue on this rather simplistic thread. We get PHP and Perl in the expressive camp, Go in the interpretable camp.

Now ChatGPT seems to cop out with Rust, saying it’s emphasizes both expressiveness and interpretability. Functional languages like Haskell, Scala and Elixir are in this camp too. Then we have another camp of system languages that emphasize performance like C and Zig.

What’s also interesting is having this categorization in order of release date, here adding more languages. 
  1. Emphasis on expressiveness: Prolog (1972), Perl (1987), Lua (1993), JavaScript (1995), PHP (1995), Ruby (1995)
  2. Emphasis on interpretability: COBOL (1959), Python (1991), Go (2009)
  3. Both expressiveness and interpretability: Haskell (1990), OCaml (1996), Erlang (1998), Scala (2004), F# (2005), Elixir (2011), Rust (2010), Swift (2014)
  4. Less expressive and less interpretable: Fortran(1957), C (1972), C++ (1985), Java (1995), Kotlin (2011), Zig (2015)
For funsies I got ChatGPT to divvy up languages into more groups here. Note that 'interpretability' changes meaning from 'easy for humans to parse' with 4 camps to 'easy for machines to parse' with 8 camps, more context here.

In yesterday’s post I shared David Beazley's advice on improving Python skills. Today I’m reminded of Peter Norvig’s advice along the same thread.

Learn at least a half dozen programming languages. Include one language that emphasizes class abstractions (like Java or C++), one that emphasizes functional abstraction (like Lisp or ML or Haskell), one that supports syntactic abstraction (like Lisp), one that supports declarative specifications (like Prolog or C++ templates), and one that emphasizes parallelism (like Clojure or Go).

In the post prior to yesterday, I wrote about wanting to learn how generative models work under the hood alongside functional languages. This feels more fun. This caption by Bret Victor encapsulates this desire to explore (also inspired by Chelsea Troy's post).

How do we explore? If you move to a new city, you might learn the territory by walking around. Or you might peruse a map. But far more effective than either is both together — a street-level experience with higher-level guidance.

Likewise, the most powerful way to gain insight into a system is by moving between levels of abstraction. Many designers do this instinctively. But it’s easy to get stuck on the ground, experiencing concrete systems with no higher-level view. It’s also easy to get stuck in the clouds, working entirely with abstract equations or aggregate statistics.