jBASE PROC

jBASE PROC is the procedure-scripting language of jBASE, a MultiValue database environment now owned by Rocket Software. PROC (short for “procedure”) is one of several languages a MultiValue platform traditionally offers, sitting alongside a BASIC dialect, a paragraph macro facility, and an English-like query language. Its job is narrow but historically important: it ties together the commands a user types at the terminal, stacking them, supplying answers to prompts, branching on results, and presenting menus. jBASE PROC is best understood not as a new invention of 1991 but as jBASE’s implementation of a language that had already been in continuous use since the earliest Pick systems of the 1970s, preserved so that decades-old applications could run unchanged on modern machines.

History & Origins

PROC predates jBASE by roughly two decades. It originated in the Pick data model and its first commercial incarnation, Microdata’s Reality, released in 1973. Reality shipped with two principal user-facing languages: ENGLISH (later widely known as ACCESS or in jBASE as the Query language) for retrieving data, and PROC for executing stored sequences of commands. In an era of character terminals and command-line operation, PROC filled the role that shell scripts and batch files fill on Unix and DOS: it automated the steps an operator would otherwise type by hand.

jBASE itself arrived later. The company was founded in Hemel Hempstead, England, reportedly in 1989, and its product was first released in 1991. Its founders were engineers steeped in the Microdata/McDonnell Douglas MultiValue lineage, and a central goal of jBASE was compatibility, the ability to run applications originally written for Pick, Reality, Prime INFORMATION, and similar systems on commodity Unix and Windows hardware. To deliver that compatibility, jBASE had to support the languages those applications were written in, and PROC was one of them. So while the jBASE PROC implementation dates to the early 1990s, the language it implements is considerably older, and the syntax deliberately mirrors the traditional Pick PROC so that existing programs need little or no change.

Over the following decades the product changed hands repeatedly while the language stayed remarkably stable. Temenos Group AG acquired jBASE in 1999 to underpin its T24 banking software; Mpower1 became the worldwide distributor through its jBASE International subsidiary in 2002; Zumasys bought the distribution rights from Mpower1 and the intellectual property from Temenos in 2015; and Rocket Software acquired jBASE from Zumasys in 2021. Through all of this, PROC remained part of the supported language set.

Design Philosophy

PROC reflects the assumptions of the system it was born into: a multi-user, terminal-oriented database machine where the primary unit of work was a command typed at a prompt. Its design choices follow from that context.

• Command orchestration, not general computation. PROC is meant to drive other programs, TCL commands, BASIC programs, and queries, rather than to perform heavy logic itself. Complex business rules belong in compiled BASIC; PROC supplies the glue.
• Buffer-based, string-oriented model. PROC manipulates text in a small set of named buffers rather than working with rich typed variables. Everything is essentially a string of characters moved between buffers, assembled, and then handed to TCL.
• Stack-and-feed interaction. A PROC can build up a command, push it onto the input stack, and pre-supply the responses that the invoked program will prompt for, allowing a single procedure to walk an operator through a multi-step workflow automatically.
• Compatibility above novelty. Because PROC’s reason for existing in jBASE is to run legacy applications, the dialect intentionally avoids diverging from established Pick PROC behavior. Stability and faithful emulation matter more than adding language features.

Key Features

Buffers

The defining structural feature of PROC is its buffer model. Traditional PROC provides two input buffers (primary and secondary) and two output buffers (primary and secondary), together with a set of file buffers used when reading records from the database. The primary output buffer is what eventually gets passed to TCL as a command line; the input buffers hold parameters and prompted-for data. Much of writing a PROC consists of moving and assembling text among these buffers.

The PQ Header

By long-standing convention, a traditional PROC begins with the line PQ, which marks the item as a procedure for the PROC processor. Some Pick variants introduced extended “New PROC” forms identified by headers such as PQN or PQX, which add capabilities like additional file buffers; jBASE supports PROC for compatibility with the applications that rely on it.

Control Flow and Commands

PROC offers the building blocks of a small scripting language. A typical PROC uses commands to:

• read fields from the input buffer and from database records into buffers,
• format and concatenate text in the output buffer,
• branch with conditional IF tests and jump to labels,
• call subroutine PROCs and return,
• prompt the terminal operator for input and display messages, and
• hand the assembled command to TCL for execution with the P (process) command.

A schematic example illustrates the shape of a procedure that prompts for a customer number and then runs a report:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

PQ
   T "Enter customer number: ",+    ;* display a prompt, stay on line
   IN CUSTNO                        ;* read operator input into a buffer
   IF # CUSTNO GO 100               ;* if nothing entered, jump to label 100
   H LIST CUSTOMERS '               ;* build a command in the output buffer
   A CUSTNO                         ;* append the customer number
   P                                ;* pass the assembled command to TCL
   X                                ;* exit the procedure
100 T "No customer number supplied."
   X

The exact command letters and their semantics vary by implementation and by whether a procedure is a traditional PROC or an extended one; the snippet above is illustrative of the style rather than a guaranteed-portable program. The essential pattern, prompt, capture, assemble, and process, is what PROC is built to express.

PROC Among the MultiValue Languages

PROC is one tool in a larger toolbox. A MultiValue platform such as jBASE typically also provides:

Within this ecosystem PROC occupies the scripting niche, and for many shops Paragraph or jBC has gradually taken over the work PROC once did, even as existing PROCs continue to run.

Evolution

The story of jBASE PROC is one of preservation rather than reinvention. The language acquired its core characteristics, the PQ header, the input/output buffer model, the stack-and-feed interaction style, in the 1970s Pick and Microdata systems. When jBASE adopted it around 1991, the point was fidelity: a PROC that worked on Reality should behave the same way on jBASE. As a result there is no dramatic version history of “PROC 2.0” features in the way one finds for actively evolving general-purpose languages. Instead, PROC’s evolution is bound up with the evolution of the platform that hosts it. Each new jBASE release, through the Temenos, Mpower1, Zumasys, and now Rocket eras, has continued to carry PROC support so that the installed base of legacy applications keeps running. The most recent line, Rocket jBASE 6.2.x (6.2.1 was released in October 2024), maintains this commitment while the surrounding product gains modern connectivity, tooling, and platform support.

Current Relevance

PROC today is firmly in the category of maintained legacy. Few new applications are written primarily in PROC; greenfield jBASE work tends to favor jBC for logic and modern interfaces for the front end. But PROC remains relevant for two concrete reasons. First, an enormous body of existing MultiValue software, much of it decades old and still mission-critical, contains PROC routines that drive menus and batch jobs, and rewriting them carries cost and risk that businesses are rarely eager to take on. Second, jBASE’s whole value proposition has long been “run your Pick-era application unchanged on modern hardware,” and honoring PROC is part of keeping that promise. As long as Rocket Software supports jBASE, PROC continues to be a living, if quiet, part of the platform.

Why It Matters

jBASE PROC matters less as a language to learn fresh than as a window into a distinct and enduring tradition in computing. The MultiValue/Pick world developed its own complete software stack, database, query language, BASIC dialect, and procedure language, largely in parallel with, and independent of, the Unix and SQL mainstreams that came to dominate textbooks. PROC embodies the assumptions of that world: terminal-centric interaction, string-and-buffer data handling, and the tight coupling of a command language to the database it sits on.

Its longevity is itself the lesson. A scripting language designed for 1970s green-screen terminals is still shipping, in supported form, in a 2024 commercial product, because the applications written in it never stopped earning their keep. jBASE PROC is a reminder that in enterprise computing, compatibility and continuity are features in their own right, and that the languages which survive longest are often not the most fashionable, but the ones whose job, quietly stacking commands so a business can keep running, simply never went away.