The Evolution from Fixed to Free Format RPG

 

Overview

RPG (Report Program Generator) has undergone several significant transformations throughout its long history, but none have been as revolutionary as the shift from fixed format to free format. Originally developed as a tightly structured, column-based language, RPG was once notorious for its rigid syntax, where every piece of code had to be written in specific columns on a line. However, with the advent of RPG IV and eventually free-format RPG, the language shed much of its historical baggage, embracing a more modern, flexible, and readable style.

This article explores the key phases in RPG's evolution from fixed to free format, emphasizing the impact this shift has had on how developers write, maintain, and think about RPG code.

---

1. The Fixed Format Era: Constraints and Structure

The Legacy of Column-Based Coding

In the early days of RPG (starting with RPG II), the language was strictly column-based, inheriting a lot of its formatting rules from the punch card systems in use at the time. Each line of code was divided into specific columns, and each column had a defined purpose. Deviating from these rules would lead to syntax errors, making the development process cumbersome and unintuitive, especially for new programmers.

Column Design in Fixed Format

Here’s how the columns were generally used in traditional fixed-format RPG:

• Columns 1-5: Sequence numbers for punch card operations or for editing convenience.
• Column 6: Continuation indicator to signal that the line of code continues from the previous line.
• Columns 7-8: Specification type, which indicated the type of operation (C for calculation, H for header, I for input, etc.).
• Columns 9-11: Factor 1 – first operand (optional depending on the operation).
• Columns 12-13: Operation code (e.g., ADD, SUB, CHAIN, etc.).
• Columns 14-24: Factor 2 – the second operand or constant to be used in the operation.
• Columns 25-35: Result field where the result of the operation was stored.
• Columns 36-80: Comment area or indicator fields.

Here’s an example of a basic fixed-format RPG IV code snippet:

C     'HELLO'      DSPLY
C     *INLR        SETON

Each line adheres to a strict structure, with operations (like DSPLY and SETON) tied to specific columns.

Drawbacks of Fixed Format

1. Low Readability: Fixed format required that code be written in predefined columns, making it difficult for developers unfamiliar with RPG to understand. The code appeared cryptic, especially to those used to more modern languages like C or Java.

2. Development Overhead: The need to manually place operations in specific columns created additional work. A simple syntax error, such as misaligning a column, could cause the entire program to fail or behave unexpectedly.

3. Rigid Structure: Fixed-format RPG enforced a single way of writing code. This rigidity made the language harder to adapt to more complex, modern programming paradigms, such as modularity, object-oriented programming, or working with APIs.

---

2. RPG IV: A Turning Point

In 1994, IBM released RPG IV (also known as RPGLE), which marked a significant shift towards modernization. RPG IV introduced several major enhancements, but it was still rooted in fixed-format conventions, though with some relaxations and enhancements.

Key RPG IV Enhancements:

1. Longer Variable Names: RPG IV allowed for variable names up to 4096 characters, a significant improvement over the previous limit of 6 characters. This increased the readability and self-documenting nature of the code.

2. Expanded Data Types: RPG IV introduced new data types such as date, time, and timestamp, allowing for more sophisticated manipulation of time-based data.

3. Modular Programming: The concept of procedures and modules was introduced in RPG IV, allowing developers to write modular, reusable code. This was a step towards more modern development methodologies.

4. Embedded SQL: RPG IV allowed the direct use of SQL within RPG code, making it easier to interact with databases, a common requirement in enterprise applications.

Initial Steps Towards Free Format

While RPG IV still adhered largely to fixed-format conventions, IBM began loosening the rules:

• Some operations, like calculation specifications, no longer required precise column alignment.
• More complex data structures (arrays, data structures, etc.) were supported, opening up more flexibility for developers.

The following RPG IV example shows a slight relaxation from the rigid structure of earlier versions:

C     EVAL      result = x + y
C     IF        result > 100
C     EXSR      print_large
C     ENDIF

While this version is more readable than earlier RPG versions, it still requires some alignment in columns.

---

3. The Introduction of Free-Format RPG

The major revolution came in 2013 when IBM introduced fully free-format RPG. This was a major overhaul that brought RPG in line with modern programming languages by abandoning the historical column restrictions entirely.

What is Free-Format RPG?

Free-format RPG is a style of RPG programming where the code is no longer constrained by specific column positions. Developers can write code in a much more natural and readable way, similar to languages like C, Java, or Python.

Here’s an example of how code written in free-format RPG looks:

dcl-s message char(50);
message = 'Hello, Free Format RPG!';
dsply message;
*inlr = *on;

As you can see, the code flows naturally from left to right without worrying about which column a particular instruction should be in. This significantly increases readability and reduces the overhead associated with writing RPG code.

Key Features of Free-Format RPG

1. No Column Restrictions: Unlike fixed-format, there are no columns that dictate where specific instructions must begin. You can write code freely across the line.

2. Structured Blocks: Free-format allows for the use of structured control statements (IF, DO, SELECT, FOR) in a way that is visually aligned and easier to follow.

3. Enhanced Readability: Code written in free format looks much cleaner and is easier to understand for both RPG developers and those coming from other languages.

4. Modern Control Structures: Free-format RPG supports modern control structures like FOR, WHILE, and DO-WHILE loops, bringing the language closer to other mainstream programming languages.

5. Flexible Declarations: Declarations for variables, files, and data structures (DCL-S, DCL-F, DCL-DS) can be made without column alignment. Additionally, free-format RPG allows for in-line initialization of variables, further simplifying the code.

Fully Free-Format RPG Example:

ctl-opt dftactgrp(*no) actgrp(*new);

dcl-s totalSales packed(15:2);
dcl-s discountRate packed(5:2) inz(0.05);
dcl-s finalPrice packed(15:2);

totalSales = 1000.00;
finalPrice = totalSales * (1 - discountRate);

if finalPrice > 900.00;
   dsply ('High Discount Applied');
endif;

*inlr = *on;

This example demonstrates the clean and easy-to-read syntax in free-format RPG. You no longer need to align your code in specific columns, making it easier for developers to focus on logic rather than format.

---

4. Transitioning from Fixed to Free Format: Benefits and Challenges

Benefits of Free Format RPG

1. Improved Developer Productivity: Free format allows developers to write code faster and with fewer errors, as they no longer need to adhere to column-based rules.

2. Enhanced Maintainability: Free-format code is easier to read and maintain, allowing teams to understand the business logic without getting bogged down by formatting concerns.

3. Better Integration with Modern Tools: Free format integrates well with modern development environments such as RDi (Rational Developer for i), offering features like syntax highlighting, code folding, and inline debugging.

4. Attracting New Developers: Free format makes RPG more approachable for developers who are familiar with other modern programming languages, helping businesses maintain and grow their RPG talent base.

Challenges of Transitioning

While free format is a significant improvement, organizations that have legacy systems with fixed-format RPG face challenges:

1. Legacy Code: Many enterprises still have large codebases in fixed format. Converting these systems to free format can be time-consuming and risky without proper planning.

2. Skill Gap: Some experienced RPG developers who are used to fixed format might initially resist the switch to free format due to familiarity with the old style.

---

5. RPG Free Format Today and Its Future

The move to free-format RPG has cemented the language's place in modern enterprise environments. While the AS/400 and its descendants (now IBM i) remain popular in industries like manufacturing, logistics, finance, and healthcare, the transition to free format ensures that RPG remains relevant and adaptable to modern IT practices.

Modern Use Cases

• Web Services and APIs: Free-format RPG allows for easier integration with web services (REST/SOAP) and the use of JSON/XML data formats.

• Database-Driven Applications: RPG remains a strong contender for applications that require heavy interaction with IBM Db2 databases.

• Cloud and Hybrid Environments: As IBM i evolves to support cloud and hybrid infrastructures, free-format RPG is well-positioned to handle these new deployment models.

---

Conclusion

The evolution from fixed to free format RPG is one of the most transformative changes in the history of the language. By abandoning the constraints of column-based formatting, free-format RPG has brought a new level of flexibility, readability, and modernity to a language that’s been serving businesses for over half a century. For developers familiar with traditional RPG, the transition to free format might seem daunting, but the long-term benefits in terms of productivity, maintainability, and ease of integration with modern tools make it a critical step forward.

As we move deeper into this tutorial, we will explore the syntax and best practices for writing free-format RPG, giving you the tools to transition effectively and embrace the power of this modernized language.

What is RPG? - Understanding the Origins, Evolution, and Modern RPG

RPG (Report Program Generator) is a high-level programming language developed by IBM in 1959 for generating business reports. Over the years, it has grown into a full-fledged general-purpose programming language, especially prominent in the IBM i (formerly AS/400) ecosystem. Although it started as a tool for producing reports from business data, RPG has continuously evolved, keeping pace with modern development practices, particularly with the introduction of RPG IV and its free-format syntax.

In this article, we will explore:

• The origins and history of RPG
• Evolution from RPG II to RPG IV
• The transition from fixed format to free format
• Modern uses of RPG on IBM i
• Why RPG is still relevant today

---

The Origins of RPG

RPG was originally designed in the late 1950s by IBM as a simpler alternative to assembly language. At the time, businesses were looking for a more efficient way to generate reports from data stored in punch cards and magnetic tapes. IBM introduced RPG as a high-level tool that could describe and generate business reports with minimal programming effort.

Early RPG: Punch Cards and Business Reports

RPG's name comes from its original function: Report Program Generator. Early versions of the language were designed to generate detailed reports from data stored in tabular form. Instead of coding individual instructions, developers could describe the format of a report, and RPG would handle the mechanics of pulling data and formatting it.

The early language was highly structured, and programs were designed to process one record at a time, read from sequential data files. Programmers would use punched cards with fixed columns to define operations, and every line of code adhered strictly to this rigid format.

RPG I and RPG II (1960s - 1970s)

RPG I, the earliest version, quickly became popular for producing business forms, invoices, and financial reports. In 1969, IBM released RPG II, which expanded the language to include more advanced features for data processing, such as indexed file access, conditional logic, and basic arithmetic operations.

Despite its improvements, RPG II remained very rigid in its structure, requiring specific columns for code and making it difficult to read, especially compared to modern languages.

---

The Evolution of RPG: From RPG III to RPG IV

RPG III (1978)

In the late 1970s, IBM introduced RPG III as part of its System/38 platform, a precursor to the AS/400. RPG III was a major step forward, allowing for more complex data structures, better control over file access, and new ways to organize logic using subroutines.

The structure of RPG III was still fixed-format, meaning that developers had to adhere to column-based code entry, but the language introduced a more modular approach to program design.

The Birth of AS/400 and RPG/400 (1988)

The launch of IBM’s AS/400 in 1988 was a milestone for RPG. The AS/400 became a popular platform for mid-sized businesses and enterprises to manage their IT infrastructure, and RPG/400 became the dominant language used on the platform.

RPG/400 was essentially an enhanced version of RPG III, optimized for the AS/400 environment, but still firmly based on fixed-format coding practices.

---

The Introduction of RPG IV and Free Format

RPG IV (1994): A New Beginning

The 1990s saw a massive overhaul of RPG with the introduction of RPG IV (also called RPGLE, where LE stands for Integrated Language Environment). RPG IV introduced many modern programming concepts, such as:

• Longer variable names (up to 4096 characters)
• Procedures and modules (allowing for modular, reusable code)
• Support for data types like date, time, and timestamp
• Integration with other languages, including C and SQL

RPG IV was a massive improvement in terms of readability, functionality, and flexibility. It also marked a shift away from column-specific coding toward a more modern and flexible approach.

However, even in RPG IV, the language was still primarily fixed-format, meaning that although the functionality had expanded, developers still needed to follow specific column rules when writing code.

---

Free Format RPG (2013): Embracing Modern Syntax

In 2013, IBM introduced fully free-format RPG, fundamentally changing how the language looked and felt. With free format, RPG finally shed its historical reliance on fixed columns, aligning with modern coding practices.

Key Features of Free Format RPG:

1. No Column Restrictions: Code is no longer constrained by specific columns. Instead, you can write code freely, as with other modern languages like Java, Python, or C.
2. Enhanced Readability: The code is easier to read and write. Developers can use indentation, spaces, and line breaks however they see fit, making the code much more maintainable.
3. Simplified Syntax: Free format eliminates much of the archaic syntax and introduces clearer, more intuitive instructions.
4. Integration with Modern Tools: Free format RPG works seamlessly with modern development tools such as Rational Developer for i (RDi), bringing advanced code editing, debugging, and refactoring tools to the RPG development process.

Here's a quick comparison of fixed-format RPG and free-format RPG:

Fixed Format RPG IV Example:

C     'HELLO'  DSPLY
C     *INLR    SETON

Free Format RPG Example:

dcl-s msg char(10) inz('HELLO');
dsply msg;
*inlr = *on;

As you can see, the free format version is much more readable and intuitive, removing the old constraints of column-based coding and introducing variable declarations (dcl-s) and inline operations (dsply).

---

Modern RPG and Its Uses

Today, RPG on IBM i is a powerful language used for building and maintaining mission-critical applications in sectors such as finance, healthcare, logistics, and manufacturing. Many businesses continue to use RPG because of its stability, integration with IBM's robust platforms, and the legacy systems they still depend on.

Typical Use Cases for RPG:

1. Enterprise Resource Planning (ERP) Systems: RPG is often used to develop and maintain ERP systems, where it handles massive amounts of transactional data reliably.
2. Data Processing Applications: RPG’s original strength in data processing makes it ideal for applications where large datasets need to be processed and reported.
3. Web Services and APIs: RPG can be integrated with web services, allowing businesses to expose and consume APIs, making it adaptable to modern web architectures.
4. SQL Integration: RPG can natively embed SQL for advanced data manipulation, making it an excellent tool for database-heavy applications.

---

Why RPG is Still Relevant Today

Despite the explosion of new languages and technologies, RPG remains relevant in the IT world for several reasons:

1. Legacy Systems: Many large enterprises still rely on RPG-based applications that were developed decades ago, and replacing or rewriting these systems would be prohibitively expensive.
2. Reliability and Performance: RPG programs running on IBM i are known for their exceptional reliability and performance. They handle complex workloads with ease, making them a trusted tool for mission-critical operations.
3. Modernization: With free format and integration with modern tools, RPG has modernized itself to remain competitive, giving long-time developers a way to bring legacy systems into the 21st century without completely rewriting codebases.

---

Conclusion

RPG has come a long way from its origins as a report generator for punch cards. Today, it's a versatile, high-level language capable of handling a wide range of applications, from enterprise resource planning to web services. With the introduction of free format RPG, the language has embraced modern development practices, making it easier to learn, write, and maintain.

In this tutorial series, we will continue exploring RPG free format in detail, starting with its syntax, setup, and how you can leverage it in the IBM i environment.

RPG Programming Language: A Journey into AS400's Core

In the vast landscape of programming languages, there exist hidden gems that have stood the test of time, quietly powering essential systems behind the scenes. One such gem is RPG (Report Program Generator), a language deeply intertwined with the AS400/IBM Power Systems and IBM i-based core systems. In this exploration, we delve into the essence of RPG, its evolution, and why it continues to thrive in today's digital age.

Introduction to RPG: A Legacy of Innovation

RPG, initially known as Report Program Generator, emerged in the late 1950s as a tool for generating business reports on IBM mainframe computers. Over the decades, RPG evolved significantly, adapting to changing technological landscapes while retaining its core principles of simplicity and efficiency. Today, RPG stands as a robust programming language integral to the operations of AS400 and IBM i-based systems.

Why RPG? Understanding its Role in Core Systems

RPG's enduring popularity in core systems stems from its unparalleled ability to handle business logic efficiently. AS400 and IBM i environments rely heavily on RPG for its seamless integration with database management systems, streamlined data processing capabilities, and unparalleled reliability. Moreover, RPG's structured nature and built-in features simplify development, maintenance, and debugging, making it the preferred choice for mission-critical applications.

RPG III: Structured Programming Constructs

RPG III introduced structured programming constructs, enhancing code readability and maintainability. Let's take a look at a simple RPG III code snippet for calculating the sum of numbers in a loop:

     C           MOVE      *ZERO         TOTAL
     C           DO        10        I = 1     TO      10
     C                   ADD       ARRAY(I)      TOTAL
     C           ENDDO
  

In this snippet, we initialize the `TOTAL` variable to zero and then loop through an array `ARRAY` with 10 elements, adding each element to the `TOTAL` variable.

RPG IV: Introducing Free-Format Syntax

With the advent of RPG IV, also known as RPGLE (RPG IV Language Extension), IBM modernized the language, introducing free-format syntax and aligning it with contemporary development practices. Let's revisit the previous example using RPG IV's free-format syntax:

     total = 0;
     do i = 1 to 10;
          total += array(i);
     enddo;
  

In RPG IV's free-format syntax, the code becomes more concise and resembles modern programming languages, eliminating the need for fixed-format columns.

Unveiling RPG's Features and Advantages

One of RPG's defining features is its rich set of built-in functions tailored for business applications. From arithmetic operations to file handling and report generation, RPG offers a comprehensive toolkit for developers to tackle diverse challenges with ease. Additionally, RPG's native support for database interactions streamlines data access and manipulation, enhancing productivity and performance.

RPG's structured programming paradigm promotes code clarity and maintainability, fostering collaboration among developers and ensuring long-term viability of applications. Moreover, RPG's integration with IBM's development tools provides a cohesive ecosystem for end-to-end application development, from coding to deployment and beyond.

Comparing RPG with Modern Languages: Bridging the Gap

While RPG's roots trace back to an era preceding modern programming languages, its evolution has not halted. With the introduction of RPG IV, also known as RPGLE (RPG IV Language Extension), IBM modernized the language, aligning it with contemporary development practices. Notably, RPG IV introduced free-format syntax, liberating developers from the constraints of fixed-format coding and bringing RPG closer to modern languages like Python and Java.

In comparison to other languages, RPG's forte lies in its specialization for business applications and seamless integration with IBM's ecosystem. While languages like Python excel in versatility and ease of use, RPG shines in domains where reliability, performance, and integration are paramount.

RPG's Evolution and the Free-Format Revolution

RPG has undergone several iterations, each introducing significant enhancements to the language. RPG I and II laid the foundation, while RPG III introduced structured programming constructs. However, it was RPG IV that revolutionized the language, offering free-format syntax and modernizing its capabilities for the digital age.

The introduction of free-format RPG IV marked a turning point, making the language more accessible to a new generation of developers accustomed to modern coding practices. IBM's efforts to position RPG as a general-purpose language for AS400 and IBM i platforms have paid dividends, attracting fresh talent and ensuring the language's relevance in contemporary software development landscapes.