Lenguaje de control de trabajos

Tanto en DOS como en OS, la unidad de trabajo es la tarea . Una tarea consta de uno o varios pasos, cada uno de los cuales es una solicitud para ejecutar un programa específico. Por ejemplo, antes de la llegada de las bases de datos relacionales , una tarea para generar un informe impreso para la gerencia podría constar de los siguientes pasos: un programa escrito por el usuario para seleccionar los registros apropiados y copiarlos a un archivo temporal ; ordenar el archivo temporal según el orden requerido, generalmente utilizando una utilidad de propósito general; un programa escrito por el usuario para presentar la información de manera que sea fácil de leer para los usuarios finales e incluya otra información útil, como subtotales; y un programa escrito por el usuario para formatear las páginas seleccionadas de la información del usuario final para su visualización en un monitor o terminal.

Tanto en DOS como en OS JCL, la primera "tarjeta" debe ser la tarjeta JOB, que: ^{[ 10 ]}

• Identifica el trabajo.
• Normalmente proporciona información para que el departamento de servicios informáticos pueda facturar al departamento de usuarios correspondiente.
• Define cómo se debe ejecutar el trabajo en su conjunto, por ejemplo, su prioridad en relación con otros trabajos en la cola.

Los procedimientos (comúnmente llamados procs ) son JCL preescritos para pasos o grupos de pasos que se insertan en un trabajo. Ambos JCL permiten el uso de dichos procedimientos. Los procs se utilizan para repetir pasos que se usan varias veces en un mismo trabajo o en varios trabajos diferentes. Ahorran tiempo al programador y reducen el riesgo de errores. Para ejecutar un procedimiento, basta con incluir en el archivo JCL una única "tarjeta" que copia el procedimiento desde un archivo específico y lo inserta en el flujo del trabajo. Además, los procs pueden incluir parámetros para personalizar el procedimiento en cada uso.

Tanto DOS como OS JCL tienen una longitud máxima de línea utilizable de 80 caracteres, porque cuando se usaron por primera vez DOS/360 y OS/360 el método principal para proporcionar nueva entrada a un sistema informático eran las tarjetas perforadas de 80 columnas . ^{[ 11 ]} Posteriormente fue posible enviar trabajos a través de archivos de disco o cinta con longitudes de registro más largas, pero los componentes de envío de trabajos del sistema operativo ignoraban todo lo que seguía al carácter 80.

En rigor, ambas familias de sistemas operativos utilizan solo 71 caracteres por línea. Los caracteres 73 a 80 suelen ser números de secuencia de tarjeta que el sistema imprime en el informe de fin de trabajo y que son útiles para identificar la ubicación de cualquier error reportado por el sistema operativo. El carácter 72 generalmente se deja en blanco, pero puede contener un carácter no vacío para indicar que la instrucción JCL continúa en la siguiente tarjeta.

Todos los comandos, nombres de parámetros y valores deben estar en mayúsculas, excepto los nombres de archivo USS .

Todas las líneas, excepto las de entrada en flujo (ver más abajo), deben comenzar con una barra inclinada " /", y todas las líneas que procesa el sistema operativo deben comenzar con dos barras inclinadas //, siempre comenzando en la primera columna . Sin embargo, hay dos excepciones: la instrucción delimitadora y la instrucción de comentario. Una instrucción delimitadora comienza con una barra inclinada y un asterisco (* /*), y una instrucción de comentario en JCL del sistema operativo comienza con un par de barras inclinadas y un asterisco (* //*) o un asterisco en JCL de DOS.

Muchas sentencias JCL son demasiado largas para caber en 71 caracteres, pero se pueden extender a un número indefinido de tarjetas de continuación mediante:

La estructura de los tipos de tarjeta más comunes es: ^{[ 12 ]}

Tanto DOS como JCL de sistemas operativos permiten la entrada de datos en flujo, es decir, "tarjetas" que son procesadas por el programa de aplicación en lugar del sistema operativo. Los datos que se conservan durante mucho tiempo normalmente se almacenan en disco, pero antes de que el uso de terminales interactivas se generalizara, la única forma de crear y editar dichos archivos de disco era introduciendo los nuevos datos en tarjetas.

DOS y el JCL del sistema operativo tienen diferentes maneras de señalar el inicio de la entrada en flujo, pero ambos finalizan la entrada en flujo en /*la columna 1 de la tarjeta que sigue a la última tarjeta de datos en flujo. Esto hace que el sistema operativo reanude el procesamiento del JCL en la tarjeta siguiente /*. ^{[ 13 ]}

• JCL del sistema operativo: Las sentencias DD se pueden usar para describir datos en flujo, así como conjuntos de datos. Una sentencia DD que trata datos en flujo tiene un asterisco (*) después del identificador DD, por ejemplo //SYSIN DD *, . Las sentencias JCL se pueden incluir como parte de los datos en flujo usando las sentencias DD DATA.

Un operando llamado DLM permitía especificar un delimitador (el valor predeterminado es "/*"). Especificar un delimitador alternativo permite que JCL se lea como datos, por ejemplo, para copiar procedimientos a un miembro de la biblioteca o para enviar un trabajo al lector interno .

• Un ejemplo ^{[ 14 ]} que envía un trabajo al Lector Interno ( INTRDR ) y luego elimina dos archivos es:

// SUBM EXEC PGM = IEBGENER // SYSPRINT DD SYSOUT = Z // SYSUT2  DD SYSOUT = ( A , INTRDR ) // SYSIN  DD DUMMY // SYSUT1  DD DATA , DLM = ZZ // RUNLATR JOB ACCT , MANIX , CLASS = A . TYPRUN = HOLD //* ^ un TRABAJO para ejecutar más tarde // CPUHOG EXEC PGM = PICALC1K // SALIDA  DD DSN = PICALC .1000 DGTS , ESPACIO = ( TRK , 1 ), DISP = (, MANTENER ) ZZ //* ^ como se especifica en DLM=ZZ // DROPOLDR EXEC PGM = IEFBR14 // DELETE4  DD DSN = PICALC .4 DGTS , DISP = ( ANTIGUO , ELIMINAR ) // DELETE5  DD DSN = PICALC .5 DGTS , DISP = ( ANTIGUO , ELIMINAR )

1. El programa llamado PICALC1K esperará a que se libere manualmente (TYPRUN=HOLD).
2. El programa llamado IEFBR14 se ejecutará AHORA y, una vez finalizado, se eliminarán los dos archivos existentes, PICALC.4DGTS y PICALC.5DGTS.

• JCL de DOS: Simplemente introduzca los datos en el flujo después de la tarjeta EXEC del programa.

Fred Brooks , quien supervisó el proyecto OS/360 en el que se creó JCL, lo calificó como "el peor lenguaje de programación jamás ideado por nadie, en ningún lugar" en The Design of Design , donde lo usó como ejemplo en el capítulo "Cómo se equivocan los diseñadores expertos". ^{[ 15 ]} Atribuyó esto a la incapacidad de los diseñadores para darse cuenta de que JCL es, de hecho, un lenguaje de programación.

Gran parte de la complejidad de JCL de los sistemas operativos, en particular, se deriva de la gran cantidad de opciones para especificar la información de los conjuntos de datos . Mientras que los archivos en sistemas operativos tipo Unix se abstraen en flujos ordenados de bytes, y la tarea de leer y escribir datos estructurados corresponde exclusivamente a los programas de nivel de usuario (que, en última instancia, ingieren y emiten dichos flujos), y los detalles prácticos del almacenamiento y acceso a los datos son gestionados en gran medida por el sistema operativo sin el conocimiento de los programas de usuario; los conjuntos de datos en OS/360 y sus sucesores exponen sus tipos y tamaños de archivo, tipos y longitudes de registro, tamaños de bloque, información específica del dispositivo, como la densidad de la cinta magnética , e información de etiquetas. Aunque existen valores predeterminados del sistema para muchas opciones, aún queda mucho por especificar por parte del programador, mediante una combinación de JCL e información codificada en el programa. Cuanta más información se codifique en el programa, menos flexible será, ya que la información del programa anula cualquier cosa en JCL; por lo tanto, la mayor parte de la información generalmente se proporciona a través de JCL.

Por ejemplo, para copiar un archivo en un sistema operativo Unix , el usuario introduciría un comando como este:

copiar archivoantiguo archivonuevo

El siguiente ejemplo, utilizando JCL, podría usarse para copiar un archivo en OS/360:

// IS198CPY TRABAJO ( IS198T30500 ), 'COPIAR TRABAJO' , CLASE = L , MSGCLASS = X // COPY01 EXEC PGM = IEBGENER // SYSPRINT DD SYSOUT = * // SYSUT1  DD DSN = ARCHIVO ANTIGUO , DISP = SHR // SYSUT2  DD DSN = ARCHIVO NUEVO , // DISP = ( NUEVO , CATLG , ELIMINAR ), // ESPACIO = ( CYL ,( 40 , 5 ), RLSE ), // DCB = ( LRECL = 115 , BLKSIZE = 1150 ) // SYSIN  DD DUMMY

Una segunda explicación de la complejidad de JCL radica en las diferentes expectativas para ejecutar una tarea en comparación con las que se encuentran en un PC o en un entorno tipo Unix.

• Las CPU System/360 de gama baja eran menos potentes y más caras que las PC de mediados de la década de 1980 para las que se diseñó MS-DOS  . OS/360 estaba pensado para sistemas con un tamaño mínimo de memoria de 32 KB y DOS/360 para sistemas con un mínimo de 16  KB. Una CPU 360/30 —de gama baja cuando se anunció System/360 en 1964— procesaba de 1,8K a 34,5K instrucciones por segundo. ^{[ 16 ]} La primera IBM PC en 1981 tenía 16 KB o 64 KB de memoria y procesaría alrededor de 330K instrucciones por segundo. ^{[ 17 ] [ 18} ] Como resultado, JCL tenía que ser fácil de procesar para la computadora , y ^la facilidad de uso para los programadores era una prioridad mucho menor. En esta época, los programadores eran mucho más baratos que las computadoras.  
• JCL fue diseñado para el procesamiento por lotes . Por lo tanto, debe indicarle al sistema operativo todo, incluyendo qué hacer según el resultado de cada paso. Por ejemplo, DISP=(NEW,CATLG,DELETE)significa "si el programa se ejecuta correctamente, crea un nuevo archivo y cataloga; de lo contrario, elimina el archivo nuevo". Los programas que se ejecutan en una PC a menudo dependen de que el usuario limpie los archivos después de que surjan problemas de procesamiento.
• Las máquinas System/360 fueron diseñadas para ser compartidas por todos los usuarios de una organización. Por lo tanto, la JOBtarjeta le indica al sistema operativo cómo facturar la cuenta del usuario ( IS198T30500), qué cantidad predefinida de almacenamiento y otros recursos se pueden asignar ( CLASS=L), y varias otras cosas. //SYSPRINT DD SYSOUT=*le indica a la computadora que imprima el informe del programa en la impresora predeterminada que está cargada con papel normal, no en alguna otra impresora que podría estar cargada con cheques en blanco. DISP=SHRle indica al sistema operativo que otros programas pueden leer OLDFILE al mismo tiempo .

Las versiones posteriores de los sistemas operativos DOS/360 y OS/360 conservan la mayoría de las características del JCL original , aunque se han simplificado para evitar que los clientes tengan que reescribir todos sus archivos JCL. Muchos usuarios guardan como procedimiento cualquier conjunto de instrucciones JCL que probablemente se utilice más de una o dos veces. ^{[ 19 ]}

La sintaxis de JCL del sistema operativo es similar a la sintaxis de las macros en el lenguaje ensamblador de System/360 y, por lo tanto, habría resultado familiar para los programadores en una época en la que muchos programas se codificaban en lenguaje ensamblador.

// TLBL TAPEFIL,'COPYTAPE.JOB',,,,2 // ASSGN SYS005,200 // DLBL DISKFIL,'COPYTAPE.JOB',0,SD // EXTENT SYS005,VOL01,1,0,800,1600

Los parámetros JCL de DOS son posicionales, lo que dificulta su lectura y escritura, pero facilita su análisis por parte del sistema.

• El programador debe recordar qué elemento va en qué posición en cada tipo de instrucción.
• Si se omiten algunos parámetros opcionales pero se incluyen otros posteriormente, los parámetros omitidos deben representarse mediante comas sin espacios, como en la instrucción TLBL anterior.

En cierta medida, el JCL de DOS mitiga las dificultades de los parámetros posicionales al utilizar más instrucciones con menos parámetros que el JCL del sistema operativo. En el ejemplo, las instrucciones ASSGN, DLBL y EXTENT realizan la misma función (especificar dónde se debe almacenar un nuevo archivo de disco) que una sola DDinstrucción en el JCL del sistema operativo.

En la versión original de DOS/360 y en la mayoría de las versiones de DOS/VS, era necesario especificar el número de modelo del dispositivo que se utilizaría para cada archivo de disco o cinta , incluso para los archivos existentes y los temporales que se eliminarían al finalizar el proceso. Esto significaba que, si un cliente actualizaba a un equipo más moderno, era necesario modificar muchos archivos JCL.

Los modelos posteriores de la familia DOS/360 redujeron el número de situaciones en las que se requerían los números de modelo de los dispositivos.

Originalmente, DOS/360 requería que el programador especificara la ubicación y el tamaño de todos los archivos en la tarjeta DASD . La EXTENTtarjeta especifica el volumen donde reside la extensión, la pista absoluta inicial y el número de pistas. En z/VSE, un archivo puede tener hasta 256 extensiones en diferentes volúmenes.

Cada instrucción JCL se divide en cinco campos: ^{[ 22 ]}

Campo identificador Campo nombre Campo operación Campo parámetro Campo comentarios ^ ^ ^ ^ sin espacio espacio espacio espacio

El campo Identificador debe concatenarse con el campo Nombre , es decir, no debe haber espacios entre ellos.

• Campo identificador ( //): El campo identificador indica al sistema que una instrucción es una instrucción JCL y no datos. El campo identificador consta de lo siguiente:
  • Las columnas 1 y 2 de todas las sentencias JCL, excepto la sentencia delimitadora, contienen//
  • Las columnas 1 y 2 de la instrucción delimitadora contienen/*
  • Las columnas 1, 2 y 3 de una declaración de comentario JCL contienen//*
• Campo de nombre : El campo de nombre identifica una instrucción específica para que otras instrucciones y el sistema puedan hacer referencia a ella. Para las instrucciones JCL, debe codificarse de la siguiente manera:
  • El nombre debe comenzar en la columna 3.
  • El nombre consta de 1 a 8 caracteres alfanuméricos o nacionales ( $, #, @).
  • El primer carácter debe ser alfabético.
  • El nombre debe ir seguido de al menos un espacio en blanco.
• Campo de operación : El campo de operación especifica el tipo de instrucción o, en el caso de la instrucción de comando, el comando. El campo de operación debe codificarse de la siguiente manera:
  • El campo de operación consta de los caracteres que aparecen en el cuadro de sintaxis de la instrucción.
  • La operación sigue al campo de nombre.
  • La operación debe ir precedida y seguida de al menos un espacio en blanco.
  • La operación será una de JOB, EXECy DD.
• Campo de parámetros : El campo de parámetros, también conocido a veces como campo de operando, contiene parámetros separados por comas. El campo de parámetros debe codificarse de la siguiente manera:
  • El campo de parámetros sigue al campo de operación.
  • El campo de parámetros debe ir precedido de al menos un espacio en blanco.
  • El campo de parámetros contiene parámetros que son palabras clave utilizadas en la instrucción para proporcionar información como el nombre del programa o del conjunto de datos.
• Campo de comentarios : Contiene comentarios . El campo de comentarios debe codificarse de la siguiente manera:
  • El campo de comentarios sigue al campo de parámetros.
  • El campo de comentarios debe ir precedido de al menos un espacio en blanco.

// NEWFILE DD DSN = MYFILE01 , UNIT = DISK , SPACE = ( TRK , 80 , 10 ), // DCB = ( LRECL = 100 , BLKSIZE = 1000 ), // DISP = ( NEW , CATLG , DELETE )

Todos los parámetros principales de las sentencias JCL del sistema operativo se identifican mediante palabras clave y pueden presentarse en cualquier orden. Algunos de estos contienen dos o más subparámetros, como SPACE(cuánto espacio en disco asignar a un nuevo archivo) y DCB(especificación detallada de la estructura de un archivo) en el ejemplo anterior. Los subparámetros a veces son posicionales, como en SPACE, pero los parámetros más complejos, como DCB, tienen subparámetros de palabras clave.

Los parámetros posicionales deben preceder a los parámetros de palabra clave. Los parámetros de palabra clave siempre asignan valores a una palabra clave mediante el signo igual ( =). ^{[ 23 ]}

Esta DDinstrucción se utiliza para hacer referencia a datos. Vincula la descripción interna de un conjunto de datos de un programa con los datos de dispositivos externos: discos, cintas, tarjetas, impresoras, etc. La instrucción DD puede proporcionar información como el tipo de dispositivo (por ejemplo, '181', '2400-5', 'TAPE'), el número de serie del volumen para cintas o discos y la descripción del archivo de datos, denominada DCBsubparámetro después del Bloque de Control de Datos (DCB) en el programa que se utiliza para identificar el archivo.

La información que describe el archivo puede provenir de tres fuentes: la información de la tarjeta DD, la información de la etiqueta del conjunto de datos de un archivo existente almacenado en cinta o disco, y la macro DCB codificada en el programa. Al abrir el archivo, estos datos se combinan, priorizando la información de la tarjeta DD sobre la información de la etiqueta, y la información de la DCB sobre ambas. La descripción actualizada se escribe entonces en la etiqueta del conjunto de datos. Esto puede tener consecuencias no deseadas si se proporciona información incorrecta de la DCB. ^{[ 24 ]}

Debido a los parámetros mencionados anteriormente y a la información específica para diversos métodos y dispositivos de acceso, la instrucción DD es la instrucción JCL más compleja. En un manual de referencia de IBM, la descripción de la instrucción DD ocupa más de 130 páginas, más del doble que las instrucciones JOB y EXEC combinadas. ^{[ 25 ]}

La instrucción DD permite insertar datos en línea en el flujo de trabajo. Esto resulta útil para proporcionar información de control a utilidades como IDCAMS, SORT, etc., así como para proporcionar datos de entrada a los programas.

Desde sus inicios, el JCL para la familia de sistemas operativos OS ofreció un alto grado de independencia del dispositivo. Incluso para los archivos nuevos que debían conservarse tras finalizar el trabajo, se podía especificar el tipo de dispositivo en términos genéricos, por ejemplo, UNIT=DISK, UNIT=TAPE, o UNIT=SYSSQ(cinta o disco). Por supuesto, si era necesario, se podía especificar un número de modelo o incluso una dirección de dispositivo específica. ^{[ 26 ]}

Los procedimientos permiten agrupar una o más sentencias " EXEC PGM= " y DD y luego invocarlas con " EXEC PROC= procname" -o- simplemente "EXEC procname" ^{[ 27 ]}

Una herramienta denominada Biblioteca de Procedimientos permitía almacenar previamente los procedimientos.

// PROCESO DE IMPRIMIR // EJECUTAR IMPRIMIR PGM=IEBGENER // SYSUT1  DD DSN = CEO . FILES . DAYEND . RPT24A , DISP = SHR // SYSUT2  DD SYSOUT = A // SYSIN  DD DUMMY // PEND // EJECUTAR IMPRIMIR

Los procedimientos JCL del sistema operativo se parametrizaron desde el principio, lo que los convirtió en algo parecido a macros o incluso subrutinas simples y, por lo tanto, aumentó su reutilización en una amplia gama de situaciones. ^{[ 28 ]}

// MYPROC PROC FNAME = MYFILE01 , SPTYPE = TRK , SPINIT = 50 , SPEXT = 10 , LR = 100 , BLK = 1000 ..... // NEWFILE DD DSN =& FNAME , UNIT = DISK , SPACE = ( & SPTYPE , & SPINIT , & SPEXT ), // DCB = ( LRECL =& LR , BLKSIZE =& BLK ), DISP = ( NEW , CATLG , DELETE ) ....

En este ejemplo, todos los valores que comienzan con el signo de ampersand " &" son parámetros que se especificarán cuando un trabajo solicite el uso del procedimiento. La instrucción PROC, además de darle un nombre al procedimiento, permite al programador especificar valores predeterminados para cada parámetro. Por lo tanto, se podría usar el mismo procedimiento de este ejemplo para crear nuevos archivos de diferentes tamaños y formatos. Por ejemplo:

// JOB01 JOB .......... // STEP01 EXEC MYPROC FNAME=JOESFILE,SPTYPE=CYL,SPINIT=10,SPEXT=2,LR=100,BLK=2000 o // JOB02 JOB .......... // STEP01 EXEC MYPROC FNAME=SUESFILE,SPTYPE=TRK,SPINIT=500,SPEXT=100,LR=100,BLK=5000

En trabajos de varios pasos, un paso posterior puede usar una referencia en lugar de especificar completamente un archivo que ya se ha especificado en un paso anterior. Por ejemplo:

// MYPROC ................ // MYPR01 EXEC PGM = .......... // NEWFILE DD DSN =& MYFILE , UNIT = DISK , SPACE = ( TRK , 50 , 10 ), // DCB = ( LRECL = 100 , BLKSIZE = 1000 ), DISP = ( NEW , CATLG , DELETE ) .... // MYPR02 EXEC PGM = .......... // INPUT01 DD DSN = * . MYPR01 . NEWFILE

Aquí, MYPR02se utiliza el archivo identificado como NEWFILEen el paso MYPR01( DSNsignifica "nombre del conjunto de datos" y especifica el nombre del archivo; un DSN no puede exceder los 44 caracteres ^{[ 29 ]} ).

En trabajos que contienen una combinación de JCL específico del trabajo y llamadas a procedimientos, un paso específico del trabajo puede hacer referencia a un archivo que se especificó completamente en un procedimiento, por ejemplo:

// MI TRABAJO TRABAJO .......... // PASO01 EJECUTAR MIPROC Utilizando un procedimiento // PASO02 EJECUTAR PGM = ......... Paso que es específico de este trabajo // ENTRADA01 DD DSN = * . PASO01 . MIPROCEDENTE01 . NUEVOARCHIVO

donde DSN=*.STEP01.MYPR01.NEWFILEsignifica "utilizar el archivo identificado como NEWFILEen el paso MYPR01del procedimiento utilizado por el paso STEP01de este trabajo". Usar el nombre del paso que llamó al procedimiento en lugar del nombre del procedimiento permite al programador usar el mismo procedimiento varias veces en el mismo trabajo sin confusión sobre qué instancia del procedimiento se utiliza en la referencia.

Los archivos JCL pueden ser largos y complejos, y el lenguaje no es fácil de leer. OS JCL permite a los programadores incluir dos tipos de comentarios explicativos:

• En la misma línea que una instrucción JCL. Se pueden extender colocando un carácter de continuación (convencionalmente " X") en la columna 72, seguido de " // " en las columnas 1 a 3 de la siguiente línea.
• Las líneas que contienen únicamente comentarios se utilizan a menudo para explicar los puntos principales de la estructura general del JCL, en lugar de detalles específicos. Estas líneas también se emplean para dividir archivos JCL largos y complejos en secciones.

// MYJOB JOB .......... //* Líneas que contienen solo comentarios. //******** Se usa a menudo para dividir la lista JCL en secciones ******** // STEP01 EXEC MYPROC Comentario 2 en la misma línea que la instrucción // STEP02 EXEC PGM = ......... El comentario 3 se ha extendido y X // se desborda a otra línea. // INPUT01 DD DSN = STEP01 . MYPR01 . NEWFILE

OS JCL permite a los programadores concatenar ("encadenar") archivos de entrada para que el programa los vea como un solo archivo, por ejemplo

// INPUT01 DD DSN = MYFILE01 , DISP = SHR // DD DSN=JOESFILE,DISP=SHR // DD DSN=SUESFILE,DISP=SHR

La segunda y la tercera instrucción no tienen valor en el campo de nombre, por lo que el sistema operativo las trata como concatenaciones. Los archivos deben ser del mismo tipo básico (casi siempre secuenciales) y deben tener la misma longitud de registro; sin embargo, la longitud del bloque no tiene por qué ser la misma.

En versiones anteriores del sistema operativo (ciertamente antes de OS/360 R21.8), la longitud del bloque debe estar en orden descendente, o el usuario debe inspeccionar cada instancia y agregar a la instrucción DD nombrada la longitud máxima del bloque encontrada, como en, por ejemplo,

// INPUT01 DD DSN = MYFILE01 , DISP = SHR , BLKSIZE = 800 // DD DSN=JOESFILE,DISP=SHR (BLKSIZE se asume igual o menor que 800) // DD DSN=SUESFILE,DISP=SHR (BLKSIZE se asume igual o menor que 800)

En versiones posteriores del sistema operativo (sin duda después de OS/MVS R3.7 con las "unidades seleccionables" adecuadas), el propio sistema operativo, durante la asignación, inspeccionaba cada instancia en una concatenación y la sustituía por la longitud máxima de bloque encontrada.

Una solución habitual era simplemente determinar la longitud máxima posible del bloque en el dispositivo y especificarla en la instrucción DD con nombre, como por ejemplo:

// INPUT01 DD DSN = MYFILE01 , DISP = SHR , BLKSIZE = 8000 // DD DSN=JOESFILE,DISP=SHR (BLKSIZE se asume igual o menor que 8000) // DD DSN=SUESFILE,DISP=SHR (BLKSIZE se asume igual o menor que 8000)

El objetivo de esta medida de reserva era garantizar que el método de acceso asignara un conjunto de búferes de entrada lo suficientemente grande como para albergar todos y cada uno de los conjuntos de datos especificados.

El sistema operativo espera que los programas establezcan un código de retorno que indique el grado de éxito que el programa consideró. Los valores convencionales más comunes son: ^{[ 30 ] : p.87}

• 0 = Normal - todo correcto
• 4 = Advertencia: errores o problemas menores
• 8 = Error: errores o problemas importantes
• 12 = Error grave: errores o problemas importantes, no se debe confiar en los resultados (por ejemplo, archivos o informes generados).
• 16 = Error terminal: problemas muy graves, ¡no utilice los resultados!

OS JCL se refiere al código de retorno como COND("código de condición") y puede usarlo para decidir si se ejecutan los pasos subsiguientes. Sin embargo, a diferencia de la mayoría de los lenguajes de programación modernos, los pasos condicionales en OS JCL no se ejecutan si la condición especificada es verdadera , lo que da origen al acrónimo , "Si es verdadero, continuar [sin ejecutar el código]". Para complicar aún más las cosas, la condición solo se puede especificar después del paso al que se refiere. Por ejemplo:

// MI TRABAJO TRABAJO ........... // PASO01 EJECUTAR PROGRAMA = PROG01 .... // PASO02 EJECUTAR PROGRAMA = PROG02 , COND = ( 4 , GT , PASO01 ) .... // PASO03 EJECUTAR PROGRAMA = PROG03 , COND = ( 8 , LE ) .... // PASO04 EJECUTAR PROGRAMA = PROG04 , COND = ( SOLO , PASO01 ) .... // PASO05 EJECUTAR PROGRAMA = PROG05 , COND = ( PAR , PASO03 ) ....

medio:

1. Ejecuta el programa STEP01y recopila su código de retorno.
2. No ejecute STEP02si el número 4 es mayor que STEP01el código de retorno de .
3. No ejecute STEP03si el número 8 es menor o igual que cualquier código de retorno anterior.
4. Ejecutar STEP04solo si STEP01finaliza de forma anómala.
5. Ejecutar STEP05, incluso si STEP03termina de forma anormal.

Esto se traduce en el siguiente pseudocódigo :

Ejecutar STEP01 si el código de retorno de STEP01 es mayor o igual a 4 entonces Ejecutar PASO02 fin si si algún código de retorno anterior es menor que 8 entonces Ejecutar PASO03 fin si si STEP01 terminó anormalmente entonces Ejecutar PASO04 fin si si STEP03 terminó anormalmente entonces Ejecutar PASO05 demás Ejecutar PASO05 fin si

Tenga en cuenta que, al leer los pasos que contienen CONDinstrucciones al revés, se pueden comprender con bastante facilidad. Este es un ejemplo de transposición lógica . Sin embargo, IBM introdujo posteriormente la condición IF en JCL, lo que facilitó la codificación para los programadores, manteniendo el CONDparámetro (para evitar realizar cambios en los JCL existentes donde COND parmse utiliza).

El CONDparámetro también puede especificarse en la JOBinstrucción. En ese caso, el sistema "realiza las mismas pruebas de código de retorno para cada paso de un trabajo. Si se cumple una prueba de código de retorno de la instrucción JOB, el trabajo finaliza". ^{[ 31 ]}

Los trabajos utilizan varios programas de utilidad de IBM para facilitar el procesamiento de datos. Estas utilidades son especialmente útiles en el procesamiento por lotes. Las utilidades se pueden agrupar en tres conjuntos:

• Utilidades para conjuntos de datos: cree, imprima, copie, mueva y elimine conjuntos de datos.
• Utilidades del sistema: Mantener y gestionar catálogos y otra información del sistema.
• Servicios de métodos de acceso: Procesar conjuntos de datos con y sin método de acceso de almacenamiento virtual (VSAM).

El JCL del sistema operativo es innegablemente complejo ^{[ 32 ]} y se ha descrito como "hostil para el usuario" ^{[ 33 ] [ 34 ]} . Como preguntaba un libro de instrucción sobre JCL: "¿Por qué incluso los programadores sofisticados dudan cuando se trata del lenguaje de control de trabajos?" ^{[ 35 ].} El libro afirmaba que muchos programadores copiaban tarjetas de control sin comprender realmente su funcionamiento, o "creían en los rumores generalizados de que el JCL era horrible y que solo los informáticos 'recalcitrantes' lo entendían", y delegaban la tarea de descifrar las instrucciones del JCL a otra persona ^{[ 35 ]} . Esta actitud se podía encontrar en los libros de texto de lenguajes de programación, que preferían centrarse en el lenguaje en sí y no en cómo se ejecutaban los programas. Como decía un libro de texto de Fortran IV al enumerar los posibles mensajes de error del compilador WATFOR : "¿Has sido tan insensato como para intentar escribir tus propias tarjetas de control del sistema 'DD'? Detente de inmediato; corre, no camines, en busca de ayuda" ^{[ 36 ] .}

Sin embargo, algunos libros que profundizaban en JCL enfatizaban que, una vez aprendido hasta alcanzar un nivel de competencia al menos aceptable, se obtenía libertad respecto a las configuraciones predeterminadas de la instalación y un control mucho mayor sobre cómo un sistema IBM procesaba la carga de trabajo. ^{[ 35 ] [ 32 ]} Otro libro comentaba sobre la complejidad, pero decía: «Anímense. La capacidad de JCL que obtendrán del capítulo anterior es todo lo que la mayoría de los programadores necesitarán». ^{[ 32 ]}

Una versión temprana del lenguaje de control de entrada de trabajos para la entrada remota de trabajos de OS/360 (número de programa 360S-RC-536) utilizaba el identificador en las columnas 1 y 2 del registro de entrada y consistía en una única instrucción de control: (Definición de entrada de trabajo). Los "comandos de estación de trabajo", como , , y también comenzaban con . ^{[ 37 ]} .. JEDLOGONLOGOFFSTATUS .. 

Para JES2, las sentencias JECL comienzan con /*, para JES3 comienzan con //*, excepto para los comandos remotos y . Los comandos para los dos sistemas son completamente diferentes. /*SIGNON  /*SIGNOFF 

Para VSE, las sentencias JECL comienzan con ' * $$' (nótese el espacio único ). El lenguaje de control de entrada de trabajos define las líneas de inicio y fin de los trabajos JCL. Indica a VSE / POWER cómo se maneja este trabajo. Las sentencias JECL definen el nombre del trabajo (utilizado por VSE/POWER), la clase en la que se procesa el trabajo y la disposición del trabajo (es decir D, L, , K, H).

Ejemplo:

* $$ TRABAJO JNM=NOMBRE,DISP=K,CLASE=2[algunas declaraciones de JCL aquí]* $$ EOJ