‘A Language a Day’ — Advent Calendar 2019

Welcome to my Advent Calendar 2019. Last year, I was publishing daily articles about one-liners in Raku. This year, I decided to spend time on filling the gap in other areas and try as many other languages as possible.

During the last decade or so, a lot of programming languages appeared. Some of them are more successful, some are less. Some are louder, some are less. Some are supported by big IT companies, and some are created and developed by enthusiasts.

I am sure you can name a dozen of languages that you are aware of but never tried. Same here for me. I heard about many new languages, but either never touched them or tried a Hello, World! example only.

Programming languages are amazing. You start loving them individually as soon as you start writing a few test programs. The more you learn, the more you feel the language and the design ideas behind them.

In this year’s Advent Calendar series (1 through 24 December 2019), I am going to post daily articles covering the basics of different programming languages: the new day — the new language. To make language overviews more useful, I will try to follow the same pattern and will try to dig those aspects of the language that are required to write the following mini projects:

  • Hello, World!
  • A Factorial function, implemented either recursively or in a functional style
  • A program that creates an array of different objects and polymorphically calls methods on them
  • An implementation of the Sleep Sort algorithm. That’s not a thing for production, but a great way to demonstrate concurrent features of a language.

The examples from this list will be marked with this this blue background.

The description of the language will also follow a pattern:

  • Installing a compiler and running a program
  • Creating and using variables
  • Defining and using functions
  • Object-oriented features
  • Exception handling (not for every language)
  • Basics of concurrency and parallelism

Another restriction is that I will try to use compile line compilers as much as possible, and will try to limit the examples in such a way so that you do not need creating different configuration files to compile and run them.

Whenever possible, I will try to give some information about the unique features of the language (e. g., XHP patterns in Hack, or macros in Rust, or TeX typing in Julia).

All examples will be uploaded on GitHub, which will be linked at the end of each article.

The series has its RSS feed, which you may use to learn about the new post when it appears.

The first languages to go are TypeScript, Hack, Rust, Kotlin, and Crystal. What’s next? — We’ll see it together. I hope you will join the journey and will have fun.