SlimeJCL — JCL → Spring Batch Transpiler
A SlimeNENC companion product. Carries COBOL-batch’s essential JCL counterpart through a bit-exact migration to Spring Batch / Workflow, leveraging maximum reuse of SlimeNENC IP.
Even if you bit-exactly transpile COBOL to Java with SlimeNENC, leaving JCL (job startup, I/O, scheduling) to the customer balloons the project from 6 months to 18 months, and SlimeNENC’s bit-exact claim collapses the moment the JCL side behaves differently. SlimeJCL closes that gap by bit-exactly migrating JCL into Spring Batch — achieving “migration project complete in one toolchain.”
A SlimeNENC-family tool that moves legacy code into a modern language without changing its meaning. A hand rewrite quietly drifts and causes incidents; SlimeNENC doesn't interpret meaning — it copies only the "skeleton" (structure), so the computed results stay identical to the original. It proves the behaviour first, so migration anxiety disappears. It copies only what it can, honestly, and isolates what it can't.
Hand rewrites drift on subtle numeric/exception differences (boundary conditions), and verifying that (old-vs-new testing) costs enormous labour. SlimeNENC faithfully mirrors language-specific traps, proves "zero divergence" via differential testing, backed by an independent reference implementation. The deliverable is a machine-checkable "certificate of behavioural invariance," not human UAT. No overstating; what it can't do isn't hidden.
Source is projected onto a Slot IR (language-independent structural intermediate form) and transcribed structure-preserving into the target. The statically-determined core is made bit-exact; dynamic, state-dependent parts are honestly isolated (isolate, don't confabulate). Backed by differential fuzzing plus formal methods where applicable, with deterministic verification a third party can reproduce locally.
Projection (π) of source as unique structure, not semantics. Primitives are modelled rigorously in bit-vector theory and formally verified over all inputs; composition/loops are covered by Csmith-style differential fuzzing — a two-tier guarantee. Non-reproducible computation (float/parallel/AI) goes to tier-③: meaning-equivalence + convergence + residual. "Where there is form, prove it in bytes; where there is none, in meaning. Lie on neither face."
📋 "Ask your AI at this level" copies this page's explanation with an instruction matched to the level you picked. Paste it into your own AI (Claude · GPT · Gemini · Grok) to dig deeper at that resolution.
SlimeJCL is an upsell-only product offered under the precondition of an active SlimeNENC license. It is technically and IP-wise designed around SlimeNENC integration, and we do not offer SlimeJCL as a standalone product. If you do not yet have a SlimeNENC license, please consider SlimeNENC first.
Key targets (Phase 4 GA goals)
(looser than SlimeNENC Subset A’s 100.000% due to JCL syntax diversity)
IBM z/OS / Fujitsu FNJCL / Hitachi VOSJCL / NEC ACOS NCRP
Already in SlimeNENC corpus (CBSA + carddemo + Defects Suite + Portfolio + BankDemo)
Reuses SlimeNENC Subset A’s 9-stage architecture
One row in lex-prefix map + 5-10 attribute keywords (parser unchanged)
SlimeNENC’s S2-S5/S7-S8 stages reused for JCL
Relationship with SlimeNENC — Three-stage rocket
| Tier | Product | Precondition |
|---|---|---|
| 1 | SlimeNENC (Subset A: cross-language transpilation) | None — new customers OK |
| 2 | SlimeNENC + PSDP (Subset B: within-language parallelization) | SlimeNENC license |
| 3 | SlimeJCL (this product) | Active SlimeNENC license required |
land-and-expand:
[Year 1] Land with SlimeNENC — COBOL → Java migration [Year 1.5-2] Upsell SlimeJCL — JCL → Spring Batch, completing the COBOL+JCL pair [Year 2+] Apply PSDP — bit-exact parallelization shortens the nightly batch window ↓ Cloud-native (Spring Batch → AWS Step Functions / Airflow)
JCL Slot IR design — maximum reuse of SlimeNENC IP
Following SlimeNENC Subset A’s Slot IR (Core64 + Ext32) philosophy, JCL is normalized into a language-agnostic intermediate representation:
| JCL syntax | Slot ID | Description |
|---|---|---|
//<jobname> JOB ... | JCL-JOB | Job declaration (CLASS, MSGCLASS, TIME, NOTIFY, COND, etc.) |
//<step> EXEC PGM=<prog> | JCL-EXEC-PGM | Program execution step |
//<step> EXEC PROC=<proc> | JCL-EXEC-PROC | Procedure invocation |
//<dd> DD DSN=... | JCL-DD-DSN | Dataset reference (DISP/UNIT/VOL/SPACE/DCB) |
//<dd> DD SYSOUT=... | JCL-DD-SYSOUT | Spool output |
// JCLLIB ORDER=... | JCL-LIB | Procedure library reference |
// SET name=value | JCL-SET-VAR | Symbolic parameter setting |
// IF cond THEN / ENDIF | JCL-IF | Conditional execution (z/OS extension) |
Each Slot is Core48 + Ext16 = 64 bits, providing audit-chain compatibility with SlimeNENC.
9-stage pipeline (JS1-JS9)
SlimeNENC Subset A’s 9-stage architecture is reused for JCL; new implementation is limited to the emitter (JS6) and per-dialect lexer:
(integrated with SlimeNENC)
(DD shuffle, etc.)
Four major JCL dialect fingerprints
JCL dialect differences are concentrated in line-leading prefixes plus attribute keywords (no parser-wide variance like COBOL). Cost to add a new dialect: one row in the lex-prefix map + 5-10 attribute keywords (~30 minutes, parser unchanged).
| Dialect | Primary markers | Calibration state |
|---|---|---|
| IBM z/OS JCL | // <name> JOB ... (// + space), EXEC PGM=, EXEC PROC=, DD DSN=, DD SYSOUT=, JCLLIB ORDER=, &SYSUID, IEFBR14, SYSIN DD *, terminator /* /& | ✅ Most of the 233 existing files are IBM z/OS; bit-exact validation planned in Phase 4-3 |
| Fujitsu FNJCL (NetCOBOL) | /JOB (single slash, distinct from IBM’s //), /EXEC PGM=, /DD DSN=, /PROC, /AIM ... (Fujitsu transaction base) | △ Public-spec based, calibration via PoC in progress |
| Hitachi VOSJCL | \JOB (backslash), \EXEC PGM=, \FD file definition, KFSB*****-{E,I,W} message-ID convention, \TRN ... for OpenTP1 | △ Public-spec based, calibration via PoC in progress |
| NEC ACOS JCL (NCRP) | \$JOB or ;;JOB, \$EXEC PGM=, \$DD / \$FD, NCRP mentions | △ Public-spec based, calibration via PoC in progress |
Note: the prefix on the JOB line discriminates dialects with ~99% accuracy; the remaining 1% is settled by attribute patterns (CLASS/DISP keyword sets). Mirroring SlimeNENC’s 14-value dialect-detect, dialect-transpile coverage centers on IBM z/OS; Fujitsu/Hitachi/NEC are at the fingerprint stage with PoC-based conversion calibration in progress.
Spring Batch translation map (key entries)
| JCL syntax | Spring Batch equivalent |
|---|---|
// JOB CLASS=A,MSGCLASS=X,TIME=1440 | @Bean public Job <name>Job() + JobParameter("class", "A") + timeout config |
// EXEC PGM=COBOL_PGM | Step + Tasklet calling CobolPgm.main() (transpiled by SlimeNENC) |
// EXEC PROC=MYPROC | JobBuilder.flow().next(myProcSteps) |
// DD DSN=PROD.FILE,DISP=SHR | FlatFileItemReader + RandomAccessFile mode |
// DD DSN=PROD.OUT,DISP=(NEW,CATLG,DELETE) | FlatFileItemWriter + AfterJob listener |
// DD SYSOUT=* | Logback appender |
// DD * (instream) | String literal in @Bean |
COND=(8,LT) | JobExecutionDecider (evaluates prior-step exit code) |
// JCLLIB ORDER=PROD.PROCS | @Configuration class scan path |
// SET HLQ=AWS.M2 | @Value("${jcl.hlq:AWS.M2}") |
&SYSUID | System.getProperty("user.name") |
IEFBR14 (NULL prog) | () -> RepeatStatus.FINISHED (no-op tasklet) |
Existing validation corpus (no separate ingest required)
The validation JCL corpus for SlimeJCL is already in the SlimeNENC corpus — 233 files (bundled with COBOL repos cloned during Phase 1+2):
| IBM CBSA | 102 files (EPL 2.0, IBM’s official banking sample with CICS+DB2+BMS) |
|---|---|
| AWS carddemo | 55 files (Apache 2.0, official AWS Mainframe Modernization) |
| Defects Suite | 49 files (MIT, paired JCL for each .CBL) |
| Portfolio Mgmt | 15 files (sentientsergio, IBM z/OS extensions) |
| Rocket BankDemo | 12 files (Rocket EULA, internal QA only) |
| Total | 233 files, of which 221 are in the publicly distributable layer |
Typical use cases
| Financial batches | Migrate nightly core-banking batches bit-exactly with SlimeNENC (COBOL → Java) + SlimeJCL (JCL → Spring Batch) as a pair. Single-toolchain delivery cuts effort by ~50% while preserving an end-to-end audit-chain trail. |
|---|---|
| Cloud migration | For z/OS → AWS Mainframe Modernization / IBM Cloud / Azure migrations, converting the JCL side to Spring Batch makes the workload cloud-native and container-runnable. |
| Cron / Workflow migration | Spring Batch becomes the bridge to Apache Airflow / Argo Workflow / AWS Step Functions, enabling staged migration from SlimeJCL output. |
| Audit-grade batch consolidation | The full transformation chain (JCL → Spring Batch + COBOL → Java) is integrated into the SlimeNENC audit chain, allowing auditors to re-verify after the fact. |
Availability / Pricing
| Targeted GA | 2026-Q3 (after Phase 4-1 through 4-5 completion) |
|---|---|
| License model | Annual add-on attached to a SlimeNENC license (no standalone sale) |
| Indicative price | 30-50 % of the SlimeNENC base license fee (subject to market validation, finalized at GA) |
| Migration PoC | SlimeNENC + SlimeJCL paired PoC available as a separate professional service |
| Pre-orders | Pre-orders open in 2026-Q2 to existing SlimeNENC customers (priority allocation slots) |
Phase 4 roadmap
- Phase 4-1 (1 month)Implement JS1 JCL Lex (IBM z/OS), achieve 100% lex-pass on all 233 files, finalize Slot IR schema
- Phase 4-2 (2 months)JS6 Spring Batch emitter scaffold; convert 50 of 233 files to Spring Batch; measure javac PASS rate
- Phase 4-3 (3 months)Bit-exact comparison framework (JCL job execution vs Spring Batch execution); reach 99.95%+ on all 233 files
- Phase 4-4 (4-5 months)Add Fujitsu/Hitachi/NEC JCL dialect lexers (PoC calibration); audit-chain integration; Mini-PSV application
- Phase 4-5 (6 months)Public benchmark (CBSA + carddemo JCL converted via SlimeJCL with end-to-end behavior validation); productize for sales; GA
Related products
Pre-order (existing SlimeNENC customers) See SlimeNENC (Subset A) See PSDP (Subset B) See other products