Modernization track · Core · self-paced ~30h with labs (5 days as a cohort) · prerequisite: CS105 or CS110 (can read and write a sequential-file batch program); CS120 helpful
Java 21 taught to working COBOL developers, one COBOL idea at a time, each proven against the COBOL original running on SteelFrame: PIC and COMP-3 meet int, long, String and BigDecimal; paragraphs become methods; copybooks become classes; EBCDIC and packed decimal are decoded in Java and checked field by field against the mainframe; reports, reject files and control totals come out byte-identical; JUnit and golden-file tests replace "run it and look"; SORT, SEARCH, CALL and the DB2 cursor get their honest equivalents. 50 short videos (about 6h20m) rebuilding CardDemo’s account-master print program CBACT01C as a Java AcctReport with control totals, byte for byte. Every lesson refers back to the AWS CardDemo application running live on SteelFrame — its COBOL source, batch jobs, CICS screens and VSAM/DB2 data — and every lab starts on the mainframe side: you run the legacy program under your own user to produce the golden, then make the Java match it.
Self-paced available Cohort
Open for enrollment now. The lesson videos for this course are in production — release order across the track: CS510 → CS520 → CS530 → CS521 → CS535 → CS500 → CS550 → CS525 → CS540 → CS545 — and every session below is published as its lessons and lab now and marked Coming soon until its videos are released. CS510 is first in the release order.
Plans: Free individual at no cost, or Paid individual at $349 per course, one-time — code review, extra exercises, grading and priority support.
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.
Coming soon The videos for this session are being produced; its lessons and lab are published here now.
Five videos. What transfers from COBOL (fixed layouts, read-process-write, control totals, return codes) and what does not (objects, exceptions, the JVM, a build tool instead of IGYWCL); the VS Code seat with the SteelFrame dataset tree in the same window; reading AcctReport.java the way you read CBACT01C — class as program plus WORKING-STORAGE, method as paragraph, main as the PROCEDURE DIVISION entry; javac, java and Maven, with the JAR as your load module and the classpath as your STEPLIB. Live on the system: READACCT submitted and its CBACT01C SYSOUT in SDSF beside the finished Java output, the IGYWCL compile listing beside mvn package.
LAB Checkpoint 1: fork the course repo, build it, run AcctReport against the ACCTDATA export, change the header line to your userid and prove with the equiv diff that only that line differs from your own run_capture golden of READACCT.
Coming soon The videos for this session are being produced; its lessons and lab are published here now.
Six videos. int and long sizes against PIC 9(n) — and why an account number is a String; BigDecimal scale and rounding modes reproducing ROUNDED and COBOL truncation exactly (a COMPUTE ROUNDED program run on SteelFrame beside the Java); Strings are not fixed-length — MOVE padding and truncation as helper methods, shown in hex; dates in java.time against PIC 9(8) and X(10); the cent that disappeared — a COBOL sum over ACCTDATA that keeps the cent beside the double that loses it.
LAB Checkpoint 2: CBACT01C’s balance arithmetic in Java — a Money type and the sums of current balance and credit limits over the 50 accounts — identical to your own ACCTSUM run on SteelFrame; the static rule (no float/double on money) in force from here on.
Coming soon The videos for this session are being produced; its lessons and lab are published here now.
Five videos. Methods with explicit parameters for paragraphs whose inputs were hidden in WORKING-STORAGE, and why PERFORM THRU has no equivalent; if/else, switch and loops for EVALUATE and PERFORM VARYING, with CBTRN02C’s reject ladder in EDIT; scope — which WORKING-STORAGE items become fields, locals or nothing; exceptions replacing FILE STATUS and RETURN-CODE discipline, with a FILE STATUS 35 and an S0C7 in SDSF beside the Java stack traces.
LAB Checkpoint 3: the read-until-EOF loop and CBTRN03C’s control break in Java — account subtotals and the grand total byte-identical to your TRANREPT run, the report date the one declared difference.
Coming soon The videos for this session are being produced; its lessons and lab are published here now.
Five videos. CVACT01Y as a Java record with every offset; OCCURS, REDEFINES and FILLER — arrays and lists, views over one buffer, nothing — shown in hex on the OCCURS and REDEFINES teaching variants of the account file; generating the class from the copybook with the course cpy2java tool and reviewing what it cannot know; List, Map and sorting as your in-core table, with the card-xref file as the lookup CBTRN01C needs.
LAB Checkpoint 4: AccountRecord and a fixed-width parser for the 300-byte extract — all 50 records parsed, every field equal to SteelFrame’s decode_records.
Coming soon The videos for this session are being produced; its lessons and lab are published here now.
Five videos. byte[], ByteBuffer and Charset IBM037 — the JDK decodes EBCDIC natively, shown against an IDCAMS PRINT HEX of the account file; packed decimal by hand — nibbles, the sign nibble, scale — on the COMP-3 image; zoned decimal and the overpunched sign; reading the real export_state envelope with its checksums; a byte-true reader proven field by field and round-tripped to identical bytes.
LAB Checkpoint 5: AccountBytesReader over the EBCDIC and packed images — 50/50 records, every field equal to decode_records, encode back to byte-identical files.
Coming soon The videos for this session are being produced; its lessons and lab are published here now.
Five videos. java.nio.file readers and writers for fixed-width output with try-with-resources as the CLOSE you cannot forget; report lines with an edited-picture formatter because String.format is almost right in three wrong ways, checked byte by byte against TRANREPT; error files and control totals as first-class outputs, with POSTTRAN’s 38-record reject file in BROWSE; the line endings and trailing spaces that break a byte diff, read off the equiv report.
LAB Checkpoint 6: AcctReport reproduces CBACT01C’s SYSOUT byte for byte from the EBCDIC bytes, with a totals file equal to ACCTSUM and a reject file — against your own run_capture golden.
Coming soon The videos for this session are being produced; its lessons and lab are published here now.
Five videos. JUnit 5 — a test per paragraph-equivalent, with a ZWSUNIT test deck run on CBACT01C as the mainframe-side twin; golden-file tests where the COBOL output is the expected file; the Maven lifecycle, Surefire and its report beside the IGYWCL listing; debugging in VS Code beside the SteelFrame debugger stopped in CBACT01C on the same record; JaCoCo coverage beside ZWSUNIT coverage.
LAB Checkpoint 7: 90% branch coverage of AcctReport with golden tests whose capture ids belong to your userid; mvn verify green.
Coming soon The videos for this session are being produced; its lessons and lab are published here now.
Four videos. Comparator and stable sorts as DFSORT control statements — and the EBCDIC collating order that reorders a report if you forget it, shown against a DFSORT step’s ICE054I output; Map replaces SEARCH ALL with the DISCGRP rate table and CBACT04C’s default-group fallback; streams for aggregate totals and when they hide bugs.
LAB Checkpoint 8: the 300 daily transactions sorted by card and type in EBCDIC order and decorated with their DISCGRP rate — a listing byte-identical to the course’s RATELIST program run on SteelFrame.
Coming soon The videos for this session are being produced; its lessons and lab are published here now.
Five videos. Packages, visibility and the CALLed subprogram as a class with a public method, with CSUTLDTC’s CALL and the link step’s SYSPRINT on screen; Maven coordinates beside STEPLIB and the load library in DSLIST; logging instead of DISPLAY and parameters instead of PARM=; Git — commit, branch, push to your course remote — beside the member statistics ISPF kept for you, and what the grader reads.
LAB Checkpoint 9: the helper package extracted as its own Maven module with DateUtil equal to a CSUTLDTC driver run on SteelFrame, built and pushed as one project.
Coming soon The videos for this session are being produced; its lessons and lab are published here now.
Five videos. JDBC — COTRTLIC’s cursor over TRANSACTION_TYPE becomes a ResultSet, host variables become parameters, SQLCODE becomes SQLException; the same SELECT in SPUFI and in Java, and the ORDER BY without which the two engines disagree; the diagnosis lab — five translated programs each with one seeded fault, the COBOL original’s run as the oracle; reading-check practice on an unseen program beside CBCUS01C; the capstone.
LAB Checkpoints 10–12: five broken programs fixed with their root causes named (four of five required); the 30-question reading check (80%); the capstone — AcctReport on a hidden ACCTDATA variant allocated under your user, report, totals and reject file byte-identical to your own READACCT and ACCTSUM runs, all craft rules green.
CobolStack Certificate — Java for COBOL Developers (CS510) 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 take a real COBOL batch program and re-express it in Java with identical bytes out, built by Maven and proven by JUnit against the mainframe’s own run — the bridge every modernization posting asks a COBOL developer to cross — and that a machine verified it.
Your seat is a private, full z/OS-compatible environment with the AWS CardDemo estate (COBOL, JCL, CICS/BMS, VSAM, DB2) and the SteelFrame oracle tools (run_capture, export_state, cics_run_script), beside your own Java 21 + Maven + PostgreSQL toolchain in the browser — nothing to install, snapshot and reset per exercise. By the end of the course the lab harness will have verified: twelve growth checkpoints, each mvn verify green and its output byte-identical to your own SteelFrame run of the COBOL original — from a one-line change proven by diff, through a byte-true EBCDIC/packed reader and a byte-identical CBACT01C report, to the capstone on a hidden ACCTDATA variant (report, totals and reject file identical; BigDecimal money, no float/double, every I/O exception handled, a test per paragraph-equivalent, 90% branch coverage).