Sample Graduate COBOL course for OS/390, DB2, JCL, Utilities

Sample Graduate COBOL course (5 weeks)

Prerequisites

The COBOL Programming course is designed for entrants into the Computing Industry. There are no formal computing experience prerequisites. All students should be of degree calibre and are expected to have demonstrated an aptitude for computing.

Course objectives Top Contents Timetable

Upon successful completion, each student will be able to:
* identify the hardware which is relevant to [client]
* list the operating systems which are in use at [client]
* list the RDBMS products which are installed at [client]
* explain the meaning of common computing terminology
* describe how data is held internally
* describe the typical stages of application development
* distinguish between the common types of processing
* identify the purposes of the programming languages used at [client]
* logon to TSO
* explain how ACF2/RACF controls access to resources
* use ISPF to create a file
* use the ISPF editor
* define data structures for input and output files and print lines
* produce COBOL definitions from data structures
* describe the principal constructs of structured programming
* use schematic logic components such as SEQ, SEL, OR, ITER, END
* describe the use of cohesion and coupling in determining program module qualities
* given a program specification, produce a data structure diagram and a program structure diagram
* given a program structure diagram, produce COBOL which corresponds to the program flow and logic control
* use SDSF (or similar software) to follow the progress of a job (e.g. compilation)
* code IDENTIFICATION DIVISION entries
* code ENVIRONMENT DIVISION entries
* code SELECT statements for all types of files
* code SPECIAL-NAMES entries
* code DATA DIVISION entries for all types of data
* explain how numeric data may be stored
* code data definitions for binary, packed, and zoned numeric data
* code data definitions for elementary and group data items (structures)
* code statements which move and initialize data
* code statements which test conditions
* write statements which perform arithmetic
* specify printer files and create edited fields
* code statements which perform the common file-handling tasks
* write statements which control the flow of a program
* code data definitions for indexed and subscripted tables
* write statements which will search a table
* write statements which call a module
* code the entries needed in a called module
* use statements which manipulate strings
* code an internal SORT
* identify the parts of COBOL which are relevant to a CICS program
* use appropriate compiler options to generate useful information
* interpret compiler output
* interpret linkage editor output
* given a dump, find the cause of the failure and the contents of the relevant data entries using Xpediter
* describe how a DB2 database is held on physical storage
* list the tasks involved in implementing a DB2 application
* explain the meaning of terminology such as table and view
* state how data is arranged in a DB2 table
* describe the use of primary and foreign keys
* explain how the use of indexes can improve access to DB2 data
* describe how a DB2 program is prepared for execution
* use SQL statements such as SELECT, INSERT, UPDATE, DELETE
* use statements which combine tables
* describe the two phase commit procedure
* describe the security facilities of DB2
* access Librarian to view source code
* compile a program and interpret compilation errors via SDSF
* edit a program to fix errors
* use Xpediter to test a program
* use FileAID to create a VSAM file
* use FileAID to view the contents of a file
* use FileAID to process members of a pds
* identify commonly used JCL parameters
* correct syntax errors in job control statements
* arrange job control statements into a correct order
* code conditional JCL
* explain the significance of special DDNAMEs
* write DD statements which access datasets on disks, tapes, printers, and 'card' files
* determine, by inspecting and interpreting messages, the likely cause of errors in jobs
* use the OUTPUT statement to establish print attributes
* create in-stream and catalogued procedures
* override, nullify, and add parameters to procedures
* define and assign values to symbolic variables in procedures
* use the most common MVS utilities
* apply [client] standards to JCL statements and parameters
* describe the functions and use of DATAMANAGER
* use CA-Spool to print data on local printers
* use CA-VIEW (SAR) to specify lists of jobs
* use CA-VIEW to locate output from failed jobs
* determine the cause of error in failed jobs

Course contents Top Objectives Timetable

Introduction to IT
Computing personnel (who does what, and likely role of students); designer, analyst, programmer, support staff, operator, sys prog, etc.

Hardware at [client]
Components of mainframe, UNIX boxes, PCs & similarities; I/O devices and characteristics; memory types and uses; multi-programming, multi-processing; common constraints of hardware; PC concepts; using DOS commands.

Data in computers
ASCII, EBCDIC, UNICODE, hex notation; Numeric data, binary, packed, zoned, floating point; Negative data; Concepts of group and elementary items; Records, record structures, fields; Files, indexes, databases, identifying common RDBMS; Data on the PC: hierarchical structure, directories.

Developing an application
Stages of development: analysis, design, prototyping, coding, testing, documentation, training, implementation, maintenance; Types of processing: batch, online (e.g. CICS); Online enquiry and update, batch report, batch merge, batch update, sorting; Languages used at [client], typical usage for each; Compilation process, pre-processors, interpreters, linkage editors, loaders; Event-driven concepts; Program re-use, object orientation; Centralised and distributed processing: introduction.

OS/390 system
OS/390 component parts and related program products. OS/390 concepts: data spaces, hiperspaces, address spaces, paging, swapping; task management; real, expanded, and auxiliary storage; how SRM and WFM control the environment; main components: JES2, SDSF, VTAM, CICS, IMS, DB2, TSO, REXX, Data Facility products, DFHSM, DFSMS; Security products, ACF2 or RACF; job scheduling.

Using TSO and ISPF
Logging on to TSO; Using ISPF; Editing with ISPF.

Running jobs
Submitting jobs for execution; test data; Using SDSF.

Introduction to programming
Structured programming principles; Events and event-driven programming; Batch programming approach; Program components; Samples from languages.

Using LIBRARIAN
Concepts; browsing, editing, creating, printing source code; using Archive, setting options.

Introduction to COBOL
Language standards, LE COBOL, ANS 85, ANS 74, ANS 68; compilation options and procedures. Program structure: IDENTIFICATION, ENVIRONMENT, DATA, PROCEDURE divisions; reserved words; syntax: data names, sentences, statements, clauses, paragraphs, sections; a sample program.

Getting started
Specifying the IDENTIFICATION DIVISION and ENVIRONMENT DIVISION; program name; SPECIAL-NAMES contents; FILE-CONTROL contents: SELECT statement for standard files and alternate indexes.

Defining data
DATA DIVISION structure: FILE, WORKING-STORAGE, and LINKAGE sections; file descriptions; record descriptions; data item descriptions: level numbers, elementary and group items, data types, PICTURE, SYNC, REDEFINES, VALUE, FILLER, repeated structures, 88 levels.

Basic processing statements
Imperative and conditional statements; data movement: MOVE, ACCEPT; conditions: relational, logical, condition-names.

Compiler input and output
Compilation options; COPY statement, DATAMANAGER; compilation output and error messages; object program structure.

Arithmetic statements
Data types; error handling; ADD, SUBTRACT, MULTIPLY, DIVIDE, COMPUTE.

Printer files
Edited picture fields; line counts, page counts; WRITE AFTER PAGE.

File handling
Opening and closing files; ACCESS clause and its implications; READ, WRITE, DELETE, REWRITE, START, READ NEXT; alternate indexes; return codes.

Controlling program flow
Program termination: STOP RUN, GOBACK; GO TO, PERFORM, EXIT; NEXT SENTENCE; GO TO DEPENDING.

Table handling
OCCURS clause, defining table entries; indexed vs subscripted tables; SET and SEARCH statements; loading tables with data; variable length tables.

Modular programming
CALL statement and parameters; LINKAGE SECTION and parameter specification; GOBACK, EXIT PROGRAM, ENTRY, CANCEL, the USING clause; FUNCTION calls.

Advanced features
SET condition names; INSPECT; STRING, UNSTRING; setting condition codes.

Internal SORT
Sort file description; INPUT and OUTPUT procedures; SORT and MERGE statements; RELEASE, RETURN.

Dumps and debugging
JCL and compilation options: SYSDBOUT, SYSOUT, SYSUDUMP; typical causes of dumps.

Compiling programs
Librarian; submitting programs for compilation; using SDSF to locate output; amending programs which have compilation errors.

Preparing for Xpediter
Introduction, structure of an Xpediter execution; libraries and datasets used: DDIO, loadlib, allocate, log, script. Specifying the libraries to be used. Interactive mode of execution. Use with CICS, IMS, and DB2. Compiling the program, modifying compilation options; preparing the allocation list for batch execution; invoking Xpediter, supplying run-time parameter values. Viewing and setting PF keys.

Using Xpediter commands
Line commands, primary commands, inserted commands; displaying the contents of data fields; modifying data; using MONITOR and REVERSE commands; setting breakpoints before and after executing statements; using COUNT to determine which lines were not executed during a test run; scrolling; using scripts; using FIND; testing values: IF and WHEN; INSERT; INTERCEPT; keeping data fields and their values on the screen.

Introduction to DB2
Comparison of DB2 tables with VSAM files and hierarchical databases (e.g. IMS, TOTAL); DB2 and the Relational Model; tasks and personnel involved in implementing a DB2 system; DML and DDL; sample uses of DB2.

Tables and DB2 architecture
How data is arranged; storage groups, databases, tablespaces, indexes, tables, views; basic table design, keys, table splitting; referential integrity, foreign keys, constraints, triggers; functions of the catalog tables; typical disk requirements; physical storage considerations; temporary tables.

Accessing DB2 data
How programs can access DB2, SQL language; precompile and BIND process; EXPLAIN. Access from TSO and batch. Functions and use of DB2I and SPUFI. SQL communication area. DCLGEN.

SQL programming
SELECT statement, predicates, JOIN and UNION queries; scalar functions; labeled durations;column functions: BETWEEN, NULL, LIKE, EXISTS, IN; GROUP BY; UPDATE, DELETE, INSERT; CASE expressions; special registers; subquery with IN; subquery with NOT IN; correlated subselect; EXISTS, ANY, ALL; outer joins; dynamic SQL; access from COBOL or PL/1; using cursors, host variables, indicator variables; CICS considerations; running in batch, IKJEFT01.

Security and integrity considerations
Facilities which can be controlled; GRANT and REVOKE. Overview of locking; COMMIT, ROLLBACK. Load utility.

Using FileAID
Defining QSAM and VSAM files; viewing the contents of files; editing the contents of files; viewing non-character data in files; processing members of a pds.

Running jobs in OS/390 and MVS
Overview of a job; how JES processes a job; MVS datasets and access methods; compilation and link edit; statements: JOB, EXEC, DD, OUTPUT, PROC, PEND, JCLLIB, IF, ENDIF, INCLUDE, SET, etc.; syntax rules; JES2 control statements: JOBPARM, ROUTE, etc.

The JOB Statement
Function and format; positional parameters: accounting information, 'programmer' name; keyword parameters: CLASS, MSGCLASS, NOTIFY, REGION, TIME, TYPRUN, etc; how jobnames are handled by TSO and the security system.

The EXEC and IF Statements
Function and format; constructing stepnames; PGM and PROC; common parameters: PARM, REGION, TIME; use of the IEFBR14 program. Conditional tests, COND, IF-THEN-ELSE-ENDIF.

The DD Statement
Function and format; use of DDNAME to link program with JCL; function of the catalogs; SMS and non-SMS datasets; parameters for VSAM, printer, QSAM, tape, pds, in-stream, and generation datasets; DSN, DISP, SYSOUT, UNIT, VOL, SPACE, DCB, LABEL, DUMMY, AMP, etc; Special DDNAMES: JOBLIB, STEPLIB, SYSUDUMP, SYSOUT, SYSIN, SYSPRINT, SYSLIB, etc; special techniques: concatenated datasets, temporary datasets, non-existent datasets, backwards referencing.

The OUTPUT Statement
Function and format: controlling printer output, remote printers, FCBs, special stationery, multiple copies, etc; options for retaining output in the JES dataset.

Catalogued Procedures
Catalogued and In-stream procedures; using parameter libraries; modifying EXEC parameters; modifying DD parameters; symbolic parameters; setting defaults, PROC; handling in-stream data; JCLLIB, SET.

Batch Utilities
Introduction to general format and required datasets; IEBCOPY, IEBGENER, IEBUPDTE, IEHLIST, IEHINITT, etc. SORT, IKJEFT01, DFSRRC00.

Online Utilities
Using CA-Spool (CMA-Spool); using CA-VIEW (SAR).

Introduction to MVS dump codes
System and User abend codes; messages on log; common failures (e.g. OC7, 806, B37).

Course timetable (approx) Top Objectives Contents

Day 1
Introduction to course and objectives
Personal introductions Computing personnel (who does what, and likely role of students)
* designer, analyst, programmer, support staff, operator, sys prog, etc.
Hardware at [client]
* components of mainframe, UNIX boxes, PCs & similarities
* I/O devices and characteristics
* memory types and uses
* multi-programming, multi-processing
* common constraints of hardware
Software concepts, operating systems used at [client]
Get to know your PC

Day 2
Data in computers ASCII, EBCDIC, UNICODE, hex notation
Numeric data, binary, packed, zoned, floating point Negative data in these forms
Concepts of group and elementary items
Records, record structures, fields
Files, indexes, databases, identifying common RDBMS
The OS/390 system
Logging on to TSO
Using ISPF Editing with ISPF

Days 3-5:
Structured Programming
Developing an application, stages of development:
* analysis, design, prototyping, coding, testing
* documentation, training, implementation, maintenance
Types of processing: batch, online (e.g. CICS)
Online enquiry and update, batch report, batch merge, batch update, sorting
Structured data diagrams; defining data structures for input and output files, print lines.
Top down design and structured programming constructs; sequence, selection, iteration, conditions, elementaries.
Schematic logic, SEQ, SEL, OR, ITER, END; program module qualities, cohesion, coupling.
Producing a structure diagram
Sample programs and diagrams
Case study exercises, graded from simple to more advanced

Days 6-17 (but overlapping during days 19-25)
COBOL NB: programs will be written to [client] structured standards
Librarian, compiling SDSF, viewing output JCL introduction, running programs
Structured Programming Standards and Guidelines; COBOL implications
Producing COBOL from the structure diagram Testing programs.
Producing test data
DATAMANAGER
Xpediter

Days 18-21
DB2 and SQL

Days 22-25
JCL and Utilities: further details and consolidation
File-AID
CMA-Spool
CA-VIEW (SAR)