Submitting Jobs from ISPF: Edit Member → Submit & JCL Templates

Submitting batch jobs from ISPF is a fundamental skill for mainframe operations. You create or edit JCL (Job Control Language) members, then submit them for batch processing. ISPF provides integrated job submission capabilities, making it easy to submit jobs directly from the editor. Understanding job submission and JCL templates helps you work efficiently with batch processing. This tutorial covers editing JCL members, submitting jobs, using JCL templates, and best practices.

Job submission from ISPF streamlines the batch job workflow. Instead of using separate tools, you can edit and submit jobs within the same ISPF session. JCL templates provide reusable patterns for common job types, saving time and ensuring consistency. This tutorial provides practical guidance for job submission in ISPF.

Understanding Job Submission

Job submission sends JCL to the job entry subsystem for batch processing.

What is Job Submission?

Job submission is the process of sending a JCL job to the job entry subsystem (JES) for batch processing. When you submit a job:

• JCL is sent to JES
• Job receives a job ID
• Job enters the job queue
• Job is processed according to class and priority
• Job output is generated

Job Submission Workflow

The typical workflow for submitting jobs:

• Create or edit JCL member
• Review JCL for correctness
• Submit the job using SUBMIT command
• Note the job ID
• Monitor job status
• Review job output

Editing JCL Members

Before submitting, you need to create or edit JCL members.

Creating a JCL Member

To create a new JCL member:

• Select Option 2 (Edit) from ISPF Primary Option Menu
• Enter PDS name and new member name
• ISPF opens editor for new member
• Enter JCL statements
• Save the member

Editing Existing JCL

To edit an existing JCL member:

• Select Option 2 (Edit)
• Enter PDS name and member name
• ISPF opens editor with existing JCL
• Make modifications
• Save changes

Basic JCL Structure

A basic JCL job includes:

1
2
3
4
5
6
7
8
9
10
11
//JOBNAME  JOB (ACCT),'JOB DESCRIPTION',CLASS=A,MSGCLASS=X
//STEP1    EXEC PGM=PROGRAM
//SYSPRINT DD   SYSOUT=*
//SYSIN    DD   *
  Input data here
/*
//STEP2    EXEC PGM=ANOTHER
//INPUT    DD   DSN=USERID.DATASET.NAME,DISP=SHR
//OUTPUT   DD   DSN=USERID.OUTPUT.NAME,DISP=(NEW,CATLG),
//            SPACE=(TRK,(10,5)),DCB=(RECFM=FB,LRECL=80)
/*

This shows a basic JCL structure with JOB statement, EXEC statements, and DD statements.

Submitting Jobs

ISPF provides several ways to submit jobs.

Using SUBMIT Command

The primary way to submit a job is using the SUBMIT command:

• While editing a JCL member, type SUBMIT (or SUB) on the command line
• Press Enter
• ISPF submits the job and displays job ID
• Job is sent to JES for processing

Example:

1
Command ===> SUBMIT

After submission, ISPF displays something like:

1
SUBMIT JOB(JOB12345) SUBMITTED

SUBMIT Line Command

You can also use SUBMIT as a line command:

• Type SUB on a specific line
• ISPF submits from that line
• Useful for submitting specific job steps

Submit from Command Line

You can also submit from TSO command line:

1
SUBMIT 'USERID.SOURCE.JCL(MEMBER)'

This submits a JCL member directly without opening the editor.

Submit Multiple Jobs

You can submit multiple jobs by:

• Submitting multiple JCL members sequentially
• Creating a JCL with multiple JOB statements
• Using SUBMIT command multiple times
• Submitting from command line in a loop

JCL Templates

JCL templates provide reusable patterns for common job types.

What are JCL Templates?

JCL templates are pre-written JCL patterns that you can copy and customize for specific jobs. Templates include:

• Common JCL structures
• Standard job parameters
• Frequently used DD statements
• Common job patterns
• Best practice examples

Creating Templates

To create JCL templates:

• Create a PDS for templates (e.g., USERID.TEMPLATES.JCL)
• Create template members for different job types
• Include placeholders for customization
• Document template usage
• Organize templates by job type

Common Template Types

Common JCL template types include:

• Compile Jobs: For compiling programs
• Copy Jobs: For copying datasets
• Sort Jobs: For sorting data
• Utility Jobs: For utility operations
• Application Jobs: For specific applications

Example Compile Template

Example COBOL compile template:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//COMPILE  JOB (ACCT),'COBOL COMPILE',CLASS=A,MSGCLASS=X
//COMP     EXEC PGM=IGYCRCTL
//STEPLIB  DD   DSN=COBOL.COMPILER.LIB,DISP=SHR
//SYSLIB   DD   DSN=USERID.COPYLIB,DISP=SHR
//SYSIN    DD   DSN=USERID.SOURCE.COBOL(&MEMBER),DISP=SHR
//SYSLIN   DD   DSN=USERID.LOAD(&MEMBER),DISP=(NEW,CATLG),
//            SPACE=(TRK,(5,2)),DCB=(RECFM=FB,LRECL=80)
//SYSPRINT DD   SYSOUT=*
//SYSUT1   DD   SPACE=(CYL,(1,1))
//SYSUT2   DD   SPACE=(CYL,(1,1))
//SYSUT3   DD   SPACE=(CYL,(1,1))
//SYSUT4   DD   SPACE=(CYL,(1,1))
//SYSUT5   DD   SPACE=(CYL,(1,1))
//SYSUT6   DD   SPACE=(CYL,(1,1))
//SYSUT7   DD   SPACE=(CYL,(1,1))
/*

This template can be copied and customized with specific member names and datasets.

Example Copy Template

Example dataset copy template:

1
2
3
4
5
6
7
8
9
10
//COPY     JOB (ACCT),'COPY DATASET',CLASS=A,MSGCLASS=X
//STEP1    EXEC PGM=IEBCOPY
//SYSPRINT DD   SYSOUT=*
//INDD     DD   DSN=&INDSN,DISP=SHR
//OUTDD    DD   DSN=&OUTDSN,DISP=(NEW,CATLG),
//            SPACE=(TRK,(10,5)),DCB=(RECFM=FB,LRECL=80)
//SYSIN    DD   *
  COPY INDD=INDD,OUTDD=OUTDD
/*
/*

This template uses symbolic parameters (&INDSN, &OUTDSN) that you replace with actual dataset names.

Using Templates

To use a JCL template:

• Copy the template member to a new member
• Edit the new member with job-specific values
• Replace placeholders with actual values
• Review and customize as needed
• Submit the customized job

Job Submission Best Practices

Following best practices helps you submit jobs effectively:

• Review JCL Before Submission: Check JCL for errors before submitting
• Use Meaningful Job Names: Use descriptive job names
• Set Appropriate Job Classes: Use correct job classes for your jobs
• Use Templates: Leverage JCL templates for consistency
• Document Customizations: Document any template customizations
• Monitor Job Status: Check job status after submission
• Review Job Output: Always review job output for errors
• Test in Test Environment: Test jobs before production submission

Job Monitoring

After submission, monitor job status and output.

Checking Job Status

To check job status:

• Use SDSF (System Display and Search Facility)
• Type "SDSF" at TSO command line
• View job status in SDSF panels
• Check job output datasets
• Review job logs

Viewing Job Output

To view job output:

• Use SDSF to view output
• Browse output datasets
• Check SYSOUT datasets
• Review error messages
• Verify job completion

Common Job Submission Scenarios

Common scenarios for job submission.

Submitting a Compile Job

To submit a compile job:

• Edit or create JCL member with compile statements
• Specify source dataset and member
• Specify output load library
• Review JCL for correctness
• Submit using SUBMIT command
• Monitor compile status
• Review compile output

Submitting a Copy Job

To submit a copy job:

• Create JCL with copy utility (IEBCOPY, etc.)
• Specify input and output datasets
• Set appropriate parameters
• Submit the job
• Verify copy completed successfully

Submitting Multiple Related Jobs

To submit multiple related jobs:

• Create JCL with multiple JOB statements
• Or submit multiple JCL members sequentially
• Use job dependencies if needed
• Monitor all jobs
• Verify all jobs completed

Troubleshooting Job Submission

Common issues and solutions.

Job Not Submitted

If job is not submitted:

• Check JCL syntax for errors
• Verify JCL member exists
• Check for authorization issues
• Review error messages
• Verify JES connectivity

Job Fails Immediately

If job fails immediately:

• Check JCL syntax
• Verify dataset references
• Check job class validity
• Review JES error messages
• Check job parameters

Job in Hold Status

If job is in hold status:

• Check job class availability
• Verify job parameters
• Check for resource constraints
• Review hold reasons
• Release hold if appropriate

Explain Like I'm 5: Submitting Jobs

Think of submitting jobs like sending a letter through the mail:

• Editing JCL is like writing a letter with instructions. You write down what you want the computer to do (like "compile this program" or "copy this file"). It's like writing a recipe that tells the computer exactly what steps to follow!
• Submitting is like putting your letter in the mailbox. When you submit a job, you're sending your instructions to the computer's job processing system. The system takes your letter (JCL) and processes it according to your instructions. It's like mailing your recipe to a kitchen that will follow it!
• Job ID is like a tracking number for your letter. After you mail it, you get a tracking number so you can check where it is. The job ID lets you check on your job to see if it's running, completed, or if there were any problems. It's like having a tracking number for your recipe!
• JCL Templates are like form letters. Instead of writing a letter from scratch every time, you can use a template that has the basic structure already written. You just fill in the specific details (like names or dates) and send it. It's like having a recipe template where you just change the ingredients!

So submitting jobs is like sending instructions to the computer through a special mail system, and you can use templates to make it faster and easier!

Practice Exercises

Complete these exercises to reinforce your understanding of job submission:

Exercise 1: Create and Submit a Simple Job

Practice basics: create a simple JCL member, write basic JCL statements, submit the job, verify job ID, and understand basic submission. Master basic job submission.

Exercise 2: Create a JCL Template

Practice templates: create a JCL template for a common job type, include placeholders, document the template, and understand template structure. Master template creation.

Exercise 3: Use a Template

Practice usage: copy a template to a new member, customize it with specific values, submit the customized job, and understand template usage. Master template usage.

Exercise 4: Submit Multiple Jobs

Practice multiple: submit multiple JCL members, understand job queue, monitor multiple jobs, and learn multiple submission. Master multiple job submission.

Exercise 5: Monitor Job Status

Practice monitoring: submit a job, check job status using SDSF, view job output, understand job states, and learn job monitoring. Master job monitoring.

Related Concepts