Clipper

Clipper was a compiler for the dBASE language that became a language in its own right. dBASE III was an interpreter: every copy of an application needed dBASE on the machine, and every line was re-read each time it ran. Nantucket Corporation’s Clipper compiled the same programs into stand-alone DOS .EXE files that could be handed out without a dBASE licence. From 1985 into the early 1990s it was one of the most common ways to build small business database software on the IBM PC. Its descendants, Harbour and xHarbour (open source) and Xbase++ and FlagShip (commercial), still compile Clipper code today. The language they implement is Clipper, not dBASE.

History and Origins

Nantucket and the dBASE compiler

Nantucket was founded by Barry ReBell, who ran the business, and Brian Russell, who ran the technical side. Using Clipper (Que, 1988), a guide to Summer ‘87, says the two knew each other from Ashton-Tate, the publisher of dBASE. ReBell had run a company that supplied Ashton-Tate with temporary staff, and some Ashton-Tate programmers thought a compiler should be the next step for dBASE. Datamation covered the product in its 1 February 1985 issue, before it shipped. It reported that Clipper’s chief architect had come to Nantucket from Ashton-Tate after Ashton-Tate declined to build a compiler, and that Russell expected Ashton-Tate to welcome Clipper. The company was then listed in Malibu, California. By June 1985 its ads gave an address on South Sepulveda Boulevard in Culver City.

The first release was called Winter ‘84, although it did not ship in the winter of 1984. On a surviving copy, the main executable is dated 18 April 1985 and other files are dated up to 19 May 1985. The collector who described the disk noted that “their releases were a bit delayed.” By June 1985, Nantucket was running full-page ads in Computer Language and, from that autumn, in BYTE. They called Clipper “the first true compiler for dBASE III.”

The seasonal releases

Until 1990, releases were named after seasons rather than numbered:

Summer ‘87 lasted a long time. Retailers were still listing it in 1989, and many developers kept using it well after Clipper 5.0 came out.

Clipper 5 and the break from dBASE

Clipper 5.0 shipped in 1990, and Nantucket was advertising it heavily in Computerworld by October that year. It was no longer sold as a dBASE compiler. Its ads called it “The Application Development Standard,” and it added features that had nothing to do with dBASE:

• Lexically scoped LOCAL and STATIC variables alongside the older dynamically scoped PUBLIC and PRIVATE memory variables
• Code blocks: compiled, first-class anonymous expressions that can be stored, passed and run with EVAL(). They replaced much of the old macro (&) string evaluation
• A full preprocessor with #define, #include, #command and #translate. Much of the xBase command language itself was defined through preprocessor rules in a standard header, so developers could add their own commands the same way
• Built-in object classes such as TBrowse, Get and Error, used through : message syntax. Developers could not define their own classes in standard Clipper 5, so third-party class libraries filled that gap

Later in the 5.x line, Clipper added replaceable database drivers (RDDs), which separated the language from any single file format. A July 1991 book on Clipper 5.0 still described RDDs as something that would “become available.” By 1993, third parties such as the Advantage Xbase Engine were selling their own RDDs.

The changes in 5.0 were large enough to split the user base. A 1991 Library Computing review quotes a self-employed developer who still used Summer ‘87 although he had owned 5.0 for nearly a year. Clipper 5.01 followed, and it was being sold at retail by mid-1991.

Computer Associates

At the beginning of May 1992, ReBell, who according to Computer Business Review was Nantucket’s founder and 100% shareholder, sold the company to Computer Associates International. At the time Nantucket was also developing Aspen, an object-oriented, Windows-oriented product for the Clipper community. Computer Associates later released it as CA-Visual Objects. The DOS product was renamed CA-Clipper:

Many programmers thought 5.2e was the best of these. CA-Clipper 5.3 came with the Blinker linker for real mode and the ExoSpace linker for protected mode. Protected mode let applications use memory above DOS’s 640 KB limit. Clipper never became a native Windows product; Windows work went to Visual Objects instead. On 22 April 2002 Computer Associates and GrafX Software announced a licensing agreement under which GrafX took over marketing and distribution of CA-Clipper and CA-Visual Objects. By one reseller’s account, Computer Associates wrote in January 2004 that it had “no remaining interest in Nantucket or CA-Clipper software.”

Design Philosophy

Clipper’s first goal was compatibility: take the programs dBASE III developers already had and make them run faster, with no dBASE installed. Nantucket’s 1985 ads said Clipper would run dBASE III programs “2 to 20 times faster” than the standard dBASE interpreter. That range was Nantucket’s marketing claim. The ads did not say which programs, operations or machines produced it.

Clipper also removed things. It was a compiler, so it had no interactive dot prompt, which was central to using dBASE. Clipper programs were edited in a text editor, compiled, linked with a DOS linker such as PLINK86 (bundled with early releases), and run. That made Clipper a language for building and distributing applications, while dBASE remained a tool for working with data interactively.

From version 5 onward, the goal changed from matching dBASE to extending it. Clipper added scoping, code blocks and a programmable preprocessor. It kept the xBase commands (USE, SEEK, REPLACE, @ ... SAY ... GET) that made existing code and existing developers productive.

Key Features

xBase commands and screen forms

Much of a Clipper program is dBASE-style commands for opening tables, moving through records and drawing text-mode data-entry screens:

USE Customer SHARED NEW
CLEAR
@ 1, 0 SAY "CustNum" GET Customer->CustNum PICTURE "999999" ;
       VALID Customer->CustNum > 0
@ 3, 0 SAY "Contact" GET Customer->Contact VALID !Empty(Customer->Contact)
@ 4, 0 SAY "Address" GET Customer->Address
READ

@ ... GET together with READ gave field-by-field editing with picture masks and validation rules built into the language. This was the main reason Clipper applications could be built quickly.

Clipper 5 language features

FUNCTION Main()
   LOCAL aPrices := { 12.50, 3.99, 7.25 }
   LOCAL bTax    := {| n | n * 1.08 }   // a code block
   LOCAL nTotal  := 0

   AEval( aPrices, {| n | nTotal += Eval( bTax, n ) } )
   ? "Total with tax:", nTotal
   RETURN NIL

Code blocks ({| params | expression }) were Clipper 5’s most important addition. They let library functions such as AEval(), DBEval() and the TBrowse object take behaviour as a parameter, much like function pointers or lambdas in other languages.

Other characteristics

• Dynamic typing with character, numeric, date, logical, memo, array, code block, object and NIL values. Hungarian-style prefixes like cName, nTotal and aList were a convention, not something the language enforced
• Macro operator &, which compiles and runs a string at run time. It was inherited from dBASE
• Native .DBF tables and .NTX indexes, plus other formats through the RDD layer in later 5.x releases
• An extensible library: C and assembly routines could be linked into Clipper programs. This supported a large market for add-on libraries

Evolution and Successors

Clipper’s development ended with 5.3b, but its source code was portable enough that other products took it over:

• FlagShip (multisoft Datentechnik) is a commercial compiler, first aimed at Unix and later at Linux, for porting Clipper and other xBase applications
• Xbase++ (Alaska Software) is a commercial 32-bit Windows successor that claims compatibility with Clipper Summer ‘87 and 5.x and adds object orientation
• Harbour, started in 1999, is an open-source, cross-platform Clipper-compatible compiler. xHarbour is a fork of it that adds more extensions
• CA-Visual Objects grew out of Nantucket’s Aspen project. It shares Clipper’s syntax but is a separate Windows language

Because these products exist, Clipper code has run far longer than any DOS compiler normally would. Code written for Summer ‘87 can, in many cases, still be compiled for 64-bit Linux or Windows today.

Current Relevance

CA-Clipper itself is a discontinued DOS product. It runs in DOS emulators and on old hardware, and no one sells or supports it. The language is still used through Harbour and its relatives. Some businesses still run Clipper-derived systems, and Clipper user communities reportedly remain active, especially in Brazil and parts of Europe. The Usenet group comp.lang.clipper and archives such as The Oasis keep decades of add-on libraries and discussion.

Why It Matters

Clipper showed that a compiler for another company’s interpreted language could be a successful business. It did well enough that its users came to treat it as the main language and dBASE as the ancestor. For many small companies in the late 1980s, a custom Clipper application was the first software written specifically for them, which made Clipper an important part of the “xBase” era of PC database programming. The language also shows how software outlives the company that made it. Nantucket was sold in 1992 and CA-Clipper stopped in the late 1990s, but the language continues in open-source compilers.