How the Language Atlas works

The same small program prints 55 in Tcl, Objective-C and Visual Basic, yet it takes one command to run in Tcl, two in Objective-C and a project file in Visual Basic. The Language Atlas gives 12 less common languages a short course each, and every example in it shows the commands that ran it and the version of each tool that printed its output, so that you can repeat any run on your own computer.

This lesson shows how the atlas is laid out: the four lessons each language gets, how to read a recorded terminal sessionterminal session: A run of commands typed one after another in a terminal, kept with what each one printed. In a recorded session the lines after $ are the commands to type, and the lines below them are their output. and repeat it, why one Tcl expression prints 9 on one version and 11 on another, and the register that says why a language is in the atlas, waiting for a later edition or left out.

Every atlas language gets the same four lessons

Take Tcl. Its mini-course has four lessons, and every other language of the atlas has the same four, in the same order:

1. Setup and where it is used. Install the pinned toolchain, check that it reports the pinned version and run a first program.
2. Idioms, compared with a language you know. Tcl next to Python and Bash, Visual Basic next to C#. Each idiom is a pair of short programs that print the same thing.
3. The signature feature. What the language does that the one you know does not: for Tcl, its event loop and coroutines.
4. A project with tests. One small program that uses the first three lessons, with tests that say when it works.

The order follows what each lesson needs. Idioms can only be compared once something runs, the signature feature reads naturally only after the everyday idioms do, and the project needs all three. Step through the four lessons for Tcl, and see where a failing project test sends you:

The way back from lesson 4 to lesson 2 is the one you will use most. In a new language, tests rarely fail on syntax, which the compiler or interpreter rejects at once; they fail on an idiom that means something else, such as a division. The twelve languages, with the language each one’s lesson 2 starts from and each one’s signature feature:

The track page lists each language’s four lessons under a module of its own. A capstone module at the end asks for one money-splitting specification in any atlas language.

A recorded session names its commands and its versions

Here are the three programs of the opening, one per tab. Each says hello and adds the whole numbers 1 to 10; the Visual Basic program comes with its project file, which says how to build it:

# Says which Tcl runs it, then adds the whole numbers 1 to 10.
puts "Hello from Tcl [info patchlevel]"
set total 0
for {set n 1} {$n <= 10} {incr n} {
    incr total $n
}
puts "1 + 2 + ... + 10 = $total"

// Says hello, then adds the whole numbers 1 to 10.
#import <Foundation/Foundation.h>
#include <stdio.h>

int main(void) {
    @autoreleasepool {
        NSString *greeting = @"Hello from Objective-C";
        printf("%s\n", greeting.UTF8String);
        NSInteger total = 0;
        for (NSInteger n = 1; n <= 10; n++) {
            total += n;
        }
        printf("1 + 2 + ... + 10 = %ld\n", (long)total);
    }
    return 0;
}

' Says hello, then adds the whole numbers 1 to 10.
Module Program
    Sub Main()
        Console.WriteLine("Hello from Visual Basic")
        Dim total As Integer = 0
        For n As Integer = 1 To 10
            total += n
        Next
        Console.WriteLine($"1 + 2 + ... + 10 = {total}")
    End Sub
End Module

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <OptionStrict>On</OptionStrict>
  </PropertyGroup>

</Project>

None of the three languages runs in the browser here, so this page shows a recorded terminal session instead: each command as it was typed after a $, and below it what the command printed.

from session import run

# One small program in three atlas languages. Each tool first says which version it is; then the program is built
# where the language needs a build, and run. The last three lines run one Tcl expression on two versions of Tcl.
run("""
echo 'puts [info patchlevel]' | tclsh9.0
tclsh9.0 pin/hello.tcl
clang --version | head -n 1
clang -fobjc-arc -Wall -Wextra -framework Foundation pin/hello.m -o hello
./hello
dotnet --version
dotnet run --project pin/hello
echo 'puts "[info patchlevel]: 010 + 1 = [expr {010 + 1}]"' | /usr/bin/tclsh
echo 'puts "[info patchlevel]: 010 + 1 = [expr {010 + 1}]"' | tclsh9.0
""")

$ echo 'puts [info patchlevel]' | tclsh9.0
9.0.4
$ tclsh9.0 pin/hello.tcl
Hello from Tcl 9.0.4
1 + 2 + ... + 10 = 55
$ clang --version | head -n 1
Apple clang version 21.0.0 (clang-2100.3.34.2)
$ clang -fobjc-arc -Wall -Wextra -framework Foundation pin/hello.m -o hello
$ ./hello
Hello from Objective-C
1 + 2 + ... + 10 = 55
$ dotnet --version
10.0.401
$ dotnet run --project pin/hello
Hello from Visual Basic
1 + 2 + ... + 10 = 55
$ echo 'puts "[info patchlevel]: 010 + 1 = [expr {010 + 1}]"' | /usr/bin/tclsh
8.5.9: 010 + 1 = 9
$ echo 'puts "[info patchlevel]: 010 + 1 = [expr {010 + 1}]"' | tclsh9.0
9.0.4: 010 + 1 = 11

Read it from the top. Each part starts by asking a tool for its version, and the answer is the toolchain pintoolchain pin: The exact version of the compiler, interpreter or SDK that an example was built and run with, such as Tcl 9.0.4 or the .NET SDK 10.0.401. Another version may print something else for the same file. of what follows: tclsh9.0 answered 9.0.4, clang answered Apple clang version 21.0.0, and dotnet answered 10.0.401. Then come the commands that build and run the program. Tcl runs the script directly. Objective-C, a superset of C, is compiled first: clang writes a program named hello, and the next line runs it. Visual Basic needs its project file, and dotnet run builds the project before it runs it. All three print 55.

Under the session, the page says it was recorded with Python 3.14.8 and gives a Python command. That is the small script that typed the commands and kept what they printed, so the session replays the same way every time. You do not need it to repeat the run: the commands to type are the lines after each $.

Repeating a session takes five moves, and two of them can send you back. Step through them with this session’s own versions:

The version comes first because a run on another version proves nothing about the program, as the next section shows with one line of Tcl.

One Tcl expression, two versions, two answers

The last two lines of the session run the same expression, expr {010 + 1}, on two Tcls of one Mac. macOS still ships Tcl 8.5.9 as /usr/bin/tclsh, while the tclsh9.0 used above is 9.0.4:

Neither answer is a bug. Before 9.0, Tcl read a number that starts with 0 as octal, so 010 was eight. The Tcl 9.0 release notes record the change in one line: “0NNN format is no longer octal interpretation. Use 0oNNN”. In Tcl 9, 010 is ten, and an octal number needs the 0o prefix.

So the version is part of an example, as much as the file is. A recorded output is a fact about one version: the same script can print something else on the next release, and you cannot tell which from the output alone. That is why every atlas session starts with the version lines, and why the first check when your output differs is the version, not the program. The 9.0 release notes list other incompatible changes too; the third lesson of this module reads them as a reference reader would.

The register says why a language is in, waiting or out

A language joins the atlas when a free toolchain runs it from a command line, so every example can show a real run that you can repeat, and when its official documentation can be cited. The register keeps every language that was considered, with one of three statuses and the reason for it:

ABAP shows that the rules are applied, not assumed. Its own runtime belongs to SAP systems, so it could have been left out with VBScript. Instead its examples run on the abaplint transpiler, a transpilertranspiler: A compiler whose output is source code in another high-level language rather than machine code. The abaplint transpiler turns ABAP into JavaScript, which Node.js then runs. that turns ABAP into JavaScript for Node.js, which Exercism’s ABAP test runner also depends on. The choice has a price that the ABAP lessons state: the transpiler takes ABAP 7.02 syntax, newer syntax is converted first, and topics that only an SAP system can show are named as such.

VBScript’s reason comes from Microsoft’s own list of deprecated Windows features:

VBScript is deprecated. In future releases of Windows, VBScript will be available as a feature on demand before its removal from the operating system.

A course about a language on its way out of its only platform would teach towards nothing.

Practise: check a run against its record

The exercise turns the five moves of repeating a session into code: find the version in what a tool printed, and compare your output with the record only when the version is the pin. Its sample tests use this lesson’s own session, from the hello programs to 010 + 1 on both Tcls.

def version_of(line):
    """Return the first version number in the line, such as "21.0.0", or None when the line has none."""
    # Replace this line with your code.
    return None


def check_run(pin, version_line, recorded, mine):
    """Return "same", "other version" or "other output", as the prompt describes."""
    # Replace this line with your code.
    return "same"

from run_check import check_run, version_of


def test_versions_from_the_session():
    """finds the version in what tclsh9.0, clang and dotnet printed"""
    assert version_of("9.0.4") == "9.0.4"
    assert version_of("Apple clang version 21.0.0 (clang-2100.3.34.2)") == "21.0.0"
    assert version_of("10.0.401") == "10.0.401"


def test_no_version_in_the_line():
    """returns None for a line without a version number"""
    assert version_of("zsh: command not found: tclsh") is None


def test_same_run():
    """says "same" for the pinned version and the recorded output"""
    recorded = "Hello from Tcl 9.0.4\n1 + 2 + ... + 10 = 55\n"
    assert check_run("9.0.4", "9.0.4", recorded, recorded) == "same"


def test_other_version_is_checked_first():
    """says "other version" for Tcl 8.5.9, whatever it printed"""
    assert check_run("9.0.4", "8.5.9", "11\n", "9\n") == "other version"
    assert check_run("9.0.4", "8.5.9", "11\n", "11\n") == "other version"


def test_other_output():
    """says "other output" when the version is the pin and a line differs"""
    assert check_run("9.0.4", "9.0.4", "010 + 1 = 11\n", "010 + 1 = 9\n") == "other output"


def test_line_ends_do_not_count():
    """ignores spaces at the ends of lines, Windows line endings and a missing last newline"""
    recorded = "Hello from Visual Basic\n1 + 2 + ... + 10 = 55\n"
    mine = "Hello from Visual Basic  \r\n1 + 2 + ... + 10 = 55"
    assert check_run("10.0.401", "10.0.401", recorded, mine) == "same"

Then work through the self-check on the four ideas of this lesson, from the four lessons of a mini-course to the register. It begins with the idea your earlier answers show you know least:

Interview questions

Warm-up (fresher to mid-level): What is a toolchain pin, and why does a recorded output need one?

A toolchain pin is the exact version of the compiler, interpreter or SDK that a program was built and run with, such as Tcl 9.0.4 or the .NET SDK 10.0.401. A recorded output is only true for that version: expr {010 + 1} prints 9 on Tcl 8.5.9 and 11 on Tcl 9.0.4, because Tcl 9 stopped reading a leading zero as octal. Without the pin, someone who gets a different answer cannot tell whether the program, the input or the tool changed. With it, the first check takes a second: ask the tool for its version and compare. Teams pin toolchains in files for the same reason, such as a global.json that names the .NET SDK, so that a laptop and a build server use the same compiler.

Two more questions about repeatable runs, of the kind a team asks someone who will own a build:

Key takeaways

• Every atlas language gets four lessons in the same order: setup, idioms compared with a language you know, the signature feature, and a project with tests.
• A recorded session starts with each tool’s version, and the lines after each $ are the commands to type.
• Repeat a run in order: match the version first, then type the commands, then compare the output line by line.
• The same Tcl expression, 010 + 1, prints 9 on Tcl 8.5.9 and 11 on Tcl 9.0.4, so the version is part of every example.
• The register gives every language that was considered a status and a reason: in the atlas, waiting for a later edition, or left out.