C.CodeCompared.To/Ruby

puts prints a value followed by a newline — the direct equivalent of printf("...\n").

ruby hello.rb parses, compiles to bytecode, and executes in one command. For quick experiments, irb (Interactive Ruby) provides a REPL. The -e flag executes a one-liner without creating a file.

Consecutive # lines are the idiomatic Ruby style for multi-line comments. The =begin/=end markers must be at the very beginning of the line.

p calls .inspect on its argument, showing quotes on strings and brackets on arrays — invaluable for debugging. Unlike printf, Ruby uses string interpolation (#{expression}) instead of format specifiers for most output.

The runtime tracks types automatically, and variable names use snake_case by convention. There is no distinction between stack-allocated primitives and heap-allocated objects — everything in Ruby is an object.

The .class method returns the actual runtime class of any object. This is fundamentally different from C, where a variable's type is fixed at declaration and enforced by the compiler.

SCREAMING_SNAKE_CASE is the convention for simple values, and constants respect module/class scope. Reassigning a constant produces a warning but is not a fatal error.

Calling a method that nil does not understand raises a clean NoMethodError. Conversion methods like nil.to_s, nil.to_a, and nil.to_i all return sensible empty values.

This is a common source of bugs when C programmers write Ruby — if count in C checks for non-zero; in Ruby it always succeeds because 0 is truthy.

The splat operator * in a destructuring pattern captures remaining elements into an array. This eliminates a whole class of C boilerplate — swapping, returning multiple values, and unpacking results.

Operations that require #include <string.h> and manual loops in C — converting case, checking for a substring, reversing — are single method calls. There are no null terminators, no buffer overflows, and no separately tracked lengths.

Single-quoted strings do not interpolate: '#{name}' prints the literal text #{name}. No format specifiers, no buffer size, no null terminator to manage.

All these operations require manual loops, temporary buffers, or external libraries in C. Ruby strings also support regular expressions natively via match, scan, and gsub with pattern arguments.

The terminator label is arbitrary, and chomp removes the trailing newline that heredocs include. Unlike C's adjacent string literal trick, heredocs support interpolation by default — use a single-quoted terminator (<<~'LETTER') to disable it.

For multiple arguments, pass an array: "format" % [first, second]. sprintf and its alias format are also available. For most output, string interpolation is preferred.

Attempting to mutate a frozen string raises FrozenError. Use dup to get a mutable copy, or the unary plus operator: +greeting returns an unfrozen duplicate.

No int, long, uint64_t, or __int128 needed; the runtime automatically promotes to a big-integer representation. Underscores are allowed in numeric literals for readability: 1_000_000.

Predicate methods ending in ? return true or false: even?, odd?, positive?, negative?, zero?. The times method replaces C's counting for loop, and upto/downto handle ranges.

Math functions live in the Math module: Math.sqrt, Math.sin, Math::PI. Floating-point division by zero produces Float::INFINITY, not undefined behavior.

-7 / 2 is -4 in Ruby but -3 in C — a common source of bugs when porting C logic. Ruby's % always returns a non-negative result when the divisor is positive; in C99 the sign follows the truncation, so -7 % 3 == -1. The ** operator handles exponentiation; no pow() call needed.

to_i accepts a radix argument: "0xFF".to_i(16) parses hexadecimal, and 255.to_s(16) formats it. No headers to include.

There is no fixed capacity, no element type restriction, and no manual length tracking. The %w[word list here] shorthand creates an array of strings without quotation marks.

Negative indexing eliminates the common C pattern of array[length - 1]. Slicing returns a new array with no manual allocation or copy, and an out-of-bounds access returns nil rather than undefined behavior.

push (or <<) appends; pop removes from the end; unshift prepends; shift removes from the front. These map to the standard stack and queue operations without any memory management ceremony.

These come from the Enumerable module. No temporary arrays to allocate, no index management, no explicit loops.

The first argument is the initial accumulator value. The symbol shorthand inject(:*) is equivalent to a block that applies *. sum is a built-in convenience method for the common addition case.

sort returns a sorted copy using the <=> spaceship operator. uniq removes duplicates preserving order; flatten recursively expands nested arrays (no C equivalent at all); compact removes nil values. Methods ending in ! mutate in place: sort!, uniq!.

The { key: value } syntax uses symbol keys (the most common style); { "key" => value } accepts any object as a key. Hashes maintain insertion order (since Ruby 1.9).

Accessing a missing key returns nil rather than a sentinel value or undefined behavior. fetch is the strict version: fetch(:key) raises KeyError when the key is absent; fetch(:key, default) returns the default. Use bracket access when absence is expected; use fetch when absence means a programming error.

each on a hash yields two-element key-value pairs that Ruby automatically destructures into block parameters. Hashes include the full Enumerable module: map, select, reject, any?, all?, min_by, sort_by. The keys and values methods return plain arrays.

Hash.new(default) returns the default value for any missing key, making accumulation patterns like word counting a one-liner. For a computed default (e.g. a new array per key), use a block: Hash.new { |hash, key| hash[key] = [] }. merge combines two hashes, with the rightmost values winning on conflicts.

Ruby ranges are first-class objects: 1..10 (inclusive) and 1...10 (exclusive). A range can be iterated, queried for membership, converted to an array, and used in pattern matching. There is no C equivalent — ranges must be simulated with arithmetic or loops. Character ranges also work: ("a".."z").

Ranges support each and the entire Enumerable suite: map, select, reduce, first, sum, etc. String ranges iterate character-by-character using Ruby's lexicographic successor. The step method adds stride control: (1..20).step(5) visits 1, 6, 11, 16.

Ranges work as when clauses in case expressions because Ruby calls === (case equality) on each pattern. case in Ruby returns the matched value, so the entire construct is an expression that can be assigned directly. This is far cleaner than the cascading if/else if required in C.

Ruby's keyword is elsif (not else if). No parentheses around the condition, no curly braces around the body — just end. if is an expression and returns the matched branch's value: label = if flag then "yes" else "no" end. The parentheses in C's if (condition) are mandatory syntax; in Ruby they are optional stylistic noise.

unless condition is equivalent to if !condition — it reads more naturally for negative guards. Postfix unless places the condition after the action: do_something unless error. Avoid using unless with an else clause or with a negative condition — it becomes difficult to reason about.

Ruby has the same ternary operator as C: condition ? value_if_true : value_if_false. Postfix if and unless are idiomatic for single-line guards: statement if condition. The postfix form is preferred over a full if...end block when there is only one line to execute.

while loops run while the condition is true; until runs while it is false (equivalent to while !condition). Ruby has no do...while construct — use loop do ... break if condition end for a guaranteed first execution. Note that ++ and -- do not exist in Ruby; use += 1 and -= 1.

Ruby's case/when has no fallthrough — there is no break required. Multiple patterns in one when are comma-separated. Each when uses === (case equality) for matching, enabling regex patterns, range membership, and class type checks in addition to literal equality.

loop do ... end is Ruby's infinite loop — equivalent to for (;;) or while (1). break exits the loop; next skips to the next iteration (C's continue). Both break and next work inside blocks too: next inside each skips to the next element, and break stops the entire iteration.

Ruby methods return the value of their last expression — no return keyword is required (though it can be used for early exit). There is no return type declaration, no static, and no static buffer trick for returning strings. Methods at the top level become private methods of Object. The method body is indented 2 spaces; end closes it.

Ruby supports default parameter values directly in the method signature — no wrapper function, no sentinel value, no overloads. Default values are evaluated at call time, not definition time, so dynamic defaults like def log(message, time = Time.now) work as expected. Multiple parameters can have defaults, as long as they come after required parameters.

Ruby keyword arguments are declared with a colon after the parameter name. At the call site, the argument names are visible and order-independent. Required keyword arguments (no default) raise ArgumentError if omitted. This self-documenting call style eliminates the positional ambiguity of C function calls with multiple parameters of the same type.

*args in a Ruby method signature collects any number of positional arguments into an array — type-safe and without the manual va_list machinery. **kwargs collects keyword arguments into a hash. The splat works at the call site too: print_all(*items_array) spreads an array into positional arguments.

Ruby 3.0 introduced an endless method syntax: def name(params) = expression. It reads like a mathematical definition and is equivalent to a normal method with an implicit return. This is closer to C's single-expression function bodies ({ return expr; }) but without the braces or return. Use it for simple, single-expression methods.

A Ruby block is an anonymous chunk of code passed to a method — similar in spirit to a C function pointer, but more ergonomic. The do |params| ... end form is conventional for multi-line blocks; { |params| ... } for single-line. Blocks are passed implicitly — they are not a declared parameter in the method signature. yield inside a method invokes the block.

yield transfers control to the caller's block, optionally passing arguments. Any method can accept a block — no special parameter is required in the signature. block_given? checks whether the caller provided one. This is the mechanism behind all of Ruby's iterators: each, map, and select all call yield internally.

A Proc object stores a block as a value that can be called later, passed around, and returned from methods. The ->(params) { body } syntax creates a lambda — a stricter form that enforces argument count and treats return as returning from the lambda itself (not the enclosing method). The &:method_name shorthand converts a symbol to a block that calls that method on each element.

The Enumerable module provides predicate methods that eliminate manual loops for common queries: all?, any?, none?, one?. find returns the first matching element (or nil). count with a block counts matching elements. min, max, and sum work directly without a loop. All these are available on any collection that implements each.

Each chained method returns a new array that the next method operates on. The chain reads left-to-right, closely matching the intent: "take the numbers, keep the even ones, square them, sum the result." The entire pipeline allocates intermediate arrays; use Enumerator::Lazy for large datasets where intermediate collections would be wasteful.

Ruby classes bundle data and methods together — no separate struct definition, no manual method dispatch table. Instance variables start with @ and are automatically created on first assignment in initialize. BankAccount.new allocates the object and calls initialize. to_s is Ruby's toString equivalent; puts object calls it automatically.

attr_accessor generates both a getter and a setter for an instance variable. attr_reader generates only a getter. attr_writer only a setter. Setters follow the name= naming convention — person.name = "Alicia" calls the name= method. This replaces every manual getter/setter function from the C struct pattern.

Ruby uses < for inheritance: class Dog < Animal. Overriding a method is simply redefining it — no vtable, no function pointer, no virtual keyword. super calls the parent's version. Ruby supports single inheritance only, but modules serve as mixins for sharing behavior across unrelated classes.

Class methods are defined with self.method_name — equivalent to C static functions scoped to the struct. Class variables @@name are shared across all instances and subclasses. In practice, Ruby developers often prefer class-level instance variables (@count on the class itself) to avoid inheritance edge cases with @@.

Ruby classes are always "open" — any class, including built-in types like String, Integer, and Array, can be reopened and extended at any time. This is called monkey patching. C has no equivalent: built-in types are not extensible. Used with care, open classes make code read naturally; used carelessly, they can cause surprising conflicts.

Ruby modules serve as namespaces — grouping related constants and classes under a name, similar to C's naming prefix convention. The :: operator accesses constants inside a module. Unlike C's convention-based prefixing, Ruby namespaces are enforced by the runtime. Modules can be nested arbitrarily deep.

include ModuleName mixes all of a module's methods into a class — a form of multiple inheritance without the diamond-problem ambiguity. Modules are Ruby's answer to interfaces (with default implementations). A class can include any number of modules. This is far cleaner than C's #include hacks or function pointer tables for sharing behavior.

Including Comparable and implementing the single <=> (spaceship) operator automatically provides <, >, <=, >=, ==, between?, and clamp — replacing the manual comparator function from C's qsort. The spaceship operator returns -1, 0, or 1 for less-than, equal, or greater-than.

Ruby uses exceptions instead of error codes. raise throws an exception object; rescue catches it. The call site is clean — no out-parameters, no return value check, no errno. Exceptions propagate up the call stack until caught; if uncaught, they terminate the program with a backtrace. The begin...rescue...end block is the try/catch equivalent.

rescue catches specific exception types; the bare rescue => catches any StandardError. ensure always executes after the begin block — whether it succeeded, raised, or was rescued — equivalent to C's cleanup code that must run regardless of the error path. Ruby's GC frees memory automatically, so ensure is mainly for closing files and releasing external resources.

Custom exceptions are just classes that inherit from StandardError (or another exception class). The inheritance hierarchy lets you rescue at different levels of specificity — catching NetworkError will also catch NotFoundError. Exception classes can carry additional data (like @resource), replacing the need for separate error-detail parameters.

retry inside a rescue block re-executes the entire begin block from the top — eliminating the manual loop-and-flag pattern required in C. raise with no arguments re-raises the current exception. raise with a string creates a RuntimeError. raise with an exception class and message creates a specific exception.

Ruby uses a garbage collector — the runtime automatically reclaims memory for objects that are no longer reachable. There is no malloc, no free, no use-after-free, no double-free, and no memory leak from forgetting to clean up. The trade-off is that GC adds runtime overhead and introduces occasional pause times — acceptable for most applications, not for hard real-time systems.

Ruby symbols (:name) are immutable, interned identifiers. Every occurrence of the same symbol literal in a program is the same object — identity comparison is O(1). Unlike strings, symbols never need allocation or duplication for comparison. They are used for hash keys, method names, and option values — anywhere a stable, lightweight label is needed.

Calling .freeze on any Ruby object makes it permanently immutable — analogous to const in C, but applied at runtime to any object. Attempting to mutate a frozen object raises FrozenError. In Ruby 4.0, string literals are frozen by default. Freezing is useful for constants, configuration hashes, and objects passed across thread boundaries.

Ruby's case/in pattern matching (available since Ruby 3.0) enables structural dispatch on object type, value, and shape simultaneously — no type tag enum or union required. The => operator captures matched values into a variable. Guard clauses (if condition) add extra constraints. This replaces large chains of if/elsif type checks.

Array patterns match both the structure (number of elements) and the type of each element simultaneously. The => operator binds a matched value to a local variable. *rest captures remaining elements. The one-line pattern match form (expression => pattern) is useful for destructuring a known structure without a full case expression.

Hash patterns match a subset of keys — extra keys are ignored by default. Values can be matched by type (String), by literal value, by range ((18..) matches 18 or greater), or captured with =>. **rest captures unmatched keys. Hash pattern matching replaces chains of key_exists && type_check && value_check.

The find pattern ([*, pattern, *]) searches for an element matching the middle pattern anywhere in the array, with the splats capturing everything before and after. A regex works as the pattern for string elements. This replaces the manual linear scan loop needed in C. The find pattern is particularly useful for parsing mixed-type collections or log lines.