Ruby.CodeCompared.To/COBOL

Every COBOL program begins with IDENTIFICATION DIVISION and ends with STOP RUN. The four DIVISIONS must appear in a fixed order: IDENTIFICATION, ENVIRONMENT, DATA, PROCEDURE. The minimal program above has only IDENTIFICATION and PROCEDURE — ENVIRONMENT and DATA are optional when the program needs no file access or stored data.

In free-format COBOL, *> begins a comment to the end of the line — the direct equivalent of Ruby's #. In traditional fixed-format COBOL, an asterisk in column 7 makes the entire line a comment. The *> syntax was introduced in COBOL 2002 and works in both free and fixed format.

COBOL separates data declarations from executable code entirely. The DATA DIVISION's WORKING-STORAGE SECTION holds variables that persist for the program's lifetime — similar to Ruby's instance variables but all at the same scope level. Every variable must be declared with a PICTURE (PIC) clause that precisely defines its format and size.

Every COBOL program has up to four DIVISIONS in a fixed order: IDENTIFICATION (program metadata), ENVIRONMENT (platform and file configuration), DATA (variable declarations), and PROCEDURE (executable code). Ruby has no equivalent structure — code and data intermingle freely in any order. The rigid DIVISION structure was designed to make programs self-documenting and machine-readable from punch cards.

The infamous COBOL column restrictions were a relic of 80-column punch cards from the 1960s. In fixed format, division and section names had to start in column 8 (Area A) and statements in column 12 (Area B) — getting this wrong caused cryptic errors. Modern COBOL (2002+) eliminates these restrictions with the >>SOURCE FORMAT IS FREE directive. All examples on this page use free format.

PIC X(n) declares a fixed-width alphanumeric field of n characters — like a Ruby String, but with a fixed maximum length that never changes. When you store a shorter string, COBOL pads it with spaces on the right. When you store a longer string, COBOL silently truncates it. There is no dynamic resizing — a PIC X(20) field is always exactly 20 bytes in memory.

PIC 9(n) declares an unsigned decimal integer with exactly n digits. A PIC 9(5) field holds values from 0 to 99999 — the 9 in the PICTURE clause represents one decimal digit, and (5) is a repetition count. COBOL stores numbers in decimal by default, not binary. This guarantees exact decimal arithmetic, which is critical for the financial calculations COBOL was designed to perform.

The S prefix in PIC S9(n) makes a numeric field signed so it can hold negative values. Without S, a COBOL numeric field cannot store a negative number — attempting to do so causes silent data corruption. The sign is stored as a zone code in the last digit or as a separate byte, depending on the USAGE clause. Omitting S from a field that participates in signed arithmetic is a common COBOL bug.

The V in a PICTURE clause marks the implied decimal point position — it is not stored as a character. PIC 9(5)V99 defines a field with 5 digits before the decimal and 2 after. No decimal character is stored in memory; COBOL tracks where the decimal falls conceptually. This is how COBOL avoids floating-point precision problems: all financial arithmetic uses exact decimal storage, never IEEE 754 binary floating-point.

The VALUE clause initializes a WORKING-STORAGE field when the program starts. Without it, numeric fields default to zero and alphanumeric fields default to spaces. COBOL has no boolean type; flags are typically represented as PIC X(1) fields with values "Y"/"N" or "T"/"F". VALUE is only valid in WORKING-STORAGE — not in FILE SECTION or LINKAGE SECTION fields.

A COBOL group item is a level-01 item with subordinate items at higher level numbers (05, 10, 15, etc.). It is similar to a Ruby hash or struct — a named collection of related fields. The group item itself (WS-PERSON) has no PIC clause; its size is the sum of all its children. Referencing the group item as a whole treats it as a flat PIC X field of the combined length of all children concatenated.

Level-88 condition names define named boolean conditions attached to a data field. The condition is TRUE when the parent field equals one of the VALUES listed. They make business logic read like plain English: IF ACCOUNT-ACTIVE is self-documenting in a way that IF WS-STATUS = "ACTIVE" is not. The closest Ruby analogy is predicate methods like account.active?. Level-88 items are one of COBOL's most celebrated and distinctive features.

The USAGE clause controls how a numeric field is stored in memory. The default (DISPLAY) stores one digit per byte as a character. COMP stores the value in binary like a C integer, which is faster for arithmetic. COMP-3 (packed decimal) stores two digits per byte — the IBM mainframe standard that is space-efficient and still common in legacy systems today. All three produce the same numeric value when displayed; only the internal storage representation differs.

COBOL has no local variables. All variables in a standalone COBOL program live in WORKING-STORAGE SECTION and persist for the entire run. They are initialized once via VALUE clause and retain their values between paragraph calls — equivalent to Ruby instance variables, except there is no concept of scope. All WORKING-STORAGE fields are effectively global within the program.

The MOVE statement is COBOL's assignment operator — there is no = for assignment. MOVE always copies; it never moves in the C++ or Rust sense. MOVE pads with spaces (for alphanumeric) or zeros (for numeric) when the source is shorter than the destination. MOVE SPACES TO field clears an alphanumeric field; MOVE ZEROS TO field clears a numeric field.

COBOL's MOVE can copy one value into multiple destinations in a single statement: MOVE source TO dest1 dest2 dest3. The source is evaluated once and copied to each destination sequentially. This is unique to COBOL — most languages require a separate assignment for each variable. It is commonly used to initialize multiple fields to the same value or to copy a record into several buffers simultaneously.

COBOL has "figurative constants" — built-in literals that represent commonly needed values. SPACES (or SPACE) fills an alphanumeric field with blanks; ZEROS (or ZERO, ZEROES) sets a numeric field to zero; HIGH-VALUES fills with the highest byte value (xFF); LOW-VALUES fills with x00. These are not functions but built-in keywords that COBOL applies to any compatible field type automatically.

INITIALIZE resets a data item (or an entire group item) to its default empty state: alphanumeric fields get SPACES, numeric fields get ZEROS. Applied to a group item, it initializes all elementary items within the group at once. INITIALIZE is more convenient than writing individual MOVE SPACES and MOVE ZEROS statements for every field in a large record — a common pattern after processing one record before reading the next.

COBOL uses hyphens in data names (WS-ACCOUNT-NUMBER), not underscores. The WS- prefix for WORKING-STORAGE items is a widespread convention that makes the data origin visible in the code. COBOL is completely case-insensitive — WS-NAME, ws-name, and Ws-Name all refer to the same field. In contrast, Ruby is case-sensitive: name and Name are different identifiers (where Name would be a constant).

COBOL's ADD verb has two forms. ADD a b GIVING result computes a + b and stores it in result (like result = a + b). ADD value TO field adds directly to the field in place (like Ruby's +=). Multiple values can be summed in one statement: ADD a b c TO total. There is no + operator for addition in COBOL — every arithmetic operation uses a verb.

SUBTRACT mirrors ADD in structure. SUBTRACT value FROM total GIVING result computes total - value. SUBTRACT value FROM field modifies the field in place (equivalent to -=). Note the unusual syntax: SUBTRACT 350 FROM 1000 means 1000 − 350 = 650. The FROM operand is the minuend (the number being subtracted from), not the result — a common stumbling block for newcomers.

MULTIPLY a BY b GIVING result computes a × b. MULTIPLY value BY field multiplies the field in place. The multiplier comes first, then BY, then the multiplicand — reading like "multiply 12 by 8". MULTIPLY does not support exponentiation; use COMPUTE for that. The result field must be large enough to hold the product or high-order digits are silently truncated.

COBOL's DIVIDE verb computes both quotient and remainder in a single statement. There is no % modulo operator — REMAINDER is a clause of the DIVIDE verb itself. The form DIVIDE a BY b GIVING quotient computes a ÷ b. The alternative DIVIDE b INTO a GIVING quotient is equivalent but has reversed operand order, which is a common source of confusion.

COMPUTE allows arithmetic expressions using standard mathematical notation — the only COBOL verb that uses +, -, *, /, and ** (exponentiation). Intrinsic functions like FUNCTION SQRT can be used inside COMPUTE expressions. It replaces verbose chains of ADD/SUBTRACT/MULTIPLY/DIVIDE for complex calculations and reads much like Ruby's assignment with an expression.

Arithmetic verbs can include ON SIZE ERROR to detect numeric overflow — when the result is too large for the destination field. Without this handler, COBOL silently truncates the high-order digits. ON SIZE ERROR makes overflow explicit: 9999 × 9999 = 99,980,001 cannot fit in a PIC 9(5) field, so the SIZE ERROR branch runs. NOT ON SIZE ERROR handles the success case. Ruby integers are arbitrary precision and never overflow.

COBOL strings are fixed-width character arrays defined by their PIC X(n) clause. FUNCTION LENGTH returns the declared field length — always 30 for a PIC X(30) — not the length of the current content. This is unlike Ruby's String#length which returns the actual string length. A PIC X(30) field is always 30 characters wide; shorter strings are padded with trailing spaces.

COBOL's STRING verb concatenates multiple sources into a destination field. DELIMITED BY SPACE stops copying at the first space (trimming trailing spaces from fixed-width fields). DELIMITED BY SIZE copies the full field length as-is. The WITH POINTER clause tracks the current write position. COBOL has no + operator or #{} interpolation for strings — STRING is the only concatenation verb.

UNSTRING is the inverse of STRING — it splits a source string on a delimiter and stores successive tokens into destination fields. DELIMITED BY SPACE splits on any single space. Multiple destinations receive successive tokens. UNSTRING also supports multiple delimiters, a TALLYING count of fields filled, and a POINTER clause for partial processing. It is COBOL's equivalent of Ruby's String#split.

INSPECT TALLYING counts occurrences of a character or substring within a field. FOR ALL "s" counts every occurrence of lowercase "s" throughout the field. FOR LEADING "s" counts only leading occurrences. COBOL is case-sensitive inside string literals even though COBOL keywords themselves are case-insensitive — "s" and "S" are different characters here, just as in Ruby.

INSPECT REPLACING modifies a field in place, replacing one character or substring with another. REPLACING ALL "o" BY "0" replaces every "o" with "0". REPLACING LEADING "H" BY "h" replaces only leading characters. REPLACING FIRST "l" BY "L" replaces only the first occurrence. Unlike Ruby's String#gsub, INSPECT REPLACING always operates in-place and replacements must be the same length as the original.

COBOL intrinsic functions like UPPER-CASE and LOWER-CASE are used with the FUNCTION keyword and return a value that must be stored with MOVE. They are not methods on a string object but standalone functions. Intrinsic functions were added in COBOL 2002 — older programs use INSPECT REPLACING for case conversion. Other useful functions include FUNCTION TRIM, FUNCTION REVERSE, and FUNCTION NUMVAL (string-to-number conversion).

COBOL's IF statement uses END-IF to close the block (in modern COBOL). ELSE IF chains multiple conditions. The comparison operators are =, >, <, >=, <=, and NOT =. Alternatively, COBOL supports English-language comparisons: IF WS-SCORE IS GREATER THAN 90 is valid and equivalent to IF WS-SCORE > 90.

EVALUATE is COBOL's switch/case statement. WHEN OTHER matches everything not caught by earlier WHEN clauses — equivalent to Ruby's else in a case expression. Unlike C's switch, COBOL's EVALUATE does not fall through — each WHEN block is independent. EVALUATE also supports ranges (WHEN 1 THRU 5) and multiple values (WHEN 1, 2, 3).

EVALUATE TRUE evaluates each WHEN condition as a boolean expression, executing the first one that is TRUE. This is the recommended replacement for deeply nested IF/ELSE IF chains in COBOL. It is equivalent to Ruby's case true when condition... pattern. EVALUATE TRUE is more readable than nested IF statements and aligns with COBOL's design goal of business-readable code.

A level-88 condition name can list multiple VALUES, making it TRUE when the parent field contains any of them. This replaces verbose IF field = "A" OR field = "B" chains with a single readable name. Business logic in COBOL is meant to read like plain English: IF ACCOUNT-NEEDS-PROCESSING is self-documenting in a way that a multi-value comparison is not.

SET condition-name TO TRUE assigns the first VALUE of the condition name's clause to the parent field. It is the canonical way to change a status field using its named condition: SET ACCOUNT-ACTIVE TO TRUE sets WS-STATUS to "ACTIVE". This is more maintainable than MOVE "ACTIVE" TO WS-STATUS because the string literal is defined in exactly one place — the 88-level clause — rather than scattered throughout the code.

CONTINUE is COBOL's no-op statement — it does nothing but is syntactically valid wherever a statement is required. It serves the same purpose as Python's pass or Ruby's bare nil when an IF branch must exist but has no action. CONTINUE is also used as a placeholder when restructuring code — a COBOL idiom for marking "this case is handled by doing nothing".

PERFORM n TIMES repeats a block n times — COBOL's equivalent of Ruby's Integer#times. The block is delimited by END-PERFORM. COBOL has no blocks, closures, or anonymous functions — all repetition is expressed through PERFORM. The count can be a literal or a numeric data field.

PERFORM UNTIL continues while the condition is FALSE — it loops UNTIL the condition becomes TRUE. This is the inverse of Ruby's while: COBOL has no while keyword. PERFORM UNTIL WS-COUNTER > 5 is equivalent to Ruby's while counter <= 5. The body must manually increment the counter — COBOL does not do this automatically.

PERFORM VARYING is COBOL's for-loop. FROM start BY step UNTIL condition sets up the counter. The counter advances by step before each condition check. PERFORM VARYING can be nested using the AFTER clause: PERFORM VARYING row FROM 1 BY 1 UNTIL row > 3 AFTER column FROM 1 BY 1 UNTIL column > 4 creates a nested loop in a single statement — useful for iterating two-dimensional tables.

PERFORM WITH TEST AFTER UNTIL condition is COBOL's do-while loop — the body executes at least once, and the condition is checked at the end of each iteration. The default PERFORM UNTIL uses TEST BEFORE (checks condition first). This pattern is common in COBOL file-reading loops where you need to read at least one record before deciding whether to continue.

EXIT PERFORM immediately terminates the current PERFORM loop — COBOL's equivalent of Ruby's break. It can only appear inside a PERFORM block, not inside a called paragraph. EXIT PERFORM CYCLE skips to the next iteration (like Ruby's next). Both were introduced in COBOL 2002 and are not available in older COBOL dialects.

A COBOL paragraph is defined by its name followed by a period on the same or next line. Paragraphs are COBOL's equivalent of Ruby methods — named blocks of code called with PERFORM. Unlike Ruby methods, paragraphs take no parameters and return no values; all data exchange happens through WORKING-STORAGE fields. Paragraphs must appear after STOP RUN to prevent the program from falling through into them after the main logic ends.

COBOL paragraphs have no parameters or return values. The calling code sets WORKING-STORAGE fields before PERFORM, and the paragraph reads and writes those shared fields. This is COBOL's equivalent of passing arguments and returning a result — but entirely through shared global state. Compared to Ruby's clean method signatures, COBOL's paragraph communication requires careful documentation of what each paragraph reads and writes.

PERFORM paragraph THRU other-paragraph executes every paragraph from the first through the last in physical source order. It is a common COBOL pattern for grouping related steps: define INITIALIZE-SECTION, PROCESS-SECTION, and CLEANUP-SECTION as consecutive paragraphs and call all three with one PERFORM THRU. Ruby has no equivalent — you call each method individually or extract them into a single method.

The PROCEDURE DIVISION can be organized into named SECTIONS, each containing multiple paragraphs. A SECTION groups related paragraphs together — PERFORMing a SECTION executes all its paragraphs in sequence. Sections provide a higher level of organization than individual paragraphs, similar to how Ruby classes group related methods. Modern COBOL programs typically use either sections or flat paragraphs, not both.

PERFORM paragraph-name n TIMES calls a paragraph n times — equivalent to Ruby's n.times { method_call }. If the paragraph needs different input each call, set the relevant WORKING-STORAGE fields before calling, or use PERFORM VARYING with a counter that the paragraph reads. COBOL paragraphs retain and modify WORKING-STORAGE between calls — the WS-COUNTER field above accumulates across all three calls.

The OCCURS clause defines a table (COBOL's term for an array). OCCURS 5 TIMES creates 5 elements, accessed with 1-based subscripts: WS-SCORE(1) through WS-SCORE(5). COBOL tables are always 1-indexed — unlike Ruby's 0-indexed arrays. The table is defined as a subordinate item within a group item, which can be referenced as a whole unit representing the entire table.

Iterating over a COBOL table always uses PERFORM VARYING with a numeric subscript. There is no COBOL equivalent of Ruby's Array#each or Array#map — the index must be manually managed. The subscript is used directly in parentheses: WS-SCORE(WS-INDEX). Table subscripts must be integer data items or integer literals; expressions inside subscripts are not supported in standard COBOL.

Summing a COBOL table requires a PERFORM VARYING loop that explicitly adds each element to an accumulator. There is no built-in equivalent of Ruby's Array#sum or Enumerable#reduce. The accumulator pattern — initialize a sum variable to 0, then ADD each element — is pervasive in COBOL business logic. This verbosity is by design: every operation is stated explicitly, leaving nothing implicit.

A two-dimensional COBOL table is created by nesting OCCURS clauses. The outer OCCURS defines rows; the inner OCCURS defines columns within each row. Access uses two subscripts: WS-CELL(row, column). COBOL supports up to seven dimensions of subscripting. This nesting pattern maps directly to Ruby's array-of-arrays, but COBOL requires all dimensions to be declared upfront with their maximum sizes.

OCCURS n TO m TIMES DEPENDING ON field declares a variable-length table where the active element count is stored in a separate numeric field. The table is allocated for the maximum size (m) but only WS-ITEM-COUNT elements are considered valid at runtime. This is COBOL's approach to dynamic arrays — the maximum size must be known at compile time, but the active size can vary during execution.

DISPLAY is COBOL's primary output verb — equivalent to Ruby's puts. It writes to standard output followed by a newline. WITH NO ADVANCING suppresses the newline, like Ruby's print. DISPLAY can output literals, data fields, or combinations: DISPLAY "Name: " WS-NAME. Unlike puts, a single DISPLAY statement can output multiple items consecutively with no separator between them.

DISPLAY outputs all its operands in sequence with no separator between them. COBOL has no string interpolation syntax like Ruby's #{}. To combine literal text with variable values, list them all as DISPLAY operands. Understanding field widths matters here: WS-FIRST-NAME is PIC X(10) so "Alice" will display as "Alice " (with 5 trailing spaces) before the ", Age:" label.

COBOL "edited" PICTURE clauses format numbers for display. Z suppresses leading zeros (replaces them with spaces), , inserts a comma, . inserts a decimal point, and $ inserts a dollar sign. You always MOVE from a numeric field (PIC 9) into an edited field just before display — edited fields cannot be used in arithmetic. This declarative formatting is one of COBOL's most powerful features for generating financial reports without any format string syntax.

COBOL intrinsic functions are called with the FUNCTION keyword and their result must be captured with MOVE or COMPUTE. Useful numeric functions include MAX, MIN, ABS, MOD, INTEGER, and SQRT. Date functions include FUNCTION CURRENT-DATE (returns a 21-character field with date, time, and UTC offset). Intrinsic functions were added in COBOL 2002; older COBOL code often implemented these calculations manually.

COBOL file handling is declared across three DIVISIONS. The ENVIRONMENT DIVISION's FILE-CONTROL assigns a logical file name (CUSTOMER-FILE) to a physical file path. The DATA DIVISION's FILE SECTION declares the record layout with an FD (File Description) entry. Only then does the PROCEDURE DIVISION use OPEN/READ/WRITE/CLOSE. This multi-division declaration is COBOL's way of separating the "what" (record layout) from the "how" (access pattern) and the "where" (file path). File I/O requires a real filesystem and cannot run in the browser.

File access in COBOL always follows the same verb sequence: OPEN → READ/WRITE → CLOSE. AT END in the READ statement sets a condition when there are no more records — the standard end-of-file detection pattern. The READ-UNTIL-END-OF-FILE loop reads one extra record at the end (the "priming read" pattern) to trigger AT END. COBOL has no equivalent of Ruby's each_line iterator; the loop must be written explicitly. File I/O requires a real filesystem.

COBOL writes files by moving data into the record buffer (the 01-level item under FD) and then calling WRITE on that record. You never write "to the file" directly — you write the record buffer. OPEN OUTPUT creates the file (or truncates it). WRITE AFTER ADVANCING 2 LINES is the COBOL way to add blank lines in a report. File I/O requires a real filesystem and cannot run in the browser.

COBOL keywords and data names are completely case-insensitive — DISPLAY, display, and Display are identical. This includes field names: WS-NAME and ws-name refer to the same field. In contrast, Ruby is case-sensitive: name, Name, and NAME are three different identifiers (where Name would be a constant). Traditional COBOL was written entirely in uppercase; modern COBOL allows mixed case, but production code remains uppercase by convention.

A PIC X(n) field is always exactly n characters wide. Storing "Alice" in a PIC X(10) field pads it with 5 trailing spaces: "Alice ". This causes subtle bugs: WS-NAME = "Alice" is FALSE because COBOL compares the full 10-character field "Alice " against "Alice" (padded to match). Use FUNCTION TRIM(field TRAILING) to remove trailing spaces before comparison or display. Ruby strings are dynamic and never have this problem.

COBOL MOVE silently truncates when the source is longer than the destination: "Alexander the Great" MOVEd into a PIC X(10) field produces "Alexander ". There is no overflow error, warning, or exception. This silent truncation is a major source of data integrity bugs in COBOL programs, especially when field sizes change during maintenance. Ruby strings grow dynamically to hold any content — there is no equivalent silent truncation.

In traditional fixed-format COBOL, a period (.) ends the scope of any open IF, PERFORM, or EVALUATE — regardless of indentation. A misplaced period after an IF body makes subsequent statements run unconditionally, even when the condition was false. This was a notorious source of COBOL bugs for decades. Modern COBOL uses explicit scope terminators (END-IF, END-PERFORM, END-EVALUATE) to eliminate the ambiguity. This page uses free-format COBOL throughout, which strongly encourages explicit scope terminators.

COBOL has no functions, methods, or closures. Logic is organized into paragraphs (and sections), called with PERFORM. Parameters and return values are communicated through WORKING-STORAGE fields — there is no way to pass arguments directly to a paragraph. COBOL 2002 introduced user-defined functions (FUNCTION MY-FUNC(args)) compiled separately, but they are rarely used in practice. This is COBOL's most significant structural limitation compared to modern languages like Ruby.