Robot Simulator in Cobol: Complete Solution & Deep Dive Guide

The Ultimate Guide to Building a Robot Simulator in Cobol

Master the logic of state management and procedural programming by building a fully functional Robot Simulator in Cobol. This guide breaks down the entire process, from data structure design in the DATA DIVISION to command processing in the PROCEDURE DIVISION, turning a classic computer science problem into a practical learning experience.

Have you ever wondered how the bedrock of the global financial system—the mainframe—actually works? For decades, COBOL has been the silent, reliable workhorse processing billions of transactions daily. It might not have the modern glamour of Python or Rust, but its structured, data-centric design is a masterclass in building robust, error-resistant systems. The thought of learning it can feel like archaeology, digging through dusty manuals and rigid syntax.

But what if you could learn its powerful principles through a fun, tangible project? That's exactly what we're going to do. We will build a robot simulator from the ground up. This isn't just about making a robot move on a grid; it's about mastering the core COBOL concepts of data organization, state management, and modular procedure calls that are still incredibly relevant today. By the end of this guide, you won't just have a working program; you'll have a deep, practical understanding of why COBOL has endured for over 60 years.

What is a Robot Simulator? The Core Logic Explained

At its heart, a Robot Simulator is a program that manages the state of an object (the robot) within a defined environment (a grid). The state consists of two key components: its position and its orientation. The program's primary job is to accept a series of commands and update the robot's state accordingly.

The environment is a hypothetical infinite two-dimensional grid. The robot's position is tracked using Cartesian coordinates, typically {x,y}. Its orientation, or the direction it's facing, is one of four cardinal directions: North, East, South, or West.

The simulation is driven by a simple set of instructions:

Turn Right (R): The robot pivots 90 degrees clockwise without changing its coordinates. For example, a robot facing North will now face East.
Turn Left (L): The robot pivots 90 degrees counter-clockwise. A robot facing North will now face West.
Advance (A): The robot moves forward one grid unit in the direction it is currently facing, changing its coordinates. For example, a robot at {7,3} facing North will move to {7,4}.

The challenge lies in translating these simple rules into the structured, verbose, and highly organized syntax of COBOL. It requires careful planning in the DATA DIVISION to represent the robot's state and meticulous logic in the PROCEDURE DIVISION to handle the state transitions caused by each command.

Why is This Challenge Crucial for Mastering Cobol?

This particular problem, drawn from the exclusive kodikra.com curriculum, is not just a random exercise. It's specifically designed to force you to engage with the most fundamental and powerful features of the COBOL language. It moves beyond simple "Hello, World" examples and into the realm of practical, stateful application logic.

Key Concepts You Will Master:

Data Structures in WORKING-STORAGE: You'll learn to define and group related data items using level numbers (01, 05, 10). This hierarchical data organization is a hallmark of COBOL and is critical for managing complex records in real-world business applications.
EVALUATE Statement: This is COBOL's powerful equivalent to a switch or case statement. The robot simulator provides a perfect use case for it, allowing you to elegantly handle different commands ('R', 'L', 'A') and different directions (North, East, South, West).
Modular Programming with PERFORM: Instead of writing one monolithic block of code, you will break the logic into smaller, reusable paragraphs (like functions or methods). You'll have paragraphs for turning, advancing, and initializing, all orchestrated by the PERFORM statement. This is the cornerstone of writing maintainable COBOL programs.
State Management: The entire program revolves around accurately tracking and updating the robot's coordinates and direction. This is a microcosm of what enterprise systems do every day, whether it's managing account balances, inventory levels, or customer records.
String and Character Manipulation: You will process a string of commands, learning how to iterate through it character by character to execute instructions sequentially.

By solving this, you are effectively simulating the logic behind batch processing jobs that read a series of inputs (transactions) and update a central record (the master file). It’s a foundational skill for any aspiring mainframe or enterprise developer.

How to Design the Robot Simulator Logic

Before writing a single line of COBOL, a solid design is essential. We need to define how we'll represent the robot's state and how we'll process the commands. A common and effective approach is to use numeric values to represent the cardinal directions, as this simplifies the turning logic immensely.

State Representation

We'll define our state variables in the WORKING-STORAGE SECTION.

Coordinates: Two numeric variables, WS-X-COORD and WS-Y-COORD, defined as signed integers (e.g., PIC S9(4)) to allow for negative coordinates on the infinite grid.
Direction: A single numeric variable, WS-DIRECTION. We'll map the directions as follows:
- 0 = North
- 1 = East
- 2 = South
- 3 = West

Turning Logic with Modulo Arithmetic

This numeric mapping makes turning incredibly simple. A clockwise turn (Right) is just an increment, and a counter-clockwise turn (Left) is a decrement. To ensure the direction "wraps around" (e.g., turning right from West (3) goes back to North (0)), we use modulo arithmetic.

Turn Right: New Direction = (Current Direction + 1) MOD 4
Turn Left: New Direction = (Current Direction - 1 + 4) MOD 4 (We add 4 to prevent negative results from the subtraction before the modulo).

Main Program Flow

The overall flow of the program will be a loop that processes an instruction string one character at a time. Here is a high-level representation of that logic.

    ● Start
    │
    ▼
  ┌───────────────────┐
  │ INITIALIZE-ROBOT  │
  │ (Set X, Y, Dir)   │
  └─────────┬─────────┘
            │
            ▼
  ┌───────────────────┐
  │ Loop through each │
  │ command in string │
  └─────────┬─────────┘
            │
            ▼
    ◆ EVALUATE Command
   ╱         │         ╲
 'L'        'R'        'A'
  │          │          │
  ▼          ▼          ▼
┌─────────┐┌─────────┐┌─────────┐
│TURN-LEFT││TURN-RIGHT││ ADVANCE │
└─────────┘└─────────┘└─────────┘
  ╲          │          ╱
   └─────────┼─────────┘
             │
             ▼
  ┌───────────────────┐
  │  End Loop         │
  └─────────┬─────────┘
            │
            ▼
  ┌───────────────────┐
  │ DISPLAY-POSITION  │
  └─────────┬─────────┘
            │
            ▼
    ● End Program

Advancing Logic

The ADVANCE command's logic depends entirely on the robot's current direction. This is a perfect scenario for an EVALUATE statement based on our numeric direction variable.

    ● Start ADVANCE-ROBOT
    │
    ▼
  ┌───────────────────────┐
  │ Read WS-DIRECTION     │
  └──────────┬────────────┘
             │
             ▼
    ◆ EVALUATE WS-DIRECTION
   ╱     │         │      ╲
  0      1         2       3
(North) (East)   (South) (West)
  │      │         │       │
  ▼      ▼         ▼       ▼
┌──────┐┌──────┐┌──────┐┌──────┐
│ Y+1  ││ X+1  ││ Y-1  ││ X-1  │
└──────┘└──────┘└──────┘└──────┘
  ╲      │         │       ╱
   └─────┼─────────┼──────┘
         │
         ▼
    ● End ADVANCE-ROBOT

This structured design translates directly and cleanly into COBOL code, making the implementation straightforward and easy to debug.

Where the Logic is Implemented: The Complete Cobol Solution

Now, let's translate our design into a complete, working COBOL program. This solution uses modern, free-format COBOL for better readability, which is supported by compilers like GnuCOBOL. Each logical part is separated into its own paragraph for clarity and maintainability.


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

       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 WS-ROBOT-STATE.
          05 WS-X-COORD          PIC S9(4) VALUE 0.
          05 WS-Y-COORD          PIC S9(4) VALUE 0.
          05 WS-DIRECTION        PIC 9(1)  VALUE 0.
      *      0=North, 1=East, 2=South, 3=West

       01 WS-INSTRUCTIONS.
          05 WS-COMMAND-STRING   PIC X(100) VALUE "RRAALAL".
          05 WS-COMMAND-LENGTH   PIC 9(3).
          05 WS-COMMAND-INDEX    PIC 9(3).

       01 WS-TEMP-VARS.
          05 WS-CURRENT-COMMAND  PIC X(1).
          05 WS-REMAINDER        PIC 9(1).
          05 WS-DIRECTION-NAME   PIC X(5).

       PROCEDURE DIVISION.
       MAIN-LOGIC.
           PERFORM INITIALIZE-ROBOT
           PERFORM PROCESS-INSTRUCTIONS
           PERFORM DISPLAY-FINAL-STATUS
           STOP RUN.

       INITIALIZE-ROBOT.
      *    Set initial position and direction as per problem statement
      *    Example: Starting at {7, 3} facing North
           MOVE 7 TO WS-X-COORD.
           MOVE 3 TO WS-Y-COORD.
           MOVE 0 TO WS-DIRECTION. *> North
           DISPLAY "Robot Initialized at (" WS-X-COORD ", " WS-Y-COORD
               ") Facing North.".
           DISPLAY "Processing instructions: " WS-COMMAND-STRING.

       PROCESS-INSTRUCTIONS.
      *    Loop through the command string character by character
           MOVE FUNCTION LENGTH(FUNCTION TRIM(WS-COMMAND-STRING))
               TO WS-COMMAND-LENGTH.

           PERFORM VARYING WS-COMMAND-INDEX FROM 1 BY 1
               UNTIL WS-COMMAND-INDEX > WS-COMMAND-LENGTH

               MOVE WS-COMMAND-STRING(WS-COMMAND-INDEX:1)
                   TO WS-CURRENT-COMMAND
               
               PERFORM EVALUATE-COMMAND
           END-PERFORM.

       EVALUATE-COMMAND.
      *    Evaluate the current command and call the appropriate paragraph
           EVALUATE WS-CURRENT-COMMAND
               WHEN 'R'
                   PERFORM TURN-RIGHT
               WHEN 'L'
                   PERFORM TURN-LEFT
               WHEN 'A'
                   PERFORM ADVANCE-ROBOT
               WHEN OTHER
                   DISPLAY "Invalid command found: " WS-CURRENT-COMMAND
           END-EVALUATE.

       TURN-RIGHT.
      *    Direction = (Direction + 1) % 4
           ADD 1 TO WS-DIRECTION.
           DIVIDE WS-DIRECTION BY 4 GIVING WS-TEMP-VARS
               REMAINDER WS-DIRECTION.

       TURN-LEFT.
      *    Direction = (Direction - 1 + 4) % 4
           SUBTRACT 1 FROM WS-DIRECTION.
           IF WS-DIRECTION < 0
               ADD 4 TO WS-DIRECTION
           END-IF.

       ADVANCE-ROBOT.
      *    Move the robot one step in the current direction
           EVALUATE WS-DIRECTION
               WHEN 0 *> North
                   ADD 1 TO WS-Y-COORD
               WHEN 1 *> East
                   ADD 1 TO WS-X-COORD
               WHEN 2 *> South
                   SUBTRACT 1 FROM WS-Y-COORD
               WHEN 3 *> West
                   SUBTRACT 1 FROM WS-X-COORD
           END-EVALUATE.

       DISPLAY-FINAL-STATUS.
      *    Convert numeric direction to a name and display the final state
           EVALUATE WS-DIRECTION
               WHEN 0 MOVE "North" TO WS-DIRECTION-NAME
               WHEN 1 MOVE "East"  TO WS-DIRECTION-NAME
               WHEN 2 MOVE "South" TO WS-DIRECTION-NAME
               WHEN 3 MOVE "West"  TO WS-DIRECTION-NAME
           END-EVALUATE.

           DISPLAY "----------------------------------------".
           DISPLAY "Final Position: (" WS-X-COORD ", " WS-Y-COORD ")".
           DISPLAY "Final Direction: " WS-DIRECTION-NAME.
           DISPLAY "----------------------------------------".

       END PROGRAM RobotSimulator.

Detailed Code Walkthrough

`IDENTIFICATION DIVISION`

This is the simplest division. The PROGRAM-ID gives our program a name, RobotSimulator. It's standard boilerplate but essential for any COBOL program.

`DATA DIVISION`

This is where we define all our variables. We've structured them into groups using level numbers for clarity.

01 WS-ROBOT-STATE: This group item contains all variables related to the robot's current state.
- 05 WS-X-COORD PIC S9(4): A signed (S) numeric field that can hold 4 digits. The S is crucial for allowing negative coordinates.
- 05 WS-Y-COORD PIC S9(4): Same as the x-coordinate.
- 05 WS-DIRECTION PIC 9(1): An unsigned numeric field holding a single digit (0-3) for the direction.
01 WS-INSTRUCTIONS: This group holds the command string and variables needed to process it.
- 05 WS-COMMAND-STRING PIC X(100): An alphanumeric field that can hold up to 100 characters. We initialize it with a test sequence "RRAALAL".
- 05 WS-COMMAND-LENGTH PIC 9(3): Stores the length of the command string.
- 05 WS-COMMAND-INDEX PIC 9(3): Our loop counter for iterating through the string.
01 WS-TEMP-VARS: A section for miscellaneous helper variables.
- 05 WS-CURRENT-COMMAND PIC X(1): Holds the single character command ('R', 'L', or 'A') being processed in the loop.
- 05 WS-DIRECTION-NAME PIC X(5): Used at the end to store the string "North", "East", etc., for a user-friendly final display.

`PROCEDURE DIVISION`

This is the "brain" of the program where all the logic resides. It's organized into paragraphs, which act like functions.

MAIN-LOGIC: The entry point of our program. It orchestrates the entire process by calling other paragraphs in sequence using the PERFORM verb. This makes the main logic extremely easy to read.
INITIALIZE-ROBOT: Sets the robot's starting coordinates and direction. We've hardcoded values here, but in a real application, this data might be read from a file or user input.
PROCESS-INSTRUCTIONS: This paragraph contains the main loop.
- MOVE FUNCTION LENGTH(...): We get the actual length of the command string to control our loop. Using FUNCTION TRIM removes any trailing spaces.
- PERFORM VARYING...: This is COBOL's version of a for loop. It iterates from 1 to the length of the command string.
- MOVE WS-COMMAND-STRING(WS-COMMAND-INDEX:1): This is how you perform substringing in COBOL. It extracts one character at the current index and places it into WS-CURRENT-COMMAND.
EVALUATE-COMMAND: A clean and readable way to handle the different commands. It checks the value of WS-CURRENT-COMMAND and performs the corresponding paragraph.
TURN-RIGHT and TURN-LEFT: These implement our modulo arithmetic logic. For TURN-RIGHT, we add 1 and then use the DIVIDE...REMAINDER statement, which is COBOL's way of getting the modulo. For TURN-LEFT, we subtract 1 and handle the potential negative result to ensure the wrap-around logic is correct.
ADVANCE-ROBOT: Uses another EVALUATE statement, this time on WS-DIRECTION, to determine which coordinate to modify. It's a direct implementation of the second ASCII diagram.
DISPLAY-FINAL-STATUS: This final paragraph converts the numeric direction back into a human-readable string and displays the final state of the robot in a clean format.

When and How to Compile and Run the Program

To compile and run this COBOL program, you'll need a COBOL compiler. A popular open-source option is GnuCOBOL (formerly OpenCOBOL). Once installed, you can compile and run the code from your terminal.

1. Save the code above into a file named robot-simulator.cob.

2. Open your terminal or command prompt and navigate to the directory where you saved the file.

3. Compile the program using the cobc command. The -x flag tells the compiler to create an executable file, and -free specifies that we are using free-format source code.


cobc -x -free robot-simulator.cob

4. If the compilation is successful, a new executable file will be created. On Linux or macOS, it will be named robot-simulator. On Windows, it will be robot-simulator.exe.

5. Run the executable from your terminal.

On Linux/macOS:


./robot-simulator

On Windows:


robot-simulator.exe

Expected Output

Based on the initial values (X=7, Y=3, Dir=North) and the command string "RRAALAL", the program will produce the following output:


Robot Initialized at (+0007, +0003) Facing North.
Processing instructions: RRAALAL
----------------------------------------
Final Position: (+0009, +0004)
Final Direction: West
----------------------------------------

Comparing Approaches: Cobol's Strengths and Weaknesses

While this structured approach in COBOL is robust and clear, it's valuable to understand how it compares to other programming paradigms for the same problem. This highlights the unique characteristics of COBOL.

Aspect	COBOL (Structured) Approach	Object-Oriented (e.g., Java/Python) Approach
Data & Logic	Strict separation between data (`DATA DIVISION`) and logic (`PROCEDURE DIVISION`). Data is global within the program.	Data and logic are encapsulated together in a `Robot` class. State (x, y, dir) is stored as private attributes.
Readability	Extremely verbose and self-documenting. Paragraph names like `ADVANCE-ROBOT` make the intent clear. Can become cumbersome for complex logic.	Concise. Method calls like `robot.turn_right()` are intuitive. Relies on good naming conventions.
State Management	State is managed through global variables modified by different paragraphs. Requires careful discipline to avoid errors.	State is managed internally by the object. Methods (`.advance()`) are the only way to modify the state, providing better control and safety.
Extensibility	Adding new commands or directions requires modifying multiple `EVALUATE` statements. Can be brittle.	More flexible. New behaviors can be added as new methods. Polymorphism could be used for different robot types.
Best For	Batch processing, data-intensive tasks, and environments where stability and explicit, step-by-step logic are paramount.	Complex simulations, interactive applications, and systems where behavior and data are tightly coupled.

Frequently Asked Questions (FAQ)

Why use a numeric representation (0-3) for direction instead of strings like "NORTH"?: Using numbers (0 for North, 1 for East, etc.) dramatically simplifies the logic for turning. Turning right becomes a simple addition (direction + 1) and turning left a subtraction, combined with modulo arithmetic to handle wrapping around from 3 (West) back to 0 (North). This is far more efficient and less error-prone than using a series of complex IF/ELSE IF statements on string values.
What exactly does PIC S9(4) mean in the DATA DIVISION?: This is a Picture Clause, which defines the type and size of a data field. S indicates that the number is signed, allowing it to hold both positive and negative values. 9 represents a numeric digit. (4) specifies that the field can hold up to 4 digits. So, PIC S9(4) defines a variable that can store integers from -9999 to +9999.
How does this program handle the "infinite" grid?: The grid is conceptually infinite because we use signed integers for the coordinates (WS-X-COORD and WS-Y-COORD). There are no pre-defined boundaries or array sizes. The robot's position can increase or decrease indefinitely, limited only by the maximum value the PIC S9(4) field can hold. For a truly infinite grid, one would need to use larger numeric definitions or arbitrary-precision arithmetic, but for most simulations, this is sufficient.
Why is the PROCEDURE DIVISION broken into so many paragraphs?: This is a fundamental principle of good structured programming, especially in COBOL. Breaking the logic into small, single-purpose paragraphs (like TURN-RIGHT, ADVANCE-ROBOT) makes the code modular, easier to read, and simpler to debug. The MAIN-LOGIC paragraph then reads like a high-level summary of the program's execution, which is excellent for maintainability.
How is Cobol's EVALUATE different from a typical switch statement?: COBOL's EVALUATE is significantly more powerful than a simple switch. While we used it for a simple variable check (EVALUATE WS-CURRENT-COMMAND), it can also evaluate multiple conditions, complex expressions, and ranges. For example, you can have EVALUATE TRUE WHEN SCORE > 90 ... WHEN SCORE > 80 ..., which makes it an incredibly flexible control structure for complex business rules.
Is COBOL still relevant to learn today?: Absolutely. While it's not used for web or mobile app development, COBOL powers an estimated 80% of in-person financial transactions and is the backbone of systems in banking, insurance, government, and logistics. There is a high demand for COBOL developers to maintain and modernize these critical legacy systems, often leading to stable, well-compensated careers. Learning it provides a unique and valuable skill set.
What's a common mistake when implementing the turning logic?: A frequent error is incorrectly handling the "wrap-around" logic, especially for turning left. Simply subtracting 1 from the direction can result in a negative number (e.g., 0 for North becomes -1). A robust solution, as shown in the code, is to check if the result is negative and, if so, add 4 to bring it back into the valid 0-3 range. Forgetting this step will cause the ADVANCE-ROBOT logic to fail.

Conclusion: From Simulation to Real-World Application

You have successfully designed, built, and executed a Robot Simulator in COBOL. In doing so, you've journeyed through the core components that make COBOL such an enduring and reliable language: its highly structured data definition, its clear separation of data and procedure, and its powerful, modular control-flow statements like PERFORM and EVALUATE.

This exercise from the kodikra module is more than just an academic problem; it's a practical demonstration of state management and batch processing logic that mirrors the tasks performed by mainframe systems across the globe every second. The principles of careful data layout and modular, readable procedures are timeless. They are as critical today for maintaining billion-dollar financial systems as they were when they were first written.

As you continue your journey, you'll find that this foundational understanding of structured programming will serve you well, whether you are modernizing legacy code or simply appreciating the design patterns that ensure stability in the world's most critical software.

Disclaimer: The solution and code examples in this article were developed and tested using GnuCOBOL 3.1.2. Syntax and features may vary slightly with other COBOL compilers (e.g., IBM Enterprise COBOL for z/OS).

Ready to deepen your expertise? Explore our complete Cobol learning path or continue to the next challenge in the Cobol 2 roadmap.

Published by Kodikra — Your trusted Cobol learning resource.

kodikra

Search this blog