bs (programming language)

From Wikipedia, the free encyclopedia
Designed byRichard C. Haight
First appeared1980; 44 years ago (1980)
Influenced by

bs is a programming language and a compiler/interpreter for modest-sized programs on UNIX systems.[1] The bs command can be invoked either for interactive programming or with a file containing a program, optionally taking arguments, via a Unix shell, e.g., using a Shebang (Unix) #!/usr/bin/bs.

An early man page states, "[bs] is a remote descendant of Basic [sic] and SNOBOL4, with a little C thrown in."[1]


The bs command appears in UNIX System III Release 3.0 (1980), first released outside of Bell Labs in 1982.[1] It was written by Dick Haight (Richard C. Haight) circa 1978, who recounts it as follows:[2]

I wrote bs at the time Unix (V 3?) and all of the commands were being converted from assembler to C. So [ Ken Thompson’s ] bas became my bs — sort of.

The Release 3.0 manual mentions bs prominently on page 9 (emphasis added):[3]

Writing a program. To enter the text of a source program into a UNIX file, use ed(1). The four principal languages available under UNIX are C (see cc(1)), Fortran (see f77(1)), bs (a compiler/interpreter in the spirit of Basic, see bs(1)), and assembly language (see as(1)).

While not released outside prior to System III, the bs command was present internally in UNIX/TS 1.0 (November 1978),[4] PWB/UNIX 2.0 (June 1979),[4] and CB UNIX editions 2.1 (November 1979)[5][6] and 2.3 (1981).[7] The bs command does not appear in some earlier internal releases, e.g., the UNIX Support Group’s March 1977 release,[4] nor the PWB/UNIX manual dated May, 1977,[8] suggesting its creation circa 1978. It does not appear in any version of Research Unix nor the Berkeley Software Distribution.

Subsequently and into the 1990s, bs was included in a variety of System III-derived or System V-derived commercial operating systems including, but not limited to: PC/IX;[9] UNIX System V Releases 2 & 3: SVR2,[10] SVR3, SVR3.2 (1986);[11] HP-UX;[12] AIX;[13] and A/UX.[14] (The User's Manual for the AT&T UNIX PC (3B1) specifically mentions that the bs command is not available, but that it is available on SVR3.2.[10])

Occasionally, bs was touted as one of the primary programming languages for development under UNIX.[3][9][15] However, bs is not included in the POSIX.1 commands and utilities (the standard List of Unix commands) nor in the Single UNIX Specification and is not provided with most contemporary operating systems. For example in Linux, similar syntax and functionality is provided by bc, Perl, and POSIX shell.

In the 21st century, bs is present in, at least, HP-UX Release 11i (2000),[12] as well as AIX versions 6.1 (2007)[13] and 7.2 (2018),[16] likely due to their UNIX System V heritage.

Design and features[edit]

The bs[1] man page, ostensibly the programming language's only specification, characterizes it as follows:

Bs is designed for programming tasks where program development time is as important as the resulting speed of execution. Formalities of data declaration and file/process manipulation are minimized. Line-at-a-time debugging, the trace and dump statements, and useful run-time error messages all simplify program testing. Furthermore, incomplete programs can be debugged; inner functions can be tested before outer functions have been written and vice versa.

A bs program is compiled and executed differently from programs written in the other principal Unix programming languages of the time: C, FORTRAN, and assembly language, whose respective commands compile program source code to executable assembler output (a.out). Instead, a bs program is, first, converted by the bs command to an internal reverse Polish (RPN) intermediate representation and then executed by the command's internal virtual stack machine.[17] The bs language, thus, is a hybrid interpreter and compiler and a divergence in Unix programming from Ancient Unix.

The bs language shares some features and syntax with BASIC, SNOBOL, and C, the two former presumably inspiring its name. Like BASIC, it can be used interactively, either executing statements immediately or collecting them into a program to be executed subsequently. Like in SNOBOL4, the assignment operator (=) is used for I/O and bs can execute code in strings, using its eval function. It also includes SNOBOL's interrogation operator (?) used to test whether an expression evaluation succeeds or not. The built-in format function, limited to one argument, supports a subset of C's printf format conversion specifiers, e.g., "%f".

The language has some conspicuous elements. For instance, its program functions are defined using the fun ... nuf syntax and its functions can have local variables. Also, bs can operate in two modes, either interpreting (and executing) statements and programs or compiling them, and switching between the two using compile and stop. Otherwise, its functionality is unique only collectively (in one language), since individual features are redundant with those of coexisting tools, such as the Unix Shell, e.g., file I/O and loops, and AWK, e.g., associative arrays and Regular expression matching.

The bs language was meant for convenient development and debugging of small, modular programs. It has a collection of syntax and features from prior, popular languages but it is internally compiled, unlike a Shell script. As such, in purpose, design, and function, bs is a largely unknown, modest predecessor of hybrid interpreted/compiled languages such as Perl and Python.

Syntax Examples[edit]

The following examples are derived from an A/UX bs(1) man page.[18]

This example uses bs as a calculator:

$ bs 
# Distance (inches) light travels in a nanosecond. 
186000 * 5280 * 12 / 1e9 
# Compound interest 
# (6% for 5 years on $1,000). 
int = .06 / 4 
bal = 1000 
for i = 1 5*4 bal = bal + bal*int 
bal - 1000 

This example is the outline of a typical bs program:

# initialize things: 
var1 = 1 
open("read", "infile", "r") 
# compute: 
while ?(str = read) 
# clean up: 
# last statement executed (exit or stop): 
# last input line: 

This example demonstrates I/O:

# Copy "oldfile" to "newfile". 
open("read", "oldfile", "r") 
open("write", "newfile", "w")
while ?(write = read) 
# close "read" and "write": 
# Pipe between commands. 
open("ls", "!ls *", "r") 
open("pr", "!pr -2 -h ’List’", "w") 
while ?(pr = ls) ... 
# be sure to close (wait for) these: 

Sample Program[edit]

The following is a sample bs program that emits the words to the song 99 Bottles of Beer using /usr/bin/bs.[19]

fun sing(n, end) s
   s = ("s", "")[ match(n, "^1$") ]
   put = format(format(format("%s bottle%%s of beer%%%%s", n), s), end)

for n = 99, n, put = ""
   sing(format("%-0.0f", n), " on the wall,")
   sing(format("%-0.0f", n), ",")
   put = "take one down, pass it around,"
   sing((format("%-0.0f", n), "no")[ 0 == n ], " on the wall.")

See also[edit]


  1. ^ a b c d UNIX User's Manual (Release 3.0 ed.). Bell Telephone Laboratories, Incorporated. 1980. p. 95.
  2. ^ Personal communication from Dick Haight, 10 September 2019.
  3. ^ a b UNIX User's Manual (PDF) (Release 3.0 ed.). Bell Telephone Laboratories, Incorporated. 1980. p. 9.
  4. ^ a b c Personal conversation with John R. Mashey, 9 September 2019.
  5. ^ "CB/UNIX man 7", The Unix Heritage Society, November 1979. Retrieved on 9 September 2019.
  6. ^ "CB/UNIX man 1", The Unix Heritage Society, November 1979. Retrieved on 9 September 2019.
  7. ^ J. D. Doan, ed. (May 1981). CB-UNIX Programmer's Manual, Edition 2.3 (PDF). Columbus, OH: Bell Telephone Laboratories. p. iii.
  8. ^ T. A. Dolotta; R. C. Haight; E. M. Piskorik, eds. (May 1977). "Section 1". PWB UNIX Programmer's Manual, Edition 1. Piscataway, New Jersey: Bell Telephone Laboratories.
  9. ^ a b "IBM Goes UNIX". PC Magazine. June 12, 1984. p. 218.
  10. ^ a b "Volume 1". AT&T UNIX PC UNIX System V User's Manual (PDF). AT&T. 1986. p. 8.
  11. ^ "Volume 1 Commands and Utilities". UNIX Programmer's Manual (PDF). AT&T. 1986. p. 41.
  12. ^ a b "Section 1 (A-M)". HP-UX Reference Release 11i User Commands (PDF) (1 ed.). Hewlett-Packard Company. 2000. p. 93.
  13. ^ a b "Section 1 (a-c)". AIX Version 6.1 Commands Reference (PDF) (First ed.). International Business Machines Corporation. 2007. p. 251.
  14. ^ "Section 1 (A-L)". A/UX Command Reference (PDF) (2.0 ed.). Apple Computer, Inc. 1990. p. 93.
  15. ^ "A/UX: Development Tools", Apple, Inc, 18 February 2012. Retrieved on 9 September 2019.
  16. ^ "Section 1 (a-c)". AIX Version 7.2 Commands Reference. IBM Corporation. 2018. p. 282.
  17. ^ Personal conversation with Dick Haight, 12 September 2019.
  18. ^ The /FILES file, A/UX 3.0.1 installation media, Apple Inc. (1993)
  19. ^ "Language BS", 99 Bottles of Beer, 8 August 1996. Retrieved on 9 September 2019.