PILOT

Programmed Inquiry, Learning, or Teaching (PILOT) is a simple high-level programming language developed in the 1960s. ^[1] Like its younger sibling LOGO, it was developed as an early foray into the technology of computer-assisted instruction.

Contents

• History
• Language syntax
• Command letters
• Derivatives
• References
• Further reading

PILOT is an imperative language similar in structure to BASIC and FORTRAN in its basic layout and structure. Its keywords are single characters, T for "type" to print text, or A for "accept", to input values from the user.

History

Starting in 1960, John Amsden Starkweather a psychology professor at the University of California, San Francisco medical center, developed a simple system for automating the construction of computer question-and-answer tests. By 1962 the system was functional on the IBM 1620 and given the name "Computest". This proved interesting enough to gain a grant for further development by the U.S. Office of Education in 1965. ^[2]

Using this funding, Starkweather began development of an expanded version of the system with more functionality. He gave this version the new name PILOT. Early versions were shown in 1966, and the almost-complete version was released in 1968. The next year it was released into the public domain. ^[3]

PILOT was later adopted by H. Dean Brown at the Stanford Research Institute (SRI) Education Laboratory. Brown popularized PILOT as a language for use directly by children. Brown's efforts changed the language from one intended for use by teachers to write tests and instructional materials to one intended to be used to teach programming. ^[4]

In 1973, Starkweather brought together a number of people interested in computer aided teaching to develop a machine-independent specification for the language, PILOT-73. A portable subset was Aldo defined as Core PILOT. Core was then ported to the Datapoint 2200, an Intel 8008 powered terminal that would later be known as a personal computer. At $13,000, this was more expensive than many contemporary minicomputers and did not see much use. However, this port proved very useful after the Intel 8080 came to market and spawned many inexpensive microcomputers. ^[2]

Starting in the late 1970s, Western Washington University began expanding the language into Common PILOT. This formed the basis for a number of later microcomputer variants, including most versions on the MOS 6502. These varied from the Common definition, as well as from each other. PILOT on the Apple II was written in UCSD Pascal. These versions led to a revival of the PILOT language for teaching, and led to an expanded version known as Super PILOT which added device control so programs could play videodisks and similar tasks. Atari PILOT took the language in a different direction by adding turtle graphics adapted from LOGO. ^[2]

For a time there was an effort to make a single standard for the language as IEEE Standard 1154-1991, but this was abandoned in 2000. ^{[2] [5]}

Language syntax

A line of PILOT code contains (from left to right) the following syntax elements:

• an optional label
• a command letter
• an optional Y (for yes) or N (for no)
• an optional conditional expression in parentheses
• a colon (":")
• an operand, or multiple operands delimited by commas.

A label can also be alone in a line, not followed by other code. The syntax for a label is an asterisk followed by an identifier (alphanumeric string with alphabetic initial character).

 R:Next line of input replaces current contents of accept buffer  A:  R:Next line of input replaces accept buffer, and string variable 'FREE'  A:$FREE  R:Next 3 lines of input assigned to string variables 'X', 'Y' and 'Z'  A:$X,$Y,$Z  R:Numeric input assigned to numeric variable "Q"  A:#Q

 R:Assign arithmetic mean of #X and #Y to #AM  C:#AM=(#X+#Y)/2

  J:*RESTART 

  R:Search accept buffer for "TRUTH", the value of MEXICO and "YOUTH", in that order   M:TRUTH,$MEXICO,YOUTH 

  R:The next line prints a literal string   T:Thank you for your support.   R:The next line combines a literal string with a variable expression   T:Thank you, $NAME. 

  R:Call subroutine starting at label *INITIALIZE   U:*INITIALIZE 

  R:Type message if x>y+z   T(#X>#Y+#Z):Condition met 

Derivatives

Extensions to core PILOT include arrays and floating point numbers in Apple PILOT for the Apple II, and LOGO-inspired turtle graphics in Atari PILOT for Atari 8-bit computers. ^[6]

Between 1979 and 1983 the UK PILOT User Group was run by Alec Wood a teacher at Wirral Grammar School for Boys, Merseyside UK. Several machine code versions of a mini PILOT were produced for the microcomputers of the time and a school in Scotland developed an interactive foreign language tutorial where pupils guided footprints around a town asking and answering questions in German, French, etc. An article in the December 1979 of Computer Age covered an early implementation called Tiny Pilot and gave a complete machine code listing.

Versions of PILOT overlaid on the BASIC interpreters of early microcomputers were not unknown in the late 1970s and early 1980s, and Byte Magazine at one point published a non-Turing complete derivative of PILOT known as Waduzitdo by Larry Kheriarty as a way of demonstrating what a computer was capable of. ^{[7] [8]} PETPILOT (PILOT for the Commodore PET) was the first non-Commodore language for the PET and was written in Microsoft BASIC which shipped with the PET, with a little assistance from Bill Gates. It was created in 1979 by Dave Gomberg and could run on a 4K PET (which was never shipped) and ran well on the 8K PETs that Commodore shipped. It was written in Larry Tessler's living room on PET serial number 2.

1983's Vanilla PILOT for the Commodore 64 added turtle graphics, ^[9] as did Super Turtle PILOT which was published as a type-in listing in the October 1987 issue of COMPUTE! magazine. ^[10]

In 1991 the Institute of Electrical and Electronics Engineers (IEEE) published a standard for Pilot as IEEE Std 1154-1991. It has since been withdrawn. ^[11] A reference implementation based on this was implemented by Eric Raymond, and maintained—-reluctantly—-for the next 15 years. ^[12]

In 1990 eSTeem PILOT for Atari ST computers was developed and programmed by Tom Nielsen, EdD. Based on the IEEE Standards for PILOT, it includes Atari-specific features such as control of Laserdisc and CDROM devices. ^[13]

A 2018 hobbyist implementation, psPILOT, based in part on the IEEE standard, was implemented using Microsoft's PowerShell scripting language. ^[14]

Related Research Articles

BASIC is a family of general-purpose, high-level programming languages designed for ease of use. The original version was created by John G. Kemeny and Thomas E. Kurtz at Dartmouth College in 1963. They wanted to enable students in non-scientific fields to use computers. At the time, nearly all computers required writing custom software, which only scientists and mathematicians tended to learn.

Forth is a stack-oriented programming language and interactive integrated development environment designed by Charles H. "Chuck" Moore and first used by other programmers in 1970. Although not an acronym, the language's name in its early years was often spelled in all capital letters as FORTH. The FORTH-79 and FORTH-83 implementations, which were not written by Moore, became de facto standards, and an official technical standard of the language was published in 1994 as ANS Forth. A wide range of Forth derivatives existed before and after ANS Forth. The free and open-source software Gforth implementation is actively maintained, as are several commercially supported systems.

The MOS Technology 6502 is an 8-bit microprocessor that was designed by a small team led by Chuck Peddle for MOS Technology. The design team had formerly worked at Motorola on the Motorola 6800 project; the 6502 is essentially a simplified, less expensive and faster version of that design.

MMIX is a 64-bit reduced instruction set computing (RISC) architecture designed by Donald Knuth, with significant contributions by John L. Hennessy and Richard L. Sites. Knuth has said that,

MMIX is a computer intended to illustrate machine-level aspects of programming. In my books The Art of Computer Programming, it replaces MIX, the 1960s-style machine that formerly played such a role… I strove to design MMIX so that its machine language would be simple, elegant, and easy to learn. At the same time I was careful to include all of the complexities needed to achieve high performance in practice, so that MMIX could in principle be built and even perhaps be competitive with some of the fastest general-purpose computers in the marketplace."

In computing, NaN, standing for Not a Number, is a particular value of a numeric data type which is undefined as a number, such as the result of 0/0. Systematic use of NaNs was introduced by the IEEE 754 floating-point standard in 1985, along with the representation of other non-finite quantities such as infinities.

Tiny BASIC is a family of dialects of the BASIC programming language that can fit into 4 or fewer KBs of memory. Tiny BASIC was designed by Dennis Allison and the People's Computer Company (PCC) in response to the open letter published by Bill Gates complaining about users pirating Altair BASIC, which sold for $150. Tiny BASIC was intended to be a completely free version of BASIC that would run on the same early microcomputers.

Atari BASIC is an interpreter for the BASIC programming language that shipped with Atari 8-bit computers. Unlike most American BASICs of the home computer era, Atari BASIC is not a derivative of Microsoft BASIC and differs in significant ways. It includes keywords for Atari-specific features and lacks support for string arrays.

COMAL is a computer programming language developed in Denmark by Børge R. Christensen and Benedict Løfstedt and originally released in 1975. It was based on the BASIC programming language, adding multi-line statements and well-defined subroutines among other additions.

Integer BASIC is a BASIC interpreter written by Steve Wozniak for the Apple I and Apple II computers. Originally available on cassette for the Apple I in 1976, then included in ROM on the Apple II from its release in 1977, it was the first version of BASIC used by many early home computer owners.

Commodore BASIC, also known as PET BASIC or CBM-BASIC, is the dialect of the BASIC programming language used in Commodore International's 8-bit home computer line, stretching from the PET (1977) to the Commodore 128 (1985).

In computer programming, a parameter or a formal argument is a special kind of variable used in a subroutine to refer to one of the pieces of data provided as input to the subroutine. These pieces of data are the values of the arguments with which the subroutine is going to be called/invoked. An ordered list of parameters is usually included in the definition of a subroutine, so that, each time the subroutine is called, its arguments for that call are evaluated, and the resulting values can be assigned to the corresponding parameters.

The COSMAC is an 8-bit microprocessor family introduced by RCA. It is historically notable as the first CMOS microprocessor. The first production model was the two-chip CDP1801R and CDP1801U, which were later combined into the single-chip CDP1802. The 1802 represented the majority of COSMAC production, and today the entire line is known simply as the RCA 1802.

HP Time-Shared BASIC is a BASIC programming language interpreter for Hewlett-Packard's HP 2000 line of minicomputer-based time-sharing computer systems. TSB is historically notable as the platform that released the first public versions of the game Star Trek.

In computing, tee is a command in command-line interpreters (shells) using standard streams which reads standard input and writes it to both standard output and one or more files, effectively duplicating its input. It is primarily used in conjunction with pipes and filters. The command is named after the T-splitter used in plumbing.

Color BASIC is the implementation of Microsoft BASIC that is included in the ROM of the Tandy/Radio Shack TRS-80 Color Computers manufactured between 1980 and 1991. BASIC is a high level language with simple syntax that makes it easy to write simple programs. Color BASIC is interpreted, that is, decoded as it is run.

The Mouse programming language is a small computer programming language developed by Dr. Peter Grogono in the late 1970s and early 1980s. It was developed as an extension of an earlier language called MUSYS, which was used to control digital and analog devices in an electronic music studio.

In 1979, Honeywell Information Systems announced a new programming language for their time-sharing service named TEX, an acronym for the Text Executive text processing system. TEX was a first-generation scripting language developed around the time of AWK and used by Honeywell initially as an in-house system test automation tool.

In computer programming, a function is a callable unit of software logic that has a well-defined interface and behavior and can be invoked multiple times.

SCELBAL, short for SCientific ELementary BAsic Language, is a version of the BASIC programming language released in 1976 for the SCELBI and other early Intel 8008 and 8080-based microcomputers like the Mark-8. Later add-ons to the language included an extended math package and string handling. The original version required 8 kB of RAM, while the additions demanded at least 12 kB.

A BASIC interpreter is an interpreter that enables users to enter and run programs in the BASIC language and was, for the first part of the microcomputer era, the default application that computers would launch. Users were expected to use the BASIC interpreter to type in programs or to load programs from storage.

References

Further reading

• John Starkweather (1985). User's guide to Pilot. Prentice-Hall. ISBN   978-0-13-937755-6.