You already know Go.Now explore other languages.

Where Go programmers go for data, scripting, and getting an idea running in five lines. Python trades Go's static types and compile step for dynamic typing, exceptions, comprehensions, and a vast library ecosystem — the lingua franca of data science and machine learning.

• Dynamic and duck typing — no type declarations and no interface to satisfy; if an object has the method, it works
• Comprehensions — [x*x for x in items if ...] replaces the hand-written map/filter loops Go makes you spell out
• Exceptions with try/except/finally instead of (value, error) and the endless if err != nil
• Classes, inheritance, and dunder methods (__add__, __repr__) — real OOP and operator overloading, which Go has none of
• Generators, decorators, and an enormous standard library plus PyPI — batteries included for data and ML

From structs and goroutines to classes and Futures. Dart brings full OOP, sound null safety, named parameters, and async-first design to a Go programmer who already thinks in types.

• Sound null safety — String is non-nullable at compile time; String? makes it nullable. No nil panics at runtime
• Named parameters with required — replaces the fragile positional argument lists that Go forces on every API
• Full OOP: classes, inheritance, mixins, and abstract interfaces — where Go uses structs + embedding + implicit interfaces
• Exceptions instead of (value, error) returns — Dart propagates errors automatically; no if err != nil at every call site
• Futures and Streams replace goroutines and channels for async I/O; Isolates provide true parallelism with no shared memory
• Dart 3 Records give multiple return values, and sealed classes with exhaustive switch expressions add pattern matching

Go's systems niche without the garbage collector — and with a type system that catches far more at compile time. Rust trades goroutines and GC for ownership, sum-type enums, and Result/Option, eliminating nil-panics and data races before the program ever runs.

• Ownership and borrowing instead of a garbage collector — deterministic cleanup, no GC pauses, and data races caught at compile time
• Enums are true sum types — what Go fakes with iota constants or tagged structs, with exhaustive match the compiler enforces
• Result and Option replace (value, error) and nil — the ? operator collapses if err != nil, and there is no null to dereference
• Traits with generics and bounds — like interfaces, but implemented explicitly, monomorphised, and able to carry default methods
• Iterator pipelines — map/filter/fold as zero-cost abstractions, replacing Go's hand-written loops

The same structural typing you already trust, with the type-level expressiveness Go leaves on the table. TypeScript interfaces are satisfied by shape — exactly like Go's — but the type system adds unions, literal types, and discriminated unions for the sum types Go never grew.

• Structural interfaces, just like Go — a value fits an interface by its shape, not by declaring implements
• Union types (number | string) and literal types ("active" | "inactive") express what Go can only fake with any and a type switch
• Discriminated unions give exhaustively-checked sum types — the compiler flags the variant you forgot to handle
• Errors are thrown and caught with try/catch, not returned as (value, error) — no if err != nil after every call
• async/await over a single event loop replaces goroutines and channels — concurrency without the shared-memory races

The systems language for Go programmers who want to drop the garbage collector. Zig keeps Go's small, readable spirit but makes memory explicit, errors part of the type system, and code generation happen at compile time — no runtime, no GC pauses, no hidden allocations.

• Explicit allocators instead of a garbage collector — deterministic cleanup with defer/errdefer and no GC pauses
• comptime — run real code at compile time, and write generics as ordinary functions taking a type parameter
• Error unions (!T) with try/catch replace (value, error) and the endless if err != nil
• Optionals (?T) instead of nil — absence is in the type, and there is no null pointer to dereference
• Tagged unions with exhaustive switch give the sum types Go lacks; no hidden allocations or control flow anywhere

The class-based, exception-driven system Go deliberately avoided. Java trades Go's implicit interfaces for an explicit implements keyword, its (value, error) returns for a full exception hierarchy, and its composition-only model for real inheritance — while sharing garbage collection and, since virtual threads, a genuinely lightweight concurrency story.

• Explicit implements declarations instead of Go's implicit, structural interfaces — the single biggest philosophical gap between the two languages
• Exceptions (try/catch/throws, checked vs. unchecked) instead of Go's explicit (value, error) return convention checked at every call site
• Classes with extends inheritance instead of Go's struct embedding — a Java subclass genuinely is-a its parent, where Go composition only borrows fields and methods
• Virtual threads (Java 21+) close much of the gap with goroutines — cheap, JVM-scheduled threads where a plain Thread used to be comparatively expensive
• Older, more elaborate generics (wildcards, type erasure) versus Go's newer, simpler type-parameter generics introduced in 1.18
• Garbage collection in both — one of the few places a Go programmer will feel immediately at home

Where Go programmers go when they want expressiveness over explicitness. Ruby trades Go's ceremony — error checks after every call, explicit loops, no generics-free verbosity — for blocks, exceptions, and an object model so consistent that even integers have methods.

• Blocks and Enumerable — map, select, reduce built into every collection, replacing Go's hand-written for-range loops
• Exceptions instead of error values — the happy path is never interrupted by if err != nil; errors propagate until something rescues them
• Dynamic typing and duck typing — no type declarations, no interface satisfaction to declare; if an object responds to the method, it works
• Open classes and metaprogramming — reopen String or Integer and add methods at runtime; define methods on the fly
• Pattern matching — case/in destructures arrays and hashes and binds variables in one step, with no manual index checks