You already know Ruby.Now learn anything else.

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

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

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

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

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

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

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

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

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

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"

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

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

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

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

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

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

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

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

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

Godot's native scripting language, and the natural next engine for a DragonRuby developer — dynamically typed like Ruby, Python-flavored in syntax, with the game's structure living in a retained tree of nodes rather than in one tick function.

• Immediate mode vs. a retained scene tree — DragonRuby re-emits its whole frame from args.state every tick; Godot gives you persistent nodes you mutate in _process(delta)
• Signals are the built-in observer pattern — a node emits died and anything can subscribe, replacing the flag you would poll every tick
• No blocks and no yield — behavior is passed as a Callable (func(x): return x * 2) and invoked with .call()
• No exceptions at all — no raise, no rescue; failures come back as error codes or sentinel values that every caller checks
• Optional static typing that earns its keep — var speed := 200.0 is checked when the script loads and compiles to faster bytecode, which matters at 60 frames a second
• match is real pattern matching, destructuring arrays and dictionaries much like Ruby 4's case/in

A fast, friendly, purely functional language from Richard Feldman — no garbage collector, no lifetimes, no nulls: memory is managed by compile-time reference counting, and all I/O is delegated to a host "platform" written in another language.

• Purely functional with managed effects — effectful functions are marked with a ! suffix (main!, echo!), so purity is visible in every signature
• Compile-time reference counting instead of a garbage collector or ownership annotations — memory safety with zero programmer bookkeeping
• Tag unions with exhaustive match — the compiler catches every unhandled case
• The Try type replaces both nil and exceptions — every fallible operation returns Ok or Err
• The platform model — a Roc program cannot perform I/O on its own; a host written in Rust, Zig, or another language provides every effect

The original BEAM language, born at Ericsson for telephone switches that must never stop — Erlang made lightweight processes, message passing, supervision, and hot code reloading mainstream decades before anyone called it "the actor model."

• Millions of cheap, isolated processes that share nothing and communicate only by message passing — the foundation of fault-tolerant systems
• "Let it crash" plus supervision trees (OTP) — components fail and restart cleanly instead of defending against every error
• Everything is immutable, and pattern matching drives assignment, function heads, and message handling
• Nine nines of reliability in production telecom — the pedigree the whole BEAM ecosystem inherits
• Elixir, Gleam, and LFE all compile to the same VM — Erlang is the bedrock they stand on

A delightful language for reliable web applications — Elm is a pure functional language that compiles to JavaScript, famous for producing no runtime exceptions in practice and for compiler errors so helpful they read like a friendly tutor.

• No runtime exceptions in practice — the compiler proves your code handles every case before it ever runs
• Legendarily friendly compiler errors that pinpoint the problem and suggest the fix
• Everything is immutable and every function is pure — the same inputs always give the same output
• The Elm Architecture (Model / update / view) inspired Redux and much of modern front-end state management
• A small, curated language with enforced semantic versioning across its whole package ecosystem

The widest gap on this site, and worth crossing once. Odin takes away the garbage collector, objects, blocks, exceptions, and metaprogramming — and hands you the machine, plus an implicit context that makes manual memory genuinely pleasant.

• No garbage collector: defer delete(...) beside every allocation, or an arena that drops a thousand of them in one call
• No classes and no inheritance — a struct is plain data and a "method" is a procedure whose first parameter is the thing it works on
• No blocks and no closures, so .select.map.sum becomes one loop — the biggest day-to-day adjustment, and the one that stops allocating intermediate arrays
• No exceptions: errors are ordinary return values, and or_return forwards them without the pyramid of checks
• Symbols become real enums and duck typing becomes a tagged union, so a typo is a compile error instead of a case that quietly matches nothing
• No method_missing, no open classes, no define_method — every call is resolved before the program starts

A shell whose pipelines carry structured data, Nushell will feel less like Bash and more like Enumerable — ls | where size > 1MB | sort-by modified is a typed query, not text mangling.

• The table — a first-class type Ruby has no counterpart for; every command speaks it, so ls returns queryable rows rather than lines to parse
• where, select, sort-by, group-by, reduce — an Enumerable vocabulary at the shell prompt
• Immutable let bindings by default, so swapping each for par-each is all it takes to go parallel
• Typed filesize and duration literals — 3kB and 1min + 30sec are values, not strings to re-parse
• Custom commands with typed parameters, real --flags, and help text generated from comments
• from json, from csv, parse — every format decodes into the same data model, which is why curl | jq largely disappears

The Erlang VM with a Ruby-inspired syntax, Elixir makes fault-tolerant, massively concurrent systems approachable — and beautiful.

• The Actor model — processes communicate by message passing, no shared memory, no data races
• Pattern matching and the pipe operator |> — code that reads like a transformation pipeline
• Fault tolerance via supervisors — processes crash and restart automatically, by design
• Macros and the AST — Elixir rewrites itself, just like Ruby's metaprogramming but at the syntax level
• Phoenix Framework — a web framework that makes Rails look slow

What your code actually becomes. x86-64 assembly removes the three things every other language on this site provides and never mentions: types, named local variables, and a standard library. What is left is sixteen registers, a flat array of bytes, and a calling convention everyone has agreed to obey.

• No variables — sixteen general-purpose registers are the only fast storage, and remembering what is in each one is your job
• A bare label is an address; square brackets around it mean the contents — the exact inverse of C, where a name means its contents and & gets the address
• No standard library at all here: output is the write syscall, and turning a number into text is a division loop you write yourself
• Every arithmetic instruction quietly updates a flags register nothing declares — cmp is a subtract that keeps only the flags
• A struct is a set of constant offsets and an array index is one addressing mode, so record.score and values[index] both vanish into a single instruction