Pascal.CodeCompared.To/COBOL

A Pascal program is a single program Name; begin ... end. block. A COBOL program is split into DIVISIONS: IDENTIFICATION DIVISION names the program with PROGRAM-ID, and PROCEDURE DIVISION holds the executable statements. DISPLAY is COBOL's equivalent of Pascal's writeln, and STOP RUN. is the mandatory final statement.

Pascal comments use curly braces { ... } (or (* ... *)); COBOL free-format comments start with *> and run to the end of the line. Both languages date from an era where comment syntax had to coexist with fixed-column punch-card layouts, though modern free-form dialects of both have moved past that constraint.

Pascal has one flat program structure: an optional uses clause, const/type/var declarations, then a single begin...end. body. COBOL formally separates concerns into up to four DIVISIONs — IDENTIFICATION (naming), ENVIRONMENT (system/file configuration), DATA (every variable's declaration), and PROCEDURE (the executable logic) — a considerably more rigid, bureaucratic structure with no Pascal parallel.

Pascal's Integer is a single, fixed-width machine type with a range decided by the compiler and platform. COBOL's PIC 9(3) declares exactly how many decimal DIGITS the field holds — 9(3) means up to three digits, 0–999 — a picture of the data's shape rather than a reference to a machine word size, closer in spirit to specifying a column width on a form.

This is the central theme of this whole comparison. Pascal's Real is IEEE 754 binary floating point — it carries the same representation error every modern language's float type has (0.1 + 0.2 is not exactly 0.3). COBOL's PIC 9(2)V99 is a genuinely different representation: an implied decimal point (the V) over exact decimal digits, with NO floating-point rounding error at all — precisely why COBOL, not Pascal or any binary-float language, became the language of bank ledgers and financial systems.

Both languages check a value against its declared shape, but the mechanism differs: Pascal's type system is abstract (Integer, Real, String are named types the compiler reasons about). COBOL's PICTURE clause describes the literal shape of the data on the "form" — how many digits, whether signed, where the decimal point falls — closer to specifying a punch-card column layout than to a type in the modern sense.

Pascal's := and COBOL's MOVE ... TO ... both copy a value into a variable, but COBOL spells it as an English verb phrase rather than a symbol — consistent with COBOL's design goal of reading like a specification document a non-programmer manager could follow.

Pascal uses the familiar + and - infix operators with a separate := assignment. COBOL's traditional arithmetic verbs are English sentences: ADD n TO field and SUBTRACT n FROM field both modify the destination field in place, with no separate assignment step and no operator symbols at all. COBOL also supports COMPUTE with ordinary operator syntax, covered next.

COBOL's COMPUTE statement allows ordinary infix operator expressions — COMPUTE result = a * b * c — reading almost exactly like the Pascal assignment it mirrors. Idiomatic COBOL still tends to prefer the English-verb forms (ADD/SUBTRACT/MULTIPLY/DIVIDE) for simple single operations, reserving COMPUTE for anything with more than one operator.

COBOL's optional ROUNDED phrase on an arithmetic statement explicitly requests standard rounding to the destination field's declared decimal places, rather than silent truncation — a control financial-precision COBOL code reaches for constantly and Pascal has no dedicated phrase for at all (Pascal would need an explicit call to Round or similar as a separate step).

Pascal's modern string type is a managed, growable string. COBOL's PIC X(20) declares a FIXED-WIDTH alphanumeric field — always exactly 20 characters, space-padded on the right if the stored value is shorter. Displaying WS-NAME after storing "Ada" prints "Ada" followed by 17 trailing spaces, not just the three letters — a real behavioral difference from Pascal's exact-length string.

Pascal's + concatenates strings directly, growing the result. COBOL's STRING ... DELIMITED BY SIZE INTO ... statement is a considerably more verbose verb-based construct — the destination must already be a fixed-width field big enough to hold the result, since COBOL strings never grow dynamically.

Pascal's array[1..5] of Integer declares a fixed-size indexed collection directly. COBOL expresses the same idea with the OCCURS n TIMES clause on a group-item field, nested one level inside a parent 01-level record — table declaration is a property attached to a field, not a standalone type the way Pascal's array is.

The structure is close — Pascal's if ... then ... else and COBOL's IF ... ELSE ... END-IF both branch on a condition. COBOL requires the explicit scope terminator END-IF in modern free-format style (older fixed-format COBOL relied on the period instead), where Pascal uses begin...end blocks only when a branch has more than one statement.

Pascal's case...of and COBOL's EVALUATE...WHEN are close structural cousins — both match ordinal/discrete values against a chain of alternatives with a catch-all (Pascal's else, COBOL's WHEN OTHER). COBOL's EVALUATE is notably more powerful: it can also evaluate multiple conditions simultaneously (EVALUATE TRUE ALSO ...), something Pascal's single-value case cannot express at all.

Pascal's for counter := 1 to 5 do always steps by exactly 1 (or -1 with downto), with no step-size option at all. COBOL's PERFORM VARYING ... FROM ... BY ... UNTIL ... spells out the initial value, the step size, and the exit condition explicitly — considerably more verbose, but able to step by any amount, something Pascal's dedicated for cannot do without falling back to a while loop.

Pascal's while condition do continues WHILE the condition is true. COBOL's PERFORM UNTIL condition is phrased the opposite way — it continues UNTIL the condition becomes true — so translating requires inverting the condition (count < 5 becomes WS-COUNT >= 5), a small but easy-to-miss gotcha when porting logic between the two languages.

A Pascal procedure is a distinct named unit, declared before use, with its own scope for local variables. A COBOL paragraph is just a label (GREET.) in the PROCEDURE DIVISION followed by statements running to the next label — there is no separate declaration section, no local scope of its own, and no formal parameter list at all.

This is the biggest structural gap between the two languages' procedural models. A Pascal procedure declares exactly which arguments it only reads (plain value parameters, passed by value) and which it can modify (var parameters, passed by reference) — the compiler enforces this contract at every call site. A standard COBOL paragraph takes NO PARAMETERS AT ALL: COMPUTE-AREA simply reads and writes WS-RADIUS and WS-AREA because they happen to be global WORKING-STORAGE fields already in scope. Nothing but a comment or naming convention documents which fields a given paragraph touches.

COBOL's PERFORM STEP-ONE THRU STEP-TWO runs every paragraph from STEP-ONE through STEP-TWO in the order they are physically written in the source file — a genuinely new idea for a Pascal programmer, since Pascal calls procedures individually by name and has no notion of a contiguous "range" of them determined by source position rather than an explicit list.

Pascal functions are user-defined: Square is declared with its own body and return type, and Pascal has no restriction on writing arbitrary custom functions. COBOL DOES support user-defined paragraphs returning values indirectly (via a global field), but its FUNCTION keyword specifically invokes one of a fixed, built-in set of INTRINSIC functions (FUNCTION MOD, FUNCTION SQRT, FUNCTION UPPER-CASE, and dozens more) — closer to Pascal's built-in Sqrt/Round than to a general user-defined function mechanism.

This is a genuinely close structural match. Pascal's record groups named, typed fields under one type; COBOL's hierarchical level-number structure does the same thing — a parent 01 WS-PERSON group item containing child 05-level elementary fields, accessed by name (WS-NAME, WS-AGE) exactly like person.Name/person.Age. The numbering (01, 05, 10, ...) encodes nesting depth instead of Pascal's explicit record...end block syntax.

Pascal's writeln takes explicit width/precision formatting directives per value (price:0:2 means "0 width, 2 decimal places"). COBOL's DISPLAY needs no formatting directive at all for a PICTURE-typed field — the field's own PIC clause already fully determines how many digits and decimal places print, since that shape was fixed at declaration time.

Pascal's string holds exactly the characters assigned to it — [Al] prints with no padding. COBOL's PIC X(10) field is ALWAYS exactly 10 characters wide; storing "Al" pads the remaining 8 positions with spaces, so DISPLAY "[" WS-NAME "]" prints [Al ] — 8 trailing spaces before the closing bracket, a genuine surprise for anyone assuming a "string" behaves like Pascal's exact-length one.

This is not accidental verbosity — it is COBOL's explicit design goal. COBOL (COmmon Business-Oriented Language) was deliberately designed by its 1959 committee to read like an English-language specification a non-programmer manager could review and approve, not to be terse for the programmer writing it. Pascal, designed a decade later for teaching structured programming, optimizes for a programmer's clarity and brevity instead — a genuine difference in design priorities, not merely a difference in syntax.