Introduction

Why this matters: understanding where languages come from explains the trade‑offs you feel every day when writing code. Designs are responses to specific problems, hardware, and eras - and those roots still shape performance, safety, tooling, and community norms.

  • It helps you choose the right tool: what excels at systems/embedded, web backends, scripting, data, or games.
  • It makes legacy code and ecosystems less mysterious: you’ll recognize why APIs, build tools, and idioms look the way they do.
  • It surfaces strengths and pitfalls early: memory safety vs. control, GC pauses vs. simplicity, dynamic power vs. predictability.
  • It improves collaboration: shared context leads to clearer discussions about style, architecture, and risk.

Think of this page as a quick map - not a verdict. Use history to inform your decisions, not to fuel language wars.

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.

Critism

  • Memory safety hazards: manual allocation, dangling pointers, buffer overflows; large surface of undefined behavior.
  • Concurrency correctness is hard without higher‑level primitives; data races are easy to introduce.
  • No modules or packages in the language spec; build and dependency management are external conventions.
  • Limited standard library compared to modern languages; many tasks require non‑portable extensions.
  • Portability pitfalls across compilers/architectures due to implementation‑defined behavior; strict aliasing traps.
  • See also: Memory safety, Buffer overflow.

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.

Critism

  • High complexity and large feature surface; multiple paradigms and legacy features increase cognitive load.
  • Template metaprogramming error messages and compile times can be painful; subtle ODR/ABI issues across libraries.
  • Backward compatibility preserves unsafe or confusing constructs; many foot‑guns and undefined behavior remain.
  • Ecosystem fragmentation across standards and toolchains; portability can be non‑trivial.
  • Hard to enforce consistent style/idioms across teams; “there’s more than one way” leads to divergence.
  • See: Criticism of C++.

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.

Critism

  • Very young and experimental: unstable syntax/semantics may change; expect breaking iterations.
  • Small ecosystem and limited libraries; many tasks require writing from scratch.
  • Tooling and documentation are evolving; fewer learning resources compared to mainstream languages.
  • Not performance‑tuned yet; reference implementations may be slow.
  • See: fun-lang.xyz for current status and roadmap.

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.

Critism

  • Historically lacked generics; the 1.18 design is intentionally minimal and may feel limiting for advanced use cases - see Go generics.
  • Error handling is verbose and repetitive (if err != nil); no exceptions by design - see Why no exceptions?.
  • Package versioning and module proxies can confuse newcomers; replace/vendor workflows have sharp edges.
  • Runtime GC pauses can impact low‑latency tails compared to manual or ownership‑based models.
  • Language purposely omits common features (inheritance, macros), which some teams miss.

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.

Critism

  • Verbosity and boilerplate (especially pre‑records/pattern matching); slower iteration vs. dynamic languages.
  • Startup time and memory footprint can be high for small CLIs/microservices, though AOT/GraalVM help.
  • Checked exceptions can lead to noisy code; generics use type erasure, limiting some expressiveness.
  • Ecosystem complexity (build tools, frameworks) can be overwhelming for small projects.
  • See: Criticism of the Java programming language.

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.

Critism

  • Language quirks: implicit coercions, == vs ===, NaN, hoisting, and automatic semicolon insertion.
  • Callback hell historically; async patterns evolved over time (callbacks → Promises → async/await) with mixed ergonomics.
  • Tooling sprawl and frequent churn; build pipelines can be complex and fragile.
  • Inconsistent browser APIs/histories; cross‑environment differences (browser vs Node vs Deno).
  • Security supply‑chain risks in the massive npm ecosystem.
  • See: Criticism of JavaScript · Talk: WAT by Gary Bernhardt.

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.

Critism

  • 1‑based array indexing and nil semantics can surprise users coming from C/Java/JS.
  • Small standard library; community packages vary in quality and maintenance.
  • Numeric type history (floats vs ints) across versions can cause portability concerns; LuaJIT targets 5.1 features.
  • Package management and versioning (LuaRocks) are less standardized than in larger ecosystems.
  • Single‑threaded VM; concurrency is cooperative via coroutines only.
  • See: Reference manual on indices and types · LuaRocks notes.

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.

Critism

  • “Line noise” perception: syntax with sigils/context can be hard to read/maintain for newcomers.
  • Many ways to do the same thing (TMTOWTDI) can hinder consistency across teams/codebases.
  • Historical association with CGI/legacy stacks; modernization uneven across the ecosystem.
  • Performance behind newer JITed/dynamic languages in some workloads.
  • See: Criticism of Perl and discussions around the Perl/Raku split.

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).

Critism

  • Inconsistent function naming and parameter orders across the standard library due to historical evolution.
  • Historically weak typing/surprises (loose comparisons); gradual typing remains optional.
  • Security pitfalls in older tutorials/examples; foot‑guns with register_globals legacy still visible in the wild.
  • Performance used to lag significantly (pre‑7); modern PHP improved but perception persists.
  • Ecosystem fragmentation and framework lock‑in risks for long‑lived systems.
  • See: Criticism of PHP.

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.

Critism

  • Performance: CPython is relatively slow compared to native/JITed languages for CPU‑bound code.
  • The Global Interpreter Lock (GIL) constrains true parallel CPU threading in CPython.
  • Packaging/env management can confuse newcomers (pip, venv, system vs user installs), though improving with pyproject.toml.
  • Dynamic typing without enforcement can shift bugs to runtime unless type hints and checkers are adopted.
  • Version transitions (e.g., 2→3) caused ecosystem splits; long tail of outdated materials persists.

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.

Critism

  • Steep learning curve: the borrow checker and lifetimes can be challenging initially - see The Rust Book.
  • Compile times can be long, especially with heavy generics/monomorphization.
  • Async ecosystem fragmentation (different runtimes/executors); trait object ergonomics can confuse.
  • Interop with existing C++/C build systems can be non‑trivial; unsafe still required at some FFI boundaries.
  • Tooling is excellent but expectations around zero‑cost abstractions can lead to over‑engineering.
  • See: Why async Rust is hard.

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

Usage snapshot

Programming language usage (illustrative, 2026)

Small print: The percentages shown are illustrative for 2026 to visualize relative usage; replace with your preferred dataset and date (e.g., GitHub Octoverse, Stack Overflow, TIOBE) if you want exact figures.

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