Go.CodeCompared.To/Ruby

Ruby has no package clause, no import, and no main function. Top-level code runs top to bottom the moment the file is loaded. puts writes a value followed by a newline — the everyday equivalent of fmt.Println.

Ruby is interpreted: there is no go build, no compiled binary, and no separate toolchain to invoke. ruby hello.rb parses and runs in one shot, and irb gives you a REPL for quick experiments. The trade-off is that the Ruby interpreter must be present wherever the script runs.

Ruby uses # for single-line comments instead of //. For block comments it uses =begin/=end, which must start in column one — there is no /* ... */ form.

Where Go imports packages by path and references them through a qualifier (strings.ToUpper), Ruby requires a library by name and its constants and methods become available globally (JSON.generate). The standard library ships with Ruby, so no module download or go.mod entry is needed.

Ruby has no var, no :=, and no type annotations — a variable springs into existence on first assignment and can later hold a value of any type. There is also no "declared but not used" error, so an unused variable is perfectly legal.

Go gives every declared variable a typed zero value (0, "", false, nil). Ruby has a single nil for "nothing" and no concept of an uninitialised-but-typed variable — referencing an unassigned name raises NameError rather than yielding a zero value.

In Ruby any identifier that begins with a capital letter is a constant, so the convention is SCREAMING_SNAKE_CASE. Unlike Go, Ruby constants are not truly immutable — reassigning one only prints a warning rather than failing to compile — so they are a convention enforced socially, not by the language.

Go forbids mixing numeric types and requires an explicit float64(count) conversion. Ruby coerces an Integer to a Float automatically in arithmetic. Concatenating a number into a string still needs an explicit .to_s, however — Ruby will not implicitly stringify the way it implicitly widens numbers.

Ruby strings are full objects with hundreds of methods. length counts characters (not bytes), and slicing uses str[start, count] or a range. Note that string literals are frozen by default in Ruby 4.0, so to build a string in place you start from +"..." (a mutable copy) and append with <<.

Ruby builds strings with inline interpolation: #{expression} inside a double-quoted string evaluates any Ruby code and inserts the result. There is no need for Printf verbs like %s or %d — though Ruby does offer format/sprintf with the same C-style verbs when you want explicit formatting.

Ruby calls these as methods on the string itself rather than passing the string to a strings package function. A method ending in ? conventionally returns a boolean (include?), and sub replaces the first match while gsub replaces them all. p prints a value’s inspect form, handy for seeing array structure.

In Go a string is a byte sequence and indexing yields bytes, so multibyte UTF-8 needs range or the utf8 package to walk runes. Ruby strings are character-aware by default: length already counts characters and each_char iterates them, with bytesize available when you specifically want bytes.

Both languages do integer division when both operands are integers. Where Go makes you convert one side with float64(...), Ruby offers Integer#fdiv for an explicit float result, or you can simply write one literal as 7.0.

A Go int is a fixed 64-bit value that silently overflows, so large integers require the math/big package and its method-based arithmetic. Ruby has no such ceiling: an Integer transparently promotes to arbitrary precision, so 2 ** 100 just works and stays an ordinary Integer.

Ruby’s format (aliased as sprintf) uses the same C-style format verbs you already know from fmt.Printf. The difference is that it returns the formatted string rather than printing it, so you pair it with puts — or use the terse "%.2f" % price operator form.

Ruby’s Array is one growable, heterogeneous type — there is no separate fixed array vs slice distinction, no append reassignment dance, and no capacity to track. push (or <<) mutates in place, and a Range like 1..2 slices it. An array may freely hold mixed types.

Instead of a for ... range loop, Ruby asks the collection to iterate itself by handing a block to each_with_index. The block parameters appear between |...|. Note the order is reversed from Go’s index, value: Ruby yields value, index.

This is where Ruby diverges most sharply from Go. The standard library has no map/filter/reduce, so Go expresses every transformation as an explicit loop. Ruby’s Enumerable module gives every collection map, select, reject, reduce, sum, and dozens more, chained together as a pipeline.

Array#sort returns a new sorted array, leaving the original untouched (use sort! to sort in place). For a custom key, sort_by takes a block that maps each element to its sort key — much terser than Go’s sort.Slice comparator, and it computes each key only once.

Ruby’s Hash is the counterpart to a Go map. A key difference: a Ruby Hash preserves insertion order when you iterate, whereas Go deliberately randomises map iteration order. Keys may be any object, not just one declared key type.

Go’s comma-ok idiom distinguishes "absent" from "present but zero". Ruby returns nil for a missing key by default (so you check with nil?), and fetch lets you supply a fallback or raise KeyError when a key truly must exist.

Ruby has a Symbol type — an immutable, interned identifier written :name — that Go lacks entirely. Symbols are the idiomatic key for hashes that act like records, because they are faster to compare and never duplicated in memory. The name: value syntax is shorthand for :name => value.

Ruby uses elsif (not else if), drops the parentheses around the condition, and closes the block with end instead of braces. Ruby also has a trailing-modifier form — puts "B" if score >= 80 — and an unless keyword for negated conditions.

Go folds every loop into the single for keyword. Ruby keeps while (and until) but rarely uses a C-style counter loop — idiomatic Ruby asks an object to iterate: 3.times, (1..5).each, or array.each. The integer literal 3 responds to times because everything, including numbers, is an object.

Both stop after the first match without fall-through. Two differences stand out: Ruby’s case is an expression that returns a value, so it can be assigned directly; and when compares with the === operator, which means you can match against ranges, classes, and regular expressions, not just equal values.

Go statements do not produce values and the language intentionally omits the ternary operator. In Ruby almost everything is an expression: an if/else evaluates to its last expression, so you can assign its result directly. The C-style condition ? a : b ternary is also available.

A Ruby method needs no parameter types, no return type, and usually no return keyword — the value of the last evaluated expression is returned automatically. Ruby 4.0 also supports an endless one-liner form: def greet(name) = "Hello, #{name}".

Go has true multiple return values; Ruby fakes them by returning an Array and relying on destructuring assignment to unpack it (low, high = ...). The same mechanism splats into the left-hand side, so first, *rest = [1, 2, 3] binds rest to [2, 3].

Ruby’s splat operator *numbers gathers any number of positional arguments into an array, the direct analogue of Go’s ...int. To spread an existing array back into arguments, prefix it with * at the call site: sum(*[1, 2, 3]).

Ruby supports both default values and named keyword arguments, which Go omits entirely. A keyword written port: 5432 is optional with a default, while host: with no default is required. Callers pass them by name in any order, which removes the long positional argument lists Go forces.

Both languages have closures that capture surrounding variables by reference. Ruby’s -> { ... } creates a lambda (a Proc object); you invoke it with .call, the bracket form counter[], or counter.(). The captured count lives on for as long as the lambda does.

A block is Ruby’s signature feature and has no Go equivalent. Every method may be passed one anonymous block of code, which it runs with yield. This is why iteration in Ruby reads as collection.each do |item| ... end rather than a language-level loop — the loop is just a method receiving a block.

A stored function in Ruby is a Proc or lambda. The & operator converts one into the block a method expects, so map(&double) applies it to each element. The symbol form &:to_s is shorthand for "call this method on each item" — an idiom you will see everywhere in Ruby.

Ruby has classes rather than plain structs. State lives in instance variables prefixed with @, which are private by default; attr_accessor generates the getter and setter methods that expose them. The constructor is always named initialize and is invoked by Point.new.

Go attaches methods to a type through an explicit receiver written before the method name. Ruby defines methods inside the class body, and they implicitly operate on self (the current instance). Because the receiver is implicit, a method refers to the object’s own state simply by naming the @ variables.

Go composes behaviour by embedding one struct in another and promoting its methods. Ruby has classical single inheritance with class Dog < Animal, and a subclass can override a method and still reach the parent’s version with super — there is genuine "is-a" inheritance, which Go deliberately avoids.

Ruby classes are open: you can reopen any class — even a built-in like String or Integer — and add or redefine methods at runtime. Go forbids declaring a method on a type from another package, which is why utilities there are free functions. Ruby’s power here comes with the responsibility not to surprise other code.

Go has structural interfaces: a type satisfies Speaker automatically by having a Speak method. Ruby goes further and drops the interface declaration altogether — announce simply calls speak, and any object that responds to it works. This is duck typing: "if it quacks like a duck, it is a duck."

Ruby mixes shared behaviour in with modules. By include Comparable and defining a single <=> ("spaceship") method, a class gains <, >, sort, min, max, and between? for free. This is closer to Go interfaces granting capabilities, but the module supplies real method implementations, not just a contract.

Go’s type switch inspects the dynamic type held by an any. Ruby’s case does the same because when Integer uses Integer === value, which is true when value is an instance. Idiomatic Ruby often prefers value.respond_to?(:each) — asking whether an object can do something rather than what class it is.

This is the deepest philosophical split between the two languages. Go returns errors as ordinary values you must check after every call. Ruby raises exceptions that unwind the stack until a rescue catches them, so the happy path stays uncluttered by if err != nil and errors propagate automatically until something handles them.

Go’s defer schedules cleanup to run when the function returns. Ruby’s ensure clause plays the same role: its body runs whether the method finishes normally or an exception is raised, making it the place to close files or release locks. Unlike defer, it is attached to a begin/end block rather than stacked per statement.

A Go custom error is any type implementing the Error() string method. A Ruby custom exception is a class that inherits from StandardError; rescue can then match it by class, and subclasses let you build an exception hierarchy that callers rescue at whatever level of specificity they need.

In Go, dividing by zero panics, and only a deferred recover can stop the unwinding — panics are reserved for truly exceptional situations. In Ruby that same division raises an ordinary ZeroDivisionError, caught by a normal rescue. Note the method-level rescue: no explicit begin is needed when rescuing the whole method body.

Go starts a lightweight goroutine with go and coordinates with a WaitGroup. Ruby’s Thread.new starts an OS-backed thread, and join waits for it to finish. A caution for Go programmers: a global interpreter lock in the standard CRuby means threads do not run pure-Ruby code in parallel — they shine for I/O, not CPU-bound work.

A channel is central to Go’s "share by communicating" model. Ruby’s nearest equivalent is Queue (a thread-safe FIFO from the standard library): producers push with << and consumers pop, which blocks until an item is available. There is no close with range semantics, so consumers loop until the queue is empty or read a sentinel value.

Ruby’s Thread#value returns the value of the thread’s block, blocking until the thread completes — so threads.map(&:value) gathers every result in order without a shared slice or a WaitGroup. Passing index into Thread.new(index) binds it per iteration, the same care you take when capturing a loop variable in a goroutine.

Ruby’s Mutex mirrors sync.Mutex, but its synchronize method takes a block and releases the lock automatically when the block exits — even on an exception — so you never pair a manual Lock/Unlock by hand the way Go (without defer) requires.

Ruby’s case/in (stable since Ruby 3.0) destructures and matches in one step, and binds variables as it goes — the pattern [0, y] matches a two-element array whose first item is 0 and captures the second as y. Go has no structural pattern matching, so the same logic becomes a series of manual index checks.

A hash pattern matches the keys you name and ignores the rest, binding their values to like-named variables — name: with no value captures user[:name] into name. Combined with a literal like role: "admin", it both filters and extracts in a single clause, replacing the type-assert-and-compare dance Go requires over an any map.

Ruby patterns combine type checks and structure in one clause: [Integer => first, Integer => second] matches a two-element array of integers and binds both at once. This fuses Go’s type switch and length check into a single, declarative branch — one of the clearest places where Ruby’s expressiveness shows against Go’s explicitness.