Open Access IV

Open Access IV was the 1992 fourth release, and the last major DOS version found, of Open Access, an integrated business package from Software Products International (SPI) of San Diego. It combined a relational database, spreadsheet, word processor, graphics, communications and desk accessories. It is listed in a language encyclopedia because of what its database module contained: a programming language, which SPI’s own files simply call Programmer and Computerwoche called PRO, for building complete menu-driven applications on top of the database.

Strictly speaking, Open Access IV is a product and Programmer is the language inside it. Sources describe the language inconsistently, and no reference manual was available for this page, so its description below rests mainly on sample source code from SPI’s own German installation disks of 1987.

History and Origins

SPI and the first Open Access

SPI grew out of a San Diego software scene. Computerworld reported in April 1984 that “the folks at SPI come from the University California San Diego,” and that the company had been licensing software to manufacturers since 1979. Spanish Wikipedia names its president as John Bowne, but gives 1984 as the year SPI began operating, which conflicts with that report.

Open Access was launched in 1983. Practical Computing said so directly in February 1986, reviews from 1984 reproduce screens reading “(C) 1983,” and InfoWorld was calling it “a new program” in December 1983. The encyclopedia’s master list gives 1982, but no source found dates any Open Access product to that year. WinWorld and German Wikipedia give 1984, and that may reflect when copies actually shipped: InfoWorld’s December 1983 report still describes the program in the future tense.

The first version belonged to the integrated-software boom alongside Symphony, Framework and Ovation. InfoWorld’s report listed six functions at $595: database management, spreadsheet, three-dimensional graphics, word processing, telecommunications and time management. SPI’s advertising claimed 60 man-years of development. Creative Computing’s October 1984 survey listed versions for the IBM PC and the Tandy 2000, requiring 192K of memory and two disk drives.

The database was the centre of the design. Australian PC World noted in July 1984 that it borrowed commands from dBase II and that, according to SPI, its query language derived from IBM’s SQL. When Popular Computing reviewed the package in April 1985 it noted macros, but said the things missing were “a clock and a programming language.”

Programmer arrives with Open Access II

That gap closed with Open Access II. PC Australia announced it in September 1986 with “a database programming language,” and the sample programs on a surviving 1987 disk set carry file dates from 1986 and 1987. A Network edition followed in October 1986, according to Datamation.

Datamation’s report of 1 March 1987 is the clearest period statement of what the language was for. It says SQL “is used for specifying data retrieval criteria, and the Programmer programming language is used for customized application development.” PC Magazine’s November 1987 network comparison, by contrast, refers to “the SQL programming language in Open Access II,” which shows how loosely the two could be run together.

Open Access III and IV

Open Access II was revised through 1988. Computerwoche reported in February that release 2.1 was due by March, with spell-checking and hyphenation, and DOS International also reported a version 2.1 with that support. The same Computerwoche piece calls the language PRO and says SPI had introduced a runtime system so that PRO applications could start directly from DOS without an installed copy of Open Access. Open Access III followed. The Computer History Museum holds a disk dated 1989, DOS International’s April 1990 issue says it had been seen at Comdex and would appear in German at CeBIT, and PRONOM gives 1990 as its release year.

Open Access IV was announced in Germany by Computerwoche on 23 October 1992 as the fourth release, available immediately at about 3,000 marks. It required MS-DOS 3.0 or later. A Vintage Computing Lab inventory entry records version 4.0 from 1992 on 3.5-inch disks, and a UK advert from August 1993 lists a Programmer and a Compiler among its components. Later point releases seem to exist: German Wikipedia lists an undated 4.01b, and a WinWorld forum user reports having 4.01.

Design Philosophy

Open Access was designed so that a non-programmer could get a long way without code. The 1993 UK advert puts it this way: “There is no need for programming to create powerful forms and complex reports. Yet a programming language for the database is included to further customize your database applications.”

That produced a layered system:

1. Forms and reports built interactively, for ordinary users.
2. SQL-style queries for selecting data.
3. Programmer for full applications with their own menus, windows and logic.

Programmer treats the things a business application needs as language statements, not library calls. Database views, windows, menus and field-level input are all part of its vocabulary.

Key Features

The examples here come from sample programs on the Open Access II German installation disks preserved at the Internet Archive, whose program files are dated August 1987 and whose samples are dated 1986 and 1987. They show Programmer at that stage, and later versions may differ. This page has not run them.

Statements and block structure

Programmer is line-oriented, with blocks closed by explicit END keywords. ! starts a comment and \\ continues a line. Keywords appear to be case-insensitive, since the samples use both cases. SPI’s own label program includes this routine, which fills the next free output field:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

if outval > "  "                 ! Test for empty fields in DB Master
   if outnum = 1                 ! Test which field in condense file
      object.line_a = outval     !   receives insert record
   else if outnum = 2
      object.line_b = outval
   else if outnum = 3
      object.line_c = outval
   end if
   outnum = outnum + 1           ! Increment record out counter
end if

The original continues through line_g. Variables are assigned without any declaration in the samples, and conversion is explicit through functions such as string().

Database statements

Tables are reached through named views, and records through a cursor-like pointer. This condensed excerpt from the same program opens two files and walks one of them:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

view source = from S_file            ! Master DB file
view object = from lab_file          ! File receiving condensed records
use source                           ! Activate file
use object                           ! Activate file
purge object                         ! Removes all records in condensed file
if count(source) <> 0
   find source top                   ! Pointer to first record in Master DB
   while recno (source) >0           ! Sets condition for loop
      new object                     ! Zero in-memory in condensed file
      outval = source.firma
      do lab_writ                    ! Test for empty fields
      insert object                  ! Incert records into condensed file
      find source next               ! Pointer to next record in Master DB
   end while                         ! Marks end of loop
end if

Fields are addressed as view.field. Other samples use LIST to show records and DELETE to remove one. DO name runs another source file as a routine, and this is how the samples split an application into parts.

Windows and menus

Text-mode windows are declared, nested and activated by SCREEN ... END SCREEN blocks, and MENU builds a selection list. This is from a confirmation routine in SPI’s customer-management sample:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

WINDOW m_fenst = SIZE (15 + add_breite) BY 3 AT 20,10 FRAMED
WINDOW m_titel = TOP 1 in m_fenst MODE TITLE
WINDOW m_frage = BOTTOM 1 in m_fenst MODE PROMPT
SCREEN m_fenst
     PUT IN m_titel meldung FILLED
     PUT IN m_frage '<do>  <undo>' FILLED
     MENU
          : OK :        ergebnis = TRUE
          : Abbruch :   ergebnis = FALSE
          : K_UNDO :    ergebnis = FALSE
          END MENU
     END SCREEN

<do> and <undo> are Open Access’s own names for its accept and cancel keys. K_UNDO handles the cancel key as a menu case. The excerpt is slightly shortened from the original.

Building an application

A help file on the disks says that to “create a .CND file to execute, run Batch from the Programmer menu.” The batch file is a plain list of the application’s source files. A surviving one holds five names: labels, lab_main, lab_test, lab_writ and lab_rept. The 1993 advert’s separate Compiler suggests that later versions extended this process, but no technical description of it was found. A runtime system for finished applications existed by 1988, according to Computerwoche, and a Spanish advert also offers an optional run-time.

What the sources disagree on

Evolution

• Open Access (1983): six-function package with a relational database and macros, but no programming language.
• Open Access II (1986): added Programmer and a more fully relational database, per Soft Sector’s December 1986 review. Network support followed. Modules were sold separately from 1987.
• Open Access III (around 1990): DOS International tied its German launch to use with Gupta’s SQL system.
• Open Access IV (1992): SQL query support listed among the new release’s features by Computerwoche, although a four-command SQL subset was already in the 1985 package, along with PCX images in the database, a move from a 32 MB table limit to 2 GB files, and improved mail. Computerwoche also says programmers could reach additional memory to speed up applications, per SPI.

Practical Computing also reported in February 1986 on a modular family called Access Four, with spreadsheet, database, word processor and network-manager modules. Despite the name, that was a separate 1986 line and is not Open Access IV.

Decline and Current Relevance

Windows ended the market Open Access was built for. SPI’s answer was Windowbase, a Windows database, whose version 1.0 Computerwoche covered in September 1991, a year before Open Access IV. Computerwoche reported in May 1994 that Windowbase 2.0, shown that February, had been developed as the upgrade path for Open Access 4.0 users, and that its data and converted screen and print masks could carry over. The same article reported the bankruptcy filing of SPI Deutschland, a dispute over licence rights, and doubt about who would distribute Windowbase in Germany.

Spanish Wikipedia reports that SPI’s Spanish subsidiary closed in the same period and that the consultancy Sedyco took over support and distribution there. A Spanish magazine advert from Sedyco offers Open Access IV alongside a language called DASL (Data Access Script Language). German Wikipedia associates DASL with Windowbase, so the advert is not evidence that it replaced Programmer in Open Access itself.

The master list’s “Last Commercial” date of 2000 could not be confirmed. WinWorld and the Internet Archive preserve some versions, and SoftMate’s site still mentions migrating Open Access programs. German Wikipedia also records a third-party PHP extension from 2007 that read Open Access data files. There is no current vendor and no maintained implementation.

Open Access should not be confused with open-access publishing, which dominates searches for the name, or with IBM’s RPG Open Access.

Why It Matters

Open Access IV shows a pattern that was common in the PC era and is easy to overlook: a serious application language hidden inside an office product. Programmer gave business users and consultants views, record navigation, windows and menus as first-class statements, the same niche filled by dBASE and Paradox’s PAL. Its sales were substantial, at a reported 400,000 copies or so across several versions, and by SPI’s own description it was offering a query language derived from SQL on the IBM PC by 1984.

It also shows how quickly such languages disappear. Programs written in Programmer depended on a single vendor’s runtime, and the language has so little public documentation that its name is now reported inconsistently. The most reliable record of how it looked is a few sample files on old floppy disks.