Learn Cobol Logic From Zero: The Complete Two-Fer Guide

The Cobol "Two-Fer" challenge is a foundational exercise in our exclusive curriculum that teaches fundamental conditional logic and string manipulation. It involves creating a program that returns "One for [name], one for me." if a name is provided, or "One for you, one for me." if the name is blank, using core IF-ELSE statements and the powerful STRING verb.

You've probably heard the whispers about Cobol. Maybe you've pictured monolithic green-screen terminals in a dusty basement, running code written before the internet was even a concept. It's easy to feel intimidated, thinking that learning this "ancient" language is an insurmountable task filled with rigid rules and verbose syntax. You might be wondering if it's even worth your time in today's world of Python and JavaScript.

This feeling is completely valid. But what if I told you that by solving one deceptively simple problem, you could unlock the very soul of Cobol? The "Two-Fer" problem from the kodikra.com learning path is your key. It's designed to strip away the noise and focus on the absolute bedrock of the language: data definition, procedural logic, and text manipulation. This guide will transform that intimidation into confidence, proving that Cobol's structure is not a weakness, but a powerful tool for building clear, reliable, and maintainable business logic.

What is the "Two-Fer" Problem in Cobol?

At its heart, the Two-Fer problem is a logic puzzle centered on conditional string generation. The premise is simple: you're sharing something (like a cookie) and need to state who the two items are for. The program must implement the following rule:

• If a specific name is given (e.g., "Alice"), the program must produce the output: One for Alice, one for me.
• If no name is provided (i.e., the input is empty or just spaces), the program must default to a generic output: One for you, one for me.

This task, while trivial in many modern languages, is the perfect vehicle for learning fundamental Cobol constructs. It forces you to think about data structures and program flow in a way that is unique to the language, providing a solid foundation for tackling more complex mainframe applications.

Why This Simple Problem is a Pillar of Cobol Learning

You might ask, "Why this specific problem?" The answer lies in its efficiency as a teaching tool. The Two-Fer challenge isn't just about getting the right output; it's about mastering the "Cobol way" of thinking and structuring a program. It directly exposes you to the most critical components of any Cobol application.

The Core Concepts You Will Master:

• Program Structure (The Four Divisions): You'll learn the mandatory roles of the IDENTIFICATION DIVISION, ENVIRONMENT DIVISION, DATA DIVISION, and PROCEDURE DIVISION. This rigid structure is a hallmark of Cobol that promotes clarity and long-term maintainability.
• Data Definition (DATA DIVISION): Unlike languages where you can declare variables on the fly, Cobol requires you to define all data upfront in the WORKING-STORAGE SECTION. You'll become proficient with PIC clauses (e.g., PIC X(50)) to define data types and lengths explicitly.
• Conditional Logic (IF/ELSE): The problem's core logic revolves around an IF/ELSE statement. You'll learn the precise syntax, including the importance of the END-IF scope terminator, which is crucial for controlling program flow.
• String Manipulation (The STRING Verb): This is the star of the show. You will learn to use the powerful and verbose STRING verb to concatenate literals (like "One for ") and variables into a single, cohesive output string. This is a fundamental skill for generating reports and dynamic messages in real-world applications.

By solving this single challenge from the kodikra Cobol learning path, you build a mental model that applies to virtually every other Cobol program you will ever write or encounter.

How to Build the Two-Fer Solution in Cobol: A Deep Dive

Let's break down the complete solution step-by-step. We will construct the program division by division, explaining the purpose and syntax of every line of code. This approach ensures you understand not just the "what" but also the "why" behind the structure.

The Complete Cobol Source Code

Here is the full, well-commented solution. We will analyze each section in detail below.

IDENTIFICATION DIVISION.
PROGRAM-ID. TwoFer.
AUTHOR. Kodikra.

* This program solves the Two-Fer challenge from the kodikra.com
* curriculum. It demonstrates basic conditional logic and string
* manipulation in Cobol.

DATA DIVISION.
WORKING-STORAGE SECTION.
*> WS-INPUT-NAME: Holds the name provided to the program.
*   Initialized to SPACES. We check against SPACES to see if a
*   name was provided.
01 WS-INPUT-NAME       PIC X(50) VALUE SPACES.

*> WS-OUTPUT-PHRASE: The final string to be displayed.
*   Its length must be sufficient to hold the longest possible output.
01 WS-OUTPUT-PHRASE    PIC X(100).

*> WS-POINTER: A numeric variable used by the STRING verb to keep
*   track of the current position in the target string (WS-OUTPUT-PHRASE).
01 WS-POINTER          PIC 99 VALUE 1.

PROCEDURE DIVISION.
MAIN-LOGIC.
    * This is the main entry point of the program.
    * We will accept the input name here. In a real-world JCL
    * scenario, this might come from a PARM or a file. For this
    * example, we can hardcode it for testing or use ACCEPT.
    
    * For demonstration, let's test both cases.
    * Case 1: No name provided
    MOVE SPACES TO WS-INPUT-NAME.
    PERFORM GENERATE-PHRASE.
    DISPLAY "Test with no name: " WS-OUTPUT-PHRASE.

    * Case 2: A name is provided
    MOVE "Alice" TO WS-INPUT-NAME.
    PERFORM GENERATE-PHRASE.
    DISPLAY "Test with name 'Alice': " WS-OUTPUT-PHRASE.

    STOP RUN.

GENERATE-PHRASE.
    * This paragraph contains the core logic of the Two-Fer problem.
    INITIALIZE WS-OUTPUT-PHRASE.
    MOVE 1 TO WS-POINTER.

    * Check if the input name is empty (contains only spaces).
    IF WS-INPUT-NAME = SPACES
        * If no name is given, use the word "you".
        STRING "One for you, one for me."
            DELIMITED BY SIZE
            INTO WS-OUTPUT-PHRASE
    ELSE
        * If a name is provided, construct the dynamic phrase.
        STRING "One for "           DELIMITED BY SIZE
               WS-INPUT-NAME        DELIMITED BY "  "
               ", one for me."      DELIMITED BY SIZE
            INTO WS-OUTPUT-PHRASE
            WITH POINTER WS-POINTER
    END-IF.

Code Walkthrough: Deconstructing the Logic

Every Cobol program is like a well-organized book with distinct chapters. Let's read through ours.

1. IDENTIFICATION DIVISION

This is the program's header. It provides metadata, such as the program's name (PROGRAM-ID). While it has other optional entries, PROGRAM-ID is the only mandatory one.

IDENTIFICATION DIVISION.
PROGRAM-ID. TwoFer.
AUTHOR. Kodikra.

2. DATA DIVISION

This is where we declare all our variables. Think of it as the inventory or ingredients list for our program. Everything the program will work with—input, output, and temporary helper variables—must be defined here in the WORKING-STORAGE SECTION.

• 01 WS-INPUT-NAME PIC X(50) VALUE SPACES.: We define a variable named WS-INPUT-NAME. The 01 is a level number, indicating a top-level data item. PIC X(50) declares it as an alphanumeric (X) string with a fixed length of 50 characters. VALUE SPACES initializes it with spaces, which is crucial for our logic check.
• 01 WS-OUTPUT-PHRASE PIC X(100).: This will hold our final sentence. We allocate 100 characters to be safe.
• 01 WS-POINTER PIC 99 VALUE 1.: This is a helper variable specifically for the STRING verb. PIC 99 defines a two-digit number. The STRING verb uses this to know where to place the next piece of text in the destination string (WS-OUTPUT-PHRASE). We initialize it to 1 to start at the beginning.

3. PROCEDURE DIVISION

This is the "engine" of the program where all the actions happen. The logic is written in paragraphs (like MAIN-LOGIC and GENERATE-PHRASE), which are similar to functions or methods in other languages.

The core of our solution resides in the GENERATE-PHRASE paragraph. Let's visualize its flow.

    ● Start (GENERATE-PHRASE)
    │
    ▼
  ┌──────────────────┐
  │ Initialize       │
  │ WS-OUTPUT-PHRASE │
  │ & WS-POINTER     │
  └────────┬─────────┘
           │
           ▼
    ◆ Is WS-INPUT-NAME equal to SPACES?
   ╱               ╲
  Yes (Empty)      No (Name exists)
  │                  │
  ▼                  ▼
┌─────────────────┐  ┌───────────────────────────────────┐
│ STRING "you"    │  │ STRING "One for ", WS-INPUT-NAME, │
│ into output     │  │ ", one for me." into output      │
└─────────────────┘  └───────────────────────────────────┘
  │                  │
  └────────┬─────────┘
           │
           ▼
    ● End Paragraph

Let's analyze the code that implements this logic:

IF WS-INPUT-NAME = SPACES
    ...
ELSE
    ...
END-IF.

This is the conditional branch. If WS-INPUT-NAME contains nothing but spaces, the first block of code executes. Otherwise, the ELSE block executes.

Inside the `IF` Block (No Name):

STRING "One for you, one for me."
    DELIMITED BY SIZE
    INTO WS-OUTPUT-PHRASE

Here, we use the STRING verb in its simplest form.

• STRING "...": The literal text we want to move.
• DELIMITED BY SIZE: This tells Cobol to take the entire literal, from beginning to end.
• INTO WS-OUTPUT-PHRASE: This specifies the destination variable for the text.

Inside the `ELSE` Block (Name Provided):

STRING "One for "           DELIMITED BY SIZE
       WS-INPUT-NAME        DELIMITED BY "  "
       ", one for me."      DELIMITED BY SIZE
    INTO WS-OUTPUT-PHRASE
    WITH POINTER WS-POINTER

This is a more advanced use of STRING for concatenation.

• It takes multiple source items (two literals and one variable) and joins them in order.
• WS-INPUT-NAME DELIMITED BY " ": This is a critical and classic Cobol technique. Since WS-INPUT-NAME is a fixed-length field of 50 characters, if the name is "Alice", the variable actually contains "Alice" followed by 45 spaces. DELIMITED BY " " (two spaces) tells the STRING verb to copy characters from WS-INPUT-NAME only until it encounters two consecutive spaces. This effectively "trims" the trailing blanks. Using a single space might stop prematurely if the name itself contains a space (e.g., "Do Yun").
• WITH POINTER WS-POINTER: This tells the STRING verb to use our WS-POINTER variable to manage placement. After copying "One for ", the pointer is automatically updated to the next available position, ready for WS-INPUT-NAME to be placed, and so on.

Where This Logic Applies in the Real World

The conditional logic and string concatenation demonstrated in the Two-Fer problem are not just academic exercises. They are miniature versions of processes running on mainframes that power global finance, logistics, and healthcare systems every single day.

• Dynamic Report Generation: Imagine a banking program that generates millions of customer statements. Some customers have a middle initial, and some don't. The program uses `IF` statements to check if the middle initial field is blank. It then uses the `STRING` verb to construct the full name line, seamlessly handling both cases without awkward extra spaces.
• Customized User Messaging in CICS: In a CICS (Customer Information Control System) transaction screen, an operator might receive messages. The logic to build these messages—"User [username] successfully updated record [record_id]"—uses the exact `STRING` concatenation technique we practiced.
• Batch File Processing: A nightly batch job might process a file where certain fields are optional. The program reads each record, checks `IF` a field `IS NOT SPACES`, and processes it accordingly, perhaps `STRING`ing it into a formatted output record for another system.

Mastering this simple pattern prepares you for these massive, mission-critical applications.

Alternative Approaches and Best Practices

While our solution is robust and idiomatic Cobol, it's useful to understand alternative techniques and modern enhancements.

Using 88-Level Condition Names

For enhanced readability, Cobol allows you to create "condition names" using the 88 level number. This lets you assign a meaningful name to a specific value of a variable.

In our DATA DIVISION, we could add:

01 WS-INPUT-NAME       PIC X(50).
   88 INPUT-NAME-IS-BLANK VALUE SPACES.

Then, in our PROCEDURE DIVISION, the IF statement becomes much more self-documenting:

IF INPUT-NAME-IS-BLANK
    * ... logic for no name ...
ELSE
    * ... logic for when a name is provided ...
END-IF.

This is considered a best practice in professional Cobol development as it makes the business logic clearer to anyone reading the code.

Using the FUNCTION TRIM Intrinsic Function

More modern versions of Cobol (like IBM Enterprise COBOL and recent GnuCOBOL versions) support intrinsic functions, which are similar to built-in functions in other languages. The FUNCTION TRIM provides a cleaner way to handle trailing spaces.

The `ELSE` block's `STRING` verb could be rewritten as:

STRING "One for "
       FUNCTION TRIM(WS-INPUT-NAME)
       ", one for me."
    DELIMITED BY SIZE
    INTO WS-OUTPUT-PHRASE

Here, FUNCTION TRIM(WS-INPUT-NAME) returns a version of the name with trailing spaces removed. We can then use DELIMITED BY SIZE for all parts, simplifying the statement. While cleaner, it's important to know the traditional DELIMITED BY " " method, as you will encounter it constantly in existing legacy code.

Let's visualize the data flow with this modern approach.

    ● Start (Name Provided)
    │
    ▼
  ┌────────────────┐
  │ Get WS-INPUT-NAME │
  │ (e.g., "Alice   ") │
  └────────┬───────┘
           │
           ▼
  ┌────────────────┐
  │ Apply FUNCTION │
  │ TRIM           │
  └────────┬───────┘
           │
           ▼
    "Alice" (Result)
           │
           ▼
  ┌────────────────┐
  │ STRING into    │
  │ final phrase   │
  └────────┬───────┘
           │
           ▼
    ● End

Pros and Cons of the Cobol Approach

To provide context, let's compare the Cobol way with how a modern dynamic language might handle this. This highlights Cobol's specific design philosophy.

Frequently Asked Questions (FAQ)

cobc -x -o TwoFer TwoFer.cbl

Conclusion: Your First Step to Mainframe Mastery

You have successfully navigated the Cobol Two-Fer challenge. You started with a simple requirement and built a complete, robust, and readable program that embodies the core principles of Cobol. You've learned how to structure a program with the four divisions, how to meticulously define your data, how to control program flow with IF-ELSE logic, and how to perform powerful string manipulation with the STRING verb.

This single exercise from our exclusive kodikra.com curriculum is more than just a solved problem—it's a foundational building block. The patterns and techniques you've mastered here are directly applicable to the massive, mission-critical systems that power our world. You've taken your first, most important step from being curious about Cobol to becoming a capable programmer who understands its structure and power.

Ready to continue your journey? Explore the next module in our Cobol learning path to build upon these skills, or dive deeper into the language's rich features with our complete Cobol language guide.

Disclaimer: The solution and concepts discussed are based on modern Cobol standards, tested with GnuCOBOL. Syntax and features may vary slightly in different compiler environments, such as IBM Enterprise COBOL for z/OS.

Published by Kodikra — Your trusted Cobol learning resource.