You already know Ruby.Now learn anything else.

The closest major language to Ruby, Python shares Ruby's readable syntax and expressive idioms — a smaller leap than most, and dominant in data science and machine learning.

• List comprehensions and generators vs. Ruby's Enumerable and blocks
• Python's significant whitespace instead of Ruby's end keywords
• The import system vs. require and Ruby's module hierarchy
• try / except / finally vs. begin / rescue / ensure
• Threading, the GIL, and asyncio vs. Ruby's concurrency model

The language of the web, JavaScript is unavoidable, powerful, and capable of running almost anywhere.

• var / let / const vs. Ruby's local, instance, and global variables
• Prototypal inheritance — a fundamentally different object model than Ruby's class-based one, with the inheritance machinery exposed and mutable at runtime
• Closures and the this binding: a call-site-determined design that arrow functions exist to work around
• Promises and async/await vs. Ruby's Fibers, threads, and Ractors
• Destructuring, spread, and rest — features Ruby also has, with different syntax

Fast, opinionated, and built for the cloud era, Go trades Ruby's expressiveness for simplicity and raw speed.

• Goroutines and channels — lightweight concurrency that makes Ruby's threads look heavy
• Error handling without exceptions: functions return errors, you handle them explicitly
• Interfaces without inheritance — implement the methods, satisfy the interface, no declaration needed
• Pointers — the approachable kind, without manual malloc/free
• Sub-second compile times for most programs — no waiting for the build before you can test

JavaScript with a type system, TypeScript is able to catch whole classes of bugs before they ship, without abandoning dynamism.

• Type annotations vs. Ruby's duck typing — explicit contracts vs. implicit trust
• Interfaces and structural typing: types describe shape, not lineage
• Generics — like duck typing, but verified at compile time
• Type narrowing: TypeScript removes impossible types as it reads your code
• Utility types like Partial, Pick, and Readonly — a whole algebra of type transformations

Apple's modern language. Optionals, protocols, and value types make safety and expressiveness first-class.

• Optionals vs. Ruby's nil — the compiler forces you to handle the absence of a value
• Protocols and extensions — like Ruby's modules and mixins, but with more teeth
• Value types (structs, enums) vs. reference types (classes): a distinction Ruby doesn't make
• Closures and trailing closures — almost familiar: the last closure argument moves outside the parentheses like Ruby's blocks, but value-type capture semantics differ
• Pattern matching with switch — far more powerful than Ruby's case/when

The language that built the world. Understanding C illuminates Ruby itself, and just about everything else.

• Pointers — what Ruby's object references actually are at the machine level
• Manual memory management with malloc / free, and why Ruby's GC exists
• The compilation model vs. Ruby's interpretation: how source becomes executable
• Structs and unions vs. Ruby's classes — data without behavior
• How Ruby's C extension API works — the bridge between Ruby and native code

Demanding but deeply rewarding, Rust proves memory safety and bare-metal speed aren't in opposition.

• Ownership and borrowing — the idea that replaces garbage collection entirely
• No runtime, no GC: memory safety enforced at compile time, not at runtime
• Traits — like Ruby's modules, but verified statically and with zero overhead
• Result and Option — making failure and absence explicit, not exceptional
• Pattern matching with match — exhaustive, expressive, and more powerful than Ruby's case

Optimal software with no hidden control flow. Like C but with memory safety, error handling, and compile-time code execution built in.

• Allocators instead of a garbage collector — every heap allocation is explicit and the allocator can be swapped without changing library code
• Error unions (!T) and comptime-checked exhaustive switch — impossible to ignore an error or miss a case the way Ruby's rescue and case/when allow
• Comptime replaces macros, generics, and metaprogramming with a single mechanism: Zig code that runs at compile time
• No hidden control flow — no operator overloading, no implicit conversions, no exceptions unwinding through stack frames
• Optional types (?T) enforced at compile time — the null pointer problem that Ruby solves with nil checks is solved in Zig before the program even runs

The language behind Flutter, Dart brings sound null safety, async-first design, and ahead-of-time compilation to cross-platform development.

• Sound null safety — non-nullable by default; the compiler prevents null dereferences before the program runs
• Async-first: Future<T> and Stream<T> are core to the language, not an afterthought
• Named parameters with required keyword — a more explicit alternative to Ruby's keyword arguments
• Mixins — similar to Ruby's modules, but with stricter linearization rules
• AOT and JIT compilation — fast startup for production, fast iteration for development

The pragmatic JVM language, Kotlin combines expressive syntax, null safety, and interoperability with Java — popular for Android and server-side development.

• Null safety built into the type system — nullable vs non-nullable enforced at compile time, no NullPointerException surprises
• Data classes — one line replaces dozens: equals, hashCode, toString, copy, and destructuring all generated automatically
• Extension functions — add methods to existing classes without subclassing, scoped rather than global like Ruby's monkey-patching
• when expression — Kotlin's answer to case/when, but exhaustive, expression-oriented, and usable as a value
• Coroutines — structured concurrency that feels like sequential code, without the callback pyramid or thread overhead

Typed Ruby — without leaving home. Crystal's syntax is so close to Ruby that reading it feels familiar from day one, but a static type system catches entire classes of bugs before the program runs.

• Syntax nearly identical to Ruby — if you know Ruby, you can read Crystal immediately
• Static type inference — no type annotations required in most code, but types are checked at compile time
• Null safety via union types — String | Nil instead of String? makes nilability explicit and compiler-enforced
• Compiled to native machine code — Crystal programs run at C-level speed with no runtime overhead
• Fibers and channels — Go-style concurrency built into the language, not a library

A modern Lisp for the JVM, Clojure brings immutable data, functional programming, and fearless concurrency to wherever Java runs.

• Immutable data structures by default — shared state without locks or races
• The REPL-driven development loop: evaluate and reshape code as you write it
• Macros — Lisp's superpower, rewriting syntax before it runs
• core.async — Go-style channels and communicating sequential processes, as a library
• Persistent data structures — structural sharing makes immutable "updates" fast and memory-efficient

A mature, versatile language from Microsoft, C# blends object-oriented and functional styles with a type system powerful enough to rival TypeScript's.

• LINQ — SQL-style queries over any collection, with Ruby-style method chaining
• async/await — the cleanest async syntax in any mainstream language
• Pattern matching with switch expressions — exhaustive, expressive, far beyond Ruby's case/when
• Nullable reference types — opt-in null safety without rewriting the whole language
• Records and init-only properties — immutable data classes without the boilerplate

The language Rubyists most often encounter in enterprise work, Java makes explicit what Ruby hides — types, access modifiers, checked exceptions, and the full machinery of a statically typed object system.

• Static typing enforced at compile time — errors caught before the program ever runs
• The JVM — bytecode, JIT, and garbage collection as a shared platform for Kotlin, Scala, Clojure, and more
• Streams and lambdas (Java 8+) — functional-style collection operations that mirror Ruby's Enumerable
• Records (Java 16+) — concise immutable data classes, Java's answer to Ruby's Struct
• Pattern matching (Java 21+) — type-safe switch expressions that rival Ruby's case/in
• Checked exceptions — the explicit error-contract system Ruby deliberately left out

Ruby's spiritual ancestor, Perl established many of the ideas Ruby refined — regex literals, postfix conditionals, CPAN, and the conviction that there's more than one way to do it.

• Regular expressions as a first-class syntax — Perl's regex engine inspired every language that followed
• Context sensitivity — the same expression means different things in scalar vs. list context
• CPAN — the original package repository, predating npm, RubyGems, and pip by a decade
• Sigils — $scalar, @array, %hash are the ancestors of Ruby's $global, @instance, @@class variables
• "There's more than one way to do it" — the design philosophy Ruby later softened to "one preferred way"

The embeddable scripting language, Lua is the language inside Neovim, Redis, Nginx, and countless game engines — small, fast, and surprisingly deep.

• Tables are everything — arrays, dictionaries, objects, and modules all use the same structure
• Metatables replace classes — OOP emerges from a handful of hooks rather than built-in syntax
• Multiple return values without arrays — functions return several values as naturally as one
• Coroutines as first-class values — cooperative multitasking without async/await ceremony
• 1-based indexing and global-by-default scope — two gotchas every Rubyist hits immediately

The language of relational databases, SQL is the raw power beneath every Rails Active Record call — understanding it makes your queries faster, your data models clearer, and your debugging sharper.

• Every ActiveRecord query generates SQL — knowing SQL reveals exactly what .where, .joins, and .includes actually do
• Window functions (ROW_NUMBER, RANK, LAG) have no clean ActiveRecord equivalent — SQL is the only way
• CTEs name subqueries like variables — readable complex logic that ActiveRecord cannot express directly
• JOINs, GROUP BY, and HAVING map to idiomatic Ruby Enumerable operations — surprisingly similar thinking
• EXPLAIN QUERY PLAN shows why a query is slow; indexes fix it — foundations every Rails developer needs

Pure, lazy, and relentlessly principled, Haskell enforces immutability and static typing so strictly that if your code compiles, it usually works.

• Purely functional — no side effects outside of IO, making code easy to reason about and test
• Lazy evaluation by default — infinite lists, on-demand computation, and novel algorithms that would be awkward elsewhere
• Algebraic data types with exhaustive pattern matching — the compiler catches unhandled cases Ruby would silently miss
• Typeclasses — Haskell's principled alternative to Ruby's duck typing and module mixins
• Maybe and Either replace nil and exceptions with types the compiler forces you to handle
• Currying and function composition as first-class idioms — every function is a building block

C++ is C with a full OOP tower on top — classes, templates, lambdas, the STL, and memory safety via RAII, all the way down to bare metal.

• Classes, inheritance, and virtual dispatch — Ruby's OOP model, but you control every byte
• Templates — generic programming that's resolved at compile time, not via duck typing
• RAII and smart pointers — deterministic memory management without a garbage collector
• The STL: vector, map, sort, transform — Ruby's Enumerable, but statically typed
• Lambdas with captures — closures that look and feel like Ruby's blocks
• Modern C++23: std::format, ranges, structured bindings, std::optional

The shell every Rubyist already uses, Bash rewards understanding — the more you know, the fewer Ruby scripts you'll write for things the shell does natively.

• Parameter expansion — ${var:-default}, ${var^^}, ${var//old/new} — a mini-language for string manipulation
• Associative arrays and indexed arrays — Bash's answer to Ruby's Hash and Array
• Arithmetic expansion $(( )) — integer math without spawning a subprocess
• Conditionals and loops — the original control flow, from which all other shells descended
• Exit codes and traps — error handling before exceptions were invented

The language that runs the world's money, COBOL processes trillions of dollars daily — and its verbose, English-like syntax is unlike anything a Rubyist has seen.

• Every program is divided into four mandatory DIVISIONS — structure enforced by the compiler, not convention
• Variables declared with PICTURE clauses that define format byte-by-byte: PIC 9(7)V99 for a 7-digit decimal
• Arithmetic via English verbs: ADD 1 TO COUNTER instead of counter += 1
• No functions or methods — only PARAGRAPHS called with PERFORM
• 88-level condition names: named boolean flags that make business logic read like plain English
• Runs more financial transactions per day than any other language — by a wide margin

The original language of scientific computing, Fortran introduced arrays, subroutines, and floating-point arithmetic to the world — and still dominates supercomputing today.

• Arrays are a first-class type — whole-array arithmetic replaces explicit loops: prices * 0.9 discounts every element at once
• Built-in complex numbers, rich math intrinsics, and DOUBLE PRECISION — no imports required for scientific work
• INTENT(IN/OUT/INOUT) turns parameter contracts into compiler-enforced guarantees instead of documentation conventions
• ELEMENTAL functions write once, run on scalars and arrays alike — the equivalent of writing every function and its map version simultaneously
• Runs on every major HPC cluster and supercomputer; NumPy, LAPACK, and BLAS are all written in Fortran

The English-readable .NET language that pioneered RAD — with static typing, LINQ, and the full .NET ecosystem.

• English-like keywords: If...Then...End If, For Each...Next
• Case-insensitive identifiers — a surprisingly different mental model
• AndAlso / OrElse short-circuit logic vs And / Or
• LINQ query syntax reads like SQL right in your code
• Nothing for nil, Me for self, MyBase for super
• Full .NET ecosystem: List(Of T), Dictionary(Of K, V), async/await

The disciplined ancestor of modern programming — structured, strictly typed, and the language that taught a generation how to think algorithmically.

• begin...end blocks instead of Ruby's implicit block delimiters
• All variables declared in a var block before any code runs
• := for assignment, = for comparison — the reverse of every other language
• div for integer division; / always returns a real number
• Procedures (no return value) vs. functions (returns a value) — an explicit distinction
• Built-in set types, enumeration types, and subrange types with no library needed

The shell macOS ships by default, Zsh extends POSIX shell with powerful parameter flags, cleaner array handling, and a thriving plugin ecosystem — the Rubyist's daily driver.

• Parameter flags — ${(U)var}, ${(j::)array}, ${(s::)string} — built-in join, split, and case conversion without external tools
• 1-indexed arrays by default — ${fruits[1]} is the first element (unlike Bash's 0-indexed)
• typeset for all variable declarations — integers, read-only, namerefs, and associative arrays
• match[] array for regex captures — stores groups after [[ =~ ]] without Bash's BASH_REMATCH
• setopt EXTENDED_GLOB — ^pattern negation and (a|b) alternation built into glob syntax

The functional language that influenced Rust, OCaml combines Hindley-Milner type inference, algebraic data types, and first-class modules into a language that is both mathematically rigorous and practically fast.

• Hindley-Milner type inference — fully typed with almost no annotations needed
• Algebraic data types and exhaustive pattern matching enforced by the compiler
• Immutable by default: let cannot be reassigned; mutation is explicit via ref
• option instead of nil: absence is a type-level guarantee, not a runtime surprise
• The |> pipe operator (the original — F#, Elixir, and others adopted it from OCaml)
• First-class modules and functors — higher-order module programming with no equivalent in Ruby

Functional-first on .NET, F# combines immutability by default, expressive pattern matching, and the pipe operator into a language that makes data transformation feel natural.

• The |> pipe operator makes data pipelines read top-to-bottom — the idiomatic alternative to Ruby's method chaining
• Immutable by default: let bindings cannot be reassigned without the explicit mutable keyword
• Discriminated unions — typed sum types that replace Ruby's nil checks, symbol conventions, and class hierarchies
• Exhaustive pattern matching enforced by the compiler — impossible to forget a case
• Option and Result types replace nil and exceptions for expected failure paths
• Full access to the .NET ecosystem alongside a clean functional core

The actor-model language with compile-time memory safety, Pony eliminates data races and garbage-collection pauses through its unique reference capability system — every object knows exactly who can read or write it.

• Six reference capabilities (iso, val, ref, box, tag, trn) make data races impossible by construction
• Actors with message-passing concurrency — no locks, no deadlocks, no shared mutable state
• val references are globally immutable, shareable across actors like Ruby 4.0's frozen strings — but enforced by the compiler
• No null, no exceptions, no undefined behavior — failures are explicit partial functions using ?
• Garbage-collected but pause-free: the runtime interleaves GC with program execution actor-by-actor
• No class inheritance — composition through trait (nominal) and interface (structural) subtyping

Python syntax with C-level performance, Mojo is a new systems language from the creators of LLVM that combines the familiarity of Python with zero-cost abstractions, SIMD, and compile-time metaprogramming.

• Two function types: def (Python-style, flexible) and fn (strict, typed, zero-cost)
• struct value types with explicit ownership — no garbage collector pauses
• SIMD vectors as first-class language constructs — write vectorized code without intrinsics
• Compile-time parameters in square brackets: fn process[size: Int](data: SIMD[DType.float64, size])
• Native Python interoperability — import and call any Python library directly
• Error handling with raises annotations — the error contract is part of the type signature

The logic programming language, Prolog has no loops, no variables in the imperative sense, no if/else — only facts, rules, and questions. You describe what is true, and the engine figures out the how.

• No assignment — variables are unified with values during pattern matching, not "set"
• No loops — every iteration is recursion, and recursion is the only control structure you need
• Backtracking is built in: when one path fails, the engine automatically tries another
• A single rule can run forwards or backwards — append([1,2],[3,4],X) concatenates; append(X,Y,[1,2,3]) finds all splits
• Facts & rules together form a database that you query like a function call
• Lists are recursive structures with head/tail pattern matching: [H|T]

The language that powers a third of the web, PHP 8.x brings first-class types, enums, fibers, and match expressions to a language Rubyists will find surprisingly familiar.

• Constructor promotion collapses declare-and-assign into one line — more concise than Ruby's attr_accessor plus initialize
• Match expression is exhaustive and strict — no fall-through, no type coercion, no forgotten cases
• Backed enums with ::from() and ::tryFrom() — first-class value types, not just constants
• Traits share methods across unrelated classes — similar to Ruby modules but without a module hierarchy
• Named arguments let you skip optional parameters by name, just like Ruby's keyword arguments
• First-class callables turn any callable into a closure with strlen(...) syntax

The minimalist Lisp dialect from MIT — lexical scope, first-class continuations, and a tiny core that fits on a postcard. The language behind SICP.

• Tiny, elegant core — the R7RS-small standard fits in 88 pages, dwarfed by Common Lisp's thousands
• First-class continuations via call/cc — capture the rest of a computation as a callable value
• Hygienic macros via syntax-rules — pattern-based code rewriting without variable capture
• Guaranteed tail-call optimization — recursion is the idiomatic loop, not a stack-overflow risk
• Lexical scope with closures done right — the model JavaScript, Ruby, and Python all imitate

Functional meets object-oriented on the JVM — Scala blends immutable values, powerful pattern matching, and a rich type system into a language that scales from scripts to distributed systems.

• Immutable values by default with val — Ruby's lack of enforced immutability is a Scala non-starter
• Sealed traits + case classes give you algebraic data types with exhaustive compiler-checked pattern matching
• Option[A] replaces nil — absence is explicit in the type system, not a runtime surprise
• For-comprehensions desugar into flatMap/map/filter chains — monadic pipelines made readable
• Companion objects replace class methods — factory methods, constants, and extractors live alongside the class

The modern systems language C never became, D adds a module system, garbage collection, ranges, built-in unit tests, and compile-time metaprogramming — without the weight of C++ history.

• Universal Function Call Syntax (UFCS) — arr.filter!(x => x > 0).map!(x => x * 2) chains any function like a method
• Ranges like Ruby's Enumerable — lazy, composable iteration via std.algorithm and std.range
• Garbage collected by default — no manual memory management in everyday code
• Built-in unittest blocks and contract programming (in/out/invariant)
• Compile-time function execution (CTFE) — run ordinary functions at compile time for zero-cost constants

Multiple dispatch taken to its logical extreme — Julia is a high-performance dynamic language designed for scientific computing, where functions dispatch on the types of every argument simultaneously.

• Multiple dispatch — functions select their implementation based on ALL argument types, not just the receiver
• Broadcasting with . — any function or operator applied element-wise: sqrt.(numbers), x .^ 2
• Immutable structs by default — mutability is explicit, enabling aggressive compiler optimization
• 1-based indexing and range syntax (1:10, 1:2:10) follow mathematical convention
• Built-in @time, @show, and @assert macros for profiling, debugging, and validation

Array programming taken to its extreme — APL reduces programs that would take dozens of lines in Ruby to a handful of symbols, operating on entire arrays at once without explicit loops.

• Everything is an array — scalars, strings, and matrices all use the same operators
• No explicit loops — 2×1 2 3 4 5 doubles every element; +/ sums an array in one glyph
• Right-to-left evaluation — 2×3+4 is 14, not 10; there is no operator precedence
• Trains compose functions tacitly — (+/÷≢) is the average function with no variables
• Dfns are concise lambdas — {⍺+⍵} adds two arguments; {⍵≤1:1 ⋄ ⍵×∇⍵-1} is factorial