DataFlex 2.3

DataFlex 2.3 is the last major revision of the original, purely procedural DataFlex - a fourth-generation database language from Data Access Corporation of Miami in which a data-entry program begins as a picture of the screen and the code is a short list of commands attached to it. It was the version in which a product born on 8-bit CP/M machines was rewritten in C, and the version an Australian competitor chose to clone, which is why its command vocabulary ended up being examined by the High Court of Australia. It was replaced in 1991 by the object-oriented DataFlex 3.0, the ancestor of Visual DataFlex and of the DataFlex still sold today.

This page covers the 2.3 revision specifically. The wider history of the product family is on the Visual DataFlex page.

A note on the year

This site’s master list dates “Dataflex 2.3” to 1984. The contemporary record does not support that, and this page uses 1987 instead.

So 1984 is the year of DataFlex 2.0. Data Access’s own later material says that 2.3 was released in 1987, and the magazine record is consistent with that: 2.2 was still the version under review in June 1987, and 2.3 was in reviewers’ hands by spring 1988. No announcement of the 2.3 release itself turned up while researching this page, so the month is unknown and “1987” rests on the vendor’s word, bracketed by those two reviews.

History and Origins

By the company’s own account, Data Access Corporation was founded in Miami in 1976 and began as a hardware vendor before brothers Chip and Cory Casanave turned it toward software, presenting DataFlex at COMDEX in 1981. A later legal summary of the product’s history says DataFlex was published in 1981 after two years of research and development, and the 1984 manual’s copyright notice lists 1981, 1982 and 1983. Sources are not unanimous - Wikipedia dates the language’s development from 1982 - but the earliest advertising found for this page, running in InfoWorld from March 1982 under a Coral Gables address, already pitches DataFlex as “software for creators” to CP/M developers.

The early product was written in Pascal: the 2.0 manual names Digital Research’s Pascal/MT+ as the host language and offers an optional Pascal library for extending the system. Its specifications page lists 8080, 8085 and Z-80 processors alongside the 8086 family, and its list of supported systems is a snapshot of the pre-standard microcomputer market - CP/M, CP/M-86, MP/M-86, MS-DOS, PC-DOS and TurboDOS, together with a string of early local-area networks.

That breadth was the selling point. PC Magazine’s 1988 review called DataFlex an “old-timer” that had been “first developed for CP/M systems” and was among the first microcomputer databases to support true multi-user applications. The revisions before 2.3 added to this base in visible steps. Revision 2.2, advertised from late 1986 under the headline “DataFlex does windows!”, brought pop-up help screens and pull-down menus, a command to suspend a DataFlex program while another program ran, and, according to the trade-press notes of the time, shorter compile times, a better reindexing utility, integers widened from two bytes to four, and a utility to convert dBASE files.

DataFlex 2.3 followed. What reviewers singled out was:

• A rewrite in C. PC Magazine’s November 1988 review states that the product had been “rewritten from Pascal to C” and, as a consequence, no longer used overlay files. That helped on networks, where repeatedly loading overlays added traffic, at the cost of a longer load time and more memory.
• Graphics commands. The May 1988 review told existing users they would “be glad to see a full set of graphics commands”. A later legal summary counted 29 graphics-related words among the 254 listed in the language’s reference “encyclopedia”.
• General expressions and a much faster compiler, both from the same review.
• A C library from Data Access for reading DataFlex files from C programs.

The revision lettered 2.3b is the one that mattered in the long run. PC World reviewed DataFlex 2.3b for OS/2 in March 1989, and Data Access’s later upgrade documentation treats 2.3b as the fixed reference point of the whole 2.x line: its data files remained readable by every later revision, and files from revisions 2.1 and 2.2 had to be converted to 2.3b format, using a utility called dfconver that came with 2.3b, before anything newer could open them.

Design Philosophy

The screen is the program

A DataFlex program - the 2.0 manual calls it a configuration - starts with an image. The developer types the screen exactly as the operator should see it, using underscores to mark the windows where data goes. A utility then asks a few questions about each window and generates both the database file and the program that maintains it. PC Magazine described the result in 1988: define the file and build a complete data-entry and edit application “just by painting the screen with your favorite text editor”.

The generated program is short because the commands are large. This example follows the shape of the tutorial in the 1984 manual; it is illustrative and has not been run:

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

/SCREEN
            CUSTOMER MASTER FILE

  CUSTOMER NUMBER: _____
  NAME:            ______________________________
  CITY:            ____________________   ST: __
/*
OPEN CUST
ENTER CUST
    ENTRY CUST.NUMBER    {AUTOFIND}
    ENTRY CUST.NAME
    ENTRY CUST.CITY
    ENTRY CUST.ST        {CAPSLOCK}
ENTEREND
ABORT

Everything between /SCREEN and /* is the image. ENTER … ENTEREND is a macro that supplies the whole interactive loop: finding records by any indexed window, stepping forward and back through the file, clearing, saving and deleting, all bound to function keys the installer chose. There is no code for any of that in the program.

Two levels of language

A 1987 survey of screen generators in Computer Language magazine described DataFlex’s output as macro statements that the compiler expands and then “pseudocompiles” for a run-time interpreter, and observed that the macro language “constitutes a fourth generation procedural language in its own right” sitting on a lower-level procedural language handled by the same compiler. Developers could add macros of their own. The same article warned that mixing the two levels was tricky.

In practice this meant a program could start as generated 4GL and be extended, at named points such as ENTER.SAVE or ENTER.DELETE, with ordinary procedural code.

Write once, run on whatever the customer owns

Portability was the design goal that outlived everything else. DEC Professional’s December 1987 review, written from the VAX side, listed VAX/VMS, MicroVMS, MS-DOS, PC-DOS and UNIX System V and said programs written on one could be compiled and run on the others. PC Magazine’s May 1988 fact file for Version 2.3 gives DOS as the tested platform and adds that DataFlex also ran under CP/M, UNIX and VAX/VMS; PC World in 1989 said applications and data were portable among the DOS, OS/2, CP/M, UNIX and VAX/VMS versions. For a vertical-market software house in the 1980s, that list was the reason to buy.

Key Features

Data elements and indicators

The procedural layer has a small set of declared types. The 1984 manual documents STRING, NUMBER, DATE and INTEGER variables, with numbers and dates stored as packed binary-coded decimal, and a universal MOVE command that converts between types automatically.

The language’s most distinctive construct is the indicator: a true/false flag that, written in square brackets at the start of a line, decides whether that line executes.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

INTEGER count
OPEN CUST
CLEAR CUST
REPEAT
    FIND GT CUST BY INDEX.1
    [FOUND] BEGIN
        SHOWLN CUST.NAME
        INCREMENT count
    END
    [FOUND] LOOP
SHOWLN count " customers listed"

FOUND and FINDERR are set by FIND; indicators can be negated with NOT and combined, and the developer can declare more with INDICATOR. Alongside them are conventional IF tests, BEGIN-END blocks, WHILE, REPEAT-UNTIL and FOR loops, and GOTO and GOSUB. This sketch, like the one above, is assembled from constructs in the 1984 manual and is not a tested program.

Word operators, and what > used to mean

Comparisons in the 2.x language use word operators - LT, LE, EQ, GE, GT, NE, plus IN and MATCH for strings. Data Access’s 1998 upgrade paper documents what happened to symbolic operators when 3.x arrived, and in doing so records how 2.3b behaved:

In 2.3b, < and > inside an expression were minimum and maximum, and arithmetic on string variables was arithmetic on their numeric values. From 3.0 they became comparison and concatenation, with new MIN and MAX operators taking over the old meaning. Code that depended on the 2.3 behaviour kept compiling and silently produced different answers, which is why the paper spells it out.

The same paper calls the 2.3 compiler “very forgiving”: it accepted several kinds of incorrect syntax, such as an unquoted {Check=1|2|3} entry option, that later compilers reject.

Validation at the point of entry

Options in braces after an ENTRY command carry the validation. PC Magazine counted more than twenty data-validation functions in Version 2.3, including range and list checks, and noted that a single option could do a lookup in a related file that would take five to ten lines of dBASE. Its verdict on this part of the product was unreserved: “This may be the most powerful data entry system you’ll ever use.”

The database

Underneath is DataFlex’s own multi-key indexed file system, which the 1984 manual describes as B+ ISAM with all indexes kept current on every save. Deleted record space is reused automatically, so files never need packing. Relationships between files are declared in the file definitions rather than in each program.

Multi-user by file lock

DataFlex was multi-user from early on, but its locking in 2.3 was coarse. PC Magazine’s network review explained that LOCK locked all open files and that the language offered no record locking even though DOS 3 did. The idiom was REREAD - lock everything, re-read the active records so the program has current data - followed by the changes, SAVE, and UNLOCK as quickly as possible, never with keyboard input in between. The ENTER macro did this automatically around its saves. The magazine’s summary was that the product was “especially strong in data validation” but needed “some programming and careful file management” on a LAN.

A special edition ran on Univation’s LifeNet network as what the magazine called a database-server engine; the reviewer called it the most exciting feature of the product.

What it would not do

Reviewers were consistent about the gaps. There were no global operators: to raise every salary by ten percent, you wrote a loop. There were no relational verbs such as project and join, and no SQL. Changing a file’s layout meant exporting to ASCII and reloading, so experienced developers left spare space in their records. And, as PC World’s 1989 testing reportedly found, the generated reports read files sequentially unless the developer edited the code to use an index.

That last point shaped the published benchmarks. PC Magazine said outright that DataFlex’s results on its PC Labs tests “suffered” because the tests were written for products with global operators, and that real applications did better. PC World’s 1989 OS/2 tests, run by NSTL on a Compaq Deskpro 386/20 with 5MB of RAM, reportedly had the report generator’s code hand-edited before timing for that reason. Neither set of numbers is a fair measure of the language, and none is reproduced here.

Requirements and price in 1988

For the DOS edition of Version 2.3, PC Magazine listed 384K of RAM, a hard disk and DOS 2.0 or later, at $695 single-user or $1,250 for any number of network users, with a multi-user runtime at $300 and the LifeNet server edition at $1,650. PC World listed the OS/2 edition of 2.3b at $1,650, needing an 80286 or 80386 PC, 2MB of RAM and OS/2 1.0.

Evolution

DataFlex 3.0 arrived in 1991 - InfoWorld covered it that July and August, though Data Access’s own 1998 paper loosely dates it to “about 1990” - and was a different kind of product: object-oriented, with a user-interface management system for pull-down menus and scrolling lists. Procedural code remained legal, and Data Access gave 2.3 sites a bridge - the -x23 compiler flag, which compiled a program as 2.3b would have. The flag was kept through revision 3.04 and dropped in 3.05. The vendor’s explanation was plain: at some point a choice has to be made between backward compatibility and progress.

Other pieces of the 2.3 environment went the same way. Its flex.exe loader, which restarted the runtime whenever it exited, had no equivalent once the DOS runtime became a 32-bit program. Its function-key assignments gave way to CUA-style keys, though 3.2 shipped a df23ini.cfg file to restore the old ones for operators who wanted them, and a menuold program for sites that preferred the 2.3-style menu.

The data files proved more durable than the code. According to the 1998 paper, DataFlex 3.2 and Visual DataFlex could still read and write 2.3b-format files directly.

The Powerflex case

In Australia, Dr David Bennett wrote a development system designed to be compatible with the DataFlex language and its files, first called Powerflex and later PFXplus, and founded Powerflex Corporation in 1989 to sell it. He has described it as an upgrade path for DataFlex 2.3 and 3.x users, and the company’s conversion guide still says that most programs written for version 2.3 compile and run under PFXplus unchanged. It supports DataFlex’s procedural code, not its later object-oriented code - in effect, it carried the 2.3 dialect forward.

Data Access sued for copyright infringement. Bennett’s position was that he had reproduced function without copying expression; by his own account the case ran for ten years. The trial judge found in 1996 that copyright subsisted in the language’s individual command words. The Full Federal Court reversed that in 1997, and on 30 September 1999 the High Court dismissed Data Access’s appeal.

As summarised by a barrister’s note published shortly afterwards, the argument before the High Court concerned 169 words common to both products - 166 reserved words and three macros - out of the 254 in the DataFlex reference. The court held that a single reserved word is not a “computer program” within the Copyright Act: each is one instruction, not an expression of a set of instructions. On the macros, it held that Bennett’s independently written source was neither a reproduction nor an adaptation. Data Access did succeed on one point, which was left standing: a Huffman compression table from the later DataFlex file format, which PFXplus had to duplicate exactly to read compressed files, was a literary work and had been reproduced.

The decision is a standard reference in Australian software copyright, usually cited for the proposition that the vocabulary of a programming language is not protected word by word.

Current Relevance

DataFlex 2.3 is a historical version. It has been superseded since 1991, the tooling to compile its source as written disappeared with 3.05, and the character-mode line ended at 3.2. It ran only on the commercial operating systems of its day, and no freely redistributable copy or container image is known.

It lingered in the field all the same. Bowker’s Software Encyclopedia was still carrying entries around the turn of the century - the 1997 and 2000 editions, and reportedly later ones - for vertical-market packages that required the “Dataflex run time 2.3B” for multi-user MS-DOS, and Data Access’s 1998 white paper exists because enough customers were still on 2.3 to justify a detailed guide. Data Access Europe’s price list of printed documentation reportedly still included a “DataFlex 2.3b” manual set long afterwards, though that listing could not be re-checked for this review.

For anyone studying it now, the practical sources are the 1984 DataFlex 2.0 manual preserved by Bitsavers, which documents the same procedural core; the 1988 PC Magazine reviews and the March 1989 PC World review; Data Access’s “Upgrading to DataFlex 3.2”; and the PFXplus documentation, which describes the dialect from the point of view of a system built to imitate it.

Why It Matters

DataFlex 2.3 marks the end of a particular idea of what a database language was: not a query language, not a general-purpose language with a database library, but a tool in which the form on the screen was the specification, and the language’s job was to fill in everything the form implied. It did that across more kinds of computer than almost any of its contemporaries, at a time when a software house could not know what hardware its next customer would own.

It also has an unusual afterlife. Most superseded language revisions are remembered, if at all, by the people who used them. This one is remembered in law reports, because someone thought its dialect worth re-implementing and its owner thought the words themselves worth defending.