Introduction

The languages are listed in alphabetical order, not according to any specific priority.

C

C was born at Bell Labs in the early 1970s and became the portable systems language behind Unix. It’s the one I reach for when I need tight control, predictable performance, and a tiny footprint.

History

  • 1969–1973: Designed by Dennis Ritchie at Bell Labs to implement Unix, evolving from BCPL/B.
  • 1973: The Unix kernel is rewritten in C, proving a high‑level language can be used for systems programming and driving C’s adoption across academia and industry.
  • 1978: “K&R C” book popularizes the language; de‑facto reference for many years.
  • 1989/1990: ANSI/ISO C (C89/C90) standardizes the language; later revisions C99, C11, C17 (a.k.a. C18), and C23.
  • 1999: C99 brings // comments, inline, stdint.h, variable‑length arrays, and improved floating‑point support.
  • 2011: C11 introduces a formal memory model, atomics, threads, and improved Unicode support; C17/C23 focus on defect fixes and quality‑of‑life improvements.
  • Emphasis on portability, small runtimes, and a stable C ABI made it the foundation for operating systems and libraries.

Technical

  • Compiled, statically typed, close to the metal; predictable performance and small runtime footprint.
  • ISO standardized (C89/C90, C99, C11, C17, C23); minimal core with pointers, structs, and manual memory (malloc/free).
  • Undefined behavior and strict aliasing rules require care; portability often targets the well‑defined subset across compilers/OSes.
  • Concurrency via POSIX threads (pthreads) and C11 threads/atomics; no built‑in exceptions or runtime type info.
  • Toolchains: GCC, Clang/LLVM, MSVC; common builds with Make/CMake; stable C ABI makes it the lingua franca for FFI.
  • Dominant in kernels, embedded, systems/OS interfaces, and performance‑critical libraries.

Links

C++

C++ grew out of systems programming needs: performance, control over memory, and compatibility with C. I’ve never loved its complexity, but it absolutely earns its place for low‑latency, embedded, game engines, and infrastructure where every microsecond counts.

Documentary

The documentary The Story of C++ provides an insightful overview of the language’s evolution and its impact on systems programming.

History

  • Early 1980s: Bjarne Stroustrup creates “C with Classes” at Bell Labs; first release 1985 (The C++ Programming Language).
  • Late 1980s–1990s: Templates and exceptions arrive; ISO C++98/03 provides the first standard.
  • 1994–1998: The STL (by Alexander Stepanov and others) is standardized, cementing generic programming idioms; Boost (founded 1998) becomes an incubator for future standards.
  • 2011: C++11 defines a memory model and thread library; auto, rvalue references, and variadic templates modernize everyday C++.
  • 2011→today: “Modern C++” waves - C++11/14/17/20/23 add move semantics, lambdas, concurrency, modules (TS), coroutines, and concepts.
  • 2020–2023: Concepts, ranges, coroutines, modules, and constexpr enhancements reshape compile‑time and async programming; continuing ABI/toolchain diversity across platforms.
  • Design mantra: zero‑overhead abstractions and strong C compatibility for systems and performance‑critical software.

Technical

  • Compiled, statically typed, with zero‑cost abstractions as a core design goal (you don’t pay for what you don’t use).
  • RAII for deterministic resource management; manual and smart‑pointer memory control (unique_ptr, shared_ptr).
  • Powerful templates and metaprogramming; concepts (since C++20) to constrain templates.
  • Concurrency primitives in the standard library; memory model defined since C++11; coroutines in C++20.
  • STL containers/algorithms; header‑only paradigms common for performance and inlining.
  • ABI stability is platform/toolchain dependent; ODR and inline rules are frequent foot‑guns across libraries.

Links

Fun

Fun is my own small, experimental language - created to make programming, well, fun. It emphasizes simplicity, an interactive feel, and low ceremony so you can tinker and explore ideas quickly.

History

  • 2025: Initial prototypes and experiments exploring a tiny, playful language with a REPL‑first workflow.
  • 2026: Created by Johannes Findeisen (hanez); public site launched at fun-lang.xyz with examples and a simple toolchain.
  • 2026 → today: Active iteration informed by small scripts and teaching use cases; syntax and stdlib evolve pragmatically.

Technical

  • Lightweight language with a focus on approachability and interactive use (REPL‑style workflow).
  • Simple, readable syntax aimed at quick scripts and learning; files commonly use the .fun extension.
  • Minimal standard library for core tasks, growing organically with the project.
  • Designed to be easy to pick up for experimentation, teaching, and prototyping.

Links

Go

Go (Golang) was created at Google to make building networked and concurrent services simpler and faster to compile. I like its clean, opinionated tooling and how easy it is to ship static binaries.

History

  • 2007–2009: Designed by Robert Griesemer, Rob Pike, and Ken Thompson at Google; open‑sourced in 2009.
  • 2012: Go 1.0 with compatibility promise; steady evolution without breaking changes.
  • 2013–2015: gofmt culture and standard tooling become a hallmark; go generate and vendoring practices mature.
  • 2018: Modules (go mod) replace GOPATH for dependency management; 2022: Generics (Go 1.18) land with a minimal design.
  • 2023→today: Improvements in tooling, fuzzing, telemetry, and performance keep Go a default choice for cloud software.
  • Growth driven by cloud, containers (Docker/Kubernetes), and microservices.

Technical

  • Compiled, statically typed with type inference; simple syntax; garbage collected.
  • Concurrency via goroutines and channels (CSP‑inspired); scheduler multiplexes thousands of goroutines.
  • Fast builds, single static binaries by default; cross‑compilation is first‑class.
  • Minimalist standard library, strong batteries for HTTP, tooling (go fmt, go test, go mod).
  • Generics added in Go 1.18 improve expressiveness while keeping simplicity.

Links

Java

I started programming in Java in the late 90s. The JVM, garbage collection, and “write once, run anywhere” made it a dominant platform for servers and enterprise systems. Even today, its stability and tooling are hard to beat.

Documentary

The documentary The Java Story provides an insightful overview of the language’s evolution and its impact on enterprise development.

History

  • 1991: “Oak” project at Sun Microsystems led by James Gosling; 1995: Java 1.0 launches with the JVM and applets (WORA).
  • Late 1990s–2000s: J2SE/J2EE era; Java becomes the enterprise standard. Android (2008) adopts a Java‑like ecosystem.
  • 2004–2006: Java 5 (1.5) introduces generics, annotations, enum, and concurrency utilities; Java 6 polishes performance and tooling.
  • 2006–2011: OpenJDK opens development; ecosystem consolidates around open builds and community projects.
  • 2010: Oracle acquires Sun; OpenJDK becomes the open reference implementation; 6‑month release cadence since Java 9 (2017).
  • 2017→today: Predictable releases deliver features like var, records, pattern matching, sealed classes, and Loom virtual threads.
  • Recent milestones: modules (JPMS, Java 9), records/patterns, and virtual threads (Loom, Java 21) for scalable concurrency.

Technical

  • Compiled to JVM bytecode; HotSpot JIT/AOT optimizations; strong static typing with generics (type erasure).
  • Automatic memory management with multiple GC algorithms; predictable long‑running server behavior.
  • Concurrency via threads, futures, and virtual threads (Project Loom, Java 21) for scalable I/O.
  • Rich standard library and mature tooling: Maven/Gradle, JUnit, profilers, robust IDEs.
  • JPMS (modules) since Java 9; records, pattern matching, and var improve modern Java ergonomics.
  • Wide platform reach: servers (Spring, Quarkus, Micronaut), Android (Kotlin/Java interop), big data ecosystems.

Links

JavaScript

JavaScript started in the browser and now runs everywhere. Love it or hate it, it powers the web’s interactivity and a massive ecosystem across client and server.

History

  • 1995: Created by Brendan Eich at Netscape in 10 days; standardized as ECMAScript (ES) by ECMA.
  • 1997–1999: ES1/ES3 standardize the core; ES3 (1999) defines many semantics browsers relied on for a decade.
  • 2009: ES5 adds strict mode, JSON, and better object APIs; TC39 later adopts a yearly release cadence (2016→).
  • 2009: Node.js brings JS to the server; npm ecosystem explodes.
  • 2015→today: ES6+ modernizes the language (modules, classes, async/await, iterables, etc.).
  • 2019→today: TypeScript’s rise mainstreams typed tooling atop JS; Deno/Bun explore alternative runtimes.

Technical

  • Dynamically typed, prototype‑based; JIT‑compiled in modern engines (V8, SpiderMonkey, JavaScriptCore, ChakraCore).
  • Event‑loop concurrency model; async via callbacks, Promises, and async/await.
  • Runs in browsers, Node.js, and Deno; TS adds static typing (transpiled).
  • Vast ecosystem via npm; bundlers/tooling (webpack, Vite, esbuild) and test frameworks are mature.

Links

Lua

Lua is a small, embeddable scripting language from PUC‑Rio, designed to be integrated into larger systems. I like it for configuration, scripting inside applications, and places where a tiny runtime and easy C interop matter.

History

  • 1993: Created at PUC‑Rio by Roberto Ierusalimschy, Luiz Henrique de Figueiredo and Waldemar Celes for extensibility and data description.
  • 1994–1997: Early 1.x/2.x/3.x releases refine tables and metatables; 2000: Lua 4.0 simplifies the core and C API.
  • 2003: Lua 5.0 introduces coroutines and a revised module system; 2015: 5.3 adds integers/bitwise ops; 2020: 5.4 adds generational GC.
  • 2003→today: Lua 5.x line stabilizes the core; 2005: LuaJIT brings a high‑performance JIT and FFI; adoption in games, tools, and embedded.
  • Influences include Scheme and data‑description languages; designed from day one for easy C embedding and portability.
  • Longstanding use in game engines (e.g., World of Warcraft UI, Roblox historically), embedded devices, and extensibility layers.

Technical

  • Lightweight and portable: implemented in ANSI C; tiny footprint suitable for embedded and game engines.
  • Dynamically typed with automatic memory management (incremental GC); simple syntax that’s easy to embed and learn.
  • Single core data type is the table (arrays, maps, objects); metatables/metamethods enable powerful customization.
  • Coroutines provide cooperative multitasking; great for async/state machines without OS threads.
  • Embedding via C API is a first‑class use case; LuaJIT adds a high‑performance JIT and an FFI for C libraries.
  • Ecosystem: LuaRocks for packages; widely used in games, OpenResty (Nginx), Redis scripting, Neovim configs, Wireshark, and embedded devices.

Links

Perl

Perl embraced “There’s more than one way to do it.” It shines at text processing, sysadmin glue, and pragmatic scripting with CPAN’s deep library ecosystem.

History

  • 1987: Created by Larry Wall for report processing and UNIX glue.
  • 1991: Perl 4 stabilizes the language; mid‑to‑late 1990s CGI boom puts Perl at the center of early dynamic web development.
  • 1994–2000: Perl 5 era with modules, references, and OO; CPAN launches (1995) and becomes central.
  • 2000s: mod_perl, DBI, Template Toolkit, and testing culture (TAP) shape modern scripting practices.
  • 2015→: Ongoing Perl 5 development; a separate language line (formerly Perl 6, now Raku) evolves independently.
  • 2019: “Perl 6” is renamed Raku, clarifying the separate lineage while Perl 5 continues active maintenance.

Technical

  • Interpreted, dynamically typed; powerful regex and text processing at its core.
  • CPAN provides a vast repository of modules; toolchain via perl, cpan, cpanm.
  • Context‑sensitive semantics (scalar/list), sigils, and flexible syntax enable concise but dense code.
  • Strong for sysadmin, ETL, bioinformatics, legacy web (CGI to PSGI/Plack), and quick automation.

Links

PHP

PHP started as a pragmatic web scripting language and grew into a capable application platform. It was my first server‑side language, and it’s still a quick way to build and ship dynamic sites.

History

  • 1994–1997: Rasmus Lerdorf’s “Personal Home Page” tools evolve into PHP/FI; 1998: PHP 3 popularizes server‑side scripting on the web.
  • 2000: PHP 4 (Zend Engine 1); 2004: PHP 5 (Zend Engine 2) adds real OOP and improved extensions.
  • 2009–2010: PHP‑FPM becomes the de‑facto process manager; frameworks (Symfony, Laravel) and CMSs (WordPress, Drupal) drive adoption.
  • 2012: Ecosystem milestone — Composer standardizes dependency management; PSRs unify autoloading and coding styles.
  • 2014–2016: HHVM’s competitiveness helps spur substantial performance work that culminates in PHP 7.
  • 2015: PHP 7 delivers major performance gains and memory efficiency; 2020: PHP 8 introduces a JIT and modern language features.
  • 2021–2023: Fibers (8.1), enums, attributes, and better typing keep the language modern while retaining its pragmatic web focus.

Technical

  • Interpreted via the Zend Engine; PHP 8+ adds a JIT; dynamic typing with modern features: scalar/union types, attributes, enums, readonly properties.
  • Request/response model; OPcache for bytecode caching; PHP‑FPM is the common process manager for high‑performance deployments.
  • Composer as dependency manager and Packagist as the default registry; PSR standards (PSR‑1/PSR‑4/PSR‑12, etc.) guide autoloading and style.
  • Database access via PDO; rich stdlib for web (sessions, filters, curl, mbstring).
  • Concurrency/async via Fibers (8.1) with ecosystems like Amp/ReactPHP; workers/queues common for background jobs.
  • Major frameworks: Laravel, Symfony; popular runtimes in containers and serverless (e.g., Bref on AWS Lambda).

Links

Python

Python’s superpower is readability and the massive ecosystem around it. I love how it lets me move quickly - from small scripts to data work and web backends - while staying friendly to newcomers and pros alike.

Documentary

The documentary The Story of Python provides an insightful overview of the language’s evolution and its impact on programming.

History

  • 1989–1991: Created by Guido van Rossum at CWI; Python 0.9/1.0 emphasize simplicity, readability, and batteries‑included.
  • 1994–2000: Python 1.x/2.0 add modules, distutils, cyclic GC, and Unicode; 2001: PSF is founded to steward the language.
  • 2008: Python 3.0 introduces breaking changes to clean up the language; long transition from Python 2 ends with 2.x EOL in 2020.
  • 2014→today: Async (async/await), type hints (PEP 484), pyproject.toml packaging, and steady performance/tooling improvements.
  • 2018: Steering Council model replaces BDFL after Guido steps down; packaging pivots to pip/wheel/pyproject.toml.
  • 2021→today: 3.10–3.12 bring pattern matching, faster CPython, and improved typing; scientific and ML adoption surges.
  • Governance via PEPs and a core team keeps the language pragmatic and community‑driven.

Technical

  • Interpreted/byte‑compiled to .pyc by CPython; dynamically typed with optional type hints (PEP 484) checked by mypy/pyright.
  • The GIL in CPython simplifies C API safety but limits true CPU‑bound threading; multiprocessing or native extensions for parallelism.
  • venv/pip for environments and packages; packaging modernized via pyproject.toml (PEP 517/518).
  • Batteries‑included stdlib; rich ecosystems: data (NumPy/Pandas), web (Django/FastAPI), ML (PyTorch), DevOps (Ansible), scripting/automation.
  • asyncio for async I/O; type‑aware editors make large codebases maintainable despite dynamic typing.

Links

Rust

Rust set out to make systems programming safe and productive without sacrificing performance. I enjoy its fearless concurrency and helpful compiler.

History

  • 2006–2010: Graydon Hoare starts Rust; Mozilla sponsors development.
  • 2015: Rust 1.0 release with stability guarantees; rapid ecosystem growth follows.
  • 2018/2021: Edition system (2018, 2021) enables non‑breaking language evolution across the ecosystem.
  • 2021→: Rust Foundation formed; adoption in industry and open source accelerates.
  • 2022: Initial Rust support lands in the Linux kernel tree; WASM and embedded use cases expand.
  • Ongoing: Safety, tooling (cargo, Clippy, rust‑analyzer), and async runtimes mature, driving broader systems adoption.

Technical

  • Compiled, statically typed; ownership/borrowing model eliminates data races and many memory errors.
  • Zero‑cost abstractions; Result/Option and pattern matching encourage explicit error handling.
  • Concurrency via threads, async/await (tokio, async-std); no GC; great tooling (cargo, rustup).
  • Ecosystem on crates.io; FFI with C; no_std for embedded; WASM for web.

Links

Overview

Very short, opinionated guide on where each language tends to make sense:

  • C - kernels and OS interfaces, embedded/IoT, small native tools/libraries, FFI glue; when you need tight control, tiny footprints, and determinism.
  • C++ - performance‑critical native apps, real‑time systems, game engines, high‑throughput services; when you want zero‑overhead abstractions with RAII.
  • Fun - tinkering, learning, quick scripts and prototypes; when you want a playful, minimal language to explore ideas fast.
  • Go - cloud services, CLIs, networked backends, containers/orchestration; when you want simple concurrency, fast builds, and static binaries.
  • Java - long‑lived server backends, large teams, stable tooling, JVM ecosystem (Spring, big data), Android backends; when reliability and observability matter.
  • JavaScript - interactive web apps, Node.js services, cross‑platform tooling; when ubiquity and rapid iteration beat raw performance.
  • Lua - embedded scripting inside applications, game engines, OpenResty/Nginx, Redis scripting, Neovim configs; when you need a tiny embeddable runtime with easy C interop and coroutines.
  • Perl - sysadmin glue, text processing, ETL, legacy web stacks; when you want powerful regex and pragmatic scripting with CPAN.
  • PHP - dynamic websites/CMS, server‑rendered apps, quick CRUD backends, shared hosting; when you want to ship web features fast with simple ops.
  • Python - scripting/automation, data science/ML, APIs and prototypes, glue code; when developer speed and libraries outweigh raw throughput.
  • Rust - systems components, performance‑critical services, CLI tools, embedded, and safety‑critical code; when you want memory safety without GC.

Feature overview

LanguageTyping/StyleRuntime/CompilationConcurrency modelNotable strengths
CStatic, manual memoryNative compiledPOSIX/C11 threads & atomicsTiny footprint, stable C ABI/FFI
C++Static, RAII, templatesNative compiledstd::thread, atomics, coroutinesZero‑overhead abstractions, performance
FunSimple/experimentalInterpreter/REPL‑first-Playful prototyping, low ceremony
GoStatic (with inference)Native compiled (fast)Goroutines + channels (CSP)Fast builds, simple deployments
JavaStatic (generics)JVM JIT/AOTThreads, futures, virtual threadsStability, tooling, observability
JavaScriptDynamic, prototype‑basedJIT in engines (V8, etc.)Event loop; Promises/async‑awaitUbiquity, web platform reach
LuaDynamic, tables/metatablesInterpreter/LuaJITCoroutines (cooperative)Tiny embeddable runtime, easy C API
PerlDynamic, text/regex‑centricInterpreterProcesses/threads; event libsPragmatic scripting, CPAN
PHPDynamic (gradual types)Zend VM with JIT (8+)Fibers; async via libs (Amp/React)Web ergonomics, huge ecosystem
PythonDynamic (+ type hints)Bytecode (CPython)GIL; multiprocessing/asyncioReadability, rich libraries
RustStatic, ownership/borrowingNative compiledThreads; async/await (no GC)Memory safety, performance

Conclusion

If you watch any of these (where available), tell me what you took away - or share your own “language origin” story. History really does matter when picking the right tool for the job.

Comments