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?
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.
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.
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.”
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…
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.
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)
Object Oriented (C++)
Pattern-matching/Data Driven (AWK, Red)
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
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?
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!).
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 Please let me know your thoughts on those!
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…