Blue Flower

When I entered the IT business in the early 1970s, I figured that I knew it all. I knew FORTRAN and PL/I, the two major languages my company used. Over the years, I discovered that that was just the ante for the job, and that the hard part was things like figuring out what customers really wanted, versus what they said they wanted, and learning that if you design the architecture in a way that precludes a feature that customer says they do not want, they may come back in a couple years and tell you that the feature is essential. (This is not because they cannot make up their minds; it is because they may not know what they need until they start using the system. This is one of the reasons for agile development.)

In the late 1970s, I became a systems programmer on IBM System/370 mainframes. Back then, we were still using line printers and 14x17-inch green bar paper. (I remember shopping for a briefcase, and taking a piece of greenbar paper with me, to make sure the briefcase could hold listings.) When the system printed jobs, it printed a banner page with the job name in 12x12-character block letters before each job, to make it easier for the operators to separate the jobs and put the each listing in the proper bin. Here is an example of one of the block letters:

BBBBBBBBBB
BBBBBBBBBBBB
BB        BB
BB        BB
BB        BB
BBBBBBBBBB
BBBBBBBBBB
BB        BB
BB        BB
BB        BB
BBBBBBBBBBB
BBBBBBBBBB

In the program, the characters were represented as bit strings, so the first, sixth, and seventh, and twelfth lines would be

1111 1111 1100

the second and eleventh would be

1111 1111 1110

and the rest would be

1100 0000 0011

These were represented in assembly language as hexadecimal constants. (The bit strings were padded with four zero bits to make even eight-bit bytes.)

So, the letter B above would be coded like this:

B       DC    X'FFC0'
         DC    X'FFE0'
         DC    X'C030'
         DC    X'C030'
         DC    X'C030'
         DC    X'FFC0'
         DC    X'FFC0'
         DC    X'C030'
         DC    X'C030'
         DC    X'C030'
         DC    X'FFE0'
         DC    X'FFC0'

We got a new guy in the group, who had been an applications programmer. Most of the group kind of looked down on him, because he was not as technical as the rest of us.

I mentioned above things you do not learn in programming school. This guy was not a heavy-duty system internals guy, but he was great with customers. We got an microfilm printer peripheral that would save departments a ton of money over sending the work out to be done. He came up with a system that made it easy for customer departments to request microfilm output, and to index it, he gave his system a cute, memorable name, and he went around and talked it up to all the customer departments. He probably saved the company a lot more money than us 1337 but grumpy system internals types.

So this guy took over maintenance of the block letter routines. The first thing he did was to add some comments as reminders of the bit strings corresponding to each hex code:

* A = 1010   B = 1011   C = 1100   D = 1101   E = 1100  F = 1111

Although I didn't say anything, I kind of rolled my eyes internally, thinking "We're system programmers. We're supposed to know hex codes."

Several years later, long after I had moved on to another job, I realized that mentally putting the guy down for adding a hex to bit crib was a form of gatekeeping: you have to be able to do this the hard way to prove your worth. I realized that I should have put in the notes to begin with.

Thinking about it with 45 more years experience and wisdom under my belt, it occurs to me that the way I implemented it was stupid. I should have made an assembly language macro that would let us enter the block character exactly as it should appear. For example, the letter B would look like this:

B        BLKLTR 'BBBBBBBBBB  '
         BLKLTR 'BBBBBBBBBBBB'
         BLKLTR 'BB        BB'
         BLKLTR 'BB        BB'
         BLKLTR 'BB        BB'
         BLKLTR 'BBBBBBBBBB  '
         BLKLTR 'BBBBBBBBBB  '
         BLKLTR 'BB        BB'
         BLKLTR 'BB        BB'
         BLKLTR 'BB        BB'
         BLKLTR 'BBBBBBBBBBBB'
         BLKLTR 'BBBBBBBBBB  '

p>Rather than demonstrating my mad hex-to-binary conversion skillz, I could have made the thing easy to use.

It would have been even better to write a program that would read the block letters as we wanted them to print, and generate the assembly-language code. That way, if someone wanted to duplicate existing block letters, they could just type them in as-is, and the program would do the rest.

Part of what the last 45 years have taught me is that I do not have to prove to anyone that I am smart and am a good coder. I know this. And now I know that writing software that is easy to use makes me an even better coder. I wish I had realized that back then.