Reference — Language Comparisons
Speed, safety, jobs, ecosystem — the key questions answered for every major language pair.
The two most popular languages in the world, dominating different domains. Python owns AI, data science, and backend scripting. JavaScript owns the browser and has expanded aggressively into every other domain via Node.js.
| Dimension | Python | JavaScript |
|---|---|---|
| Created | 1991 — Guido van Rossum | 1995 — Brendan Eich / Netscape |
| Runtime speed | Slower — CPython is interpreted | Faster — V8 JIT compilation |
| AI / ML | Dominant — NumPy, PyTorch, HuggingFace | Minimal — TensorFlow.js is secondary |
| Web frontend | Not native — no browser runtime | The only native browser language |
| Web backend | Django, FastAPI, Flask | Node.js, Express, Fastify, Hono |
| Beginner-friendly | Best-in-class syntax clarity | Quirks: coercion, async, scope |
| Type safety | Optional type hints (mypy) | Optional via TypeScript |
| Job market | #1 globally — widest industry spread | Most open positions in total |
| Mobile | Not a natural fit | React Native, Expo |
| Concurrency | GIL limits true parallelism | Event loop — good for I/O, not CPU |
Learn Python if you want to work in AI, data science, or need the easiest possible entry into programming. Learn JavaScript if your immediate goal is building interactive websites. If you can only learn one, Python has the broader career ceiling in 2024 — but knowing both within a year is realistic and extremely employable.
Two modern languages tackling safety and performance from different angles. Go optimises for developer velocity and simplicity. Rust optimises for maximum safety and control. Both compile to fast native binaries.
| Dimension | Rust | Go |
|---|---|---|
| Created | 2010 — Graydon Hoare / Mozilla | 2009 — Robert Griesemer, Rob Pike, Ken Thompson / Google |
| Runtime speed | C-level performance, no GC pauses | Very fast — GC but low-latency |
| Memory safety | Compile-time guaranteed, no GC | GC prevents many errors, not all |
| Compile speed | Slow — complex borrow checking | Extremely fast — seconds to compile |
| Learning curve | Steep — borrow checker is unique | Gentle — one weekend to be productive |
| Concurrency | Fearless concurrency via ownership | Goroutines — trivially simple |
| Backend APIs | Axum, Actix — excellent but complex | Standard library handles most cases |
| Systems / embedded | Primary use case, Linux kernel support | Not suited for bare-metal |
| WebAssembly | Best-in-class WASM compilation | Supported but larger binary size |
| Job market | Growing fast — high salary ceiling | More open positions — cloud-native |
| Famous users | Linux kernel, Cloudflare, Mozilla, Figma | Docker, Kubernetes, Terraform, Caddy |
Go wins for building backend services, CLIs, and cloud infrastructure — you'll be productive in days and the standard library handles 80% of what you need. Rust wins when you're building something where correctness and performance are non-negotiable: OS components, embedded firmware, WebAssembly, or high-frequency systems. Go is the default; Rust is the upgrade when constraints demand it.
TypeScript is a strict superset of JavaScript — every JS file is valid TS. The question is whether the type system overhead is worth it. For anything larger than a script, the answer is almost always yes.
| Dimension | TypeScript | JavaScript |
|---|---|---|
| Created | 2012 — Anders Hejlsberg / Microsoft | 1995 — Brendan Eich / Netscape |
| Type safety | Static, catches bugs at compile time | Dynamic, bugs surface at runtime |
| IDE support | Excellent autocomplete and refactoring | Good, but less precise |
| Setup friction | Requires tsconfig and build step | Runs anywhere immediately |
| Runtime | Compiles to JavaScript — same runtime | No compilation needed |
| Team scale | Critical for large codebases | Hard to maintain at scale |
| Framework support | React, Vue, Angular all prefer TS | Works but less idiomatic |
| Job market | Now the expected standard in frontend | Still universal but declining |
| Learning curve | Type system has depth to explore | Simpler to start |
Use TypeScript for any project with more than one file, or that will live more than a week. Use plain JavaScript only for quick scripts, prototypes, or environments that don't support a build step. TypeScript is now the industry default — most job postings expect it. Learn JavaScript first to understand the fundamentals, then layer TypeScript on top within weeks.
C is the foundation of modern computing — small, portable, and direct. C++ is C extended with classes, templates, and the STL. They share a heritage but serve different purposes and demand very different approaches.
| Dimension | C | C++ |
|---|---|---|
| Created | 1972 — Dennis Ritchie / Bell Labs | 1985 — Bjarne Stroustrup / Bell Labs |
| Complexity | Small spec — fits in your head | Enormous — no one knows all of it |
| Performance | Maximum — no overhead | Maximum — zero-cost abstractions |
| Memory model | Manual — full control, full risk | Manual + RAII, smart pointers |
| OOP | None built in | Full OOP + templates + metaprogramming |
| Ecosystem | Every OS, every chip, every platform | Game engines, databases, browsers |
| Compile time | Fast | Templates can be very slow |
| Safety | No safety features — UB everywhere | RAII helps; undefined behaviour remains |
| Learning value | Teaches how computers actually work | Teaches systems + design patterns |
| Famous uses | Linux kernel, CPython, SQLite, Git | Unreal, Chrome V8, MySQL, LLVM |
Learn C first — it teaches you memory, pointers, and what the machine is actually doing. Then move to C++ when you need object-oriented design, the STL, or are working in game engines, compilers, or embedded UI. For new systems projects, seriously consider Rust instead — it delivers C/C++ performance with compile-time memory safety.
Both run on the JVM and are 100% interoperable. Kotlin is the modern, concise option Google prefers for Android. Java is the 30-year enterprise incumbent with the deepest ecosystem and job market.
| Dimension | Kotlin | Java |
|---|---|---|
| Created | 2011 — JetBrains | 1995 — James Gosling / Sun Microsystems |
| Android | Google's preferred language since 2017 | Still supported but secondary |
| Conciseness | ~40% less code than equivalent Java | More boilerplate, especially pre-Java 17 |
| Null safety | Built into the type system | NullPointerException still common |
| Coroutines | First-class structured concurrency | Project Loom (virtual threads) in Java 21 |
| Job market | Fast-growing — Android + server-side | Much larger — decades of enterprise |
| Compile speed | Slower than Java | Faster compilation |
| Multiplatform | Kotlin Multiplatform for iOS + web | JVM only |
| Learning curve | Gentler for Java developers | Well-documented; OOP-centric |
New Android projects should use Kotlin without question. For server-side JVM development, Java remains slightly safer for enterprise job hunting — but Kotlin is fully valid and growing. If you already know Java, Kotlin is a two-day migration that pays back immediately. If you're starting fresh, Kotlin is the better investment.
Both are the official modern languages for their respective mobile platforms and share striking design similarities — optionals, null safety, data classes, and functional features. Increasingly they compete in cross-platform mobile too.
| Dimension | Swift | Kotlin |
|---|---|---|
| Created | 2014 — Chris Lattner / Apple | 2011 — JetBrains |
| Primary platform | iOS, macOS, watchOS, tvOS | Android (+ JVM server-side) |
| Performance | Compiled to native — fast | JVM — fast but with GC pauses |
| Null safety | Optionals enforced by type system | Null safety enforced by type system |
| Cross-platform | Swift on Linux (server-side, growing) | Kotlin Multiplatform more mature |
| Open source | Open-sourced 2015, growing server use | Open-sourced from day one |
| Job market | Strong — iOS skills always in demand | Strong — Android skills always in demand |
| Concurrency | Swift Concurrency (async/await + actors) | Coroutines — structured and elegant |
The platform you target decides the language: Swift for Apple platforms, Kotlin for Android. If you want to target both with one codebase, Kotlin Multiplatform is currently more production-ready than Swift on Android. Both languages have bright futures and virtually identical job markets by platform.
Zig positions itself as a modern C replacement — same domain, same performance profile, but cleaner semantics, no preprocessor, and built-in cross-compilation. Still pre-1.0 but already used in production.
| Dimension | Zig | C |
|---|---|---|
| Created | 2016 — Andrew Kelley | 1972 — Dennis Ritchie / Bell Labs |
| Hidden behaviour | None — no hidden allocations, no UB by design | Undefined behaviour is pervasive |
| Preprocessor | None — comptime replaces macros cleanly | C preprocessor is powerful but fragile |
| Cross-compilation | Trivial — built into the toolchain | Complex — requires per-target toolchains |
| C interop | Import C headers directly, zero overhead | Native — it is C |
| Ecosystem | Small — pre-1.0 | Universal — 50 years of libraries |
| Stability | Breaking changes between releases | Extremely stable |
| Job market | Niche | Foundational — always in demand |
| Error handling | Error unions — explicit, typed | Convention-based, easy to ignore |
Use C for production systems that need stability, an ecosystem, and long-term maintenance. Use Zig for new greenfield projects where you can accept a pre-1.0 language — or for cross-compiling existing C projects, where Zig's toolchain is already the best option available. Zig's trajectory is strong; it will matter significantly in three to five years.
The two most influential functional languages outside academia. Haskell is pure, lazy, and theoretically elegant. OCaml is strict, fast, and pragmatically employed at Jane Street, Meta, and in the Rust compiler front-end.
| Dimension | Haskell | OCaml |
|---|---|---|
| Created | 1990 — Simon Peyton Jones et al. | 1996 — INRIA (Xavier Leroy) |
| Purity | Purely functional — effects typed via IO monad | Functional with controlled mutation |
| Evaluation | Lazy — evaluated only when needed | Strict — easier to reason about performance |
| Type system | Most powerful mainstream type system | Excellent — modules + GADTs (recent) |
| Performance | Good — GHC is an excellent compiler | Faster in practice — strict + native code |
| Industry use | Finance (Standard Chartered), compilers | Jane Street, Meta, Rust front-end, MirageOS |
| Effect system | IO monad — elegant but unfamiliar | Algebraic effects in OCaml 5 |
| Learning impact | Learning Haskell rewires how you think | Valuable but less transformative |
| Ecosystem | Hackage is large; tooling improved (GHCup) | OPAM is good; smaller than Hackage |
Learn Haskell if you want to deeply understand functional programming, type theory, and why the industry is moving toward better type systems. Use OCaml if you want to build real functional software that ships — the toolchain is pragmatic, the effect system (OCaml 5) is cutting-edge, and Jane Street's Janestreet OSS packages are exceptional engineering.
Mojo is Modular's Python superset designed for AI systems programming — same syntax, but with types, SIMD, and performance up to 68,000× faster than Python for numerical kernels. Still in early access as of 2024.
| Dimension | Mojo | Python |
|---|---|---|
| Created | 2023 — Chris Lattner / Modular AI | 1991 — Guido van Rossum |
| Performance | Up to 68,000× Python for hot loops | Interpreted — slow for numerical kernels |
| Syntax | Python-compatible — same mental model | Most readable language available |
| Ecosystem | Early — small, growing | Largest AI/ML ecosystem on Earth |
| Maturity | Pre-1.0 — breaking changes expected | Extremely stable — 30+ year ecosystem |
| Hardware access | SIMD, GPU, custom accelerators | Needs C extensions for hardware access |
| Jobs | None yet — too early | Most in-demand language globally |
| Use case | AI kernel authoring, inference engines | Everything else |
Use Python for everything today. Watch Mojo closely — if it delivers on its promise and Modular's MAX inference engine gains adoption, Mojo could become essential for AI systems engineers. The Python compatibility means the transition won't be abrupt. It is not ready to use seriously yet, but it is the most credible Python performance story ever proposed.
Both are excellent choices for backend services with high concurrency demands. Go uses goroutines and CSP channels. Elixir uses the Erlang actor model and has been proven at enormous scale — WhatsApp ran 2 million concurrent connections per server on Erlang/Elixir.
| Dimension | Elixir | Go |
|---|---|---|
| Created | 2012 — José Valim | 2009 — Griesemer, Pike, Thompson / Google |
| Concurrency model | Actor model — millions of lightweight processes | Goroutines — extremely lightweight threads |
| Fault tolerance | OTP supervisors — self-healing by design | Manual — must implement error recovery |
| WebSockets | Phoenix Channels — millions of connections | Good, but requires more boilerplate |
| Raw performance | BEAM VM — slower than native Go | Compiled native — faster throughput |
| Learning curve | Functional + OTP + actor model | One of the simplest languages to learn |
| Type system | Dynamic (Gradual typing with Dialyzer) | Static — simple and effective |
| Real-time | Phoenix LiveView — no JS required | Possible but more work |
| Job market | Niche but growing | Large and expanding |
| Famous users | Discord (5M+ concurrent), Pinterest, Bleacher Report | Docker, Uber, Dropbox, Twitch |
Choose Go for a team that values simplicity, fast onboarding, and a large hiring pool. Choose Elixir when you are building real-time collaborative systems, chat, gaming backends, or anything that requires millions of persistent connections with self-healing fault tolerance. Discord chose Elixir at 5 million concurrent users and has not switched. That should tell you something.