LEARN.COBOLSTACK.COM
//CS105  EXEC PGM=COURSE,PARM='CS105'

Developer track · Intro → Core · self-paced ~30h (4–6 weeks at 6h/week) · prerequisite: CS100

COBOL On-Ramp: Zero to a Working Batch Program

COBOL for the true beginner, taught the way the language is actually met at work: read a real program before you write one, then grow one program across twelve sessions — a DISPLAY, then data, then bytes, arithmetic, decisions, loops, a file, a report, a table, a copybook, a subprogram — until it is a real batch program with control totals. Every step compiled, run, and checked to the byte.

Self-paced available Cohort

Plans: Free individual at no cost, or Paid individual at $249 per course, one-time — code review, extra exercises, grading and priority support.

//SYLLABUS DD DISP=SHR

Syllabus

Every session ends in a lab on your own environment. Labs are machine-checked against expected outputs — you and your L&D team always know exactly where you stand.

Read before you write

A production-shaped COBOL program read top to bottom — the account-file batch program from the demo estate — with nothing skipped: IDENTIFICATION, ENVIRONMENT, DATA and PROCEDURE divisions, the coding form and why columns 8 and 12 matter, paragraphs, the read loop, where the record layout lives. How COBOL reads aloud and why that was the point in 1959. You will not write a line yet; you will learn to recognise the shape.

LAB Answer the harness’s questions about the program: which paragraph opens the file, what the record length is, where the loop ends, which FILE STATUS the program checks. All from reading.

5 videos · ~38 min
  1. 1.1 Welcome: One Program, Grown Twelve Times 7 min
  2. 1.2 The Four Divisions, Seen in a Real Program 8 min
  3. 1.3 Paragraphs, the Read Loop, and How COBOL Reads Aloud 8 min
  4. 1.4 Where the Record Layout Lives 8 min
  5. 1.5 Lab: The Reading Check, Practice Round 7 min

The pipeline: compile, link, run

What the compiler produces (the listing, the object), what the linkage editor produces (the load module in a PDS), and what the run JCL binds (DD names to datasets). Reading a listing: source with line numbers, messages, severity codes, RC 4/8/12 and what each means for whether you may run. STEPLIB, and why program-not-found is an S806.

LAB Compile a program seeded with five errors; fix each from the listing message until RC 0; run it. The harness reads your listing, not your word.

5 videos · ~40 min
  1. 2.1 Three Steps, Three Outputs 8 min
  2. 2.2 Reading a Compiler Listing 9 min
  3. 2.3 Fix the Red: Five Seeded Errors 9 min
  4. 2.4 The Run JCL: DD Names Bind to Datasets 7 min
  5. 2.5 Lab: Your Own Pipeline 7 min

Growth 1 — DISPLAY and the Data Division

Your program begins: PIC X and PIC 9, VALUE, MOVE, DISPLAY, STOP RUN. Level numbers and group items; FILLER; what a WORKING-STORAGE item physically is. The habit of naming things so the next reader — you, in six months — can read them aloud.

LAB Growth checkpoint 1: the program prints a three-line header from working storage. Output checked to the byte, including the trailing blanks you did not know you wrote.

5 videos · ~38 min
  1. 3.1 ACCTLIST Begins: The Minimal Program 7 min
  2. 3.2 WORKING-STORAGE, Level Numbers, Group and Elementary 8 min
  3. 3.3 PIC X, PIC 9, VALUE, MOVE 8 min
  4. 3.4 Naming So the Next Reader Can Read Aloud 7 min
  5. 3.5 Growth Checkpoint 1: The Header 8 min

Growth 2 — numbers are bytes

Zoned decimal and why 123 is F1F2F3; the sign overpunch; COMP-3 packed decimal nibble by nibble, all six sign nibbles; COMP binary halfword and fullword; what S9(7)V99 COMP-3 stores in five bytes. The S0C7 provoked on purpose — bad data into a packed field — and read from the dump so you never fear it again.

LAB Growth checkpoint 2: add amount fields in each storage type; hex-verify every one against the harness’s expected bytes; then cause the S0C7 and identify the offending statement from the offset.

6 videos · ~50 min
  1. 4.1 Zoned Decimal: Why 123 Is F1F2F3 8 min
  2. 4.2 COMP-3 Packed Decimal, Nibble by Nibble 10 min
  3. 4.3 COMP Binary: Halfword and Fullword 7 min
  4. 4.4 Why Packed Decimal Exists 7 min
  5. 4.5 The S0C7, Provoked on Purpose 9 min
  6. 4.6 Growth Checkpoint 2: Amount Fields, Hex-Verified 9 min

Growth 3 — arithmetic and edited output

ADD, SUBTRACT, MULTIPLY, DIVIDE and COMPUTE; intermediate precision; ROUNDED and ON SIZE ERROR and why silent truncation is the enemy; edited pictures — Z, comma, decimal point, CR/DB, floating signs — for money that reads like money.

LAB Growth checkpoint 3: interest and fee lines computed and formatted; the harness checks the cents and the rounding, both directions.

5 videos · ~40 min
  1. 5.1 ADD, SUBTRACT, MULTIPLY, DIVIDE 8 min
  2. 5.2 COMPUTE and Precedence 7 min
  3. 5.3 ROUNDED and ON SIZE ERROR 8 min
  4. 5.4 Edited Pictures: Money That Reads Like Money 9 min
  5. 5.5 Growth Checkpoint 3: Interest and Fee Lines 8 min

Growth 4 — decisions

IF/ELSE/END-IF, nested conditions and how to flatten them, EVALUATE as the decision table it really is, 88-level condition names as the readable alternative to magic values, class conditions (NUMERIC) as your first line of defence against bad data.

LAB Growth checkpoint 4: account-status classification with 88-levels and an EVALUATE, graded against a truth table of 24 cases.

5 videos · ~38 min
  1. 6.1 IF / ELSE / END-IF 7 min
  2. 6.2 Conditions: Relation, Class, Sign 7 min
  3. 6.3 88-Level Condition Names 7 min
  4. 6.4 EVALUATE: The Decision Table 8 min
  5. 6.5 Growth Checkpoint 4: Classification, 24 Cases 9 min

Growth 5 — loops and the standard skeleton

PERFORM in all its forms — paragraph, inline, TIMES, UNTIL, VARYING — and the one skeleton every batch program shares: initialise, prime, loop until end, finalise. Why GO TO is not on the syllabus. Counters and accumulators done properly.

LAB Growth checkpoint 5: the program loops over an in-storage table of five accounts and produces totals the harness checks.

5 videos · ~38 min
  1. 7.1 PERFORM: Paragraphs as Subroutines 7 min
  2. 7.2 Inline PERFORM and PERFORM THRU 7 min
  3. 7.3 TIMES, UNTIL, TEST BEFORE/AFTER 8 min
  4. 7.4 PERFORM VARYING and the n+1 Gotcha 8 min
  5. 7.5 Growth Checkpoint 5: Five Accounts in Storage 8 min

Growth 6 — the first file

SELECT/ASSIGN, the FD, OPEN/READ/CLOSE, AT END and the priming read; FILE STATUS on every I/O — the discipline that separates production code from coursework; the DD statement that binds the SELECT to a dataset; what happens when LRECL disagrees with the record (an S013 — or the silent zero-count run that is worse).

LAB Growth checkpoint 6: the program reads the real account file; record count and a control total of balances must match the harness exactly. No naked READs — the static check enforces it.

6 videos · ~50 min
  1. 8.1 Files, Records, LRECL — the Contract 7 min
  2. 8.2 SELECT/ASSIGN and the FD 8 min
  3. 8.3 OPEN, READ, AT END, CLOSE — the Priming Read 9 min
  4. 8.4 FILE STATUS: The Production Discipline 9 min
  5. 8.5 When the Record Is the Wrong Length 8 min
  6. 8.6 Growth Checkpoint 6: Count and Control Total 9 min

Growth 7 — writing: the report and the error file

WRITE and the output FD; headings, detail lines, page breaks and page counts; final totals; a second output file for records that fail validation, with a reason code, so nothing is ever silently dropped.

LAB Growth checkpoint 7: the account statement report plus an error file, both compared byte-for-byte against expected output, page breaks included.

5 videos · ~40 min
  1. 9.1 WRITE and WRITE FROM 7 min
  2. 9.2 Headings and Page Control 8 min
  3. 9.3 Totals and the Final Line 7 min
  4. 9.4 The Error File: Nothing Is Silently Dropped 8 min
  5. 9.5 Growth Checkpoint 7: Report + Error File, Byte for Byte 10 min

Growth 8 — tables and copybooks

OCCURS, subscripts, then indexes and why they differ in the bytes; SEARCH and SEARCH ALL and the sorted-table rule; two-dimensional tables. COPY: the record layout moves to a copybook and becomes a contract shared with the JCL, the VSAM cluster and the CICS screen you saw in CS100.

LAB Growth checkpoint 8: interest rates come from a rate table looked up by account type; the record layout comes from a copybook; the harness diffs your copybook against the one it expects.

6 videos · ~48 min
  1. 10.1 OCCURS and Subscripts 8 min
  2. 10.2 Loading a Table from a File 8 min
  3. 10.3 Indexes, SET, and SEARCH 8 min
  4. 10.4 SEARCH ALL and the Sorted-Table Rule 7 min
  5. 10.5 COPY: The Layout Becomes a Contract 8 min
  6. 10.6 Growth Checkpoint 8: Rate Lookup via Copybook 9 min

Growth 9 — CALL and the subprogram

Static CALL, USING, and the LINKAGE SECTION; BY REFERENCE for real; return codes between programs; how the link-edit joins two objects into one load module — and why a wrong LINKAGE picture corrupts silently instead of failing.

LAB Growth checkpoint 9: the rate calculation moves to a CALLed subprogram with its own compile; output must not change by a byte.

5 videos · ~40 min
  1. 11.1 Why Subprograms, and CALL Basics 7 min
  2. 11.2 USING and the LINKAGE SECTION 9 min
  3. 11.3 Static Link, and the Load Module Grows 7 min
  4. 11.4 GOBACK, RETURN-CODE, and Subprogram State 8 min
  5. 11.5 Growth Checkpoint 9: Refactor, Output Unchanged 9 min

Debugging and craft

Reading an abend for real: S0C7, S0C4, S013, S001, and the listing offset that points at the statement; DISPLAY as disciplined tracing; the compiler options that help and the ones that hide. A code-review checklist — FILE STATUS everywhere, no GO TO, no naked READ, names that read aloud, one paragraph one job. Restart thinking: what an operator needs from your program at 03:00.

LAB Five broken programs, five different failures; diagnose and fix each; the harness grades the fix and your one-line root-cause statement.

5 videos · ~42 min
  1. 12.1 Reading an Abend for Real 9 min
  2. 12.2 DISPLAY as Disciplined Tracing 7 min
  3. 12.3 The Code-Review Checklist 8 min
  4. 12.4 Restart Thinking: What an Operator Needs at 03:00 8 min
  5. 12.5 Diagnosis Lab: Five Broken Programs 10 min

Capstone: the program meets a dataset it has never seen

The grown program is run by the harness against a hidden input file with the edge cases production has: bad packed data, a zero balance, an account type not in the table, a page break exactly on a total line. Then where next: CS120 for the batch plumbing, CS130 to make this program keyed over VSAM, CS140 and CS150 for DB2 and CICS — or CS110 if you want the cohort intensive.

LAB Capstone run: report, error file and control totals byte-checked; static craft rules enforced; the certificate is issued from this run.

4 videos · ~34 min
  1. 13.1 The Hidden Dataset and Its Edge Cases 8 min
  2. 13.2 The Final Review 8 min
  3. 13.3 The Capstone Run 9 min
  4. 13.4 Where Next 9 min
//SKILLS  DD DSN=AFTER.THIS.COURSE

After this course, you can

//CERT    DD DSN=CS105.CERTIFICATE,DISP=(NEW,CATLG)

How the certificate is earned

CobolStack Certificate — COBOL On-Ramp (CS105) is issued from the lab harness’s own record of your runs — not from attendance. To earn it you must clear every gate below:

The certificate attests that you can read, write, compile, run and debug a complete sequential-file COBOL batch program with control totals — the COBOL + JCL + z/OS core that entry-level postings at banks, government and the outsourcers filter on — and that a machine, not an attendance sheet, verified it.

The environment

Your seat is a private, full z/OS-compatible environment with the compile-link-run pipeline, hex views and the graded lab harness in the browser — nothing to install, snapshot and reset per exercise. By the end of the course the lab harness will have verified: one program grown through twelve graded checkpoints into a complete batch application, five broken programs diagnosed and fixed, and a hidden-dataset capstone run green.