Logikal Blog

We now have a generation of kids who never worked on real computers, only x86 platforms; so Business Class Computing needs to be explained. This all started with an exchange I had on the qt-interest list with someone I respect.

-Text isn’t a stream.

Katepart would disagree.

part of the exchange, their response to my previous message

I run into this a lot when people have only worked on x86 based platforms or Unix. They don’t know what constitutes a Business/Enterprise class system or why. Some believe if you string a bunch of AWS modules together and run your enterprise on it then it must be a Business Class system. Nothing could be further from the truth.

We will start with some pictures to ease you into the conversation. This is a Class 8 truck.

The Toyota Tacoma is generally considered a Class 1 truck. A light truck like this is what many of you think of when someone says “truck.” Yes, some of you will think of Class 2a like the Ford F-150 or the Class 2b like the Ford F-250 or Chevrolet Silverado 2500. The point is that most of the x86 platforms are one of these truck classes, and Business Class computer platforms are the Class 8 lines.

Yes, as long as something could be put into boxes that fit into the bed you could probably transport it with one of these lower class trucks, but should you? The answer to that question will probably become clear with this image.

Just how many little trucks would have to be on the road to keep your local gas station supplied with fuel? How cheap do you think FedEx (or anyone else’s) overnight delivery would be if they were limited to what could fit in the back of a light duty truck? Just how soggy do you want your packages? To round out the discussion and stop all of the “but but but” chatter, just how far do you think your light or medium duty pick-up will get hauling this?

No, your eyes aren’t deceiving you. The tractor has an air-tag axle in front of the tandem drive axles. It only gets put on the ground when they are hauling something really heavy. This load obviously doesn’t qualify. Not that it matters for this discussion, but highway rules and regulations cap the maximum per axle weight, even with a permit, because roads and bridges simply can’t take much more. The only way to haul something really heavy is to put a lot of axles under it.

Computing platforms are not much different than the truck world; there are just fewer classes. Previously, we had the home hobby (x86), midrange (VAX, HP, AS/400, etc.), and the mainframe (IBM 360/370, Unisys, Amdahl). There were many makers, those are just examples, not intended to be a complete list.

Business Class Computing Differentiation

OS Understands Logical and Physical Record

Lots of people try to spin everything so that the x86 platforms can be considered Business Class Computing. As of this writing they cannot achieve the class. Oh yes, you have N-times the floating point calculation speed of a Cray; Y-times the memory and I/O capabilities of the VAX 11/780 that was used to feed work into said Cray; and some other multiplier of some other hardware point. None of that matters. You don’t yet have a business class operating system.

I know Windows and Linux fans are wailing at such a statement, but it is a simple fact. We will explore that fact in this post.

A Business Class operating system is required to provide and support both the logical and physical definition of a record.

This doesn’t mean simulated with streams or any other hack you will find on the current x86 based operating systems. The definition of a record is the foundation for all other business class functionality. This is how you do locking; have indexed files; and have file journalling. This is how you get something like MQ Series to restart after a hard system crash due to power and automatically re-dispatch the messages it had dispatched at the time of the crash. This is how robust systems work.

OS Provides At Least One Native Indexed File Type

Indexed files are still numerous in their existence. While “new” development should avoid them, they still must be maintained. If you don’t have a relational database on your box, then they are state of the art. You just have to be careful not to lock yourself in. I talk a lot about the multi-typed record in this book.

It was the norm back in the day.

Order:
 Key 0:
     Order number    char 10        15 in systems written later.
     Rec_type          char 2
     Sequence_no       char 2         Sometimes called line number
 Generic map with filler at the end for some amount.

 Record Type
 10        Invoice header
 20        Bill to information
 30        Ship to information
 40        Carrier information
 60        Invoice detail
 61        Detail comment
 62        Credit or discount line
 70        Credit or discount summary
 80        Invoice summary

This is a typical example of a multi-typed record for an order file. Not a full record obviously. The primary key started with some character based order number followed by a two character record type followed by a sequence number. Depending on the file type the sequence number (usually character as well) could be either two or three characters. It depended on how many “comment” type lines were allowed on the thing. Usually 01 – 99 was more than enough for most applications.

Why was this design used? It was incredibly fast. You did a keyed hit to the 10 record for a specific invoice then sequentially read until the invoice number changed or you hit end of file. When you are building an order entry screen that has has the bill-to, ship-to, etc. at the top and a limited scrolling region for detail lines, this perfect. Keep in mind these were green screens.

You would just have a field for Vendor/Customer ID. You would navigate to it and hit some key combination to bring up a screen like the one above.

This was amazing. It was fantastic. This was a trap. The sheer amount of code written for these types of files made it almost impossible to bring in relational databases. For companies that never grew beyond the limitations of the indexed file system it was okay. Everybody else eventually had to bite a really big bullet.

OS Provides Record/File and Other Resource Sharing

These platforms were designed to be multi-user from the start. Even back when PDP 11 machines maxed out at 2 MEG of RAM and every process had to fit (with the OS) inside 64K Words (it was a word, not byte, addressed machine) we still handled more than 60 simultaneous users plus various batch jobs. Here is an educational and entertaining side trip.

Because these operating systems were designed with business in mind they considered the need for 40+ data entry clerks all having terminals running the same order entry application writing records to the same file. Initially that file was a sequential transaction file that was periodically closed and fed to a batch job for processing. Every clerk was appending records to it, then required to log off and take a break.

Data Entry

If you can’t comprehend having a room full of data entry clerks manually keying orders in get yourself a copy of this book and read up on IT history. In particular you want to pay attention to “Please allow 6-8 weeks for delivery.”

These operating systems could allow multiple users into indexed files, but disk was incredibly expensive. The transaction files were originally punched cards and data entry was a keypunch operator.

Later things went to paper tape from a terminal of some sorts. Eventually that went to magnetic tape. All still a batch transaction file to be fed into one or more master files.

The whole transaction file batched into master files architecture started going away as companies found they could afford more disk. Now data entry was a terminal writing directly into the master indexed files.

Don’t get fixated on the phrase “a terminal.” It was one or more rooms full of operators at terminals. The typewriters just got changed out for computer terminals.

It was nothing to see 40 people (mostly women) in a room performing data/order entry. Every one of them entering orders into the same master file. The records management system provided all of the record locking and I/O. Depending on the indexed file type and the platform it could also dynamically expand the file.

Languages Work Together on Business Class Computing Platforms

      SELECT DRAW-IDX
         ASSIGN TO 'MY_MEGA_FILE'
         ORGANIZATION IS INDEXED
         ACCESS MODE IS SEQUENTIAL
         RECORD KEY IS DRAW_DT IN DRAWING_RECORD ASCENDING
         LOCK MODE IS AUTOMATIC
         FILE STATUS IS IN-STAT.
 

 ...
 

 FD  DRAW-IDX
     IS GLOBAL
     LABEL RECORDS ARE STANDARD.
 

     COPY 'CDD_RECORDS.DRAWING_RECORD' FROM DICTIONARY.
 

 ================
 
         INTEGER*1   K_DRAW_CHAN, K_ELM_COUNT
         PARAMETER( K_DRAW_CHAN=6, K_ELM_COUNT=52)
 

         CHARACTER*12  DRAWING_DATA
         PARAMETER( DRAWING_DATA='MY_MEGA_FILE')
 

  210    OPEN (UNIT=K_DRAW_CHAN, 
      1        FILE=DRAWING_DATA,
      2        STATUS='OLD',
      3        ORGANIZATION='INDEXED',
      4        ACCESS='KEYED',
      5        RECORDTYPE='FIXED',
      6        FORM='UNFORMATTED',
      7        RECL=K_DRAWING_RECORD_SIZE/4,
      8        CARRIAGECONTROL='FORTRAN',
      9        KEY=(1:8:CHARACTER),
      1        DISP='KEEP',
      2        IOSTAT=L_DRAW_STAT,
      3        SHARED,
      4        ERR=999)
 

Above the line of ==== is a snippet of COBOL from a program found in this book. Below it is some FORTRAN from the same book. While it may not be obvious to you, both of these programs operate on the same file and can do so at the same time. This is because the records management system provides the definition of the file and all access goes through the records management system.

Languages Required to Support Indexed Files

COBOL, FORTRAN, and most other languages for business class computers had/have standards mandating support for indexed files. Said support is usually somewhat generic so it doesn’t favor just one OS.

You may not have guessed this if you only worked on x86 based platforms, but language specifications of many languages actually require indexed file support. One of the reasons it has taken so long for a “free” COBOL compiler on Linux is that Gnu COBOL had to find an indexed file library that had all of the functionality required by the language specification. They settled on Berkley DB but it is behind a login screen with Oracle. You can read more about that at this link.

Common Calling Standard

Here’s where the x86 platform really falls apart. For the most part it lacks a common calling standard. This is also where some wiggle room was granted in the language specifications. Technically there is a FORTRAN calling standard, COBOL calling standard, DIBOL calling standard, insert-name-here calling standard. That means that a function or subroutine written in language-x is required to have a certain interface. A given method of arranging/receiving parameters, points of entry, points of exits, and methods of returning values; if you will.

On business class computing platforms you will find they try to respect that desire, but they tend to create a universal calling standard. This is how COBOL can call FORTRAN passing an array as a parameter even though FORTRAN stores arrays in a completely different manner.

When it comes to languages like C/C++ that like to pass things via pointer you can get into all kinds of trouble. To get around such trouble VMS (and probably other platforms) pass parameters by Descriptor. This is a well documented structure that contains all kinds of information about the string, array, custom object, whatever, along with the address of said object. This allows for under the hood “glue code” to re-arrange data if needed.

Try writing a system using six different languages on Linux. Don’t cheat by making each language it’s own stand-alone program. Have one program calling library routines written in five other languages. As an additional restriction don’t use transpilers that convert all of the source to C/C++ and compile that. You haven’t gotten any of the language’s benefit and you haven’t really completed the test.

Try doing the same thing on Windows and don’t cheat using DOT-NET.

Summary

Business Class Computing platforms provide a Records Management System that puts the multi in multi-user. It’s not some hokey SHARE hack like DOS had. It’s not something you can bolt on at a later date either. The kernel has to use and rely on the records management system.

Business Class Computing platforms generally provide a common calling standard. You can write your libraries and applications in as many of the languages supported on the platform as you want as long as the compiler works with the common calling standard.

x86 based systems generally don’t do this. OpenVMS is currently being ported to the x86 platform so soon there will be one business class operating system on the architecture.

For more interesting reading along these lines check out my latest book.

Edit: a few minutes after publishing

When Bill Gates was working on DOS he was working on an OS for a personal computer. There was very little storage and little memory. No thought was given to 64+ people trying to use it all at once.

When Ritchie was creating first C then Unix he was using a PDP. Every operating system I ever used on the PDP had a records management system. It wasn’t that he didn’t have exposure to such things. He was writing an operating system for a telecom switch and just wanted multiple people and processes to be able to happen. It was never supposed to get out into the wild.

When Linus Torvalds was creating what we now call Linux he was creating a “free” Unix like operating system for ordinary people. Even today Linux really only supports streams. You have to cobble together other things like PostgreSQL, Berkley DB, etc. if you want multiple users in the same data at the same time. Yes, there is a difference between a journaling file system and file journaling. File level journaling is done to participate in transactions, usually across multiple files.