Menu
Home Explore People Places Arts History Plants & Animals Science Life & Culture Technology
On this page
B (programming language)
Procedural programming language

B is a programming language developed at Bell Labs around 1969 by Ken Thompson and Dennis Ritchie. It was derived from BCPL and named possibly as a contraction of BCPL or after Bon, an earlier language by Thompson for Multics. B was typeless, using the machine's natural memory word as its only data type, interpreted as an integer or memory address depending on context. With the rise of ASCII processing and machines like the DEC PDP-11, B's typeless nature was limiting, prompting Thompson and Ritchie to create the typed C programming language.

We don't have any images related to B (programming language) yet.
We don't have any YouTube videos related to B (programming language) yet.
We don't have any PDF documents related to B (programming language) yet.
We don't have any Books related to B (programming language) yet.
We don't have any archived web articles related to B (programming language) yet.

History

BCPL semantics with a lot of SMALGOL syntax

— Ken Thompson, 3

Circa 1969, Ken Thompson4 and later Dennis Ritchie5 developed B basing it mainly on the BCPL language Thompson used in the Multics project. B was essentially the BCPL system stripped of any component Thompson felt he could do without in order to make it fit within the memory capacity of the minicomputers of the time. The BCPL to B transition also included changes made to suit Thompson's preferences (mostly along the lines of reducing the number of non-whitespace characters in a typical program).6 Much of the typical ALGOL-like syntax of BCPL was rather heavily changed in this process. The assignment operator := reverted to the = of Rutishauser's Superplan, and the equality operator = was replaced by ==.

Thompson added "two-address assignment operators" using x =+ y syntax to add y to x (in C the operator is written +=). This syntax came from Douglas McIlroy's implementation of TMG, in which B's compiler was first implemented (and it came to TMG from ALGOL 68's x +:= y syntax).78 Thompson went further by inventing the increment and decrement operators (++ and --). Their prefix or postfix position determines whether the value is taken before or after alteration of the operand. This innovation was not in the earliest versions of B. According to Dennis Ritchie, people often assumed that they were created for the auto-increment and auto-decrement address modes of the DEC PDP-11, but this is historically impossible as the machine didn't exist when B was first developed.9

The semicolon version of the for loop was borrowed by Ken Thompson from the work of Stephen Johnson.10

B is typeless, or more precisely has one data type: the computer word. Most operators (e.g. +, -, *, /) treated this as an integer, but others treated it as a memory address to be dereferenced. In many other ways it looked a lot like an early version of C. There are a few library functions, including some that vaguely resemble functions from the standard I/O library in C.11 In Thompson's words: "B and the old old C were very very similar languages except for all the types [in C]".12

Early implementations were for the DEC PDP-7 and PDP-11 minicomputers using early Unix, and Honeywell GE 64513 36-bit mainframes running the operating system GCOS. The earliest PDP-7 implementations compiled to threaded code, and Ritchie wrote a compiler using TMG which produced machine code.141516 In 1970 a PDP-11 was acquired and threaded code was used for the port; an assembler, dc, and the B language itself were written in B to bootstrap the computer. An early version of yacc was produced with this PDP-11 configuration. Ritchie took over maintenance during this period.1718

The typeless nature of B made sense on the Honeywell, PDP-7 and many older computers, but was a problem on the PDP-11 because it was difficult to elegantly access the character data type that the PDP-11 and most modern computers fully support. Starting in 1971 Ritchie made changes to the language while converting its compiler to produce machine code, most notably adding data typing for variables. During 1971 and 1972 B evolved into "New B" (NB) and then C.19

B is almost extinct, having been superseded by the C language.20 However, it continues to see use on GCOS mainframes (as of 2014)21 and on certain embedded systems (as of 2000) for a variety of reasons: limited hardware in small systems, extensive libraries, tooling, licensing cost issues, and simply being good enough for the job.22 The highly influential AberMUD was originally written in B.

Examples

The following examples are from the Users' Reference to B by Ken Thompson:23

/* The following function will print a non-negative number, n, to the base b, where 2<=b<=10. This routine uses the fact that in the ASCII character set, the digits 0 to 9 have sequential code values. */ printn(n,b) { extrn putchar; auto a; /* Wikipedia note: the auto keyword declares a variable with automatic storage (lifetime is function scope), not "automatic typing" as in C++11. */ if(a=n/b) /* assignment, not test for equality */ printn(a, b); /* recursive */ putchar(n%b + '0'); } /* The following program will calculate the constant e-2 to about 4000 decimal digits, and print it 50 characters to the line in groups of 5 characters. The method is simple output conver- sion of the expansion 1/2! + 1/3! + ... = .111... where the bases of the digits are 2, 3, 4, ... */ main() { extrn putchar, n, v; auto i, c, col, a; i = col = 0; while(i<n) v[i++] = 1; while(col<2*n) { a = n+1; c = i = 0; while(i<n) { c =+ v[i]*10; v[i++] = c%a; c =/ a--; } putchar(c+'0'); if(!(++col%5)) putchar(col%50?' ':'*n'); } putchar('*n*n'); } v[2000]; n 2000;

Notes

References

  1. "Its name most probably represents a contraction of BCPL, though an alternate theory holds that it derives from Bon [Thompson 69], an unrelated language created by Thompson during the Multics days. Bon in turn was named either after his wife Bonnie or (according to an encyclopedia quotation in its manual), after a religion whose rituals involve the murmuring of magic formulas."[2] /wiki/Bon ↩

  2. Thompson, Ken (7 January 1972). "Users' Reference to B" (PDF). Bell Laboratories. Archived from the original (PDF) on 17 March 2015. Retrieved 21 March 2014. /wiki/Ken_Thompson_(computer_programmer) ↩

  3. Jensen, Richard (9 December 2020). ""A damn stupid thing to do"—the origins of C". Ars Technica. Retrieved 2022-03-28. https://arstechnica.com/features/2020/12/a-damn-stupid-thing-to-do-the-origins-of-c/ ↩

  4. Ritchie, Dennis M. (March 1993). "The Development of the C Language". ACM SIGPLAN Notices. 28 (3): 201–208. doi:10.1145/155360.155580. /wiki/Dennis_Ritchie ↩

  5. Thompson, Ken (7 January 1972). "Users' Reference to B" (PDF). Bell Laboratories. Archived from the original (PDF) on 17 March 2015. Retrieved 21 March 2014. /wiki/Ken_Thompson_(computer_programmer) ↩

  6. Ritchie, Dennis M. (March 1993). "The Development of the C Language". ACM SIGPLAN Notices. 28 (3): 201–208. doi:10.1145/155360.155580. /wiki/Dennis_Ritchie ↩

  7. Ritchie, Dennis M. (March 1993). "The Development of the C Language". ACM SIGPLAN Notices. 28 (3): 201–208. doi:10.1145/155360.155580. /wiki/Dennis_Ritchie ↩

  8. Michael S. Mahoney (18 August 1989). "Interview with M.D. McIlroy". Princeton.edu. Murray Hill. /wiki/Michael_Sean_Mahoney ↩

  9. Ritchie, Dennis M. (March 1993). "The Development of the C Language". ACM SIGPLAN Notices. 28 (3): 201–208. doi:10.1145/155360.155580. /wiki/Dennis_Ritchie ↩

  10. Ken Thompson. "VCF East 2019 -- Brian Kernighan interviews Ken Thompson". YouTube. Archived from the original on 2021-11-23. Retrieved 2020-11-16. I saw Johnson's semicolon version of the for loop and I put that in [B], I stole it. https://www.youtube.com/watch?v=EY6q5dv_B-o&t=2330 ↩

  11. Thompson, Ken (7 January 1972). "Users' Reference to B" (PDF). Bell Laboratories. Archived from the original (PDF) on 17 March 2015. Retrieved 21 March 2014. /wiki/Ken_Thompson_(computer_programmer) ↩

  12. Ken Thompson. "VCF East 2019 -- Brian Kernighan interviews Ken Thompson". YouTube. Archived from the original on 2021-11-23. Retrieved 2020-11-16. I saw Johnson's semicolon version of the for loop and I put that in [B], I stole it. https://www.youtube.com/watch?v=EY6q5dv_B-o&t=2330 ↩

  13. Ritchie, Dennis M. (1984). "The Evolution of the Unix Time-sharing System". AT&T Bell Laboratories Technical Journal. 63 (6 Part 2): 1577–1593. doi:10.1002/j.1538-7305.1984.tb00054.x. Archived from the original on 11 June 2015. https://web.archive.org/web/20150611114353/https://www.bell-labs.com/usr/dmr/www/hist.html ↩

  14. "TMG". multicians.org. http://www.multicians.org/tmg.html ↩

  15. Ritchie, Dennis M. "The Development of the C Language". Bell Labs/Lucent Technologies. Archived from the original on 11 June 2015. /wiki/Dennis_Ritchie ↩

  16. McIlroy, M. D. (1987). A Research Unix reader: annotated excerpts from the Programmer's Manual, 1971–1986 (PDF) (Technical report). CSTR. Bell Labs. 139. Archived (PDF) from the original on 2022-10-09. /wiki/Douglas_McIlroy ↩

  17. Ritchie, Dennis M. (March 1993). "The Development of the C Language". ACM SIGPLAN Notices. 28 (3): 201–208. doi:10.1145/155360.155580. /wiki/Dennis_Ritchie ↩

  18. McIlroy, M. D. (1987). A Research Unix reader: annotated excerpts from the Programmer's Manual, 1971–1986 (PDF) (Technical report). CSTR. Bell Labs. 139. Archived (PDF) from the original on 2022-10-09. /wiki/Douglas_McIlroy ↩

  19. Ritchie, Dennis M. (March 1993). "The Development of the C Language". ACM SIGPLAN Notices. 28 (3): 201–208. doi:10.1145/155360.155580. /wiki/Dennis_Ritchie ↩

  20. Johnson and Kernighan. "THE PROGRAMMING LANGUAGE B". Bell Laboratories. Archived from the original on 11 June 2015. Retrieved 21 March 2014. /wiki/Stephen_C._Johnson ↩

  21. "Thinkage UW Tools Package". Thinkage, Ltd. Retrieved 26 March 2014. http://www.thinkage.ca/english/gcos/product-uwtools.shtml ↩

  22. Johnson and Kernighan. "THE PROGRAMMING LANGUAGE B". Bell Laboratories. Archived from the original on 11 June 2015. Retrieved 21 March 2014. /wiki/Stephen_C._Johnson ↩

  23. Thompson, Ken (7 January 1972). "Users' Reference to B" (PDF). Bell Laboratories. Archived from the original (PDF) on 17 March 2015. Retrieved 21 March 2014. /wiki/Ken_Thompson_(computer_programmer) ↩