Betsy writes:

I found this snippet recently in a 20-year-old RPG program.

Ah, yes, twenty years ago, RPG, that means this was written in the 1970s. What? No. That can’t be right? That’s how long ago?

Joking about my mortality aside, in the early oughts, most of the work around RPG was in keeping old mainframe systems from falling over. That entirely new code was being written, that new projects were being started twenty years ago is not a surprise, but it’s unusual enough to be remarkable. That said, the last release of RPG was in 2020, so it clearly keeps on keeping on.

In any case, this developer, we’ll call them "Stephen", needed to create an array containing the numbers 12 through 16.

Let’s take a peek at the code.

D RowFld          S              3  0 DIM(5)
D X               S              3  0
D Y               S              3  0

C                   EVAL      X = 12
C                   FOR       Y = 1 TO %Elem(RowFld)
C                   EVAL      RowFld(y) = X
C                   EVAL      X = X + 1
C                   ENDFOR

The first three lines create some variables: RowFld, which is an array containing 5 elements, and will hold our offsets. X and Y are going to hold our numeric values.

We set X equal to 12, then we start a for loop from 1 to the length of our RowFld. We set the element at that index equal to X, then increment X.

The code is awkward, but is not exactly the WTF here. This particular program displays a file and a subfile, and these values are used to position the cursor inside that subfile. The array is never iterated over, the array is never modified, the array would 100% be better managed as a set of constants, if you didn’t want to have magic numbers littering your code. More than that, the location of the subfile on the screen has never changed. And let’s be fair, this didn’t get rid of magic numbers, it just made them one through five, instead of 12 through 16, as the indexes in the array are just as arbitrary.

In other words, there’s no point to this. Even if the specific version of RPG didn’t have constants variables that you handle like constants would be fine (my checks on the documentation seem to imply that CONST first appeared in version RPG IV 7.2, which makes it look like circa 2016).

But there’s one more bit of weirdness here. Stephen had several years of experience with RPG, and all of that experience was from the "free-format" era of RPG. You see, way back in 2001, RPG finally freed itself from its dependency on punchcards, and started allowing you to write code as just strings of text, without requiring certain things to exist in certain columns. This was a generally positive enhancement, and Betsy’s team immediately adopted it, as did everyone running the latest versions of RPG. All new development was done using the "free-format" style, so they could write code like normal people. They even had a conversion tool which would do some simple string manipulation to convert legacy RPG programs into the modern style, and had basically abandoned the legacy style without looking back.

Except for Stephen, who insisted on the column oriented format. Who protested when anyone tried to modify their code to modernize it at all. "Oh, we used free-format at my last job," Stephen said when pressed, "but it’s confusing and columns are just cleaner and more readable."

Eventually, someone else wrote a program that absorbed all the functionality in Stephen’s program. Stephen kept plugging away at it for a few years afterwards, because a handful of users also refused to migrate to the new tool. But eventually they left the company for one reason or another, and Stephen found himself without users for his work, and left with them.

[Advertisement] ProGet’s got you covered with security and access controls on your NuGet feeds. Learn more.