Hubbry Logo
Pick operating systemPick operating systemMain
Open search
Pick operating system
Community hub
Pick operating system
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Contribute something
Pick operating system
Pick operating system
Pick operating system
View on Wikipedia
from Wikipedia
Pick operating system
DeveloperDon Nelson
Dick Pick
TRW
Written inAssembly language
Initial release1965 (GIRLS), 1973 (Reality Operating System)
Marketing targetBusiness data processing
Available inEnglish
Supported platformsSolaris, Linux, AIX, Windows Server (2000 and up)
Kernel typeMonolithic (or none for operating environment implementations)
Default
user interface		Text-based
LicenseProprietary

The Pick Operating System, also known as the Pick System or simply Pick,[1] is a demand-paged, multi-user, virtual memory, time-sharing computer operating system based around a MultiValue database. Pick is used primarily for business data processing. It is named after one of its developers, Dick Pick.[2][3]

The term "Pick system" has also come to be used as the general name of all operating environments which employ this multivalued database and have some implementation of Pick/BASIC and ENGLISH/Access queries. Although Pick started on a variety of minicomputers, the system and its various implementations eventually spread to a large assortment of microcomputers, personal computers,[4] and mainframe computers.[5]

Overview

[edit]

The Pick Operating System is an integrated computing platform with a database, query and procedural operation languages, peripheral and multi-user management, and BASIC programming capabilities. Its database utilizes a hash-file system, enabling efficient data storage and retrieval by organizing data into dynamic associative arrays managed by associative files.

Data within the Pick system is organized into a hierarchical structure of accounts, dictionaries, files, and sub-files based on a hash-table model with linear probing. This structure comprises variable-length records, fields, and sub-fields, with unique naming conventions that reflect its multivalued database characteristics. Records are identified by unique keys that facilitate direct access to their storage locations.[6]

Initially constrained by the era's technological limitations, the Pick system's capacity has expanded over time, removing earlier record-size limits and introducing dynamic file allocation and B-tree indexing to enhance data management capabilities.

The Pick database operates without explicit data types,[6] treating all data as character strings, which places the onus of data integrity on the applications developed for the system. This flexibility allows Pick to store data in non-first-normal-form, avoiding the need for join operations by containing all related data within single records. This approach can optimize storage and retrieval efficiency for specific kinds of datasets.

History

[edit]

Pick was originally implemented as the Generalized Information Retrieval Language System (GIRLS) on an IBM System/360 in 1965 by Don Nelson and Dick Pick at TRW, whose government contract for the Cheyenne Helicopter project required developing a database.[5] It was supposed to be used by the U.S. Army to control the inventory of Cheyenne helicopter parts.[7]

Pick was subsequently commercially released in 1973 by Microdata Corporation (and its British distributor CMC) as the Reality Operating System now supplied by Northgate Information Solutions.[8] McDonnell Douglas bought Microdata in 1981.[5]

The first Microdata implementation, called the Reality, came only with a procedural language (PROC), and a query language (ENGLISH). In 1975, Ken Simms of Pick Systems created an implementation of Dartmouth BASIC for the Reality, with numerous syntax extensions for smart terminal interface and database operations, and it was called Data/BASIC. At or near the same time, SMI of Chicago, created an extended procedural language and called it RPL.

PROC, the procedure language was provided for executing scripts. A SQL-style language called ENGLISH allowed database retrieval and reporting, but not updates (although later, the ENGLISH command "REFORMAT" allowed updates on a batch basis). ENGLISH did not fully allow manipulating the 3-dimensional multivalued structure of data records. Nor did it directly provide common relational capabilities such as joins. This was because powerful data dictionary redefinitions for a field allowed joins via the execution of a calculated lookup in another file. The system included a spooler. A simple text editor for file-system records was provided, but the editor was only suitable[6] for system maintenance, and could not lock records, so most applications were written with the other tools such as Batch, RPL, or the BASIC language so as to ensure data validation and allow record locking.

By the early 1980s observers saw the Pick Operating System as a strong competitor to Unix.[9] BYTE in 1984 stated that "Pick is simple and powerful, and it seems to be efficient and reliable, too ... because it works well as a multiuser system, it's probably the most cost-effective way to use an XT".[10] Dick Pick founded Pick & Associates, later renamed Pick Systems, then Raining Data, then (as of 2011) TigerLogic, and finally Rocket Software. He licensed "Pick" to a large variety of manufacturers and vendors who have produced different "flavors" of Pick. The database flavors sold by TigerLogic were D3, mvBase, and mv Enterprise. Those previously sold by IBM under the "U2" umbrella are known as UniData and UniVerse. Rocket Software purchased IBM's U2 family of products in 2010 and Tiger Logic's D3 and mvBase family of products in 2014. In 2021, Rocket acquired OpenQM and jBASE as well.

Dick Pick died at age 56 due to stroke complications in October 1994.[3][11]

Pick Systems often became tangled in licensing litigation, and devoted relatively little effort to marketing[12][13] and improving its software. Subsequent ports of Pick to other platforms generally offered the same tools and capabilities for many years, usually with relatively minor improvements and simply renamed (for example, Data/BASIC became Pick/BASIC and ENGLISH became ACCESS).[6] Licensees often developed proprietary variations and enhancements; for example, Microdata created an input processor called ScreenPro.

[edit]

The Pick database was licensed to roughly three dozen licensees between 1978 and 1984. Application-compatible implementations evolved into derivatives and also inspired similar systems.

  • Reality – The first implementation of the Pick database was on a Microdata platform using firmware and called Reality. The first commercial release was in 1973. Microdata acquired CMC Ltd. in the early 80s and were based in Hemel Hempstead, England. The Microdata implementations ran in firmware, so each upgrade had to be accompanied by a new configuration chip. Microdata itself was eventually bought by McDonnell Douglas Information Systems. Pick and Microdata sued each other for the right to market the database, the final judgment being that they both had the right. In addition to the Reality Sequoia and Pegasus series of computers, Microdata and CMC Ltd. sold the Sequel (Sequoia) series which was a much larger class able to handle over 1000 simultaneous users. The earlier Reality minicomputers were known to handle well over 200 simultaneous users, although performance was slow and it was above the official limit. Pegasus systems superseded Sequoia and could handle even more simultaneous users than its predecessors. The modern version of this original Pick implementation is owned and distributed by Northgate Information Solutions Reality.
  • Ultimate – The second implementation of the Pick database was developed in about 1978 by an American company called The Ultimate Corp, run by Ted Sabarese. Like the earlier Microdata port, this was a firmware implementation, with the Pick instruction set in firmware and the monitor in assembly code on a Honeywell Level 6 machine. The system had dual personalities in that the monitor/kernel functions (mostly hardware I/O and scheduling) were executed by the native Honeywell Level 6 instruction set. When the monitor "select next user" for activation control was passed to the Honeywell WCS (writable control store) to execute Pick assembler code (implemented in microcode) for the selected process. When the user's time slice expired control was passed back to the kernel running the native Level 6 instruction set.
    • Ultimate took this concept further with the DEC LSI/11 family of products by implementing a co-processor in hardware (bit-slice, firmware driven). Instead of a single processor with a WCS microcode enhanced instruction set, this configuration used two independent but cooperating CPUs. The LSI11 CPU executed the monitor functions and the co-processor executed the Pick assembler instruction set. The efficiencies of this approach resulted in a 2× performance improvement. The co-processor concept was used again to create a 5×, 7×, and dual-7× versions for Honeywell Level 6 systems. Dual ported memory with private busses to the co-processors were used to increase performance of the LSI11 and Level 6 systems.
    • Another version used a DEC LSI-11 for the IOP and a 7X board. Ultimate enjoyed moderate success during the 1980s, and even included an implementation running as a layer on top of DEC VAX systems, the 750, 780, 785, and later the MicroVAX. Ultimate also had versions of the Ultimate Operating System running on IBM 370 series systems (under VM and native) and also the 9370 series computers. Ultimate was renamed Allerion, Inc., before liquidation of its assets. Most assets were acquired by Groupe Bull, and consisted of mostly maintaining extant hardware. Bull had its own problems and in approximately 1994 the US maintenance operation was sold to Wang.
  • Prime INFORMATION – Devcom, a Microdata reseller, wrote a Pick-style database system called INFORMATION in FORTRAN and assembler in 1979 to run on Prime Computer 50-series systems. It was then sold to Prime Computer and renamed Prime INFORMATION.[14] It was subsequently sold to VMark Software Inc. This was the first of the guest operating environment implementations. INFO/BASIC, a variant of Dartmouth BASIC,[6] was used for database applications.
  • Applied Digital Data Systems (ADDS) – First developed in 1981. This was the first implementation to be done in software only, so upgrades were accomplished by a tape load, rather than a new chip. The "Mentor" line was initially based on the Zilog Z-8000 chipset and this port set off a flurry of other software implementations across a wide array of processors with a large emphasis on the Motorola 68000.
  • UniVerse – Another implementation of the system, called UniVerse, was created by VMark Software and operated under Unix and Microsoft Windows. This was the first one to incorporate the ability to emulate other implementations of the system, such as Microdata's Reality Operating System, and Prime INFORMATION. Originally running on Unix, it was later also made available for Windows. It now is owned by Rocket Software. (The systems developed by Prime Computer and VMark are now owned by Rocket Software and referred to as "U2".)
  • UniData – Very similar to UniVerse, but UniData had facilities to interact with other Windows applications. It is also owned and distributed by Rocket Software.
  • PI/open – Prime Computer rewrote Prime INFORMATION in C for the Unix-based systems it was selling, calling it PI+. It was then ported to other Unix systems offered by other hardware vendors and renamed PI/open.
  • Fujitsu Microsystems of America – Another software implementation, existing in the late 1980s. Fujitsu Microsystems of America was acquired by Alpha Microsystems on October 28, 1989.[15][16]
  • Pyramid – Another software implementation in the 1980s
  • General Automation "Zebra" – Another software implementation in the 1980s
  • Altos – A software implementation on an 8086 chipset platform launched around 1983.
  • Wicat/Pick – Another software implementation existing in the 1980s
  • Sequoia – Another software implementation, existing from 1984. Sequoia was most well known for its fault-tolerant multi-processor model,[17][18] which could be dialed into with the user's permission and his switching terminal zero to remote with the key on the system console. He could watch what was done by the support person who had dialed on his terminal 0, a printer with a keyboard. Pegasus came out in 1987. The Enterprise Systems business unit (which was the unit that sold Pick), was sold to General Automation in 1996/1997.[19]
  • Revelation – In 1984, Cosmos released a Pick-style database called Revelation, later Advanced Revelation, for DOS on the IBM PC. Advanced Revelation is now owned by Revelation Technologies, which publishes a GUI-enabled version called OpenInsight.
  • jBASE – jBASE was released in 1991 by a small company of the same name in Hemel Hempstead, England. Written by former Microdata engineers, jBASE emulates all implementations of the system to some degree. jBASE compiles applications to native machine code form, rather than to an intermediate byte code. In 2015, cloud solutions provider Zumasys[20] in Irvine, California, acquired the jBASE distribution rights from Mpower1 as well as the intellectual property from Temenos Group.[21] On 14 Oct 2021, Zumasys announced they had sold their databases and tools, including jBASE, to Rocket Software.[22]
  • UniVision – UniVision was a Pick-style database designed as a replacement for the Mentor version, but with extended features, released in 1992 by EDP in Sheffield, England.
  • OpenQM – The only MultiValue database product available both as a fully supported non-open source commercial product and in open source form under the General Public License. OpenQM was available from its exclusive worldwide distributor, Zumasys.[23] On 14 Oct 2021, Zumasys announced it had sold its databases and tools, including OpenQM, to Rocket Software.[24]
  • Caché – In 2005 InterSystems, the maker of Caché database, announced support for a broad set of MultiValue extensions, Caché for MultiValue.[25]
  • ONware – ONware equips MultiValue applications with the ability to use common databases such as Oracle and SQL Server. Using ONware, MultiValue applications can be integrated with relational, object, and object-relational applications.
  • D3 – Pick Systems ported the Pick Operating System to run as a database product utilizing host operating systems such as Unix, Linux, or Windows servers, with the data stored within the file system of the host operating system. Previous Unix or Windows versions had to run in a separate partition, which made interfacing with other applications difficult. The D3 releases opened the possibility of integrating internet access to the database or interfacing to popular word processing and spreadsheet applications, which has been successfully demonstrated by a number of users. The D3 family of databases and related tools is owned and distributed by Rocket Software.

Through the implementations above, and others, Pick-like systems became available as database, programming, and emulation environments running under many Unix variants, Linux distributions, and versions of Microsoft Windows.

See also

[edit]
  • MUMPS, the predecessor of Caché
  • DBOS, a new Database-Oriented Operating System

References

[edit]

Bibliography

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Pick operating system

View on Grokipedia
from Grokipedia
The Pick operating system is a multi-user, multi-tasking, database-centric operating system originally developed in the mid-1960s as a logistics tool for the US Army, featuring an integrated multi-dimensional database, virtual memory management, and an English-like query language for data retrieval. Originating in 1965 at TRW Systems under the name Generalized Information Retrieval Language System (GIRLS), it was created by engineers and Richard "Dick" Pick to manage spare parts inventory for the helicopter project during the , later renamed General Information Management (GIM) and Integrated Technical Data System (ITDS) by the . After the project's cancellation, the technology entered the , leading to its first commercial release in 1973 by Microdata Corporation as the Operating System on the Reality 1600 , which implemented a in for hardware independence. At its core, employs a dictionary-based file structure where data is organized into items containing attributes, values, and subvalues delimited by special characters, supporting up to 32K bytes per item and enabling flexible, schema-free storage akin to early systems. Its virtual memory architecture uses 512-byte frames for paging, allowing efficient multi-user access with up to dozens of concurrent sessions on modest hardware such as early 486 systems. Key components include the Terminal Control Language (TCL) for command invocation, the ACCESS processor for non-procedural queries and reports in natural-language style, and an extended Dartmouth BASIC for application development, all integrated to facilitate of database-driven applications. features encompass password protection, privilege levels, and file access controls, while utilities handle for up to 125 print queues and tape backups. Licensed to multiple vendors in the 1970s and 1980s—such as General Automation (Zebra) and ()—it competed with Unix for business applications in sectors like and , praised for its portability across mainframes and minicomputers. A 1981 legal settlement between Microdata and granted parallel rights to develop variants, leading to the formal Pick Operating System under Pick and Associates (later TigerLogic). By the late 1990s, implementations evolved to support modern platforms including Unix, , and Windows, with interfaces like ODBC/JDBC and web services, though adoption waned after Pick's death in 1994 due to limited marketing. It continues to see niche use in legacy systems as of 2025, maintained by vendors like Rocket Software.

Introduction

Overview

The Pick operating system is a demand-paged, multi-user, , computer operating system built around a designed primarily for business data processing applications. This architecture treats all disk memory as directly addressable , divided into fixed-size frames of 512 bytes each, enabling efficient multi-tasking and resource sharing among users. At its core, the system integrates database management capabilities with query languages like ACCESS, procedural tools such as stored procedures (PROCs), and a environment (PICK/BASIC) into a unified platform that supports rapid , updates, and application development without requiring separate layers. This tight allows developers to handle complex data relationships directly within the OS environment, using dictionary-driven access methods for formatted output and selection criteria. The is organized in a hierarchical structure consisting of accounts (top-level containers), dictionaries (metadata definitions at , master, file, and levels), and files (hash-organized collections of items), where records feature multi-valued attributes and sub-values delimited by special marks, without enforced explicit data types to accommodate flexible, dynamic arrays up to 32,267 bytes. Users interact via a text-based interface powered by the Terminal Control Language (TCL), which provides a command prompt for executing verbs related to file operations, printing, and querying. Modern implementations of Pick, maintained by Rocket Software as of 2025, support host platforms including (such as RHEL 8–10), AIX 7.3, and /11 and Server 2016–2025). The employs a licensing model, restricting reproduction and distribution without authorization from the rights holder, and features a structure where core services, including file management and process scheduling, operate within a single for .

Key Features

The Pick operating system provides multi-user capabilities through its paging mechanism, which efficiently allocates resources among concurrent users by loading only necessary program frames into physical memory as needed. This demand-paged approach supports re-entrant code execution, allowing a single copy of programs like BASIC to serve multiple users simultaneously while preventing conflicts via file locking across up to 62 groups. Such design enables seamless interaction for dozens of users on systems with limited hardware, such as 16-32 terminal ports, optimizing CPU and memory utilization for database-intensive tasks. A core distinction of is its hash-file system, which facilitates rapid data access and storage by organizing files into hashed groups using a and separation , eliminating the need for separate filesystem layers. Each file item, limited to 32,267 bytes, is stored directly with delimiters separating attributes, values, and subvalues, allowing for efficient retrieval without traditional indexing overhead. This integrated structure supports handling, enabling direct manipulation of business data within the OS environment for high-performance operations. Pick integrates query and procedural languages directly into its shell via the Terminal Control Language (TCL), permitting database operations without external tools; for instance, the ACCESS processor enables non-procedural English-like queries for sorting, selecting, and reporting on data. Procedural elements, such as the PROC language, allow users to define command sequences and screen formats, streamlining complex workflows within the OS. Complementing this, the system eschews rigid data typing, employing flexible delimiters and conversion functions to handle variable-length fields and multi-valued attributes, which suits dynamic business applications requiring adaptable data manipulation. Originally designed for legacy minicomputers like the Microdata 1600, maintains with such hardware while supporting ports to early x86 platforms, including the PC-XT, and modern emulations on architectures through compatible implementations like OpenQM. This portability ensures continued usability of legacy applications on contemporary systems without major rewrites.

Historical Development

Origins

The Pick operating system originated in 1965 as the Generalized Information Retrieval Language System (GIRLS), developed by engineers and Richard "Dick" Pick at under a U.S. Army contract for managing spare parts inventory for the Cheyenne helicopter project during the era. The Cheyenne helicopter project was canceled in 1969, after which the GIRLS technology entered the . The initial implementation was coded in on mainframes, tailored to handle real-time in environments with limited computational resources. A key innovation was the introduction of a hash-based database structure, which enabled rapid, direct data access without sequential searches, optimizing performance for concurrent queries in resource-constrained settings. This design choice laid the groundwork for integrating database functionality directly into the operating system, allowing efficient multi-user operations even on early hardware. By the late , the system had evolved from its project-specific GIRLS roots into a generalized database management system, emphasizing support for multi-user access and broader applicability beyond . Dick Pick played a pivotal role in conceptualizing this integrated model of an operating system fused with database capabilities, envisioning a platform where , retrieval, and system management operated seamlessly as one. , who passed away in 1994 at age 56 from complications of a , left a lasting legacy in pioneering such unified environments.

Commercialization

The commercialization of the Pick operating system began in 1973 when Microdata Corporation released it as Reality OS, a time-sharing business system based on minicomputers like the Microdata 1600, and abandoned the earlier "GIRLS" moniker from its research phase. This marked the transition from internal development at TRW to a market-ready product targeted at multi-user environments for data processing. Microdata, which had acquired rights to the technology, positioned Reality as an efficient solution for handling interactive users, scaling from a few to hundreds simultaneously by the late 1970s. In 1975, Ken Simms introduced Pick/BASIC, an enhanced implementation of Dartmouth BASIC tailored for the Reality system, building on prior Data/BASIC features to support smart terminal operations and database interactions through syntax extensions. This programming language became integral to application development on Pick platforms, enabling rapid creation of business logic integrated with the system's file structures. Between 1978 and 1984, the database and operating system were licensed to approximately three dozen companies, fostering a range of implementations on various hardware while maintaining compatibility. This licensing strategy, driven by the system's portable virtual machine design, allowed vendors like Ultimate Corporation and others to adapt for their minicomputers, expanding its footprint beyond Microdata's exclusive hold from 1970 to 1978. The company's evolution accelerated in the 1980s with the founding of in 1982 by Richard "Dick" , which focused on standardizing and marketing the OS independently of hardware manufacturers. handled licensing and enhancements, navigating legal disputes with prior holders like Microdata to unify the ecosystem, including a 1984 settlement granting parallel development rights. Subsequent developments integrated into broader portfolios through licensing and partnerships. Pick OS gained widespread adoption in the for business applications, particularly in and inventory management, where its integrated database excelled at handling complex, multi-user data retrieval on minicomputers from vendors like and . This market emphasis on practical, English-like query capabilities drove its use in sectors requiring efficient record-keeping and reporting, contributing to installations in thousands of sites globally by the decade's end.

Technical Architecture

Core System Design

The Pick operating system employs a architecture that tightly couples essential operating system services, including process management and I/O handling, with built-in support for database access primitives, facilitating efficient, low-latency operations in multi-user environments. This design centralizes control within a single for the kernel components, minimizing overhead from inter-module communications while enabling direct hardware interactions. The kernel resides in the absolute (ABS) section, a fixed region of frames dedicated to , which includes the monitor, processors, and core utilities loaded from the system generation tape. Central to the system's resource management is its demand-paging virtual memory subsystem, which organizes storage into fixed-size 512-byte units known as frames, allowing pages to be loaded into physical memory only when accessed. This mechanism supports an expansive virtual address space of up to 12,192,320 frames—equivalent to roughly 6.4 gigabytes—while efficiently utilizing limited RAM on contemporary hardware by swapping inactive frames to disk using a least-recently-used eviction strategy. Such paging enables the system to accommodate dozens to hundreds of concurrent users on minicomputers, scaling with memory from 64 KB (limited users) to several MB (hundreds of users), by prioritizing active processes and deferring less urgent data transfers. The memory layout divides into ABS for kernel code, workspace for process execution (with primary and secondary buffers per process), and a file area for data storage, ensuring transparent virtualization to applications. The time-sharing scheduler implements preemptive multitasking optimized for interactive workloads, employing a round-robin algorithm that assigns fixed CPU quanta to ready processes, thereby preventing any single task from monopolizing resources and maintaining low response times for user terminals. Each process receives a dedicated process control block (PCB) in the ABS section, spaced 32 frames apart per channel, which tracks state, memory allocations, and I/O status; the scheduler cycles through these to dispatch quanta, supporting overlapped terminal buffering for concurrent input/output without blocking the CPU. Process isolation occurs at the account level, where user sessions are confined to segregated memory and file spaces, enforcing security and resource limits through kernel-enforced boundaries that prevent cross-account interference. This approach scales to multiple processes per user, with phantom processes like the spooler running as dedicated system tasks to handle peripherals asynchronously. Pick's file system provides a abstraction for all persistent data as hashed files, eschewing conventional directory trees in favor of a flat, hash-based that maps item identifiers directly to storage locations via a computational hashing . Files are configured with and separation parameters to distribute across groups of , where the item ID is divided by the modulo to yield a group offset, and collisions are resolved through or overflow groups; each frame holds up to 500 bytes of data plus linkage fields for spanning larger items. This structure supports variable-length up to 32 KB, with the entire disk pool managed as a contiguous or linked available space list, enabling rapid, direct access without hierarchical navigation and treating files as extensible containers for both code and data. The kernel and foundational components are implemented in low-level tailored to the host CPU's instruction set, incorporating specialized opcodes for efficient string manipulation, bit operations, and buffered I/O to optimize performance in data-centric tasks. To enhance portability, the core includes machine-independent extensions such as macro assemblers and relocatable code segments, allowing adaptations to diverse hardware like Data General, Prime, and minicomputers while preserving the assembly-coded efficiency of critical paths. User-developed assembly programs load into reserved ABS frames (400–4095), integrating seamlessly with the kernel via standard entry points.

Database Integration

The Pick operating system features the as its central component, inherently embedded within the OS to provide seamless management for business applications. This database utilizes hashed files to store variable-length records and multi-valued fields, enabling efficient handling of complex, non-relational structures without fixed schemas. Records, known as items, are identified by unique item-IDs and can contain up to 32,267 bytes of , organized into attributes, values, and sub-values delimited by special characters: attribute mark (ASCII 254, ^), value mark (ASCII 253, ]), and sub-value mark (ASCII 252, ). Data organization follows a strict hierarchical structure, beginning with accounts that serve as isolated user spaces containing application-specific data. Within each account lies the master dictionary (MD), which acts as a file directory pointing to individual file dictionaries and associated data files. The master dictionary customizes command vocabulary and security, while file dictionaries provide metadata such as attribute definitions (e.g., V/TAG for field names, V/MAX for maximum values, V/TYPE for data types, and V/CONV for conversion codes like dates or patterns). Data files store the actual records in hashed groups, ensuring logical separation and access control across the hierarchy. Unlike traditional systems, eliminates a separate (DBMS) layer, integrating all operations directly into the OS kernel. OS commands, executed via the Terminal Control Language (TCL) shell, manipulate the database using built-in hash algorithms that compute item locations based on the item-ID, , and separation parameters for near-constant O(1) access time. For instance, commands like CREATE-FILE establish new hashed files with specified group sizes (multiples of 512-byte frames), while COPY and other utilities handle data transfer without external tools, leveraging the OS's for frame-based paging of large datasets. Overflow in full groups is managed through linked frames, maintaining performance without manual intervention. The system supports indexed access via item-IDs and enables relational-like queries directly within the TCL shell through the ACCESS processor, a non-procedural language for ad hoc inquiries. Users can employ verbs such as LIST, SORT, SELECT, and READNEXT, combined with connectives (e.g., WITH, BY, BREAK-ON) to filter, aggregate, and report on multi-valued data in real-time, facilitating business processing without compiling custom code. For example, a query might select items where a multi-valued field matches a pattern, outputting formatted results from dictionary-defined conversions. This integration allows immediate data manipulation during interactive sessions. Data flexibility is achieved through dynamic field definitions stored in dictionaries, avoiding schema rigidity and permitting runtime adjustments to data structures. Attribute-definition items allow insertion, extraction, deletion, or replacement of values using OS functions, with support for virtual attributes that compute derived data on-the-fly (e.g., totals from multi-valued fields). This design accommodates evolving business needs, such as adding sub-values to existing records, without downtime or recompilation, emphasizing Pick's focus on adaptable, high-performance data handling.

Programming Environment

Languages and Tools

The primary programming language in the Pick operating system is Pick BASIC, an enhanced implementation of Dartmouth BASIC designed specifically for database-oriented applications. It features procedural syntax with extensions for direct file operations, such as the READ and WRITE statements that interact with the system's multi-value database files, enabling seamless data retrieval and updates without external . Pick BASIC supports dynamic arrays for handling variable-length data structures, pattern matching via functions like , and multi-user file locking to coordinate concurrent access across terminals. Programs are stored as in dictionary-driven files and compiled using the BASIC command, which generates executable for efficient execution; the CATALOG command then registers the program as a in the master . For database querying and reporting, the system provides the ENGLISH/ACCESS language, a non-procedural, English-like query processor that allows users to formulate requests in syntax. It uses verbs such as LIST, SORT, COUNT, and SUM, combined with modifiers like WITH, BY, and IF, to retrieve, analyze, and format data from files without requiring programming knowledge. For example, a query like "LIST INVENTORY WITH QUANTITY > 100 ITEM-NAME PRICE" selects and displays relevant records in a columnar report, leveraging file dictionaries to interpret attribute names abstractly. This tool supports relational operations, statistical computations, and output conversions (e.g., date formatting via OCONV), making it suitable for ad-hoc inquiries and automated reports. System administration and automation rely on built-in tools integrated directly into the operating environment. The Terminal Control Language (TCL), functioning as the command shell, provides a prompt-based interface (">") for executing verbs, managing files, and controlling peripherals, with commands like SELECT for building item lists and SP-EDIT for spooler operations. Procedures are handled via PROC, an interpretive language that stores sequences of TCL commands or ACCESS statements in the master dictionary for reuse, supporting conditional branching, argument passing, and screen formatting to automate workflows like data imports or user logons. These tools operate interpretively for rapid execution, with Pick BASIC's compiler allowing seamless integration of compiled code into the multi-user runtime, where programs share re-entrant modules and maintain session-specific data buffers. The system's dictionary mechanism further enables abstract data handling by defining attributes and conversions independently of physical storage, allowing tools like BASIC and ACCESS to reference data conceptually rather than by fixed offsets.

Development Practices

Development on the Pick operating system emphasized a rapid application development cycle, facilitated by the integrated PICK/BASIC compiler and , which allowed developers to iteratively code, compile, and test programs within a single environment without needing external tools. Programs were edited using the EDITOR processor, compiled directly with the BASIC (including options like LIST ERRORS ONLY for quick error identification), and debugged via symbolic tools such as breakpoints, trace tables, and single-step execution, enabling efficient iteration for business applications. This workflow supported non-technical users through the English-like ACCESS processor for reports, reducing development time compared to traditional languages. Account-based isolation provided a structured approach to team development, where each account maintained separate dictionaries and files to prevent interference between developers or projects. The Master Dictionary (MD) per account defined unique verbs, file synonyms, and access controls, allowing teams to work in isolated environments while sharing resources via Q-pointers with security codes. was handled through file revisions, where developers saved iterative versions of program items (e.g., via COPY or EDITOR commands) as distinct items within files, enabling manual tracking and rollback without a centralized system. Testing practices leveraged the multi-user time-sharing nature of Pick for load simulation in real-world scenarios, with developers using emulated terminal sessions to mimic concurrent access and performance under varying user loads. The integrated in PICK/ supported comprehensive testing through commands like BREAK ON for conditional breakpoints and TRACE TABLE for variable monitoring, while system-level tools such as HASH-TEST evaluated file efficiency during simulated operations. Error logging to the SYSTEM-ERRORS file and select-list (e.g., SAVE-LIST) further aided in validating and application behavior across multiple users. Maintenance routines focused on ensuring system reliability through regular file backups, hash reorganization, and overflow management to handle growing datasets efficiently. Backups were performed using the FILE-SAVE or T-DUMP commands to tape, generating labeled archives with timestamps and statistics for recovery, while T-LOAD or FILE-RESTORE allowed reloading with optimized parameters. Hash reorganization involved using HASH-TEST to analyze and select optimal modulo efficiency, followed by dumping the file (e.g., T-DUMP), clearing it with CLEAR-FILE to reset the structure, updating the dictionary parameters, and reloading the data (e.g., T-LOAD) to reclaim overflow frames and prevent fragmentation; overflow was managed dynamically by linking additional frames from the space pool, monitored via POVF for available capacity. These practices, often automated via PROC scripts, minimized downtime in production environments. Customization of system prompts and menus was a key practice for tailoring the environment to domain-specific needs, particularly in applications where user interfaces required precise data presentation. Developers used the PROMPT statement in PICK/ to redefine input cues (e.g., from ">" to a custom character) and PROC commands like T for cursor-controlled menus, enabling -oriented interfaces for tasks such as analysis or inventory valuation. The ERRMSG file allowed overriding default error messages, while dictionary conversions (e.g., ML for monetary formatting) ensured outputs aligned with financial standards like decimal alignment in reports. Tools like COMPU-SHEET further supported custom financial projections by integrating with database files for spreadsheet-like computations.

Implementations and Variants

Hardware and Software Ports

Pick was first implemented as the Generalized Information Retrieval Language System (GIRLS) on the mainframe in 1965. By the early 1970s, following commercialization, it was ported to minicomputers, notably Microdata Corporation's series, where it ran as on systems like the Microdata 800, enabling for business applications with support. These implementations emphasized portability across hardware while maintaining core file structures and query capabilities. In the , Pick saw expansions to environments, driven by commercial licensing that facilitated adaptations on diverse platforms. A prominent example was Prime INFORMATION, developed by Devcom as a implementation in for Prime minicomputers running under the operating system, which provided multi-user features. This port enhanced Pick's accessibility for mid-range systems, supporting networked operations and extending its use in . Subsequent efforts, such as Prime Computer's PI/Open, rewrote elements in to run natively on Unix-based systems from vendors like and , broadening compatibility without altering the underlying Pick architecture. Modern adaptations focus on software implementations to preserve Pick's functionality on contemporary hardware. Virtual machines enable Pick-compatible environments, such as OpenQM, to operate on x86 processors, compatible with host systems, allowing legacy applications to execute in isolated environments via tools like access. Recent versions incorporate performance optimizations, including 64-bit addressing to handle larger datasets and memory footprints, improving scalability on modern x86 servers compared to the original 32-bit constraints.

Derivative Products

The first commercial derivative of the operating system was Reality OS, developed by Microdata in 1973 as a firmware-based on their hardware platform, which integrated the directly into the system for multi-user business applications. , originally developed by VMark Software in the , extended the Pick architecture with SQL extensions for querying MultiValue data and ODBC support for integration with external relational databases, enabling hybrid application environments. Similarly, UniData, developed concurrently by UniData Inc., offered comparable SQL capabilities and ODBC connectivity, with added facilities for interacting with Windows applications; both are now maintained under the U2 family by Software following its 2009 acquisition from and run natively on modern platforms including and Windows servers. jBASE, introduced in the 1990s as a portable Pick-compatible database engine, incorporates modern API integrations such as RESTful services and JSON handling to bridge legacy Pick applications with web and cloud environments. OpenQM, an open-source-influenced derivative released in 2004, builds on this by providing C API extensions and support for contemporary integration protocols, facilitating development for distributed systems, and supports Linux and Windows. Rocket Software acquired both jBASE and OpenQM in 2021 from Zumasys, consolidating them into its MultiValue portfolio for ongoing enhancements. D3, originating from Systems in the and later advanced by TigerLogic (formerly Raining Data), serves specialized business applications with its engine, emphasizing rapid for industries like retail and . , the second major Pick derivative developed around 1978 by The Ultimate Corporation, targeted similar enterprise use cases on various hardware, including DEC and systems, focusing on customizable data management for and .

Legacy and Modern Relevance

Historical Impact

The Pick operating system pioneered the tight integration of database management directly into the core operating system architecture, treating files as the fundamental unit of storage and retrieval rather than separate file systems. This approach, originating from its development in the as the Generalized Information Retrieval Language System (GIRLS), enabled efficient handling of multi-valued data structures that avoided the rigid normalization requirements of emerging relational models. By embedding query languages like English-like Access and procedural tools into the OS kernel, Pick influenced the evolution of MultiValue databases, which adopted its post-relational paradigm for flexible, non-first-normal-form handling. This design foreshadowed key concepts in modern systems, such as schema flexibility and denormalized storage for performance in business applications, predating widespread relational database adoption by companies like . In the , achieved widespread adoption in finance, retail, and manufacturing sectors, where its multi-user capabilities supported real-time for small to medium-sized enterprises. By 1981, over 5,000 Pick-based systems had been installed globally, powering thousands of vertical applications in areas like inventory management and credit processing, often handling high volumes of daily business transactions on minicomputers. Its cost-effectiveness and portability across hardware platforms, including and later 68000 series, made it a viable alternative to Unix for data-intensive workloads, particularly in regions like where it dominated SME markets until the late . Pick contributed significantly to time-sharing concepts during the minicomputer era, bridging the gap between resource-heavy mainframes and the emerging personal computing landscape by supporting dozens of concurrent users on modest hardware like Intel 486 systems with limited RAM. This virtual memory and multi-tasking model facilitated efficient resource allocation for business logic execution, influencing subsequent OS designs that prioritized database-driven multitasking over general-purpose computing. Its legacy in procedural programming endures through the Pick/BASIC language, which enabled rapid development of business applications via dictionary-driven data manipulation, predating modern rapid application development (RAD) tools by providing integrated 4GL environments for non-technical users. Culturally, 's history reflects the personalities behind its creation, notably Richard "Dick" Pick, who was recognized for his innovative contributions despite legal battles with early licensee Microdata Corporation, settled in 1981 without financial penalties. The system's naming, derived from its primary developer's surname after evolving from the acronymic GIRLS, sparked occasional amusement and minor controversy within tech communities due to unintended connotations, though developers largely dismissed it as irrelevant to its technical merits. Pick's passing in 1994 marked a turning point, contributing to the system's gradual fade from mainstream prominence amid shifting industry priorities.

Current Usage

As of 2025, operating system and its MultiValue derivatives continue to power legacy systems in sectors requiring robust , including banking, automotive dealerships, and inventory management across global enterprises. These applications leverage the system's inherent database-centric architecture for handling complex, multi-dimensional data structures that remain efficient for transaction-heavy operations in these niches. For instance, MultiValue databases derived from are recognized as leading technologies in banking for core and compliance reporting. Rocket Software, which acquired key Pick-related assets including UniVerse and UniData in 2009, actively maintains and enhances these platforms through its MultiValue Application Platform, serving thousands of organizations worldwide. Recent developments include cloud compatibility via hybrid cloud integrations with accredited partners, enabling seamless deployment on modern infrastructures without full rewrites. Additionally, recent enhancements incorporate AI features such as the MultiValue Developer Assistant for automated MV BASIC code generation and Rocket Smart Chat for GenAI-driven insights, improving developer productivity and application modernization. The platform demonstrated strong performance in the 2024 DBTA Readers' Choice Awards for MultiValue databases, underscoring its ongoing relevance with frequent updates and integrations for contemporary business needs. As of November 2025, Rocket continues to expand hybrid cloud support and AI-driven tools for legacy modernization in MultiValue environments. Migration paths to updated MultiValue environments are facilitated by services like those from MultiValue Central, which handle server transitions to new operating systems while preserving and performance. Active developer communities, including the MVDBMS Group, provide resources for troubleshooting and best practices, fostering continuity for existing implementations. In terms of 2025 performance, emulated environments, such as those using Rocket OpenQM, demonstrate capability in managing high-volume transactions on virtualized hardware, scaling from single-user setups to systems supporting hundreds of concurrent users with a compact footprint. Free personal editions of OpenQM further enable experimentation and small-scale deployments, lowering barriers for hobbyists and legacy maintenance. Despite these strengths, challenges persist, including a shortage of specialized MultiValue talent amid broader IT skills gaps and periodic updates akin to Y2K remediation for date handling in aging codebases. Nevertheless, the platforms' cost-effectiveness—through reduced ownership costs and simplified IT management—sustains adoption in niche sectors where full migrations to relational systems would be prohibitively expensive.

References

  1. https://reality.necsws.com/history/
  2. https://www.silicon.co.uk/data-storage/database/tales-tech-history-pick-operating-system-214939
  3. https://www.thinkbrg.com/insights/publications/dick-pick-girls-and-the-history-of-reality/
  4. http://bitsavers.informatik.uni-stuttgart.de/pdf//generalAutomation/GA_Pick_Systems/Pick/88A00751A03_Overview_of_the_PICK_Operating_System_Mar1984.pdf
  5. https://sites.google.com/site/pickuniverse/pick-timeline
  6. https://hackaday.com/2025/08/23/picking-an-old-operating-system/
  7. https://www.rocketsoftware.com/products/rocket-multi-value-application-development-platform
  8. https://bitsavers.org/pdf/pickSystems/The_Pick_System_Users_Reference_Manual_1985.pdf
  9. https://docs.rocketsoftware.com/bundle/universereleasenotes_rn_1421/page/evg1736982927715.html
  10. http://bitsavers.informatik.uni-stuttgart.de/pdf/generalAutomation/GA_Pick_Systems/Pick/88A00751A03_Overview_of_the_PICK_Operating_System_Mar1984.pdf
  11. https://www.rocketsoftware.com/en-us/products/multivalue/openqm
  12. https://www.dbta.com/Editorial/News-Flashes/MultiValue-Pick-Turns-50-102883.aspx
  13. https://www.osnews.com/story/143184/dick-picks-unique-database-operating-system/
  14. http://dunfield.classiccmp.org/other/pickfaq.pdf
  15. https://www.latimes.com/archives/la-xpm-1994-10-19-me-52018-story.html
  16. https://bitsavers.computerhistory.org/pdf/datapro/datapro_reports_70s-90s/Microdata/M11-633-30_8009_Microdata_Reality.pdf
  17. https://www.scribd.com/document/639564307/Exploring-the-PICK-Operating-Sys
  18. https://pickwiki.org/index.php/Pick_Operating_System
  19. https://www.techmonitor.ai/technology/pick_operating_system_still_has_a_future_married_to_unix_us_report_finds/
  20. https://www.researchgate.net/publication/380753627_UNDERSTANDING_OPERATING_SYSTEMS
  21. https://docs.rocketsoftware.com/bundle/universepickusers_ug_1411/page/bdg1687883583704.html
  22. https://docs.rocketsoftware.com/bundle/universepickusers_ug_1411/page/mqe1687883579652.html
  23. https://sysovl.info/reference_prime_faq.html
  24. https://groups.google.com/g/mvdbms/c/7MNpPOHPSIo
  25. https://www.merryplayer.com/pickmanuals/u2SQL.pdf
  26. https://www.itjungle.com/2009/09/21/tfh092109-story03/
  27. https://www.dbta.com/Editorial/Trends-and-Applications/U2-Targets-Growth-Opportunities-with-Rocket-Software-58265.aspx
  28. https://www.rocketsoftware.com/en-us/products/multivalue/u2
  29. https://www.zumasys.com/wp-content/uploads/sites/10/2021/07/MV-Connect-Datasheet.pdf
  30. https://docs.rocketsoftware.com/bundle/jbase_lib_5x/page/nyc1666031195243.html
  31. https://docs.rocketsoftware.com/bundle/openqm_ref_4/page/est1652705877484.html
  32. https://www.uniware.com.au/solutions/database/
  33. https://www.rocketsoftware.com/en-us/news/rocket-software-acquires-database-and-tools-products-zumasys-inc-companies-partner-drive
  34. https://www.pcmag.com/encyclopedia/term/pick-system
  35. https://sites.google.com/site/pickuniverse/companies-that-use-pick
  36. https://inria.hal.science/hal-01526815/document
  37. https://dl.ifip.org/db/conf/ifip9/hc2010/Lukaitis10.pdf
  38. https://www.dbta.com/Categories/MultiValue-Database-Technology-337.aspx
  39. https://www.rocketsoftware.com/en-us/products/multivalue
  40. https://www.dbta.com/Editorial/News-Flashes/Readers-Select-the-Top-MultiValue-Database-in-the-2024-DBTA-Readers-Choice-Awards-162345.aspx
  41. https://www.multivaluecentral.com/services/server-migration/
  42. https://groups.google.com/g/mvdbms
Add your contribution
Related Hubs
Contribute something
User Avatar
No comments yet.