In the beginning there was ACCESS, while PROC soon made possible practical use of the nonprocedural language that remains one of the key features of the system. In those early days, no small amount of application programming took place in Assembler. For a while, there was also the batch processor, a little-remembered artifact in the wake of our subject.

But the Pick System was not long in existence as a commercial product when the need for a procedural programming language was recognized. Necessarily incomplete, this is the story of the development and evolution of that language-Pick/BASIC.

(I told him to go write it. He said he couldn`t do it. I said he could ... and he did,) as Richard A. Pick recently recalled the late Ken Simms and the start of the Pick/BASIC project.

That comment really sets the tone for this story; a tale built on anecdotes. Pick cognoscenti will undoubtedly lament omissions and decry events recounted differently from their memories. The authors offer no apologies: this piece is presented to provide some illumination of an important component in the complex history of the Pick phenomenon ... no more, no less.

Pick/BASIC-like the Pick Operating System itself (for so long, that`s what is was, the Pick Operating System)-is a dynamic living thing (remember the Green and Rainbow manuals?). Many different people and personalities have contributed to the development of the language, sometimes contributing a major new enhancement, sometimes quietly adding little features that eventually led to a much larger capability. Not all of the story is written here: that kind of research would result in a book-length work.

Any historical discussion of Pick/BASIC has to start with an introduction to Ken Simms, who was the architect and author of the Pick/BASIC programming language and compiler. He was a student at the University of California at Irvine (UCI) when he became involved with the Pick System. When Simms went to work for Pick Systems (originally Pick & Associates), no such language existed.

(The rumor that I wrote Pick/BASIC in order to be able to play 'Star Trek` is not true. However, I did play a lot of (Star Trek) while developing the language. I needed to test the product, didn`t I?) So said Ken Simms in his introduction to Jon Sisk`s Pick/BASIC - A Programmer`s Guide, published by TAB Books in 1987.

The( Star Trek) story is the apocryphal version of how Pick/BASIC was originally written. If you ask a dozen people just how Ken got started on writing BASIC, you will get a dozen different answers. One version of this story had Dick Pick wandering into Ken`s office to see him hard at work on a new project. When asked what he was doing, Ken replied (Writing a 'Star Trek` game in Assembler.) Dick responded with (Why don`t you write it in BASIC?) When Ken remarked that no such language existed for Pick, Dick is said to have replied, (So?) Three weeks later, so the story goes, Pick had a new BASIC compiler and language.

Other sources have remarked that Ken was very involved in the gaming concept of (Star Trek) well before Pick. Sometime in 1970-71, Ken developed an electronic black box: a combination of switches, relays and lights that was a logical representation of the (Star Trek) universe. The creation of this computer game-playing machine predates Nolan Bushnell`s invention of PONG, which was first installed at a now defunct bar called Andy Capp`s in Sunnyvale, Calif.

Did he write BASIC just to play a game? Simms is also rumored to have written versions of (Star Trek) for almost any machine to which he had access. It seemed to him to be a valuable use of system resources. If indeed he was in the process of writing the game in Assembler, then writing BASIC was unnecessary. Part of what went on around him influenced the development of the language.

In 1972, an article by researchers at the University of California, Los Angeles was published about a new compiler concept. The article was a discussion of the formal grammar necessary for developing a meta compiler using the Bacchus Naur Form. The word (meta) means (about.) The meta compiler was a compiler of a compiler, a self-referential system. Simms was fascinated by the concepts presented.

This self-generating environment was the driving concept behind the WIZARD program generator, one of the first third-generation language program development tools. The original version of WIZARD was written by Ken Simms. (The Wizard 4GL is now owned and distributed by Pick Products of Australia.)

Compilers translate, optimize and assemble source code statements into machine readable code, which can then be executed. The meta compiler, which is token-oriented, produced a BASIC compiler that also uses tokens. These tokens are interpreted when a program is executed. The use of a token-based system produced a compiler with two main characteristics: (1) easy addition of new structures to the language, and (2) sometimes cryptic error messages. Pick/BASIC is a hybrid of compiled and interpreted code. A compiled BASIC program is translated from the source code to an intermediate language, which is then interpreted at runtime. Compiled Pick/BASIC uses a descriptor table that holds the program variables and their values (or a pointer to where the value is being stored on the disk).

Prior to the 1977 release of Pick, the compiled BASIC object code stored like any other item. It was written back to the same file using the original id prefixed with a $. At runtime, a copy was made in each user`s workspace. Cataloged programs were stored in the POINTER-FILE file. A modified and recompiled program would overwrite the $ version in the original file. This meant that you could be running the cataloged old version of a program as well as the uncataloged new version.

(The Pick environment was first shipped commercially in 1973. At the time the only documentation for it was a lone manual, euphemistically called the 'Green Manual,`) recounts Ian Sandler in his book The Pick Perspective, published by TAB Books in 1988.

The first Pick system (serial #1) shipped on Nov. 30, 1973. There were also three preserial number Pick machines, one of which went to the Bank of Guam. The Green Manual itself was written by Dick Pick, Chandru Murthi and Cliff Meyers. It was first printed around August 1974. In these pre-BASIC days, the Green Manual contained a considerable amount of information about the Assembler modes and how to use them. The Rainbow Manual that followed also was predominated by Assembler information.

With the advent of Pick/BASIC and the growing sophistication of the operating system, the sections in the manual on Assembler shrank from version to version. Separate Assembler manuals available from both Pick Systems and licensees carried rather stiff price tags and were not widely circulated among application programmers.

Documentation of the Assembler once again became part of the standard documentation set (for Advanced Pick, at least), with the arrival of Encyclopedia Pick (EPick). A joint development project of Pick Systems and JES and Associates, EPick lists almost all of the known User Exits (modes), along with the now more common extensions to Pick/BASIC that replace them.

(If they (computer scientists) had been involved in the development of Pick/BASIC ... it would have been a lot more constrained in its methods. The freewheeling philosophy of Pick led to a designer- and developer-friendly BASIC programming language. Variable length fields are a result of this 'unstructured` environment.`) says Chandru Murthi, a veteran of early Pick development.

Depending on how long you have been exposed to the Pick environment, there are several versions of Pick/BASIC (not including the many flavors of Pick) with which you might be familiar: First came MBASIC, which may have stood for meta-BASIC. This was followed by a joint development of SBASIC (Simms BASIC?), and DATABASIC with Microdata Corp. All of these versions cross-pollinated into the versions of Pick/BASIC in R83 (and later AP) with which we are now familiar.

Uninitiated programmers from other environments often find their initial exposure to the Pick environment to be a shock. One of the first things a newcomer notices is the lack of numeric statement labels. In Dartmouth Basic they are mandatory for each line of source code. In Pick/BASIC they are not. (Later versions have expanded the definition of a statement label to include alphabetic or alphanumeric.)

The other and equally astonishing concept of Pick/BASIC is the lack of data typing. Pick/BASIC only recognizes two types of variables-numeric or string-and two kinds of arrays-dimensioned or dynamic. The complex and confusing world of defined real numbers, integers, single- and double-precision numbers, Booleans and alphanumeric variables is cast aside for a simpler and more manageable view. Mathematical calculations are stored internally in binary form and converted for display or writing to a file. A small amount of overhead occurs when a program checks a variable to determine if it is binary and can be used in a calculation.

The intrinsic part of the Pick data structure, the dynamic array, was not included as a part of the original design of Pick/BASIC. The FIELD function was used to do a search for a reserved delimiter. Since dynamic array processing did not exist, this is how extracts on values and subvalues were done.

The functions EXTRACT, REPLACE, INSERT and DELETE followed in the footsteps of the FIELD function. As they came into acceptance, the use of FIELD to do delimiter searches became less common. Actual dynamic array referencing was introduced by Tom Ells in 1978.

The destructive backspace was implemented in June 1978 by Ted Schiffrin. Ken was reportedly mildly annoyed by the new type of backspace. Because he could type continuously on a terminal using the nondestructive backspace and still keep his place, he felt it was an unnecessary addition. This is just one example of the benefits that have accrued from many developers having worked on the language through the years: it extends beyond the capabilities of even the most visionary of designers and transcends the prejudices of each contributor.

One must also recognize the contribution made to the language by the users who, coming from varied environments, demanded enhancements to satisfy their own styles and requirements. This input has resulted in a steady stream of new functionality: the execute statement (permitting execution of any TCL command from within a Pick/BASIC program), NAMED COMMON (keeping variables active through the logon session), sizing and resizing of arrays within programs, enhanced precision and the introduction of floating point math, user-defined intrinsic functions, improved loop/repeat structures, write then/else, new assignment operators (+=, -=, /=, :=_,), extended INPUT functionality, the list goes on. Early versions did not support item locks, and for many years programmers made do with group locks. Introduction of item locks led to extensions to the read statement. BASIC on Unix-hosted Pick machines gained a whole set of capabilities to access the host environment.

The first include statement was implemented on a PRIME machine. This is due to the FORTRAN compiler underpinnings of the Microdata machines. FORTRAN came with an include statement. This was released in version 3.0 of Microdata Reality and became a feature of Pick/BASIC from version 2.0 on.

Many new features have been implemented with the release of Advanced Pick. Some have had a limited impact on Pick/BASIC, others have changed the way the language is used. Pick/BASIC computations are now executable within attribute defining dictionary items. The development of integral B-trees included expansions to the Pick/BASIC language to access them. Unlimited item sizing (the loss of the 32K barrier) led to different programming methodologies, as more lines of code could be fit into one program. [Ed. Note: Well, not every change is for the better when put to use!]

Advanced Pick`s FlashBASIC is the most dramatic single addition to the developer`s toolkit. From its 1993 introduction, FlashBASIC catapulted the language to a performance level only achievable in true compiled languages.

What is most remarkable about all of these evolutionary and revolutionary changes is how they all meet a standard that is a hallmark of the Pick System: at no time has backward-compatibility been sacrificed. Ken Simms would have been proud to know that his work remains untrammeled as the foundation of what is arguably the most powerful implementation of Dartmouth BASIC in use today.

Ken Simms, died Nov. 7, 1988, at the age of 38 after a long illness. A scholarship for computer science majors was established in his name at UCI and is still available.

Greg Amov, aka Brainstorm Software Consulting, is a Huntington Beach, Calif.-based Pick consultant. Denis Hill is vice president and chief information officer of Pick Systems as well as editor of PickWorld. Input to this article was provided by Jonathan E. Sisk of JES & Associates, John Wells of Pick Systems and Chandru Murthi of OpSys.