You already know Python.Now explore other languages.

Python's closest peer and philosophical foil. Both are readable, dynamic, and expressive, but Ruby's blocks, open classes, and "there's more than one way" ethos give you a richer object model — the language that gave the world Rails and proved convention-over-configuration could be beautiful.

• Blocks and closures — first-class behavior with do…end syntax; more powerful than Python's single-expression lambdas
• Open classes — add methods to any class, even Integer or String, without subclassing or monkey-patching via modules
• Everything is an object — integers, booleans, and nil all have methods; there's no primitive/object split
• Convention over configuration — Rails structures your entire app for you; no Django settings sprawl
• Symbols as lightweight identifiers — :name vs "name" — a distinction Python's str type doesn't make

Python's favorite upgrade path. When you've hit a performance wall or need concurrency without the GIL, Go delivers static types, native goroutines, and 10× throughput — with a learning curve much shorter than Rust or C++.

• Goroutines — thousands of concurrent tasks at ~2 KB each; Python threads are blocked by the GIL for CPU-bound work and asyncio requires async/await everywhere
• Static typing — the compiler catches type mismatches before runtime, unlike Python's duck typing and optional type hints
• 10–100× faster for CPU-bound work — compiled to native code, no interpreter overhead, no GIL
• Single binary deployment — no venv, no pip, no Python version to manage; ship one executable file
• Error values instead of exceptions — every error is explicit in the function signature; no hidden propagation
• Goroutines + channels replace both threading and asyncio with one unified model

The language of the browser, JavaScript is the one runtime every Python web developer eventually meets on the front end.

• Truthiness traps: empty [] and {} are truthy in JavaScript but falsy in Python
• Two empty values — null and undefined — where Python has only None
• === vs. ==: the strict equality you should reach for, and the coercing one you should avoid
• Array methods (map, filter, reduce) in place of list comprehensions
• Prototype-based classes with this instead of an explicit self
• A built-in event loop: async/await with no explicit asyncio.run()

The language CPython is written in. Every list, dict and str you use is a C struct with a refcount on the front — so C is less a foreign language than the floor underneath the one you already know.

• Pointers are the references Python hides — & and * make explicit what a name binding already is
• Manual malloc/free instead of reference counting, with leaks and use-after-free as the price
• No list, dict or str — a string is a pointer to bytes ending in zero, and strlen is O(n)
• Fixed-width integers that overflow, where Python's grow without limit
• Return codes and errno instead of exceptions; nothing forces the caller to check
• What a C extension and ctypes actually do, including releasing the GIL for real parallelism

Roughly what a Python developer wishes Java were — and then null becomes a type error. Inference, top-level functions, expressions instead of statements, data classes, and no ceremony to speak of. So this page is not about boilerplate: it is about what a type system buys once the boilerplate is gone.

• String and String? are different types, and the compiler refuses the call your annotation only ever documented
• data class is @dataclass with copy(), destructuring and generated equality — and == is structural while === is identity, the reverse of Python's naming
• Extension functions are monkey-patching done safely: statically resolved, scoped by import, and unable to collide with anyone else's
• when over a sealed type is checked for exhaustiveness at compile time, which is the one thing match cannot do
• Coroutines have no await at the call site and no event loop to pass around, and structured concurrency cancels the children for you
• Real parallelism, no GIL — and Gradle, honestly, in place of pip and an activated environment

Python's expressiveness, but with memory safety, concurrency without the GIL, and performance without a rewrite. Rust eliminates entire classes of bugs at compile time while keeping code readable.

• No GIL — true parallelism out of the box; Rust threads share memory without a global lock, unlike Python's threading module
• Ownership and borrowing replace garbage collection — zero-pause memory management with no runtime overhead
• Option and Result make None and errors explicit in the type system — no more AttributeError: 'NoneType' object has no attribute at runtime
• Types are checked at compile time — the class of bugs Python's type hints warn about, Rust refuses to compile
• Pattern matching with exhaustive match — more powerful than Python's match, and the compiler enforces you handle every case
• Fearless concurrency — the borrow checker prevents data races that Python's GIL only partially guards against

A struct is a copy, and that is the whole first hour. Python has nothing like value semantics — every name is a reference, which is exactly why def f(items=[]) misbehaves. Add optionals as a type rather than a value that can turn up anywhere, and most of the surprise on this page is accounted for.

• A struct — and Array, Dictionary, Set, String — copies on assignment, so no aliasing, no defensive copy, and no mutable-default-argument bug
• String and String? are different types; if let, guard let and ?? are the ceremony that buys the guarantee
• Protocols want the shape declared where duck typing asks at the moment of use, and some against any is the distinction that trips people up
• Reference counting in both — CPython counts too — except Swift has no cycle collector, so weak and unowned are your job
• async/await is spelled the same and runs on a real thread pool: genuinely parallel, with actor isolation checked by the compiler
• Strings count grapheme clusters, so "👨‍👩‍👧".count is 1 where Python counts code points and says 5

Python's familiar syntax meets compile-time type safety. TypeScript catches whole classes of bugs before they run — the same errors that only surface at runtime in Python.

• Type annotations that are actually enforced — TypeScript's type system catches mismatches at compile time, not at 3am in production
• Union types and Optional-equivalent T | null — the same expressiveness as Python's type hints, but verified by the compiler
• interface and structural typing — like Python's Protocol, but built into the language and checked everywhere
• Generics with <T> — the same concept as Python's TypeVar, with cleaner syntax and broader tooling support
• Template literals that do what f-strings do — `Hello, ${name}!` vs f"Hello, {name}!"

The static language that meets you halfway. LINQ is the comprehension you already write, yield return is yield, and async/await is spelled exactly the same. What is genuinely new is that types are checked before the program exists, that a struct copies when you assign it, and that two threads really do run at once.

• LINQ is comprehensions as a library: Where/Select/GroupBy/Aggregate, deferred exactly like a generator expression — but re-runnable, where a generator is spent after one pass
• yield return compiles to the same kind of state machine yield does, so your generators translate almost line for line
• Value types have no Python counterpart: assigning a struct, or reading one out of a list, hands you a copy — the correctness surprise that costs newcomers the most time
• Type hints check nothing; C# types are checked before the program is built, and var means inferred, never anything
• async/await looks identical and promises more: no GIL, so Tasks and AsParallel() use every core
• string? marks what may be null and the compiler warns when you forget to check — plus ?., ?? and ??= for the null dance
• Records give you @dataclass with value equality and with expressions built in, and switch expressions are a match the compiler checks for exhaustiveness

Everything you defer to run time, decided before the program starts. A type hint is a comment Java turns into a contract: the wrong argument is a build failure rather than a TypeError at 3am, there is no top level to write a script in, and the compiler asks you to say what Python let you leave implicit — the element type, the exception, the interface.

• Types are enforced, not annotated — List<String> changes what compiles, where list[str] changes nothing unless you separately run mypy
• No top level and no script: every statement lives in a method, every method in a class, and the program starts at public static void main(String[] args)
• Checked exceptions put the failure modes in the signature and make the compiler insist you handle or declare them — an idea Python has no counterpart for, and one Java itself argues about
• Real operating-system threads with no interpreter lock, so shared-memory parallelism replaces multiprocessing — and every piece of shared mutable state becomes yours to guard
• record is @dataclass(frozen=True) built into the language, and sealed interfaces plus switch patterns give match the exhaustiveness check it lacks
• 🚨 What bites: == compares identity so strings need .equals, an int wraps silently at 2³¹ where a Python integer just grows, a missing key returns null instead of raising KeyError, and there is no comprehension, no keyword argument and no REPL habit

Python syntax you already know, plus the performance you've always wanted. Mojo extends Python's familiar syntax with strict typing, value semantics, and SIMD — letting you write Python-style code that compiles to metal.

• def functions work exactly like Python's — mutable arguments, implicit typing, no ceremony
• fn functions are strict and typed — declared argument mutability, explicit return types, zero runtime overhead
• var declares a new variable; Mojo's type inference means you rarely need to spell the type out
• struct types have value semantics — no garbage collector, no hidden allocations, fully predictable performance
• SIMD vectors are a first-class type — write vectorized math in plain Mojo without intrinsics or NumPy
• Full Python interoperability via Python.import_module() — call any Python library directly

Two dynamic languages that both grew optional typing, and only one of them means it. def greet(name: str) accepts 42 and fails later, somewhere else; function greet(string $name) throws at the call, and declare(strict_types=1) stops the engine coercing on the way in. This is the rare page where your own tooling is the looser of the two.

• Declared types are checked by the engine on every call, where a Python annotation is inert unless you separately run mypy
• A fresh interpreter per request: nothing you put in a module-level dictionary survives, so every cache, session and pool lives in Redis or the database rather than in memory
• One array does the work of list, dict and tuple — and it is copied on assignment, so the mutable-default-argument bug is unreachable
• A function sees nothing outside itself: no enclosing scope, no module-level names, and a closure captures only what its use (...) clause names
• No comprehensions — array_map and array_filter with callbacks, in the opposite order from each other, and array_filter keeps the keys
• Modern PHP 8 has enums, match, readonly, constructor promotion, named arguments and ?->; Composer is the part of the ecosystem a Python developer envies

The scientific language that compiles to fast machine code, Julia gives Python developers NumPy-style array math and C-like speed without leaving a high-level, dynamic language.

• 1-based indexing and inclusive ranges (1:3 is 1, 2, 3)
• Broadcasting with the dot (sqrt.(values), numbers .* 2) instead of NumPy or loops
• Multiple dispatch instead of classes — methods live outside the type and dispatch on every argument
• ^ for exponentiation, and div(a, b) for floor division
• Blocks close with end rather than indentation
• Conditions must be a real Bool — no truthy/falsy values

Where Python's data-science world meets the language built by statisticians. R is vector-first and data-frame-native — much of what NumPy and pandas add to Python is simply how R already works.

• Everything is a vector — 42 is a length-1 vector and arithmetic is vectorised by default, so loops and comprehensions are rarely needed
• 1-based indexing with inclusive ranges — x[1] is the first element and 1:5 is 1, 2, 3, 4, 5
• <- for assignment and c() to build vectors, instead of = and list literals
• data.frame is part of base R — the original inspiration for pandas, available with no import
• NA for missing values, separate from NULL — first-class missingness rather than NaN/None
• The apply family (sapply, lapply, vapply) in place of loops and method chains