COBOL Programming I

Program anatomy

Eight videos, each one a lesson, a live demo and your own exercise on the same environment — plus companion Q&A videos for 1.2 and 1.3 that answer the questions learners ask most. What COBOL is, where it runs today and why it is worth learning now, and the rhythm of the course: watch, follow along, do the exercise before the next video. The four divisions — IDENTIFICATION, ENVIRONMENT, DATA, PROCEDURE — as cover page, plumbing, parts list and instructions, and why the compiler cares about their order. PROGRAM-ID and how it relates to the member and load-module name; CONFIGURATION versus INPUT-OUTPUT SECTION. The coding form: sequence columns, the column-7 indicator, Area A and Area B, and the column-72 edge. Division → section → paragraph → sentence → statement, numbered paragraph names, and the stray period behind the weirdest bugs. HELLO written from an empty member, the compile → link-edit → run pipeline with return codes 0, 4, 8 and 12, and a line-by-line reading of the course’s compile-link-run JCL — you read this deck; you do not write JCL in this course. Live on the system: a hundred-line program labelled division by division, a deleted DATA DIVISION header and its compiler error, a program broken three ways across the column boundaries, a missing period and its misleading diagnostics, HELLO typed live with no copy-paste, a compile job walked from listing to load module, and one syntax error producing RC 8 and no load module.

LAB Submit the provided job and find its output. Fix a program whose division headers are shuffled. Write a minimal IDENTIFICATION + ENVIRONMENT division and read the expected failure. The Broken Column Lab: five column violations to a clean compile. Find two misplaced periods from the listing alone. Write a program that DISPLAYs your name and three lines about why you are learning COBOL — clean on the first submit. Misspell DISPLAY on purpose and record each step’s RC, the failing step and the message ID, then fix it to RC 0. Point a copy of the provided JCL at your program and get every step to RC 0. Session 1 checkpoint.

The Data Division

Nine videos on how data is declared — and what it looks like in storage. WORKING-STORAGE and level numbers, group versus elementary items, and why only elementary items get a PIC. The picture characters X, A, 9, V and S, and the one fact that prevents a hundred bugs: the V has no byte. USAGE DISPLAY (zoned, one byte per digit) versus COMP binary sized by its PIC. The flagship video: COMP-3 packed decimal nibble by nibble — +12345 is 12 34 5C, −987 is 98 7D, the sign in the last nibble, the byte-count formula, and why packed fields get odd digit counts. Then why packed decimal exists at all: binary floating point cannot hold 0.10 exactly, the hardware does decimal arithmetic directly, and the rule of thumb — money and quantities COMP-3, counters and subscripts COMP, anything displayed DISPLAY or edited. VALUE and its load-time trap, figurative constants and INITIALIZE; REDEFINES as two layouts over the same storage; 88-level condition names and SET … TO TRUE. Live on the system: 123.45 displayed as 12345, a sign nibble flipping C → D in the hex view, 9(4) and S9(5) COMP-3 sharing three bytes, 0.10 added a thousand times to exactly 100.00, a date redefined into year, month and day, and raw bytes leaking through a REDEFINES over a binary field.

LAB Build a WS-EMPLOYEE group and display its parts. A predict-then-verify worksheet of six PICs. One number declared three ways, with the sizes read from the listing’s data map. Decode four packed hex dumps by hand, then prove them in the hex view. Choose DISPLAY, COMP or COMP-3 for eight described fields and justify each. A WS-TOTALS group with an INITIALIZE reset, a phone number split by REDEFINES, and a grade field with PASSING, FAILING and PERFECT 88s. Lab 2.9, the record layout: lay out the customer account record on paper first — account, name, type code, packed balance and credit limit, status with 88s, a redefined date — total its length by hand, code it, and verify the packed fields in the hex view. That record becomes the input layout for Session 5. Session 2 checkpoint.

Moving and computing

Eight videos on moving and computing. Alphanumeric MOVE: left-justify and pad, or truncate on the right, and the group move that copies bytes with no conversion at all. Numeric MOVE: alignment on the implied decimal point, automatic conversion between DISPLAY, COMP and COMP-3 — and high-order digits lost silently: no error, wrong answer. ADD and SUBTRACT with TO versus GIVING; MULTIPLY, DIVIDE INTO versus BY, REMAINDER, and sizing intermediate results. COMPUTE and operator precedence, and when one formula beats a chain of verbs. ROUNDED (half-up at the receiving field’s precision) and ON SIZE ERROR, with the production rule: money arithmetic is rounded deliberately and every DIVIDE is protected. Edited pictures — Z, comma and period insertion, fixed and floating $, CR and DB, B, 0 and * check protection — as the last step before a line is written. Live on the system: ‘STEELFRAME’ truncated and padded, a group move producing garbage, 1234.56 moved into three shapes and the packed result hex-viewed, a precedence bug in an interest formula fixed with parentheses, 2/3 with and without ROUNDED, a divide by zero unprotected and then caught, and one value through six edited pictures side by side.

LAB Predict-then-verify five alphanumeric MOVEs, then four numeric MOVEs including one that silently loses its leading digit. Gross and net pay with ADD and SUBTRACT … GIVING. Seconds to HH/MM/SS with DIVIDE … REMAINDER. One period of compound interest checked by hand. Sales tax with ROUNDED and a unit price that survives a zero quantity. Edited output for the Session 2 record — floating $, zero suppression, CR for negatives. Lab 3.8, the pay calculator: overtime past 40 hours at 1.5×, tax ROUNDED, net pay, all packed, one neatly edited pay line — tested at 40, 45 and 0 hours. Keep it: Session 4 adds control flow. Session 3 checkpoint.

Control flow

Eight videos on control flow. IF / ELSE / END-IF with the modern rule — always END-IF, never a period-terminated IF — and CONTINUE as the explicit no-op. Relation, class, sign and condition-name tests, implied subjects and their traps, and IF NUMERIC as your first validation tool. EVALUATE with value lists, THRU ranges, WHEN OTHER and EVALUATE TRUE, where the first match wins. PERFORM as a subroutine call and the program shape that follows from it: a short 1000-MAIN performing numbered paragraphs, with GO TO shown once and then retired. Inline PERFORM, and PERFORM THRU with its EXIT paragraph — you will read it in legacy code constantly, so you learn exactly how it fails. PERFORM n TIMES, UNTIL with TEST BEFORE and TEST AFTER, the infinite loop behind a hung job, and PERFORM VARYING with the loop variable left at n+1. Live on the system: the dangling-ELSE bug silently executing the wrong branch, a non-numeric field driving arithmetic into a data exception and then stopped by a class test, a four-deep nested IF flattened into one EVALUATE, a THRU range swallowing an innocently inserted paragraph, TEST BEFORE versus TEST AFTER on a condition true at entry, and the n+1 value printed after END-PERFORM.

LAB Make the pay calculator’s overtime a clean IF / ELSE / END-IF. A validation paragraph for three fields — numeric, range by 88, non-blank — with one error line per failure. Letter grades with EVALUATE TRUE and THRU ranges. Restructure your program around a main paragraph of ten lines or fewer. Convert a THRU-style routine to single-paragraph PERFORMs with identical behaviour. Count the years until a balance doubles; print a times table, then the full 12×12 grid with VARYING … AFTER. Lab 4.8, structure + logic: five employees through the pay calculator with EVALUATE tax brackets, the 4.2 validation and a MAIN → INIT → PROCESS → TOTALS structure — clean compile, correct totals, at least one rejection shown. Session 4 checkpoint.

Sequential files

Ten videos — the longest session — on sequential files, the heart of batch. Streams of fixed-length records, LRECL, RECFM FB versus VB and blocking, and the record layout as the contract between programs. SELECT … ASSIGN names a logical DD and the JCL binds it to a physical dataset, so the same load module runs against different files with no recompile. The FD and its 01 as a window over the file buffer, with the professional pattern of a thin FD record and READ INTO / WRITE FROM a WORKING-STORAGE layout. OPEN in its four modes, CLOSE, and what an unclosed output file loses. The priming-read pattern — read once before the loop, PERFORM UNTIL end-of-file, read again at the bottom — and the double-processed last record it prevents. Read a file, write a record. Then the session’s centrepiece: FILE STATUS after every OPEN, READ, WRITE and CLOSE — 00, 10, 35, 37, 39 and the 9x family — with 88s and one shared check paragraph that reports file, operation and status and ends cleanly. Report headings, line counting, page breaks with WRITE AFTER ADVANCING, and grand totals sized one digit larger than any detail. Live on the system: an off-by-one-byte file, one program run against two datasets by changing only the DD, a missing DD, a READ before OPEN, a truncated output from a forgotten CLOSE, the naive read loop processing the last record twice, a status 35 from a missing dataset and a 39 from a lied-about LRECL reported exactly instead of abending, and a page 1 → page 2 rollover.

LAB Hand-decode the first customer record’s packed balance from the browse. SELECT/ASSIGN for CUSTIN and RPTOUT matched to the run JCL, FDs for both files, and INIT and WRAP-UP paragraphs. Read the customer file end to end with a record count that must match exactly. Write a detail line per record with an edited balance. Retrofit full FILE STATUS checking and prove it with one clean run and one sabotaged DD. Add a three-line heading block and page control, then grand totals cross-checked against your count. Lab 5.10, the complete report program: active customers only, edited money, headings and pages, totals and full status discipline over the 50-record file, self-graded against the published expected totals. It is the direct ancestor of the capstone. Session 5 checkpoint.

Tables

Seven videos on tables. OCCURS and 1-based subscripts kept in range — out of range means storage corruption or an S0C4, not a friendly message — with subscripts defined COMP. The REDEFINES-over-VALUEs idiom for a constant table, and runtime-loaded tables filled from a file behind an overflow guard, because rate and reference tables are loaded, not hard-coded. INDEXED BY and SET versus subscripts: compiler-managed offsets, and why SEARCH needs them. SEARCH for a serial lookup — SET to 1 first, and AT END as the not-found path that is never optional — and SEARCH ALL for a binary search, which trusts your ASCENDING KEY and returns wrong answers with no error if the table is not actually sorted. Multi-dimensional tables, PERFORM VARYING … AFTER, and the cross-foot check. Live on the system: a month-name table and a subscript of 13, a table load with the overflow guard firing, the same table walked by subscript and by index, a second SEARCH that misses an entry because nobody reset the index, SEARCH ALL fooled by two shuffled entries, and a region × quarter grid with row totals.

LAB A day-name table with a range check before every reference. Load the supplied packed rate file into a table and prove the overflow guard with the oversized file. Convert the loop to INDEXED BY and SET with identical output. A rate lookup with SEARCH — one hit, one miss, two in a row — then the same lookups with SEARCH ALL on the sorted file. A 4 × 3 region-by-product table cross-footed to one grand total both ways. Lab 6.7, table-driven reporting: load the rate table at INIT with its guard and FILE STATUS, SEARCH ALL each customer’s rate, compute a ROUNDED fee, report and total it, and flag unknown type codes — self-graded against published totals. Session 6 checkpoint.

Copybooks and subprograms

Coming soon Video 7.6, the lab walk-through, is coming soon — 7.1–7.5 are recorded, and the 7.6 lab spec is below.

Six videos on sharing code between programs. COPY: one layout in the copy library instead of twelve hand-typed ones, the expanded lines in the listing, COPY REPLACING for prefixes, and the rule that any layout used by two programs is a copybook. Subprograms as separately compiled units with all four divisions of their own, and CALL. USING and the LINKAGE SECTION, which describes the caller’s storage rather than allocating its own; parameters in matching order; BY REFERENCE versus BY CONTENT; and one parameter copybook shared by both sides as the professional pattern. Static CALL, link-edited into the caller — the link-edit step from Session 1 finally earns its keep — versus dynamic CALL, resolved from the load library at run time, and what shops choose. GOBACK versus STOP RUN in a subprogram, RETURN-CODE as the RC your JCL sees, and WORKING-STORAGE that persists between calls. Live on the system: a customer layout extracted to a copybook and one field change picked up by two programs, a separately compiled banner subprogram, a CALC-TAX subprogram with two USING parameters swapped into garbage and fixed with one copybook, a static load module versus a dynamic call picking up a changed subprogram without relinking (and failing when the module is gone), a STOP RUN that silences the caller, and a counter that survives three calls.

LAB Copybooks for the customer and rate records, with your 6.7 lab converted to COPY both. HELLO-SUB called three times. VALIDATE-DATE: a YYYYMMDD field and a return-code field, month 01–12 and day checked against month, tested with two good and two bad dates. Convert it to a dynamic call and capture both the working run and the module-not-found failure. Make it count its own calls, and have the main set a non-zero RETURN-CODE when a date fails. Lab 7.6, the shared-logic refactor: the 6.7 program becomes a main, two subprograms and three copybooks — fee calculation in a CALLed subprogram with a parameter copybook, dates through VALIDATE-DATE, a non-zero RC if any record is rejected — and its output must match 6.7 exactly, because a refactor changes structure, never results. Session 7 checkpoint.

Capstone: a small batch application

Coming soon The seven capstone videos (8.1–8.7) are being recorded and are coming soon; the full ACCTPOST spec and lab are published here now.

Seven videos building ACCTPOST, a small production-shaped batch application: read a transaction file, validate every record (numeric checks, account type by rate-table lookup, date by subprogram), apply a fee from the rate table, write a posting report with headings, pages and totals, write rejects to an error file with reason codes, and end RC 0, 4 or 8 by outcome — FILE STATUS discipline throughout. Reading a spec like a professional: nouns become files and layouts, verbs become paragraphs, rules become EVALUATE and IF, what-if questions become the error file. Copybooks for the transaction, error and report records — the error record carries the whole original record so rejects can be fixed and resubmitted — and a walking skeleton of four files opening and closing at RC 0 before any business logic. Layered validation with reason codes as an 88-documented set, unit-tested with a driver before it is wired in. The rate table loaded at INIT, SEARCH ALL inside validation, and a fee ROUNDED whose ON SIZE ERROR is itself a reject reason. Two output disciplines side by side, and the reconciliation rule the program checks itself: read = posted + rejected, every run. The RC contract and the edge cases — empty input, all rejects, a missing DD, an unsorted rate table — then a line-by-line code review that calls back every session, and a coursework-grade versus production-grade diff of the same program.

LAB Draw your own structure chart and file list from the spec. Build the skeleton to RC 0 with zero business logic. Driver-test your validation against the six-record set and its published reason codes. Match three hand-calculated fees to the penny. Produce the report and the error file over the 20-record test set and reconcile them to the published totals. Run all five test files and record RC and outcome for each in the test-log template — all five must match. Apply the self-review checklist and submit your final ACCTPOST with its test log. Course complete.