What monthly themes should we choose for #12in23?

Each month as part of #12in23 we’re going to highlight a particular language theme. This could be a paradigm (e.g. Functional Programming), a time-based category (old/new languages), a usage category (e.g. scripting).

We’re then going to build nice intro videos to those categories and hopefully work with y’all to build some cool content around them.

What categories should we choose?

Some thoughts:

  • I don’t mind if some languages fall into multiple months, but ideally that would be rare.
  • This isn’t a categorisation exercise. The aim is to find interesting themes, rather than strictly put languages into categories.
  • Each theme/category should probably have >5 languages in it.
  • It would be nice to have variation, so not all paradigms, or not all age-based, etc.

Let me know your thoughts!

  1. Functional programming(Common Lisp, Scheme, Clojure, Racket, Erlang, Elixir, Ocamel, Haskell, F#)

  2. Dynamically Typed Languages

  3. Web-Front-end languages? (Javascript, Typescript, web assembly, and elm)

  4. Languages used for backend(Javascript, Ruby, Python, Go, Java, PHP, Perl, C#)

  5. Weak typed languages

  6. Languages that runs on the Java runtime (Ballerina, Clojure, groovy, java, kotlin, raku, scala)

  7. Old languages 40 and older(ABAP, Awk, C, Lisp, COBOL, Fortran, Pascal, Prolog)(I could have missed some)

  8. Languages released in the last 15 years or so(Rust, Go, Dart, Kotlin, Swift, Typescript, Crystal, Elixir) (I could have missed some)

  9. Languages used for mobile app development(Objective-C, Swift, Javascript, C++, C#, Go)

  10. Static languages

  11. Pure Object-oriented (Ruby, Scala, Raku)

  12. Command line and editor script languages (bash, vim script perhaps some more…)

These are unordered but here some suggestions

Note: most of the “example” languages are taken mostly from Wikipedia, with that said there could be languages that should be in that category which are missing


Some suggestions for categorizations:

  • Functional: Haskell, F#, Scala, Elixir, Clojure, Common Lisp (you could split up the LISPs in their own category potentially)
  • Systems: Rust, Go, Nim, C, C++, D
  • Niche: Prolog, Pharo
  • Low-level: x86-64 assembly, MIPS Assembly, WebAssembly
  • New kids: Unison, Ballerina, Wren, Red
  • Old-school: COBOL, Fortran, C, C++
  • Scripting: AWK, Bash, Raku, Python, Lua, Perl
  • Web: TypeScript, JavaScript, PureScript, Elm, Dart
  • Corporate: Java, C#, Swift, Kotlin, ABAP, VB.NET
  • Concurrency: Unison, Ballerina, Wren, Erlang, Elixir
  • Science: R, Julia, Python

I’m certain that I’m missing some tracks for some of the categories, but this could be a useful starting point.


I’m super into this. Categorizing by paradigm is probably the most obvious thing to do, and might be useful, but maybe there’s room for a more creative approach. One reference in this regard I’d say are the Steam Awards. They have the usual suspects like “Game of the year” or “Best Soundtrack”, but they also have other categories that focus on a particular aspect of the game, while saying nothing about its genre. Categories such as “Labor of Love” to reward games that keep being updated even if it’s sometimes not in the best financial interest of the company to do so, or “best game you suck at” to reward games that might be challenging and you constantly fail at them, but you still enjoy them.

In the programming language world, some categories in this style that I can think of:

  • Outstanding Community - For languages with extremely supportive communities. Ideally, with forums or other talking spaces that are welcome to beginners. I can vouch for the Python and Unison communities, but maybe there are others.
  • A new perspective - Languages that try to innovate in some way, which make learning them not just a case of “learning one more language”, but actually teaches you something about programming. Like Go/Eralng/Elixir can teach you about the actor/green threads model, Unison that teaches you to view your code as a database or Rust which because of the borrow checker makes you re-think what a variable is and how you use them.
  • Test of time - Languages that are old but for some reason stood the test of time. They are still used and there are still good use cases to use them in new projects. Thinking of languages like Java, C, Perl, PHP, Ruby, OCaml. Maybe we could define “old language” as a language created >= 30 years ago.
  • Cool kid on the block - Emerging languages with a lot of potential.
  • Say no more - Languages known for its short syntax that allow for cool one-liners or extremely short programs source-code-wise.
  • Go meta - Languages with great support for metaprogramming.
  • The new child - Languages that take heavy inspiration from another language, but try to add something to it. Like Crystal is heavily inspired in Ruby, Kotlin in Java, Vlang in Go, Typescript in Javascript, etc.

I realize a lot of these categories might be subjective, but I think that’s ok. Also, one language might be a good fit for more than one of these categories, might make sense to consider it only in one of the categories.


@andrerfcsantos This is an excellent collection. And branding the categories with catchy names and short narratives is a fabulous idea. In my view, it’s much more engaging than paradigm monikers like “functional.”

1 Like

@ErikSchierboom Nice list. I think marrying it @andrerfcsantos suggested styling and contextualization would be cool.

1 Like

The below is, more than I’d like to, a collection fo sentiments rather than thought-through suggestions.

I came up with most of it before @andrerfcsantos posted his suggestions; I feel his are way catchier than the ones here below, which seems an important quality.


  • Functional paradigm / programming / languages because the category seems nigh meaningless to me. I feel Haskell and Lisps are too different from each other. If we group them together, why not include Python as well? And Rust? And R and Julia of course…
  • weakly typed languages because they form a nonapple category.
  • dynamically typed languages because sadly this category has not yet grown up into a proper paradigm, and so (for now) remains somewhat of a nonapple category as well.
  • statically typed languages because it is boring / too broad. Java is statically typed. This category could be strengthened into Fancy Type Systems.
  • Young languages for lack of coherency and lack of purpose. (Test of Time is fine by me though: those languages have proven useful!)
  • By deployment platform because hard to explore on Exercism.

Thoughts & Suggestions

  • An advantage of narrow categories (i.e. containing few languages) is that they make communicating with others (‘community engagement’) easier: (relatively) more students who are on ‘the same page’ are available. In contrast, e.g. communicating about OOP can be more difficult if the one is learning C#, the other Python, and yet two others Lisp and Smalltalk.

  • Exotic Workflows like Lisp’s REPL-driven dev., SmallTalk’s/Pharo’s IDE, whatever Prolog does, perhaps Unison (I wouldn’t know), maybe Lean (not available on Exercism).

  • Domain Specific Languages: Elm, PureScript, Awk, maybe Emacs Lisp and VimScript, probably many others. Strictly speaking shell languages are DSL’s too but they deserve their own category.

  • Low-level Languages (well…). Maybe split up into subcategories in the C tradition (e.g. similar call mechanisms, compiles down to C, …) and outside the C tradition (e.g. Fortran, COBOL for all I know). I know next to nothing about under-the-hood approaches, but I’d like to.

  • Some category containing Julia: its interestingness is accessible very early on in the learning process.

  • Assemblies: Wasm, X86, …

  • Any Concurrency category should definitely include Haskell, as its concurrency story is among the best ones around.

  • Macros: the Lisps, especially Racket, but also Rust and Julia.

  • Shell languages! Sadly, Exercism does not yet feature a PowerShell track.

  • Glue languages. I’m thinking Python (and Ruby?), shell languages, JavaScript (sometimes), R (if I’m feeling generous), and Go (I guess, being unfamiliar with it).

  • Exploring of languages’ interestingnesses through Exercism looks challenging to me. Are there ambitions here?


I think that the easiest idea to implement is probably the intended use case, or the average use case, of a language. Surely Perl can be used for scientific computing and C for web development, but they were never intended to be used like that.

The problem with a paradigm-oriented approach is that it’ll be difficult to have 12 clear-cut categories, and there will be guaranteed resistance on any categorization chosen (especially for multi-paradigm ones). Are C, Rust and Golang primarily Systems languages? Should C be considered a Procedural language, and C++ Object Oriented? Do we consider TCL and Perl “scripting” languages? My initial group suggestion would be the following (a subset of languages in parentheses for reference):

  • Low Level (Assembly)
  • Structured (COBOL, ABAP)
  • Procedural (C)
  • Object Oriented (C++)
  • Functional (Haskell)
  • Pattern-matching/Data Driven (AWK, Red)
  • Symbolic (Lisp)
  • Logic (Prolog)
  • Prototype-based (Javascript)
  • Lightweight (Wren, Lua, TCL)

I’m having trouble determining the last two, there isn’t an appropriate Concurrent/Parallel or Actor-based language, Multi-paradigm would be cheating as it would include a lot of already covered languages. “Generic” (Java) doesn’t really cut it. I’d have loved for this to work as a way to show the evolution of languages, but that’s more like a cyclic graph rather than a tree moving forward.

Erik’s categorization works around this issue, and focuses more on “branding” if I may say so.

A voting feature sounds like a great idea, regardless of the categories chosen :slight_smile:

1 Like

Theme: children, grandchildren, and great-grandchildren of Algol-60.


I think this is a much more helpful categorization, I think a lot of us look to learn new languages to get new perspectives so perhaps breaking down that category using some form of tags with the concepts that @meatball and @ErikSchierboom suggested would be handy?

Hi everyone! Thanks for your thoughts.

Erik and I have spent a couple of hours trying to get something that incorporates all the languages on the site. We’ve experimented with both functional grouping categories and more interesting ideas (thanks Andre for some great ideas of that type!).

This is where we’ve got to: 12in23 - Google Sheets

The languages in blue are the ones that we’re going to highlight in our intro videos for each month (generally because we know they have solid syllabuses on Exercism and think they’ll have wide interest). Lots of languages fit into multiple categories, but every language on Exercism is in one of the categories here, so we don’t mind if every category doesn’t contain every language.

I’d love ideas on what the names could be for each category. We tried to do month names e.g. “Analytical April” but failed after that one :joy: Please let me know your thoughts on those!

1 Like

Mechanical March, Simple September, Nibbly November?

What is Odds & Ends about?

PureScript is a dialect of Haskell, and as far as I know ReasonML is a member of the ML family, so these two should maybe be grouped with Haskell and StandardML. (Although, ceteris paribus, I would recommend Haskell over PureScript for learning resources reasons.) Then again, PureScript also competes with Elm, so…

1 Like

Odds & Ends is all the languages that we didn’t feel naturally fell into the other categories.

Memory Management March
Mind Shift May
Summer of Sexps
Jurassic July

Slim & Super-powered September

December Diversions


Love those suggestions @BethanyG !

1 Like

@MatthijsBlom @BethanyG Thanks :) I’ve updated the spreadsheet.

I’m missing March, August or October (I liked the March ideas but I feel like there’s something out there that’s a better fit!)

Any more ideas?

On-screen October?

Object[…] August fails on both the spelling and syllable length fronts.

Just this once a dead tree dictionary would have come in handy. I don’t think I have one :flushed:

but it wins on the alliteration. “Objectify August”

Oh, swap August and October: “August Apps” and “October OOP”

If we could get March to showcase development tools and environments: The IDE’s of March :scream:


@glennj This still has me laughing out loud…love it