Understanding the Difference Between DUMMY and NULLFILE in Mainframes

Introduction:

Mainframes have been an integral part of the computing industry for decades, supporting critical business operations and handling vast amounts of data. As mainframe programmers, it’s essential to understand the intricacies of various file handling techniques. In this blog, we will explore the key differences between DUMMY and NULLFILE in mainframes, catering to both mainframe programmers and non-programmers. We will also provide coding examples to illustrate their practical applications.

Part 1: Understanding DUMMY Files

DUMMY files are a unique type of data set in mainframes. They serve specific purposes and are crucial for various operations. Essentially, a DUMMY file doesn’t contain any data, but it is essential for certain job steps that require a valid data set reference.

1.1 Definition and Characteristics of DUMMY Files:

In simple terms, a DUMMY file is used when a program expects a data set but doesn’t need any actual data to be read or written. It acts as a placeholder to satisfy program syntax requirements.

Here are the main characteristics of a DUMMY file:

• No actual data is stored in a DUMMY file.
• The file is typically defined with the DUMMY disposition in JCL (Job Control Language).
• DUMMY files are used for various purposes, such as providing empty input data sets or bypassing certain steps.

1.2 Example: Using DUMMY Files in JCL

Let’s consider an example where we have a COBOL program that reads data from an input file and writes the output to another file. However, in some cases, we might not have any input data available. In such scenarios, we can use a DUMMY file as a placeholder for the input data set.

Here’s how the JCL would look:

//JOBNAME   JOB (ACCOUNT),'DESCRIPTION',CLASS=class,MSGCLASS=class
//STEP1     EXEC PGM=COBOLPGM
//INPUT     DD DUMMY            (Dummy input data set)
//OUTPUT    DD SYSOUT=*         (Output will be printed in the sysout)
/*

In this example, the program COBOLPGM expects an input data set. We use the DUMMY file for the INPUT DD statement to fulfill this requirement when actual data is not available.

Part 2: Understanding NULLFILEs

NULLFILEs, on the other hand, are quite different from DUMMY files in terms of their purpose and characteristics. While DUMMY files are used as placeholders, NULLFILEs serve a more specific and advanced function.

2.1 Definition and Characteristics of NULLFILEs:

A NULLFILE is a type of data set that can be read from or written to, but it doesn’t consume any system resources. Unlike DUMMY files, NULLFILEs are not just placeholders but provide a way to perform operations without storing any data.

Here are the main characteristics of a NULLFILE:

• NULLFILEs consume no disk space or memory.
• They are created using specific attributes that enable them to be used efficiently for various purposes.
• When reading from a NULLFILE, it behaves as if it contains an infinite number of records with a specific attribute value (usually NULL).

2.2 Example: Using NULLFILEs in JCL

Suppose we have a COBOL program that generates some output data, but we don’t want to store that data in a physical file. Instead, we need to perform further processing on the generated data without using additional resources.

Let’s see how we can use a NULLFILE in this scenario:

//JOBNAME   JOB (ACCOUNT),'DESCRIPTION',CLASS=class,MSGCLASS=class
//STEP1     EXEC PGM=COBOLPGM
//INPUT     DD DUMMY            (Dummy input data set or any other actual data set)
//OUTPUT    DD DSN=&&TEMPDS,DISP=(NEW,PASS),SPACE=(TRK,1),
//           DCB=(RECFM=FB,LRECL=80,BLKSIZE=80) (Temporary data set)
//NULLFILE  DD DSN=&&NULLDS,DISP=(NEW,PASS),SPACE=(TRK,1),
//           DCB=(RECFM=FB,LRECL=80,BLKSIZE=80) (NULLFILE)
//STEP2     EXEC PGM=ANOTHERPGM
//INPUT1    DD DSN=&&TEMPDS,DISP=(OLD,DELETE)  (Using temporary data set as input)
//INPUT2    DD DSN=&&NULLDS,DISP=(OLD,DELETE)  (Using NULLFILE as input)
//OUTPUT    DD SYSOUT=*                        (Output will be printed in the sysout)
/*

In this example, the program COBOLPGM generates some data, which we store in a temporary data set (&&TEMPDS). Additionally, we create a NULLFILE (&&NULLDS) to process the same data without consuming any resources.

In STEP2, we use both the temporary data set and the NULLFILE as inputs for ANOTHERPGM. This allows us to perform multiple operations on the generated data without the need to store it permanently.

Conclusion:

In conclusion, DUMMY and NULLFILE are two distinct concepts in mainframe programming. DUMMY files act as placeholders to fulfill data set requirements when no actual data is available. On the other hand, NULLFILEs provide a more advanced and efficient way to process data without consuming additional resources.

As a mainframe programmer, understanding the differences between DUMMY and NULLFILE is essential for optimizing job executions, conserving system resources, and handling various data scenarios effectively. By utilizing these techniques appropriately, developers can enhance the efficiency and performance of their mainframe applications.