Bookmark and Share
RSS

Recent Posts

sig·nif·i·cance – JES as Early Batch Middleware

October 31, 2016

It’s generally accepted that modern middleware came about because of the emergence of distributed computing systems. These new systems created a need for certain types of software that hadn’t existed before or existed mainly for internal use. This new software came about to support client-server computing. However, modern middleware software has firm roots in software that was developed for centralized computing. 

The Batch Roots of Middleware
Modern centralized computing started with support for the batch workload. Batch means collect up a bunch of work and put it through the system as a group. “Batching work” made for a more productive use the precious computer resources. The centralized computing OS developers facilitated this effort for application developers by creating a new and major subsystem, the Job Entry Subsystem (JES).
 
JES handled inputs to the OS and supported the creation of outputs to files and print. Middleware comes into this discussion through Job Control Language (JCL). JCL was a kind of centralized-computing middleware. JCL was in the middle between the application program and the OS and infrastructure. Like middleware of today, it provided a layer of abstraction to reduce complexity and improved the productivity of the programmer by providing a simple interface involving JOB, EXEC and DD statements.
 
A JCL Example
JCL improves the productivity of the application developer freeing them up from
Issuing OS commands to allocate memory and files and serialize the use of system files like output queues. Through its layer of abstraction and conventions, JCL made life simpler for the developer allowing them to focus on the logic of their application program. Here is a JCL example:
 
//IS198CPY JOB (IS198T30500),'COPY JOB',CLASS=L,MSGCLASS=X
//COPY01 EXEC PGM=IEBGENER
//SYSPRINT DD SYSOUT=*
//SYSUT1 DD DSN=IS198.TEST.INPUT,DISP=SHR
//SYSUT2 DD DSN=IS198.TEST.OUTPUT,
// DISP=(NEW,CATLG,DELETE),
// SPACE=(CYL,(40,5),RLSE),
// DCB=(LRECL=115,BLKSIZE=0),
// DATACLAS=SEQFB
//SYSIN DD DUMMY
 
JCL is elegant and simple. Consider that there are just three basic statements:

1. JOB identifies a unit of work. It tells the system (JES) how to handle it like what input queue and output queue and whom to charge for the work.
2. EXEC identifies the system or application program to run.
3. DD (there are multiples) identifies the input and output files that program named
in the execute statement will need to run.

The complexity in JCL comes with the conventions of the programs that it invokes. What are SYSUT1 SYSUT2 and SYSIN? What do these names mean? The answer comes from the utilities manual for IEBGENER, a program written by IBM to perform a utility function. Specifically, it copies the file associated with SYSUT1 to the file associated with SYSUT2. There are many other details in this simple example that can be learned quickly like how “DISP=(NEW,CATLG,DELETE)” causes the dataset to be created in real time and catalogued or deleted depending on the success of failure of the job execution. JCL has sig·nif·i·cance as it is simple, elegant and yet powerful.
 
The Story Continues
Next post, I’ll discuss how middleware also had its roots in real-time processing on centralized computers.

Posted October 31, 2016 | Permalink

comments powered by Disqus