The Grand Programming Languages Spectrum

C gave Unix its portability, and Unix made C the default language of operating systems. Fifty years on, it still sits underneath nearly everything: kernels, databases, language runtimes, firmware, and the foreign-function interface every other language uses to talk to the outside world.

The big ideaTrust the programmer. C maps almost directly onto the machine and adds nothing you didn’t ask for.

Reach for it for

Firmware, kernels, drivers, and libraries that must be callable from every other language.

Think twice for

Anything that parses untrusted input or faces a network, unless you have the discipline and tooling of a security team.

LatelyC23 brought bool, nullptr, typeof and #embed into the standard, and GCC 15 now compiles C23 by default. The next revision, C2y, adds _Countof; defer is being developed as a separate technical specification.

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define LEN(a) (sizeof(a) / sizeof((a)[0]))

typedef struct { const char *customer; int amount; bool paid; } Order;
typedef struct { const char *customer; int total; } Total;

static int by_total_desc(const void *a, const void *b) {
    return ((const Total *)b)->total - ((const Total *)a)->total;
}

int main(void) {
    Order orders[] = {
        {"ada", 120, true}, {"grace", 75, true}, {"ada", 30, false},
        {"linus", 200, true}, {"grace", 25, true},
    };
    Total totals[LEN(orders)];
    size_t count = 0;

    for (size_t i = 0; i < LEN(orders); i++) {
        if (!orders[i].paid) continue;
        size_t j = 0;
        while (j < count && strcmp(totals[j].customer, orders[i].customer) != 0) j++;
        if (j == count) totals[count++] = (Total){orders[i].customer, 0};
        totals[j].total += orders[i].amount;
    }

    qsort(totals, count, sizeof totals[0], by_total_desc);
    for (size_t j = 0; j < count; j++)
        printf("%s %d\n", totals[j].customer, totals[j].total);
    return 0;
}

C++ began as “C with Classes” and grew into the most feature-rich language in wide use. It powers game engines, browsers, databases, trading systems and most other performance-critical software, and it still gets a new standard every three years.

The big ideaZero-overhead abstraction: what you don’t use, you don’t pay for, and what you do use, you couldn’t hand-code any better.

Reach for it for

Game engines, browsers, real-time and low-latency systems, and large existing C++ codebases.

Think twice for

New network-facing services where a memory-safe language would do, or small teams without C++ veterans.

LatelyC++26 was technically completed in March 2026 with static reflection, contracts, std::execution and a hardened standard library: the biggest release since C++11.

#include <algorithm>
#include <map>
#include <print>
#include <string>
#include <utility>
#include <vector>

struct Order {
    std::string customer;
    int amount;
    bool paid;
};

int main() {
    const std::vector<Order> orders{
        {"ada", 120, true}, {"grace", 75, true}, {"ada", 30, false},
        {"linus", 200, true}, {"grace", 25, true},
    };

    std::map<std::string, int> totals;
    for (const auto& [customer, amount, paid] : orders)
        if (paid) totals[customer] += amount;

    std::vector<std::pair<std::string, int>> ranked(totals.begin(), totals.end());
    std::ranges::sort(ranked, std::greater{}, &std::pair<std::string, int>::second);
    for (const auto& [customer, total] : ranked)
        std::println("{} {}", customer, total);
}

Rust started as Graydon Hoare’s side project, was adopted by Mozilla, and reached 1.0 in 2015. It proved that a systems language can be memory-safe without a garbage collector, and it now ships in the Linux kernel, Android and Windows, and across the major cloud providers.

The big ideaOwnership: every value has exactly one owner and the compiler checks every borrow, so memory errors and data races become compile errors.

Reach for it for

Systems software, CLIs, network services, embedded and WebAssembly, and anything replacing C or C++ where security matters.

Think twice for

Quick prototypes, exploratory data work, or teams that need to be productive this week.

LatelyThe Linux kernel dropped Rust’s “experimental” label in December 2025. Google reported in late 2025 that memory-safety bugs had fallen below 20% of Android’s vulnerabilities, down from 76% in 2019, as new code moved to Rust.

use std::collections::HashMap;

struct Order {
    customer: &'static str,
    amount: u32,
    paid: bool,
}

fn main() {
    let orders = [
        Order { customer: "ada", amount: 120, paid: true },
        Order { customer: "grace", amount: 75, paid: true },
        Order { customer: "ada", amount: 30, paid: false },
        Order { customer: "linus", amount: 200, paid: true },
        Order { customer: "grace", amount: 25, paid: true },
    ];

    let mut totals: HashMap<&str, u32> = HashMap::new();
    for order in orders.iter().filter(|o| o.paid) {
        *totals.entry(order.customer).or_default() += order.amount;
    }

    let mut ranked: Vec<_> = totals.into_iter().collect();
    ranked.sort_by(|a, b| b.1.cmp(&a.1));
    for (customer, total) in ranked {
        println!("{customer} {total}");
    }
}

Zig is Andrew Kelley’s attempt at a better C: a small language with no hidden control flow, no hidden allocations and no preprocessor. It is still pre-1.0 and changes with each release, yet it already powers serious software, including the Bun runtime, the Ghostty terminal and the TigerBeetle database.

The big ideaMake everything explicit: allocators are passed in, errors are values, and compile-time code (comptime) replaces macros and generics.

Reach for it for

Performance-critical systems code, replacing C build toolchains, and projects where you want to control every allocation.

Think twice for

Anything that needs long-term API stability today, or a large hiring pool.

LatelyZig 0.16 rebuilt I/O and async around a std.Io interface that is passed in like an allocator. 0.17 reworked the build system and moved C translation out of the compiler.

const std = @import("std");

const Order = struct { customer: []const u8, amount: u32, paid: bool };

pub fn main() !void {
    var debug_allocator: std.heap.DebugAllocator(.{}) = .init;
    defer _ = debug_allocator.deinit();
    const gpa = debug_allocator.allocator();

    const orders = [_]Order{
        .{ .customer = "ada", .amount = 120, .paid = true },
        .{ .customer = "grace", .amount = 75, .paid = true },
        .{ .customer = "ada", .amount = 30, .paid = false },
        .{ .customer = "linus", .amount = 200, .paid = true },
        .{ .customer = "grace", .amount = 25, .paid = true },
    };

    var totals: std.StringArrayHashMapUnmanaged(u32) = .empty;
    defer totals.deinit(gpa);

    for (orders) |order| {
        if (!order.paid) continue;
        const entry = try totals.getOrPutValue(gpa, order.customer, 0);
        entry.value_ptr.* += order.amount;
    }

    const ByTotal = struct {
        values: []const u32,
        pub fn lessThan(ctx: @This(), a: usize, b: usize) bool {
            return ctx.values[a] > ctx.values[b];
        }
    };
    totals.sort(ByTotal{ .values = totals.values() });

    for (totals.keys(), totals.values()) |customer, total| {
        std.debug.print("{s} {d}\n", .{ customer, total });
    }
}

Bill Hall, who goes by gingerBill, started Odin in 2016 as the language he wanted for his own graphics and tools work: C’s directness without its sharp edges. It has no hidden control flow, a small set of orthogonal features, and a compiler that doubles as the build system. It is still young and its community is small, but it is used for commercial software, including the visual-effects tools from JangaFX.

The big ideaData-oriented design in the language itself: plain structs, explicit allocators passed through an implicit context, and built-in support for array programming and struct-of-arrays layouts.

Reach for it for

Games, graphics and native tools, and a calmer replacement for C in projects you control.

Think twice for

Anything that needs long-term API stability, a rich package ecosystem or a hiring pool.

LatelyThe July 2026 build added a restricted -bedrock mode and stack canaries, and made PIE and full RELRO the Linux defaults. Odin scored 82% admired in Stack Overflow’s 2026 survey, but only about 34 respondents used it.

package main

import "core:fmt"
import "core:slice"

Order :: struct {
	customer: string,
	amount:   int,
	paid:     bool,
}

Total :: struct {
	customer: string,
	total:    int,
}

main :: proc() {
	orders := []Order{
		{"ada", 120, true},
		{"grace", 75, true},
		{"ada", 30, false},
		{"linus", 200, true},
		{"grace", 25, true},
	}

	totals := make(map[string]int)
	defer delete(totals)

	for order in orders {
		if order.paid {
			totals[order.customer] += order.amount
		}
	}

	ranked := make([dynamic]Total, 0, len(totals))
	defer delete(ranked)
	for customer, total in totals {
		append(&ranked, Total{customer, total})
	}

	slice.sort_by(ranked[:], proc(a, b: Total) -> bool {return a.total > b.total})

	for row in ranked {
		fmt.println(row.customer, row.total)
	}
}

Java launched with “write once, run anywhere” and became the backbone of enterprise software, Android and big data. After a slow decade it now ships every six months, and recent releases have added records, pattern matching and virtual threads without breaking old code.

The big ideaA managed, portable runtime: the JVM handles memory, optimises hot code while it runs, and executes the same bytecode everywhere.

Reach for it for

Large backend systems, long-lived enterprise software, and data infrastructure.

Think twice for

Tiny CLIs or serverless functions where JVM start-up time matters, unless you compile ahead of time with GraalVM.

LatelyJDK 25 finalised compact source files and instance main methods, so a Java program no longer needs a class declaration; the snippet below uses them. Virtual threads, final since JDK 21, let plain blocking code scale like async code.

import static java.util.stream.Collectors.groupingBy;
import static java.util.stream.Collectors.summingInt;

record Order(String customer, int amount, boolean paid) {}

void main() {
    var orders = List.of(
        new Order("ada", 120, true),
        new Order("grace", 75, true),
        new Order("ada", 30, false),
        new Order("linus", 200, true),
        new Order("grace", 25, true));

    orders.stream()
        .filter(Order::paid)
        .collect(groupingBy(Order::customer, summingInt(Order::amount)))
        .entrySet().stream()
        .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
        .forEach(e -> IO.println(e.getKey() + " " + e.getValue()));
}

C# started as Microsoft’s answer to Java and has since out-evolved it, bringing async/await, LINQ and modern pattern matching to the mainstream. .NET is now open source and cross-platform, and C# runs everything from cloud services to Unity games.

The big ideaPragmatic evolution: absorb proven ideas from functional languages into a familiar, productive object-oriented core.

Reach for it for

Enterprise backends, Windows and cross-platform desktop apps, and games in Unity or Godot.

Think twice for

Environments the .NET runtime can’t reach, or teams wedded to the JVM ecosystem.

LatelyC# 14 added extension members and the field keyword. .NET 10 runs a single .cs file with dotnet run app.cs, no project file needed, which is how the snippet below runs.

var orders = new List<Order>
{
    new("ada", 120, true),
    new("grace", 75, true),
    new("ada", 30, false),
    new("linus", 200, true),
    new("grace", 25, true),
};

var totals =
    from order in orders
    where order.Paid
    group order.Amount by order.Customer into g
    let total = g.Sum()
    orderby total descending
    select (Customer: g.Key, Total: total);

foreach (var (customer, total) in totals)
    Console.WriteLine($"{customer} {total}");

record Order(string Customer, int Amount, bool Paid);

Robert Griesemer, Rob Pike and Ken Thompson designed Go at Google to make large-scale server software simple to write and read. It became the language of cloud infrastructure: Docker, Kubernetes, Terraform and much of the cloud-native landscape are written in Go.

The big ideaSimplicity at scale: a small language, fast compiles, one formatting style, and concurrency built into the language.

Reach for it for

Network services, cloud infrastructure, CLIs and DevOps tooling.

Think twice for

GUI apps, numerical computing, or domains that reward rich type-level modelling.

LatelyGo 1.26 made the Green Tea garbage collector the default, cutting GC overhead by 10–40%. Go 1.27 added generic methods and rebuilt encoding/json on top of json/v2.

package main

import (
	"cmp"
	"fmt"
	"maps"
	"slices"
)

type Order struct {
	Customer string
	Amount   int
	Paid     bool
}

func main() {
	orders := []Order{
		{"ada", 120, true},
		{"grace", 75, true},
		{"ada", 30, false},
		{"linus", 200, true},
		{"grace", 25, true},
	}

	totals := map[string]int{}
	for _, o := range orders {
		if o.Paid {
			totals[o.Customer] += o.Amount
		}
	}

	customers := slices.SortedFunc(maps.Keys(totals), func(a, b string) int {
		return cmp.Compare(totals[b], totals[a])
	})
	for _, c := range customers {
		fmt.Println(c, totals[c])
	}
}

JetBrains created Kotlin to fix Java’s pain points while staying fully interoperable with it. Google made it the preferred language for Android in 2019, and Kotlin Multiplatform now shares code across Android, iOS, desktop and the web.

The big ideaA better Java, pragmatically: null safety, concise syntax and coroutines, with seamless access to every Java library.

Reach for it for

Android apps, shared mobile logic, and JVM backends where Java feels heavy.

Think twice for

Teams with no JVM experience who want a minimal toolchain.

LatelyKotlin 2.4 made context parameters and explicit backing fields stable. Compose Multiplatform for iOS went stable in May 2025, so one UI codebase can now target both phones.

data class Order(val customer: String, val amount: Int, val paid: Boolean)

fun main() {
    val orders = listOf(
        Order("ada", 120, true),
        Order("grace", 75, true),
        Order("ada", 30, false),
        Order("linus", 200, true),
        Order("grace", 25, true),
    )

    orders.filter { it.paid }
        .groupingBy { it.customer }
        .fold(0) { total, order -> total + order.amount }
        .entries
        .sortedByDescending { it.value }
        .forEach { (customer, total) -> println("$customer $total") }
}

Google first pitched Dart as a replacement for JavaScript in the browser, and that never happened. Flutter rescued it: Dart’s JIT gives instant hot reload during development and its AOT compiler gives fast native release builds. It now ships apps on iOS, Android, the web and desktop.

The big ideaA language shaped for UI work: hot reload while you build, fast native code when you ship, and sound null safety throughout.

Reach for it for

Cross-platform apps with a custom UI, built with Flutter.

Think twice for

Backend services, or anything Flutter isn’t part of.

LatelyThe Dart team cancelled macros in January 2025 after years of work. Dot shorthands arrived in 3.10 and primary constructors in 3.13.

typedef Order = ({String customer, int amount, bool paid});

void main() {
  const List<Order> orders = [
    (customer: 'ada', amount: 120, paid: true),
    (customer: 'grace', amount: 75, paid: true),
    (customer: 'ada', amount: 30, paid: false),
    (customer: 'linus', amount: 200, paid: true),
    (customer: 'grace', amount: 25, paid: true),
  ];

  final totals = <String, int>{};
  for (final (:customer, :amount, :paid) in orders) {
    if (paid) {
      totals.update(customer, (sum) => sum + amount, ifAbsent: () => amount);
    }
  }

  final ranked = totals.entries.toList()
    ..sort((a, b) => b.value.compareTo(a.value));
  for (final MapEntry(:key, :value) in ranked) {
    print('$key $value');
  }
}

Apple introduced Swift in 2014 as a modern replacement for Objective-C. It combines value types, optionals and protocol-oriented design with native performance, and Swift 6 added compile-time data-race checking. It also runs on Linux, Windows, Android and microcontrollers, though most of its use is still on Apple platforms.

The big ideaSafe by default, fast by design: optionals instead of null, value types everywhere, and a compiler that catches data races.

Reach for it for

iOS, macOS, watchOS and visionOS apps.

Think twice for

Cross-platform products where Apple is one target among many, unless you’re betting on Swift’s newer Android and server support.

LatelySwift 6.2 softened strict concurrency with “approachable concurrency” defaults. An official Android workgroup is building Android support, and Embedded Swift now targets microcontrollers.

struct Order {
    let customer: String
    let amount: Int
    let paid: Bool
}

let orders = [
    Order(customer: "ada", amount: 120, paid: true),
    Order(customer: "grace", amount: 75, paid: true),
    Order(customer: "ada", amount: 30, paid: false),
    Order(customer: "linus", amount: 200, paid: true),
    Order(customer: "grace", amount: 25, paid: true),
]

let totals = orders
    .filter(\.paid)
    .reduce(into: [String: Int]()) { $0[$1.customer, default: 0] += $1.amount }

for (customer, total) in totals.sorted(by: { $0.value > $1.value }) {
    print(customer, total)
}

Brendan Eich wrote the first version of JavaScript in ten days in 1995. It became the only language every web browser runs, then spread to servers with Node.js, desktops with Electron and phones with React Native. It is still the most used language in most developer surveys.

The big ideaA dynamic, event-driven language with first-class functions, running wherever there is a browser engine.

Reach for it for

Anything that runs in a browser, small scripts, and full-stack web apps in one language.

Think twice for

Large codebases without types. Reach for TypeScript instead.

LatelyES2026 added Math.sumPrecise, Error.isError and base64 helpers on Uint8Array. Temporal, the long-awaited replacement for Date, is finished and scheduled for ES2027.

const orders = [
  { customer: "ada", amount: 120, paid: true },
  { customer: "grace", amount: 75, paid: true },
  { customer: "ada", amount: 30, paid: false },
  { customer: "linus", amount: 200, paid: true },
  { customer: "grace", amount: 25, paid: true },
];

const totals = new Map();
for (const { customer, amount, paid } of orders) {
  if (paid) totals.set(customer, (totals.get(customer) ?? 0) + amount);
}

[...totals]
  .sort(([, a], [, b]) => b - a)
  .forEach(([customer, total]) => console.log(customer, total));

PHP began as Rasmus Lerdorf’s “Personal Home Page” tools and grew into the server language of the early web. It still runs a large share of all websites, every WordPress install among them. Modern PHP, with types, a JIT and frameworks like Laravel and Symfony, is a very different language from its reputation.

The big ideaShared-nothing simplicity: every request starts fresh, so there is no state to leak and deploying is copying files.

Reach for it for

Content sites, e-commerce and CRUD web applications, especially with Laravel or WordPress.

Think twice for

Real-time systems, CPU-heavy work, or anything outside the web.