PILOT

Last updated May 09, 2024

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 an early foray into the technology of computer-assisted instruction.

Its History

PILOT was developed by John Amsden Starkweather, a psychology professor at the University of California, San Francisco medical center. In 1962, he developed a simple language for automating learning tests called Computest. Starting in 1968, he developed a follow-on project called PILOT, for various computers of the time such as the SDS 940.^[2]

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).

Command letters

The following commands are used in "core PILOT". Lines beginning with "R:" indicate a remark (or a comment) explaining the code that follows.

A: Accept input into "accept buffer". Examples:

 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

C: Compute and assign numeric value. Most PILOT implementations have only integer arithmetic, and no arrays. Example:

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

D: Dimension an array, on some implementations.

E: End (return from) subroutine or (if outside of a subroutine) abort program. Always used without any operand.

J: Jump to a label. Example:

  J:*RESTART

M: Match the accept buffer against string variables or string literals. Example:

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

The first match string (if any) that is a substring of the accept buffer is assigned to the special variable $MATCH. The buffer characters left of the first match are assigned to $LEFT, and the characters on the right are assigned to $RIGHT.

The match flag is set to 'yes' or 'no', depending on whether a match is made. Any statement that has a Y following the command letter is processed only if the match flag is set. Statements with N are processed only if the flag is not set.

N: Equivalent to TN: (type if last match unsuccessful)

R: The operand of R: is a comment, and therefore has no effect.

T: 'Type' operand as output. Examples:

  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.

U: Use (call) a subroutine. A subroutine starts with a label and ends with E: Example:

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

Y: Equivalent to TY: (type if last match successful)

Parentheses: If there is a parenthesized expression in a statement, it is a conditional expression, and the statement is processed only if the test has a value of 'true'. Example:

  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.^[3]

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.^[4]^[5] 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,^[6] as did Super Turtle PILOT which was published as a type-in listing in the October 1987 issue of COMPUTE! magazine.^[7]

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.^[8] A reference implementation based on this was implemented by Eric Raymond, and maintained—-reluctantly—-for the next 15 years.^[9]

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.^[10]

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

Related Research Articles

Forth is a procedural, concatenative, 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 logic, mathematics, and computer science, arity is the number of arguments or operands taken by a function, operation or relation. In mathematics, arity may also be called rank, but this word can have many other meanings. In logic and philosophy, arity may also be called adicity and degree. In linguistics, it is usually named valency.

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.

<span class="mw-page-title-main">Atari BASIC</span> Dialect of the BASIC programming language

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.

In computer programming, a type system is a logical system comprising a set of rules that assigns a property called a type to every term. Usually the terms are various language constructs of a computer program, such as variables, expressions, functions, or modules. A type system dictates the operations that can be performed on a term. For variables, the type system determines the allowed values of that term. Type systems formalize and enforce the otherwise implicit categories the programmer uses for algebraic data types, data structures, or other components.

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.

KERNAL is Commodore's name for the ROM-resident operating system core in its 8-bit home computers; from the original PET of 1977, followed by the extended but related versions used in its successors: the VIC-20, Commodore 64, Plus/4, Commodore 16, and Commodore 128.

<span class="mw-page-title-main">Conditional (computer programming)</span> Control flow statement that executes code according to some condition(s)

In computer science, conditionals are programming language commands for handling decisions. Specifically, conditionals perform different computations or actions depending on whether a programmer-defined Boolean condition evaluates to true or false. In terms of control flow, the decision is always achieved by selectively altering the control flow based on some condition . Although dynamic dispatch is not usually classified as a conditional construct, it is another way to select between alternatives at runtime. Conditional statements are the checkpoints in the programme that determines behaviour according to situation.

Commodore DOS, also known as CBM DOS, is the disk operating system used with Commodore's 8-bit computers. Unlike most other DOSes, which are loaded from disk into the computer's own RAM and executed there, CBM DOS is executed internally in the drive: the DOS resides in ROM chips inside the drive, and is run there by one or more dedicated MOS 6502 family CPUs. Thus, data transfer between Commodore 8-bit computers and their disk drives more closely resembles a local area network connection than typical disk/host transfers.

The computer programming languages C and Pascal have similar times of origin, influences, and purposes. Both were used to design their own compilers early in their lifetimes. The original Pascal definition appeared in 1969 and a first compiler in 1970. The first version of C appeared in 1972.

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.

This is an overview of Fortran 95 language features. Included are the additional features of TR-15581:Enhanced Data Type Facilities, which have been universally implemented. Old features that have been superseded by new ones are not described – few of those historic features are used in modern programs although most have been retained in the language to maintain backward compatibility. The current standard is Fortran 2023; many of its new features are still being implemented in compilers.

The null coalescing operator is a binary operator that is part of the syntax for a basic conditional expression in several programming languages, such as : C# since version 2.0, Dart since version 1.12.0, PHP since version 7.0.0., Perl since version 5.10 as logical defined-or, PowerShell since 7.0.0, and Swift as nil-coalescing operator.

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 computing science and informatics, nesting is where information is organized in layers, or where objects contain other similar objects. It almost always refers to self-similar or recursive structures in some sense.

In computer programming, a function, subprogram, procedure, method, routine or subroutine is a callable unit that has a well-defined behavior and can be invoked by other software units to exhibit that behavior.

<span class="mw-page-title-main">BASIC interpreter</span> Interpreter that enables users to enter and run programs in the BASIC language

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

↑ Rob Linwood. "PILOT Resource Center". Sourceforge project. Retrieved October 13, 2011.
↑ Xiuzhi Zhou (1998). "Register of the John A. Starkweather Papers, 1965-1985". University of California, San Francisco library. Retrieved October 13, 2011.
↑ Jim Conlan, Tracy Deliman (1983). Atari PILOT for beginners. Reston Publishing. ISBN 9780835903028.
↑ Brian Connors (April 6, 2001). "Waduzitdo 2001" . Retrieved October 13, 2011.
↑ Larry Kheriarty (September 1978). "WADUZITDO: How To Write a Language in 256 Words or Less". Byte.
↑ "Vanilla PILOT, PILOT that comes with turtle graphics". Infoworld. September 12, 1983. pp. 67–69. Retrieved October 13, 2011.
↑ Atarimagazines.com - COMPUTE! Issue 89, October 1987, p74
↑ IEEE Standard 1154-1991 for Programmed Inquiry, Learning, or Teaching (PILOT). IEEE Standards Committee. 1991. doi:10.1109/IEEESTD.1991.108548. ISBN 0-7381-1184-8.
↑ "Twenty years after".
↑ "Press Release: eSTeem PILOT".
↑ "psPilot".