40 Years Of DB2, But Even More For That No-Name Database Embedded In The System/38

October 2, 2023 Timothy Prickett Morgan

Last week, Big Blue celebrated the 40^th anniversary of the launch of its Database 2 relational database management system for its venerable System/370, System 308X, and System/390 mainframes. It is now called Db2, because marketing people can’t leave anything alone, and even though we now have this thing called Db2 for i, IBM didn’t mention this red-headed stepchild of a relational database as part of its celebration.

Not even once. And that’s just fine by us because the integrated relational database management system that has been the heart of our venerable System/38 and its progeny was never DB2/400 or DB2 for i or Db2 for i and it never will be. It has always been its own thing and it will always been its own thing, no matter what name the marketeers slap on it. And it always benefits from whatever innovations happening in the “real” DB2 or Db2 and its Linux and Windows Server and Unix variant, which is itself only 30 years old and which was also available for IBM’s own OS/2 PC server operating system but IBM stopped talking about that two decades ago.

The relational database at the heart of IBM i today is, if you want to start from the 1978 launch date of the System/38, 45 years old.

Here’s what happened. Retired IBM Fellow Edgar Codd published one of the most interesting papers in the field of information technology in 1969 called A Relational Model of Data for Large Shared Data Banks. A lot of people read this paper, including the architects and developers for the System/38 – that would be Frank Soltis, Dick Bains, and Roy Hoffman and one of the key developers of its database, Perry Taylor. In 1974, Codd and a team of researchers at IBM’s San Jose Research Laboratory – which primarily worked on storage – created a relational database prototype called System R based on the concepts in the paper, including an English-like query language for the DBMS that was initially called SQUARE then SEQUEL and finally SQL because of trademark issues. Donald Chamberlin and Raymond Boyce, to give names to the innovators, created SQL based on the descriptions that Codd gave in his seminal paper and successors.

Larry Ellison, Bob Miner, and Ed Oates read the Codd paper, too, and forward Software Development Labs in 1977 – when the System/38 was moving towards launch and when aircraft engine maker Pratt & Whitney was already using the System R prototype in production. SDL got a contract to create a relational database for the US Central Intelligence Agency, which was codenamed ORACLE by Ellison, and that was basically V1 of the eponymous database platform. Oracle would launch its own relational database for IBM mainframe, DEC VAX, and PC platforms in 1979 as Oracle 2. This was a year after the System/38 launched, but two years before IBM put out the Structured Query Language/Data System (SQL/DS) relational database for its DOS/VSA and VM/CMS operating systems on the mainframe and four years before IBM launched the flagship Database 2, or DB2, for its flagship MVS mainframe operating system.

According to the retelling by Soltis in his Inside The AS/400 tell-all, the System/38 developers were experimenting with two-dimensional tabular structured data formats right alongside the System R team and eventually the SQL/DS team and had come up with its own innovations. Ironically, given the size of the databases needed by small and medium businesses, the nameless integrated System/38 relational database – which was partially implemented in processor and disk controller hardware, partially implemented in microcode, and partially implemented in the Control Program Facility (CPF) operating system as good design still dictates for efficiency and ease of use and which hyperscalers are only now beginning to appreciate – the IBM Rochester team felt that they only needed to implement three of the four functions that Codd thought were necessary for a database to be relational: Order, Selection, and Projection. This System/38 database did not have Join, as System R, SQL/DS, and eventually DB2 did.

IBM Rochester has never been a joiner, I guess. But eventually, that integrated database did get the ability to create a giant virtual table out of two or more tables using the JOIN function.

The other interesting thing to remember is that the integrated database for the System/38 did not just have a SQL interface but it also had a native interface that was much faster called Data Description Specification, or DDS, and when we say much faster, we mean a lot faster. This native database support was important in an era when compute oomph was scarce and therefore expensive. Interestingly, that DDS approach was similar to the Data Language/1 query language used on the Information Management System (IMS) hierarchical database that Big Blue created for its mainframes. IMS was created by IBM in 1966 to manage the bill of materials for the Saturn V rocket for the Apollo space program at NASA. (Remember when IBM was cool and truly innovative?)

The truth about DB2 is that it really was not available on MVS until 1985 and it was not until 1988 that DB2 had enough performance to be a true online transaction processing system rather than something that we today would call a data warehouse. And even still – and I was watching this in real time as IBM tried to prove the OLTP capabilities of DB2 – DB2 had performance and scale issues. When I was a cub reporter back in 1989, there was a huge bakeoff between Tandem Computer’s NonStop distributed SQL database servers and a cluster of IBM 3090 mainframes running DB2 for the state of California’s Motor Vehicles Department – a four-year, $50 million deal that would be worth $124 million today after adjusting for inflation – and Big Blue lost.

The System/38 represents true innovation in the area of relational processing, which never needed to include joins, but the other three functions for relating data to each other within the table. Joins were necessary for larger organizations who could not put everything in a big table. (Hey, isn’t that relational database layer running atop the globally distributed storage platform called Spanner inside Google itself called BigTable? Hmmmm. . . .)

But, the real innovation that changed the use of relational databases inside among small and medium businesses was not anything specifically related to SQL, but rather the relentless and joyful advance of Moore’s Law for semiconductors over many decades and consistently superior hardware-microcode-software co-design that delivered ever-improving relational database performance.

Here is the real deal, and I had to dig through the archives of The Four Hundred to find the June 1995 issue, way back when we were monthly on paper, and in black ink on light blue paper at that. This chart has been updated in format to show color, which helps, and runs from 1980 through 1997, including two years of projections on IBM midrange and mainframe costs as well as X86 server chip costs. Take a look:

This was a projection I made as IBM was transitioning from CISC processors to the PowerPC AS processors and also while IBM was transitioning to a better generation of CMOS mainframe engines in the mid-1990s. I realize that this is a bit of mixing apples and oranges with me looking at system costs for the IBM platforms and CPU costs for X86 servers, but it is interesting in that the lines are mostly following the same trends. These are street prices for the IBM systems, and for whatever the largest system was available in each line at the time. Performance is normalized to MIPS rather than to RAMP-C or CPW, the two being the performance metrics commonly used for the AS/400 and its progeny.

The interesting bit is how much more expensive the System/38 was for transaction processing compared to an IBM System/370 mainframe back in the early 1980s. It wasn’t just a little more expensive – it was crazy more expensive.

With the launch of the AS/400 in 1988 and the advent of intelligent I/O processors that handled a lot of the functions that were previously loaded on controllers and CPUs, the performance of the AS/400 rose and the cost came way down compared to the System/38 – and in fact, with the AS/400 launch, the IBM midrange was cheaper than the mainframe for the first time. That relational database in the System/38 was absolutely not free, and even as its functions were embedded in the hardware and firmware, so was its cost.

As 1980 was coming to an end, the System/38 was around $3 million per MIPS compared to around $300,000 per MIPS for the System/370. In early 1988, the mainframe and the midrange were just north of $100,000 per MIPS, but with the AS/400 Model B70, it dropped down to $67,300 per MIPS and the gap kept opening. In 1995, the top-end CISC AS/400 cost around $13,000 per MIPS and was projected to drop to around $7,000 per MIPS with the PowerPC AS processors (it ended up being closer to $6,000 per MIPS), while pricing on the ES/9021, ES/9121, and ES/9672 mainframes ranged from $15,000 per MIPS for the “midrange” 9121 and closer to $22,500 per MIPS for the bi-polar 9021 machines; the 9672 machines were in the middle and had some single-threaded performance issues.

Similar gaps existed with the cost of systems software, support, and database software between the IBM midrange and mainframe platforms, and as far as we can tell, those gaps have not gone away, but the trend lines have persisted.

So, happy birthday to you, Db2 on the mainframe. We were always better, and since 1988, we have also been cheaper.

2 thoughts on “40 Years Of DB2, But Even More For That No-Name Database Embedded In The System/38”

Paul Houston Harkins says:

October 2, 2023 at 11:34 am

Thanks to Timothy Prickett Morgan, again, for documenting the history and the importance of the System/38 relational database defined by Edgar Codd in 1969.

“The relational database at the heart of IBM i today is, if you want to start from the 1978 launch date of the System/38, 45 years old. ”

I was an IBM Systems engineer in 1969 and in 1978 and the System/38 relational database made programming much simpler and much more powerful and programming much easier then before.

Today I still use the IBM i relational database and the incredible speed of the IBM i to maker programming much simpler and easier and understandable, in spite of the weird attempts by IBM to make programming more obtuse and difficult and look like Greek instead of English (as in COBOL or the early RPG).

psumba says:

October 3, 2023 at 2:38 pm

Remember that when it was first delivered, the System/38 was artificially handicapped to 2MB of RAM and 800MB of disk (while its address scheme could address more memory than what had been manufactured to date on Earth at the time). This was an internal IBM decision so that the small computer division of IBM (General Systems) would not compete with the large computer division (Data Processing).

This Issue Sponsored By

Table of Contents

Content archive

Recent Posts

Subscribe

Pages

Search