C.CodeCompared.To/Ruby

Ruby programs need no #include directives, no main function, and no return 0. Code at the top level executes immediately, line by line. puts prints a value followed by a newline — the direct equivalent of printf("...\n").

Ruby is interpreted — there is no compile step, no object file, no linker. 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.

Ruby uses # for single-line comments — one character shorter than //. The =begin / =end block comment exists but is almost never used in practice; consecutive # lines are the idiomatic Ruby style for multi-line comments. Both markers must be at the very beginning of the line.

Ruby has three main output methods: puts adds a newline (like printf("...\n")); print does not; p calls .inspect on its argument, which shows the type and structure — invaluable for debugging. Unlike printf, Ruby uses string interpolation (#{expression}) instead of format specifiers for most output.

Ruby variables are created on first assignment — no type declaration, no int, no double, no char[]. The runtime tracks types automatically. 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 on the heap.

In Ruby, variables are not bound to a type — only objects are. Reassigning a variable to a different type is perfectly valid. 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.

Ruby constants start with an uppercase letter; SCREAMING_SNAKE_CASE is the convention for simple values. Unlike C's #define macros (which are textual substitution with no scope), Ruby constants are real values stored in the runtime and respect module/class scope. Reassigning a constant produces a warning but is not a fatal error.

Ruby's nil is a real object of class NilClass — it is not an invalid memory address. Unlike C's NULL, dereferencing nil does not segfault; calling a method that nil does not understand raises NoMethodError. Conversion methods like nil.to_s, nil.to_a, and nil.to_i all return sensible empty values.

Ruby's truthiness rules are far simpler than C's: exactly two values are falsy — nil and false. Everything else is truthy, including 0, "", [], and 0.0. 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.

Ruby supports parallel assignment: the right-hand side is fully evaluated before assignment, enabling a clean swap without a temporary variable. 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.

In Ruby, strings are first-class objects with a rich API. Operations that require #include <string.h> and manual loops in C — like converting case, checking for a substring, or reversing — are single method calls in Ruby. There are no null terminators, no buffer overflows, and no need to track the length separately.

Ruby uses #{expression} inside double-quoted strings — a far more concise alternative to sprintf / snprintf. Any Ruby expression is valid inside the braces, including method calls and arithmetic. Single-quoted strings do not interpolate: '#{name}' prints the literal text #{name}. No format specifiers, no buffer size, no null terminator to manage.

Ruby's String class has over 80 built-in methods. strip trims whitespace from both ends; gsub performs a global substitution; split returns an array. 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.

Ruby's squiggly heredoc (<<~) strips leading whitespace automatically, so indentation in the source does not appear in the string. The terminator label is arbitrary. chomp removes the trailing newline that heredocs include. Unlike C's adjacent string literal trick, heredocs support interpolation by default — use <<~'HEREDOC' (single-quoted terminator) to disable it.

Ruby's % operator applies printf-style format strings — the same specifiers as C's printf, but without #include <stdio.h> and with a cleaner call syntax. For multiple arguments, pass an array: "format" % [arg1, arg2]. sprintf and its alias format are also available. For most output, string interpolation is preferred.

Ruby 4.0 freezes all string literals by default, analogous to C's const char * literals residing in read-only memory. Attempting to mutate a frozen string raises FrozenError instead of causing undefined behavior. Use dup to get a mutable copy, or use the unary plus operator: +greeting returns an unfrozen duplicate.

Ruby has a single Integer type that handles arbitrarily large numbers — no int, long, uint64_t, or __int128 needed. There is no integer overflow; the runtime automatically promotes to a big-integer representation when needed. Underscores are allowed in numeric literals for readability: 1_000_000.

In Ruby, integers are objects with a rich method API. Predicate methods ending in ? return true or false: even?, odd?, positive?, negative?, zero?. The times method replaces for (int i = 0; i < n; i++) for simple counting loops, and upto / downto handle ranges.

Ruby has a single Float class (IEEE 754 double precision — same as C's double). There is no float vs double distinction. Math functions live in the Math module: Math.sqrt, Math.sin, Math::PI. Float::INFINITY and division by zero produce infinity, not undefined behavior.

Ruby's / on two integers performs floor division — it rounds toward negative infinity: -7 / 2 == -4 in Ruby. C99 truncates toward zero: -7 / 2 == -3 in C. These differ for negative operands and is a common source of bugs when porting C logic to Ruby. The % modulo in Ruby 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; there is no pow() call needed.

Ruby's conversion methods follow a consistent naming convention: to_i (integer), to_f (float), to_s (string), to_r (rational). The to_i method accepts a radix argument: "0xFF".to_i(16) parses hexadecimal. These replace atoi, strtol, strtod, and snprintf — all without including any headers.

Ruby arrays are heap-allocated, dynamically sized, and heterogeneous — one array can hold integers, strings, symbols, and nil simultaneously. 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.

Ruby arrays support negative indexing: array[-1] is the last element, array[-2] the second-to-last. This eliminates the common C pattern of array[length - 1]. Slicing returns a new array — no manual allocation or copy. An out-of-bounds access returns nil rather than undefined behavior.

Ruby arrays grow and shrink automatically — no realloc, no capacity management, no free. push (or <<) appends to the end; pop removes from the end. unshift prepends to the front; shift removes from the front. These map to the standard stack and queue operations without any memory management ceremony.

Ruby's Enumerable module provides functional collection operations built into every array. map transforms each element and returns a new array; select keeps elements matching the block; reject keeps elements that do not match. No temporary arrays to allocate, no index management, no explicit loops.

reduce (alias: inject) folds an array into a single value by applying a block to an accumulator and each element in turn. The first argument is the initial accumulator value. The symbol shorthand inject(:+) is equivalent to inject { |accumulator, value| accumulator + value }. sum is a built-in convenience method for the common addition case.

sort returns a sorted copy (uses the <=> spaceship operator for comparison — no comparator function pointer needed). uniq removes duplicates, preserving order. flatten recursively expands nested arrays — there is no C equivalent at all. compact removes nil values. Methods ending in ! mutate in place: sort!, uniq!.

Ruby has a built-in Hash class — a key-value store with O(1) average lookup. The { key: value } syntax uses symbol keys (the most common style). The { "key" => value } syntax accepts any object as a key. Hashes maintain insertion order (since Ruby 1.9). There is no need for third-party libraries or manual parallel arrays.

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.