DEV Community: Stephen Johnston

COBOL Fundamentals: Data Types & Variables

Stephen Johnston — Sat, 22 Feb 2025 01:05:58 +0000

Data Types in COBOL

The COBOL standard categorizes data based on its purpose into five distinct types. These are:

Alphabetic - Used when you need to include letters (e.g., A-Z, a-z). While it might seem ideal for storing names, you should be cautious, as names can contain non-alphabetic characters. This data type can also include spaces.
Alphanumeric - Used when you need to include letters, numbers, and special characters (e.g., A-Z, 0-9, %, #). This type is most commonly used for storing names, coupon codes, or other mixed-type information.
Numeric - Used for numbers (e.g., 0-9). This data type is designed for arithmetic operations and calculations, making it essential for financial, scientific, and statistical applications.
Alphanumeric Edited - Used to format alphanumeric data for display purposes. This type allows for the insertion of fixed characters (e.g., hyphens, slashes, or spaces) into alphanumeric data.
Numeric Edited - Used to format numeric data for display purposes. This type allows for the insertion of fixed characters (e.g., currency symbols, commas, or decimal points) into numeric data.

A Note on Edited Data Types 🤦‍♂️

The Alphanumeric Edited and Numeric Edited data types can be a bit tricky at first — but simply put, it's COBOL's way of saying, "Let's make this data look fancy!" They're designed for formatting data for display, like adding commas to numbers, currency symbols, or even hyphens in text.

Variables in COBOL

In COBOL, all variables are defined in the DATA DIVISION, which is where your COBOL program defines and stores all the data it will use. COBOL variables are hierarchical and are made up of level numbers, PICTURE (or PIC) clauses, and optional default values (more on this later):

A LEVEL-NUMBER, which determines if it's an individual field, group item, or elementary item. So, what's the difference? They are:
- 01 - Indicates a top-level item. It can be standalone or the start of a group item. Fun fact: anything starting with a zero is pronounced "OH" followed by the level number (e.g., OH-ONE, OH-TWO).
- 02 - 49 - Indicates subordinate levels. These are used within groups to break down data into smaller, more manageable chunks — think of an OBJECT in modern programming languages.
- 66 - Used for what's known as RENAMES. I've not used this yet, but it seems similar to creating a view in SQL, allowing you to create an alternative view of the same data.
- 77 - Indicates a standalone item that doesn't need to be part of a group.
- 88 - Most often used for condition names. They're incredibly useful for making your code more readable. The closest comparison might be an ENUM in modern languages, though you can't access it like one (e.g., ORDER-STATUS.NEW-ORDER). Instead, you use the condition name in logical statements.
A VARIABLE NAME, the name we'll use to access this item later in the program. Like in every programming language, it has some rules — one of which goes against everything I was taught about variables 😀. These rules are:
- Length - A variable name can be as short as 1 character (please don't do this 😱—it's terrible for readability!!) and as long as 30 characters.
- Allowed Characters - Pretty standard stuff here: letters (A-Z, a-z), numbers (0-9), and hyphens (-).
- Starting & Ending Characters - In COBOL, they can start and end with a letter or a number — that's right, a number! However, you cannot start or end with a hyphen. At least they put some restrictions on the names 🤣.
- No Reserved Words - This one makes sense. Don't use reserved words (e.g., DISPLAY, ACCEPT, MOVE).
A PICTURE (or PIC) Clause - This is where the magic happens. It defines the type, size, and display format of a variable using symbols (e.g., A, 9, X). Formatting is one of COBOL's neatest tricks. I can't tell you how many times I've pulled my hair out trying to make something look a certain way when it's displayed. Well, COBOL does the heavy lifting for you — once you wrap your head around how it works! We'll dive deeper into this shortly.
A VALUE Clause - This is where you can set an initial value for your variable. It's optional.

A PICTURE Is Worth A Thousand Words

As mentioned earlier, the PICTURE clause allows you to define the structure of your data and format it in a way that makes you happy. While you might find references to the full keyword PICTURE in older code, most examples today use the abbreviated PIC. It really comes down to personal preference or your company's programming style guide. The TL;DR on the PICTURE clause is that it's a blueprint for how your data should appear.

Like any blueprint, the PICTURE clause uses special symbols that might make you go "HUH!" at first glance. I'll do my best to explain them, and while there are more than listed here, I'm focusing on the most common ones. With symbols, you can either use a single character and specify the length in parentheses (e.g., PIC 9(5)), or write it out longhand like PIC 99999. I don't recommend the long route, though — it's just more typing!

Common Symbols

The following are probably the most commonly used symbols based on what I've learned so far.

9 - This symbol is pretty self-explanatory and represents a numeric field. Example: PIC 9(5) defines a 5-digit numeric field.
A - This represents an alphabetic field. Example: PIC A(10) defines a 10-character field that can only contain alphabetic characters (A-Z). Note that in practice, PIC X is often preferred over PIC A because it's more flexible, allowing alphanumeric characters (letters, numbers, and special characters).
X - This represents an alphanumeric field. Example: PIC X(10) defines a 10-character alphanumeric field.
V - This is where things get interesting. It represents an implied decimal point. Example: PIC 9(5)V99 defines a 7-digit numeric field with two decimal places.
S - This indicates a signed number (e.g., -5.00, +5.00). I've not used this one yet.

Assigning Values to Variables

In COBOL, you can assign values to variables using the MOVE statement. This is one of the most common ways to initialize or update variables in your program.

Practical Examples

If you're like me, reading about something is fine and dandy, but seeing the code is more helpful. That said, let's dive into some code examples.

Example 1: Assigning a Value to a Numeric Field

       IDENTIFICATION DIVISION.
       PROGRAM-ID. EXP01.
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 SALARY PIC 9(5).
       PROCEDURE DIVISION.
         MOVE 50000 TO SALARY.
         DISPLAY "Salary: " SALARY.
         STOP RUN.
       END PROGRAM EXP01.

Output:

Salary: 50000

Example 2: Assigning a Value to an Alphanumeric Field

       IDENTIFICATION DIVISION.
       PROGRAM-ID. EXP02.
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 EMPLOYEE-NAME PIC X(20).
        PROCEDURE DIVISION.
           MOVE "John Doe" TO EMPLOYEE-NAME.
           DISPLAY "Employee Name: " EMPLOYEE-NAME.
           STOP RUN.
       END PROGRAM EXP02.

Output:

Employee Name: John Doe

Example 3: Assigning a Value to a Grouped Field

For this example we're going to go over a couple ways to accomplish the task at hand. In COBOL, you can assign values to a group field directly with MOVE, but you need to account for the full length of subfields, or you can move data directly into the group using MOVE ... TO ... IN. In larger COBOL applications, you might encounter multiple groups with fields of the same name (e.g., EMPLOYEE-NAME in different groups). Using MOVE ... TO IN ensures values are assigned to the correct field, avoiding potential bugs or confusion. You can also use OF instead of IN as a synonym when referencing subfields — e.g., NAME OF EMPLOYEE-DETAILS. Let's take a look at a couple examples:

MOVE ... TO

This pair of statements allows you to assign values to individual fields within a group.

       IDENTIFICATION DIVISION.
       PROGRAM-ID. EXP03A.
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 EMPLOYEE-DETAILS.
          05 EMPLOYEE-NAME PIC X(20).
          05 EMPLOYEE-ID   PIC 9(5).
       PROCEDURE DIVISION.
           MOVE "Jane Smith     56789" TO EMPLOYEE-DETAILS.
           DISPLAY "Employee Name: " EMPLOYEE-NAME.
           DISPLAY "Employee ID: " EMPLOYEE-ID.
           STOP RUN.
       END PROGRAM EXP03A.

In this example, the string "Jane Smith 56789" is padded with spaces to match the 20-character length of EMPLOYEE-NAME. The first 20 characters fill EMPLOYEE-NAME, and "56789" goes to EMPLOYEE-ID. Without padding, some compilers might space-fill EMPLOYEE-NAME and leave EMPLOYEE-ID undefined or zeroed out.

MOVE ... TO ... IN

This group of statements allows you to move data directly into the group, even if they share similar names. While I won't say never, I will say it shouldn't happen within smaller COBOL program, but if you work in a larger COBOL program you're probably going to see this.

       IDENTIFICATION DIVISION.
       PROGRAM-ID. MULTIPLE-GROUPS.
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 EMPLOYEE-DETAILS.
          05 NAME PIC X(20).
       01 MANAGER-DETAILS.
          05 NAME PIC X(20).
       PROCEDURE DIVISION.
      *> Assigning values to fields in EMPLOYEE-DETAILS
           MOVE "John Doe" TO NAME IN EMPLOYEE-DETAILS.
           DISPLAY "Employee Name: " NAME IN EMPLOYEE-DETAILS.

      *> Assigning values to fields in MANAGER-DETAILS
           MOVE "Jane Smith" TO NAME IN MANAGER-DETAILS.
           DISPLAY "Manager Name: " NAME IN MANAGER-DETAILS.

           STOP RUN.
       END PROGRAM MULTIPLE-GROUPS.

MOVE ... TO ... OF

Here's the same example using OF instead of IN, showing they work interchangeably:

       IDENTIFICATION DIVISION.
       PROGRAM-ID. MULTIPLE-GROUPS-OF.
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 EMPLOYEE-DETAILS.
          05 NAME PIC X(20).
       01 MANAGER-DETAILS.
          05 NAME PIC X(20).
       PROCEDURE DIVISION.
           MOVE "John Doe" TO NAME OF EMPLOYEE-DETAILS.
           DISPLAY "Employee Name: " NAME OF EMPLOYEE-DETAILS.
           MOVE "Jane Smith" TO NAME OF MANAGER-DETAILS.
           DISPLAY "Manager Name: " NAME OF MANAGER-DETAILS.
           STOP RUN.
       END PROGRAM MULTIPLE-GROUPS-OF.

Example 4: Dates

Another common example we'd find in a business application might be a date. Now, this is one place where COBOL, at least in all my research, seems to be lacking. COBOL doesn't natively support a dedicated DATETIME field type, so we need to handle dates ourselves. For consistency, I recommend storing dates in ISO format (YYYYMMDD) — it's unambiguous and sorts easily in files. Here are two approaches:

Date as Grouped Field

If you want to store a date in a structured way, you can use a grouped field to break it down into its components (year, month, and day). Here's an example:

       IDENTIFICATION DIVISION.
       PROGRAM-ID. CBLDATES1.
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 BIRTH-DATE.
          02 BIRTH-YEAR   PIC 9(4).
          02 BIRTH-MONTH  PIC 9(2).
          02 BIRTH-DAY    PIC 9(2).
       PROCEDURE DIVISION.
           MOVE 2025 TO BIRTH-YEAR
           MOVE 02   TO BIRTH-MONTH
           MOVE 21   TO BIRTH-DAY
           DISPLAY "Year: " BIRTH-YEAR
           DISPLAY "Month: " BIRTH-MONTH
           DISPLAY "Day: " BIRTH-DAY
           STOP RUN.
       END PROGRAM CBLDATES1.

Date as Numeric Field (ISO Format)

Using YYYYMMDD (e.g., 19850715 for July 15, 1985) avoids confusion — unlike MMDDYYYY or DDMMYYYY, where 07012025 could be July 1st or January 7th depending on the region.

       IDENTIFICATION DIVISION.
       PROGRAM-ID. CBLDATES2.
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 BIRTH-DATE PIC 9(8).
       PROCEDURE DIVISION.
           MOVE 19850715 TO BIRTH-DATE
           DISPLAY "Birth Date (YYYYMMDD): " BIRTH-DATE
           STOP RUN.
       END PROGRAM CBLDATES2.

OUTPUT

Birth Date (YYYYMMDD): 19850715

Date as Individual Edited Field

If you want to display a date with slashes (e.g., YYYY/MM/DD) from an ISO format input, you can use an Alphanumeric Edited field. Here's an example:

       IDENTIFICATION DIVISION.
       PROGRAM-ID. CBLDATES3.
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 BIRTH-DATE PIC 9999/99/99.
       PROCEDURE DIVISION.
           MOVE 19850815 TO BIRTH-DATE
           DISPLAY "Birth Date: " BIRTH-DATE
           STOP RUN.
       END PROGRAM CBLDATES3.

In this example, the PIC 9999/99/99 clause formats the date with slashes for display. The raw numeric value 19850815 is transformed into 1985/08/15.

OUTPUT

Birth Date: 1985/08/15

Summary

In this article, we explored the fundamentals of COBOL data types and variables, including how to define and format them using PICTURE clauses. We also looked at practical examples of assigning values to variables and formatting data for display. By mastering these concepts, you'll be well-equipped to handle data effectively in COBOL programs, whether you're working with numeric calculations, alphanumeric strings, or formatted displays.

If you're an experienced COBOL developer and spot any inaccuracies or areas where I could improve my explanations, I'd greatly appreciate your feedback! And if you're new to COBOL but found this article interesting, I'd love to hear from you as well. Your thoughts and questions are always welcome—I enjoy learning and growing alongside others in this journey!

Acknowledgments

Big thanks to harrywwc, a knowledgeable COBOL enthusiast who provided invaluable feedback on this article, helping me refine the details and make it more accurate. Your insights were spot on!

Introduction to COBOL

Stephen Johnston — Thu, 20 Feb 2025 03:40:36 +0000

The Problem

As businesses began relying more heavily on computers for data processing—such as payroll, inventory, banking, and more—in the 1950s, it became clear that change was needed. At the time, each computer manufacturer used its own proprietary programming language, which was often tied to specific hardware. For instance, languages like FORTRAN and Assembly required a strong mathematical background, making them inaccessible to non-technical users.

The Solution

Recognizing the inefficiency and cost of porting programs across systems, the U.S. Department of Defense (DoD) spearheaded efforts to create a standardized programming language that could be used universally. With this goal in mind, a group of experts gathered at the Conference on Data Systems Languages (CODASYL) in 1959. Among them was Grace Hopper, a pioneering computer scientist who was a driving force behind the development of the first compiler, playing a pivotal role in its creation alongside other contributors.

Out of this conference came the COmmon Business-Oriented Language (COBOL), a revolutionary language designed to meet the needs of business data processing. Among the features that made COBOL groundbreaking was its English-like syntax, which allowed non-technical people to read, understand, and even write programs. This was similar to how modern drag-and-drop website builders have democratized—or, some might argue, disrupted—web development today.

The Structure of a COBOL program

Now that we've learned a bit about COBOL and some of the problems it solved, we'll take a look at the structure of a COBOL program.

Columns in COBOL

Since COBOL dates back to the era of punched cards—where data was physically encoded on cards—it's no surprise that its code is organized into specific column-based areas, each serving a unique purpose.

Columns 1-6 - known as the Sequence Number Area, are often ignored in modern COBOL implementations.
Column 7 - Column 7, known as the Indicator Area, is primarily used for comments (marked with *) or left blank for regular code lines in modern COBOL programming.
Columns 8-11: Area A (Margin A) - Used for division headers, section headers, paragraph names, and level indicators.
Columns 12-72: Area B (Margin B) - Contains the actual COBOL statements, data definitions, and procedural code.
Columns 73-80 - known as the Identification Area, are rarely used in modern COBOL programming.

The Structure of a COBOL program

Because COBOL is English-like, perhaps it comes as no surprise that a COBOL program is structured much like a document, with divisions, sections, paragraphs, sentences, and statements. Let's explore these a little more.

Divisions: Major segments of a COBOL program that categorize different aspects like program identification, environment setup, data definitions, and procedural logic.
Sections: Group related functionality within divisions.
Paragraphs: Small blocks of code within sections for specific tasks.
Sentences: Groups of statements that perform operations within paragraphs.
Statements: Individual commands or instructions within sentences.

The Four Divisions of a COBOL program

Every COBOL program consists of four divisions; however, only two are required to write a basic COBOL program: the IDENTIFICATION DIVISION and the PROCEDURE DIVISION.

IDENTIFICATION DIVISION

The IDENTIFICATION DIVISION is mandatory for every COBOL program. Without it, the program is invalid. It provides a place to store some valuable metadata, such as the program name, author, and other details. Within this division, the PROGRAM-ID paragraph must appear directly after the IDENTIFICATION DIVISION and is the only required paragraph. Other optional paragraphs include AUTHOR, DATE-WRITTEN, DATE-COMPILED, and SECURITY.

ENVIRONMENT DIVISION

This division, which follows the IDENTIFICATION DIVISION, describes the system environment where the program will run, including:

The computer hardware and operating system.
Any I/O devices (e.g., printers, disk drives, etc.) the program will use.

The ENVIRONMENT DIVISION is divided into two sections:

CONFIGURATION SECTION - Describes the system environment.
INPUT-OUTPUT SECTION - Defines files and I/O devices, controlling how data is read from or written to these resources.

DATA DIVISION

This is where your COBOL program defines and stores all the data it will use. It's like the program's "storage room" for variables, records, and files.

The DATA DIVISION is divided into the following sections:

FILE SECTION - Defines the structure of files used for input/output.
WORKING-STORAGE SECTION - Stores temporary data and variables used during program execution.
LINKAGE SECTION - Defines data shared between programs (used in subprograms).

PROCEDURE DIVISION

The PROCEDURE DIVISION is mandatory for any COBOL program, as it contains the logic and operations that bring the program to life. This is where you define the logic, operations, and all the processing that will occur happens.

A Basic COBOL Program

If you have prior programming experience, this program will look familiar. It's the basic 'Hello World' program.

We start by declaring our IDENTIFICATION DIVISION followed by a PROGRAM-ID, which is the only required paragraph in this division.

Next, we declare the PROCEDURE DIVISION, which is where the action happens. To display output, we use the DISPLAY statement, which writes to the output device. While this is typically a terminal screen today, it was often a printer in the past.

Finally, we instruct COBOL that immediately after it displays Hello World, we want to stop everything, and that's done with the STOP RUN statement.

      *******************************************************************
      *                   IDENTIFICATION DIVISION                       *
      *******************************************************************
      * The IDENTIFICATION DIVISION provides metadata about our program,*
      * and is one of two mandatory DIVISIONS in COBOL. The PROGRAM-ID  *
      * is the only required entry within this DIVISION.                *
      *******************************************************************
       IDENTIFICATION DIVISION.
       PROGRAM-ID. HELLOWORLDPROGRAM.

      *******************************************************************
      *                     PROCEDURE DIVISION                          *
      *******************************************************************
      * The PROCEDURE DIVISION is where the program's logic is written. *
      *******************************************************************
       PROCEDURE DIVISION.

      * The DISPLAY statement prints the contents to the output device,
      * in this case, the console window.
           DISPLAY 'Hello, World'.

      * The STOP RUN statement ends the program
           STOP RUN.

Summary

In this article, I've described the history and reasoning behind COBOL, the structure of COBOL, and shown you how to write a basic program using COBOL.

As I continue to learn COBOL, I welcome any feedback or corrections. Please let me know, and I'll update the article accordingly.

Acknowledgments

Big thanks to harrywwc, a knowledgeable COBOL enthusiast who provided invaluable feedback on this article, helping me refine the details and make it more accurate. Your insights were spot on!