Misplaced Pages

BCPL: Difference between revisions

Article snapshot taken from[REDACTED] with creative commons attribution-sharealike license. Give it a read and then ask your questions in the chat. We can research this topic together.
Browse history interactively← Previous editContent deleted Content addedVisualWikitext
Revision as of 18:51, 1 January 2022 editMarkMLl (talk | contribs)Extended confirmed users2,003 edits →External links: * Add link to definitive document by Martin Richards← Previous edit Latest revision as of 21:05, 29 December 2024 edit undoFjeinca (talk | contribs)Extended confirmed users1,414 editsm Fixed grammarTags: Mobile edit Mobile app edit iOS app edit App section source 
(24 intermediate revisions by 22 users not shown)
Line 1: Line 1:
{{Short description|Multi-paradigm computer programming language}} {{Short description|Multi-paradigm computer programming language}}
{{Distinguish|text = ]}}
{{About|the programming language|the library system|Baltimore County Public Library}} {{About|the programming language|the library system|Baltimore County Public Library}}
{{More citations needed|date=May 2010}} {{Use dmy dates|date=April 2022}}

{{Infobox programming language {{Infobox programming language
| name = BCPL | name = BCPL
Line 29: Line 29:
{{More citations needed section|date=January 2017}} {{More citations needed section|date=January 2017}}


BCPL was designed so that small and simple compilers could be written for it; reputedly some compilers could be run in 16 ]s. Further, the original compiler, itself written in BCPL, was easily portable. BCPL was thus a popular choice for ] a system.{{Citation needed|date=January 2017}} A major reason for the compiler's portability lay in its structure. It was split into two parts: the front end parsed the source and generated O-code, an ]. The back end took the O-code and translated it into the machine code for the target machine. Only {{frac|5}} of the compiler's code needed to be rewritten to support a new machine, a task that usually took between 2 and 5 ]s. This approach became common practice later (e.g. ], ]). BCPL was designed so that small and simple compilers could be written for it; reputedly some compilers could be run in 16 ]s. Furthermore, the original compiler, itself written in BCPL, was easily portable. BCPL was thus a popular choice for ] a system.{{Citation needed|date=January 2017}} A major reason for the compiler's portability lay in its structure. It was split into two parts: the front end parsed the source and generated O-code, an ]. The back end took the O-code and translated it into the machine code for the target machine. Only {{frac|5}} of the compiler's code needed to be rewritten to support a new machine, a task that usually took between 2 and 5 ]s. This approach became common practice later (e.g. ], ]).


The language is unusual in having only one ]: a ], a fixed number of bits, usually chosen to align with the architecture's machine word and of adequate capacity to represent any valid storage address. For many machines of the time, this data type was a 16-bit word. This choice later proved to be a significant problem when BCPL was used on machines in which the smallest addressable item was not a word but a ] or on machines with larger word sizes such as 32-bit or 64-bit.{{Citation needed|date=January 2017}} The language is unusual in having only one ]: a ], a fixed number of bits, usually chosen to align with the same platform architecture's machine word and of adequate capacity to represent any valid storage address. For many machines of the time, this data type was a 16-bit word. This choice later proved to be a significant problem when BCPL was used on machines in which the smallest addressable item was not a word but a ] or on machines with larger word sizes such as 32-bit or 64-bit.{{Citation needed|date=January 2017}}


The interpretation of any value was determined by the operators used to process the values. (For example, <code>+</code> added two values together, treating them as ]s; <code>!</code> indirected through a value, effectively treating it as a pointer.) In order for this to work, the implementation provided no ]. ] was developed to help programmers avoid inadvertent type errors.{{Citation needed|date=January 2017}} The interpretation of any value was determined by the operators used to process the values. (For example, <code>+</code> added two values together, treating them as ]s; <code>!</code> indirected through a value, effectively treating it as a pointer.) In order for this to work, the implementation provided no ].


The mismatch between BCPL's ] and ] hardware was addressed in several ways. One was by providing standard library routines for packing and unpacking words into byte strings. Later, two language features were added: the bit-field selection operator and the infix byte indirection operator (denoted by <code>%</code>).{{Citation needed|date=January 2017}} The mismatch between BCPL's word orientation and ] hardware was addressed in several ways. One was by providing standard library routines for packing and unpacking words into byte strings. Later, two language features were added: the bit-field selection operator and the infix byte indirection operator (denoted by <code>%</code>).<ref>{{Cite web |title=Clive Feather on CPL and BCPL |url=https://www.lysator.liu.se/c/clive-on-history.html |access-date=2024-03-01 |website=www.lysator.liu.se}}</ref>


BCPL handles bindings spanning separate ]s in a unique way. There are no user-declarable global variables; instead there is a global vector, similar to "blank common" in ]. All data shared between different compilation units comprises scalars and pointers to vectors stored in a pre-arranged place in the global vector. Thus the header files (files included during compilation using the "GET" directive) become the primary means of synchronizing global data between compilation units, containing "GLOBAL" directives that present lists of symbolic names, each paired with a number that associates the name with the corresponding numerically addressed word in the global vector. As well as variables, the global vector contains bindings for external procedures. This makes dynamic loading of compilation units very simple to achieve. Instead of relying on the link loader of the underlying implementation, effectively BCPL gives the programmer control of the linking process.{{Citation needed|date=January 2017}} BCPL handles bindings spanning separate ]s in a unique way. There are no user-declarable global variables; instead, there is a global vector, similar to "blank common" in ]. All data shared between different compilation units comprises scalars and pointers to vectors stored in a pre-arranged place in the global vector. Thus, the header files (files included during compilation using the "GET" directive) become the primary means of synchronizing global data between compilation units, containing "GLOBAL" directives that present lists of symbolic names, each paired with a number that associates the name with the corresponding numerically addressed word in the global vector. As well as variables, the global vector contains bindings for external procedures. This makes dynamic loading of compilation units very simple to achieve. Instead of relying on the link loader of the underlying implementation, effectively, BCPL gives the programmer control of the linking process.{{Citation needed|date=January 2017}}


The global vector also made it very simple to replace or augment standard library routines. A program could save the pointer from the global vector to the original routine and replace it with a pointer to an alternative version. The alternative might call the original as part of its processing. This could be used as a quick ''ad hoc'' debugging aid.{{Citation needed|date=January 2017}} The global vector also made it very simple to replace or augment standard library routines. A program could save the pointer from the global vector to the original routine and replace it with a pointer to an alternative version. The alternative might call the original as part of its processing. This could be used as a quick ''ad hoc'' debugging aid.{{Citation needed|date=January 2017}}


BCPL was the first ] and the braces survived the syntactical changes and have become a common means of denoting program source code statements. In practice, on limited keyboards of the day, source programs often used the sequences <code>$(</code> and <code>$)</code> in place of the symbols <code>{</code> and <code>}</code>. The single-line <code>//</code> ]s of BCPL, which were not adopted by ], reappeared in ] and later in ]. BCPL was the first ] and the braces survived the syntactical changes and have become a common means of denoting program source code statements. In practice, on limited keyboards of the day, source programs often used the sequences <code>$(</code> and <code>$)</code> or <code></code> in place of the symbols <code>{</code> and <code>}</code>. The single-line <code>//</code> ]s of BCPL, which were not adopted by ], reappeared in ] and later in ].


The book ''BCPL: The language and its compiler'' describes the philosophy of BCPL as follows: The book ''BCPL: The language and its compiler'' describes the philosophy of BCPL as follows:
{{Quote|The philosophy of BCPL is not one of the tyrant who thinks he knows best and lays down the law on what is and what is not allowed; rather, BCPL acts more as a servant offering his services to the best of his ability without complaint, even when confronted with apparent nonsense. The programmer is always assumed to know what he is doing and is not hemmed in by petty restrictions.<ref>{{Cite book|title=BCPL: The Language and its Compiler|last1=Richards|first1=Martin|last2=Whitby-Strevens|first2=Colin|publisher=Cambridge University Press|year=1980|isbn=978-0521785433|pages=5}}</ref>}} {{Blockquote|The philosophy of BCPL is not one of the tyrant who thinks he knows best and lays down the law on what is and what is not allowed; rather, BCPL acts more as a servant offering his services to the best of his ability without complaint, even when confronted with apparent nonsense. The programmer is always assumed to know what he is doing and is not hemmed in by petty restrictions.<ref>{{Cite book|title=BCPL: The Language and its Compiler|last1=Richards|first1=Martin|last2=Whitby-Strevens|first2=Colin|publisher=Cambridge University Press|year=1980|isbn=978-0521785433|pages=5}}</ref>}}


==History== ==History==
BCPL was first implemented by ] of the ] in 1967.<ref name="IEEE_CPA_MRichards">{{cite web |url=https://www.computer.org/web/awards/pioneer-martin-richards |title=Martin Richards (2003 Computer Pioneer Award) |author=<!--Not stated--> |publisher=IEEE Computer Society |date=<!--Not stated--> |access-date=2017-11-24 |archive-url=https://archive.today/20171124083723/https://www.computer.org/web/awards/pioneer-martin-richards |archive-date=2017-11-24 |url-status = dead}}</ref> BCPL was a response to difficulties with its predecessor, Cambridge Programming Language, later renamed ] (CPL), which was designed during the early 1960s. Richards created BCPL by "removing those features of the full language which make compilation difficult". The first compiler implementation, for the ] under ] (CTSS), was written while Richards was visiting ] at the ] (MIT) in the spring of 1967. The language was first described in a paper presented to the 1969 Spring Joint Computer Conference.{{Citation needed|date=January 2017}} BCPL was first implemented by ] of the ] in 1967.<ref name="IEEE_CPA_MRichards">{{cite web |url=https://www.computer.org/web/awards/pioneer-martin-richards |title=Martin Richards (2003 Computer Pioneer Award) |author=<!--Not stated--> |publisher=IEEE Computer Society |date=<!--Not stated--> |access-date=2017-11-24 |archive-url=https://archive.today/20171124083723/https://www.computer.org/web/awards/pioneer-martin-richards |archive-date=2017-11-24 |url-status = dead}}</ref> BCPL was a response to difficulties with its predecessor, Cambridge Programming Language, later renamed ] (CPL), which was designed during the early 1960s. Richards created BCPL by "removing those features of the full language which make compilation difficult". The first compiler implementation, for the ] under ], was written while Richards was visiting ] at the ] in the spring of 1967. The language was first described in a paper presented to the 1969 Spring ].{{Citation needed|date=January 2017}}


BCPL has been rumored to have originally stood for "Bootstrap Cambridge Programming Language", but ] was never created since development stopped at BCPL, and the acronym was later reinterpreted for the BCPL book.{{Clarify|date=January 2017}}{{Citation needed|date=January 2017}} BCPL has been rumored to have originally stood for "Bootstrap Cambridge Programming Language", but CPL was never created since development stopped at BCPL, and the acronym was later reinterpreted for the BCPL book.{{Clarify|date=January 2017}}{{Citation needed|date=January 2017}}


BCPL is the language in which the original ] was written.<ref>, '']''</ref> The first ] was also written in BCPL (]). BCPL is the language in which the original ] was written.<ref>, '']''</ref> The first ] was also written in BCPL ('']'').


Several ]s were written partially or wholly in BCPL (for example, ] and the earliest versions of ]). BCPL was also the initial language used in the seminal ] ] project, the first modern ]; among other projects, the ] ] was written in BCPL. Several ]s were written partially or wholly in BCPL (for example, ] and the earliest versions of ]). BCPL was also the initial language used in the ] ] project. Among other projects, the ] ] was written in BCPL.


An early compiler, bootstrapped in 1969, by starting with a paper tape of the O-code of Martin Richards's ] compiler, targeted the ]. The two machines had different word-lengths (48 vs 24 bits), different character encodings, and different packed string representations—and the successful bootstrapping increased confidence in the practicality of the method. An early compiler, bootstrapped in 1969, by starting with a paper tape of the O-code of Richards's ] compiler, targeted the ]. The two machines had different word-lengths (48 vs 24 bits), different character encodings, and different packed string representations—and the successful bootstrapping increased confidence in the practicality of the method.


By late 1970, implementations existed for the ], the ], the ], the ], the ], the ], the ], the ] and the ]. In 1974 a dialect of BCPL was implemented at ] without using the intermediate O-code. The initial implementation was a ] hosted on BBN's ] ]s, and directly targeted the ]s used in BBN's implementation of the second generation ] used in the ]. By late 1970, implementations existed for the ], ], ], ], ], ], ], ] and Atlas 2. In 1974 a dialect of BCPL was implemented at ] without using the intermediate O-code. The initial implementation was a ] hosted on BBN's ] ]s, and directly targeted the ]s used in BBN's implementation of the second generation ] used in the ].


There was also a version produced for the ] in the mid-1980s, by Richards Computer Products, a company started by John Richards, the brother of Dr. Martin Richards.<ref>{{cite web|url=http://www.thebaron.info/archives/technology/reuters-technical-development-glossary|title=Reuters technical development: Glossary - THE BARON|website=www.thebaron.info}}</ref> The ] made use of the language. Versions of BCPL for the ] and ] computers were also released in 1986 by UK software house Arnor Ltd. MacBCPL was released for the Apple Macintosh in 1985 by Topexpress Ltd, of Kensington, England. There was also a version produced for the ] in the mid-1980s, by Richards Computer Products, a company started by John Richards, the brother of Martin Richards.<ref>{{cite web|url=http://www.thebaron.info/archives/technology/reuters-technical-development-glossary|title=Reuters technical development: Glossary - THE BARON|website=www.thebaron.info}}</ref> The ] made use of the language. Versions of BCPL for the ] and ] computers were also released in 1986 by UK software house Arnor Ltd. MacBCPL was released for the Apple Macintosh in 1985 by Topexpress Ltd, of Kensington, England.


Both the design and philosophy of BCPL strongly influenced ], which in turn influenced ].<ref name="C_Prog_Lang_KR">{{cite book |title=The C Programming Language |authors=Kernighan, Brian W. and Dennis M. Ritchie |date=1978 |pages=2 |isbn=0-13-110163-3 |publisher=Bell Telephone Laboratories |url=https://books.google.com/books?id=va1QAAAAMAAJ&q=bcpl}}</ref> Programmers at the time debated whether an eventual successor to C would be called "D", the next letter in the alphabet, or "P", the next letter in the parent language name. The language most accepted as being C's successor is ] (with <code>++</code> being C's ]),<ref> Retrieved 12 December 2017</ref> although meanwhile a ] programming language also exists. Both the design and philosophy of BCPL strongly influenced ], which in turn influenced ].<ref name="C_Prog_Lang_KR">{{cite book |url=https://archive.org/details/cprogramminglang00bria |title=The C Programming Language |date=1978 |publisher=Bell Telephone Laboratories |isbn=0-13-110163-3 |pages=2 |author1=Kernighan, Brian W. |author2=Dennis M. Ritchie }}</ref> Programmers at the time debated whether an eventual successor to C would be called "D", the next letter in the alphabet, or "P", the next letter in the parent language name. The language most accepted as being C's successor is ] (with <code>++</code> being C's ]),<ref> Retrieved 12 December 2017</ref> although meanwhile, a ] programming language also exists.


In 1979, implementations of BCPL existed for at least 25 architectures; the language gradually fell out of favour as C became popular on non-Unix systems. In 1979, implementations of BCPL existed for at least 25 architectures; the language gradually fell out of favour as C became popular on non-Unix systems.


Martin Richards maintains a modern version of BCPL on his website, last updated in 2018. This can be set up to run on various systems including Linux, FreeBSD, and Mac OS X. The latest distribution includes graphics and sound libraries, and there is a comprehensive manual. He continues to program in it, including for his research on musical automated ]. Martin Richards maintains a modern version of BCPL on his website, last updated in 2023.<ref>{{cite web |url=https://www.cl.cam.ac.uk/~mr10/BCPL/README |title=BCPL/README (BCPL Cintcode distribution) |author=Martin Richards}}</ref> This can be set up to run on various systems including Linux, FreeBSD, and Mac OS X. The latest distribution includes graphics and sound libraries, and there is a comprehensive manual. He continues to program in it, including for his research on musical automated ].


A common informal MIME type for BCPL is {{mono|text/x-bcpl}}. A common informal ] for BCPL is {{mono|text/x-bcpl}}.


==Examples== ==Examples==
=== Hello world ===
Richards and Whitby-Strevens<ref>{{Cite book|title=BCPL: The Language and its Compiler|last1=Richards|first1=Martin|last2=Whitby-Strevens|first2=Colin|publisher=Cambridge University Press|year=1980|isbn=978-0521785433|pages=8}}</ref> provide an example of the ] for BCPL using a standard system header, 'LIBHDR':
<pre>
GET "LIBHDR"
LET START() BE WRITES("Hello, World")
</pre>

=== Further examples ===
{{original research|section|date=August 2019}} {{original research|section|date=August 2019}}
If these programs are run using Martin Richards' current version of Cintsys (December 2018), LIBHDR, START and WRITEF must be changed to lower case to avoid errors. If these programs are run using Richards' current version of Cintsys (December 2018), LIBHDR, START and WRITEF must be changed to lower case to avoid errors.


Print factorials: Print factorials:
Line 125: Line 133:
* Martin Richards, '''' (Memorandum M-352, ], Cambridge, MA, USA, July, 1967) <!-- temporary copy: http://www.fh-jena.de/~kleine/history/languages/Richards-BCPL-ReferenceManual.pdf --> * Martin Richards, '''' (Memorandum M-352, ], Cambridge, MA, USA, July, 1967) <!-- temporary copy: http://www.fh-jena.de/~kleine/history/languages/Richards-BCPL-ReferenceManual.pdf -->
* Martin Richards, ''BCPL - a tool for compiler writing and systems programming'' ('''Proceedings of the Spring Joint Computer Conference''', Vol 34, pp 557–566, 1969) * Martin Richards, ''BCPL - a tool for compiler writing and systems programming'' ('''Proceedings of the Spring Joint Computer Conference''', Vol 34, pp 557–566, 1969)
* Martin Richards, Arthur Evans, Robert F. Mabee, '''' (MAC TR-141, ], Cambridge, MA, USA, 1974) * Martin Richards, Arthur Evans, Robert F. Mabee, '''' (MAC TR-141, ], Cambridge, MA, USA, 1974)
* Martin Richards, Colin Whitby-Strevens, ''BCPL, the language and its compiler'' (Cambridge University Press, 1980) {{ISBN|0-521-28681-6}} * Martin Richards, Colin Whitby-Strevens, ''BCPL, the language and its compiler'' (Cambridge University Press, 1980) {{ISBN|0-521-28681-6}}


Line 132: Line 140:
* by ] * by ]
* in the ] * in the ]
* Nordier & Associates' ] * Nordier & Associates' ]
* * (1986, ]/])
* How BCPL evolved from CPL, Martin Richards * How BCPL evolved from CPL, Martin Richards
* has commentary about BCPL's influence on C * has commentary about BCPL's influence on C
* *
*


{{Authority control}} {{Authority control}}

Latest revision as of 21:05, 29 December 2024

Multi-paradigm computer programming language Not to be confused with BASIC. This article is about the programming language. For the library system, see Baltimore County Public Library.

BCPL
Paradigmprocedural, imperative, structured
Designed byMartin Richards
First appeared1967; 58 years ago (1967)
Typing disciplinetypeless (everything is a word)
Influenced by
CPL
Influenced
B, C, Go

BCPL ("Basic Combined Programming Language") is a procedural, imperative, and structured programming language. Originally intended for writing compilers for other languages, BCPL is no longer in common use. However, its influence is still felt because a stripped down and syntactically changed version of BCPL, called B, was the language on which the C programming language was based. BCPL introduced several features of many modern programming languages, including using curly braces to delimit code blocks. BCPL was first implemented by Martin Richards of the University of Cambridge in 1967.

Design

This section needs additional citations for verification. Please help improve this article by adding citations to reliable sources in this section. Unsourced material may be challenged and removed. (January 2017) (Learn how and when to remove this message)

BCPL was designed so that small and simple compilers could be written for it; reputedly some compilers could be run in 16 kilobytes. Furthermore, the original compiler, itself written in BCPL, was easily portable. BCPL was thus a popular choice for bootstrapping a system. A major reason for the compiler's portability lay in its structure. It was split into two parts: the front end parsed the source and generated O-code, an intermediate language. The back end took the O-code and translated it into the machine code for the target machine. Only 1⁄5 of the compiler's code needed to be rewritten to support a new machine, a task that usually took between 2 and 5 person-months. This approach became common practice later (e.g. Pascal, Java).

The language is unusual in having only one data type: a word, a fixed number of bits, usually chosen to align with the same platform architecture's machine word and of adequate capacity to represent any valid storage address. For many machines of the time, this data type was a 16-bit word. This choice later proved to be a significant problem when BCPL was used on machines in which the smallest addressable item was not a word but a byte or on machines with larger word sizes such as 32-bit or 64-bit.

The interpretation of any value was determined by the operators used to process the values. (For example, + added two values together, treating them as integers; ! indirected through a value, effectively treating it as a pointer.) In order for this to work, the implementation provided no type checking.

The mismatch between BCPL's word orientation and byte-oriented hardware was addressed in several ways. One was by providing standard library routines for packing and unpacking words into byte strings. Later, two language features were added: the bit-field selection operator and the infix byte indirection operator (denoted by %).

BCPL handles bindings spanning separate compilation units in a unique way. There are no user-declarable global variables; instead, there is a global vector, similar to "blank common" in Fortran. All data shared between different compilation units comprises scalars and pointers to vectors stored in a pre-arranged place in the global vector. Thus, the header files (files included during compilation using the "GET" directive) become the primary means of synchronizing global data between compilation units, containing "GLOBAL" directives that present lists of symbolic names, each paired with a number that associates the name with the corresponding numerically addressed word in the global vector. As well as variables, the global vector contains bindings for external procedures. This makes dynamic loading of compilation units very simple to achieve. Instead of relying on the link loader of the underlying implementation, effectively, BCPL gives the programmer control of the linking process.

The global vector also made it very simple to replace or augment standard library routines. A program could save the pointer from the global vector to the original routine and replace it with a pointer to an alternative version. The alternative might call the original as part of its processing. This could be used as a quick ad hoc debugging aid.

BCPL was the first brace programming language and the braces survived the syntactical changes and have become a common means of denoting program source code statements. In practice, on limited keyboards of the day, source programs often used the sequences $( and $) or in place of the symbols { and }. The single-line // comments of BCPL, which were not adopted by C, reappeared in C++ and later in C99.

The book BCPL: The language and its compiler describes the philosophy of BCPL as follows:

The philosophy of BCPL is not one of the tyrant who thinks he knows best and lays down the law on what is and what is not allowed; rather, BCPL acts more as a servant offering his services to the best of his ability without complaint, even when confronted with apparent nonsense. The programmer is always assumed to know what he is doing and is not hemmed in by petty restrictions.

History

BCPL was first implemented by Martin Richards of the University of Cambridge in 1967. BCPL was a response to difficulties with its predecessor, Cambridge Programming Language, later renamed Combined Programming Language (CPL), which was designed during the early 1960s. Richards created BCPL by "removing those features of the full language which make compilation difficult". The first compiler implementation, for the IBM 7094 under Compatible Time-Sharing System, was written while Richards was visiting Project MAC at the Massachusetts Institute of Technology in the spring of 1967. The language was first described in a paper presented to the 1969 Spring Joint Computer Conference.

BCPL has been rumored to have originally stood for "Bootstrap Cambridge Programming Language", but CPL was never created since development stopped at BCPL, and the acronym was later reinterpreted for the BCPL book.

BCPL is the language in which the original "Hello, World!" program was written. The first MUD was also written in BCPL (MUD1).

Several operating systems were written partially or wholly in BCPL (for example, TRIPOS and the earliest versions of AmigaDOS). BCPL was also the initial language used in the Xerox PARC Alto project. Among other projects, the Bravo document preparation system was written in BCPL.

An early compiler, bootstrapped in 1969, by starting with a paper tape of the O-code of Richards's Atlas 2 compiler, targeted the ICT 1900 series. The two machines had different word-lengths (48 vs 24 bits), different character encodings, and different packed string representations—and the successful bootstrapping increased confidence in the practicality of the method.

By late 1970, implementations existed for the Honeywell 635 and Honeywell 645, IBM 360, PDP-10, TX-2, CDC 6400, UNIVAC 1108, PDP-9, KDF 9 and Atlas 2. In 1974 a dialect of BCPL was implemented at BBN without using the intermediate O-code. The initial implementation was a cross-compiler hosted on BBN's TENEX PDP-10s, and directly targeted the PDP-11s used in BBN's implementation of the second generation IMPs used in the ARPANET.

There was also a version produced for the BBC Micro in the mid-1980s, by Richards Computer Products, a company started by John Richards, the brother of Martin Richards. The BBC Domesday Project made use of the language. Versions of BCPL for the Amstrad CPC and Amstrad PCW computers were also released in 1986 by UK software house Arnor Ltd. MacBCPL was released for the Apple Macintosh in 1985 by Topexpress Ltd, of Kensington, England.

Both the design and philosophy of BCPL strongly influenced B, which in turn influenced C. Programmers at the time debated whether an eventual successor to C would be called "D", the next letter in the alphabet, or "P", the next letter in the parent language name. The language most accepted as being C's successor is C++ (with ++ being C's increment operator), although meanwhile, a D programming language also exists.

In 1979, implementations of BCPL existed for at least 25 architectures; the language gradually fell out of favour as C became popular on non-Unix systems.

Martin Richards maintains a modern version of BCPL on his website, last updated in 2023. This can be set up to run on various systems including Linux, FreeBSD, and Mac OS X. The latest distribution includes graphics and sound libraries, and there is a comprehensive manual. He continues to program in it, including for his research on musical automated score following.

A common informal MIME type for BCPL is text/x-bcpl.

Examples

Hello world

Richards and Whitby-Strevens provide an example of the "Hello, World!" program for BCPL using a standard system header, 'LIBHDR': 

GET "LIBHDR"
LET START() BE WRITES("Hello, World")

Further examples

This section possibly contains original research. Please improve it by verifying the claims made and adding inline citations. Statements consisting only of original research should be removed. (August 2019) (Learn how and when to remove this message)

If these programs are run using Richards' current version of Cintsys (December 2018), LIBHDR, START and WRITEF must be changed to lower case to avoid errors.

Print factorials: 

GET "LIBHDR"
LET START() = VALOF $(
	FOR I = 1 TO 5 DO
		WRITEF("%N! = %I4*N", I, FACT(I))
	RESULTIS 0
$)
AND FACT(N) = N = 0 -> 1, N * FACT(N - 1)

Count solutions to the N queens problem: 

GET "LIBHDR"
GLOBAL $(
	COUNT: 200
	ALL: 201
$)
LET TRY(LD, ROW, RD) BE
	TEST ROW = ALL THEN
		COUNT := COUNT + 1
	ELSE $(
		LET POSS = ALL & ~(LD | ROW | RD)
		UNTIL POSS = 0 DO $(
			LET P = POSS & -POSS
			POSS := POSS - P
			TRY(LD + P << 1, ROW + P, RD + P >> 1)
		$)
	$)
LET START() = VALOF $(
	ALL := 1
	FOR I = 1 TO 12 DO $(
		COUNT := 0
		TRY(0, 0, 0)
		WRITEF("%I2-QUEENS PROBLEM HAS %I5 SOLUTIONS*N", I, COUNT)
		ALL := 2 * ALL + 1
	$)
	RESULTIS 0
$)

References

  1. ^ "Martin Richards (2003 Computer Pioneer Award)". IEEE Computer Society. Archived from the original on 24 November 2017. Retrieved 24 November 2017.
  2. Pike, Rob (24 April 2014). "Hello Gophers". Retrieved 11 March 2016.
  3. https://www.cl.cam.ac.uk/~mr10/bcplman.pdf The BCPL Cintsys and Cintpos User Guide, 2.1.4 Section brackets
  4. "Clive Feather on CPL and BCPL". www.lysator.liu.se. Retrieved 1 March 2024.
  5. Richards, Martin; Whitby-Strevens, Colin (1980). BCPL: The Language and its Compiler. Cambridge University Press. p. 5. ISBN 978-0521785433.
  6. BCPL, Jargon File
  7. "Reuters technical development: Glossary - THE BARON". www.thebaron.info.
  8. Kernighan, Brian W.; Dennis M. Ritchie (1978). The C Programming Language. Bell Telephone Laboratories. p. 2. ISBN 0-13-110163-3.
  9. History of C++ Retrieved 12 December 2017
  10. Martin Richards. "BCPL/README (BCPL Cintcode distribution)".
  11. Richards, Martin; Whitby-Strevens, Colin (1980). BCPL: The Language and its Compiler. Cambridge University Press. p. 8. ISBN 978-0521785433.

Further reading

  • Martin Richards, The BCPL Reference Manual (Memorandum M-352, Project MAC, Cambridge, MA, USA, July, 1967)
  • Martin Richards, BCPL - a tool for compiler writing and systems programming (Proceedings of the Spring Joint Computer Conference, Vol 34, pp 557–566, 1969)
  • Martin Richards, Arthur Evans, Robert F. Mabee, The BCPL Reference Manual (MAC TR-141, Project MAC, Cambridge, MA, USA, 1974)
  • Martin Richards, Colin Whitby-Strevens, BCPL, the language and its compiler (Cambridge University Press, 1980) ISBN 0-521-28681-6

External links

Categories:
BCPL: Difference between revisions Add topic