The Programming Language B (1973)

https://web.archive.org/web/19980220175931/http://cm.bell-labs.com/cm/cs/who/dmr/bintro.html

by susam • 5 years ago

47 26 5 years ago

web.archive.org

paedubucher• 5 years ago

Is this some kind of C--? scnr

hnlmorg2• 5 years ago

I don't know what scnr means, but yes, B is literally `C--` as you put it.

Basically B was based on BCPL, a really early systems language. Then B was rewritten as C. The next iteration of C was called C++ as a joke because it's C plus 1. Though there has since been another language created as an evolution of C called D

From what I gather, B never really got much use outside of Bell Labs. But I might have missed some reports on other people using it.

1f60c• 5 years ago

I don't know what scnr means

Wiktionary tells me it stands for "sorry, could not resist".

https://de.wiktionary.org/wiki/SCNR

BoxOfRain• 5 years ago

Apparently AberMUD (way before my time but developed in Aberystwyth where I was a student) was written in B.

user2994cb2• 5 years ago

And BCPL was a cut down version of CPL: https://en.wikipedia.org/wiki/CPL_(programming_language)

int_19h2• 5 years ago

You can kinda see where C's weird i[a] notation for arrays came from, and even why.

pornel• 5 years ago

Pointer variables in C are declared in an odd way, as `int (*a)` rather than `(int*) a`. I suspect this is also due to B's legacy.

In B everything was an integer, and there was no separate pointer type. It had only pointer operators that could be applied to any integer.

veltas• 5 years ago

Declarators (the name along with pointer, array, etc annotations) in C are written parallel to how they are used, I have always assumed this was to make defining/explaining the language simpler (even though it often defies new learner's expectations), and maybe to reduce the amount of required logic in the compiler.

I think you're right that B is related to this, the reason the brackets were on the right of the name is because no type was mentioned in B (as there was only one type). If types had been named in declarations they probably would have preferred to do what Java does, i.e. `Type[] name`.

The other more archaic reason the brackets are on the right is because in the oldest B compilers the brackets were not there at all, instead when declaring 'local' (auto) vectors you just write the length of the vector after its name, like `auto name 8;` would declare a vector length 8 called 'name'. Once again this syntax makes sense without the type.

In B, declarators had not really matured yet, in some situations you could declare a vector with brackets similar to C arrays, but only of one dimension (which I think is why they were called vectors and not arrays).

hnlmorg2• 5 years ago

What I find interesting is that B uses * for escaping and special characters, eg

  putchar("New line: *n")
  putchar("Escaped double quotes: *"")

fanf2• 5 years ago

The * escape comes directly from BCPL

yiyus4• 5 years ago

I like how constrained the language was:

All arithmetic in B is integer, unless special functions are written. There is no equivalent of the Fortran IJKLMN convention, no floating point, no data types, no type conversions, and no type checking. Users of double-precision complex will have to fend for themselves. (But see ->32 for how to call Fortran subroutines.)

I wonder if it would have been beneficial to continue with this separation. Fortran and C started trying to do everything and they failed. Fortran was never a contender for C for systems programming, and C has not moved in the right direction to be better than Fortran for numerical computing.

projektfu• 5 years ago

Fortran-90 is well constrained for numerical programming and has so much inertia in the scientific community, it’s probably not going away. But C and its derivatives are good enough at numeric work for most users outside of science. Many have tried to dislodge both C and Fortran from their positions, with varying levels of success. Maybe we’ll see it in the next decade as scientists who knew how to code before university dominate and no longer want to use Fortran.

blacktriangle• 5 years ago

Having learned to code and getting a degree before going to get a job at a shop that had a ton of Fortran floating around, I'd say I grew to appreciate how direct it was for just doing math. And after working at later jobs where the scientists were allowed to write code in more expansive expressive languages than just Fortran, I really came to appreciate how Fortran enabled scientists to do science in such a way that they did not write unholy abominations of python code.

yiyus4• 5 years ago

You are absolutely right. To be honest, the current situation is not too different from this hypothetical case. Fortran is used mostly to write numeric routines and then we call them from a Python script, instead of writing text and arguments processing (for example) directly from Fortran. But I still find interesting thinking about where these languages would be if these limits had been consistently respected.

pjmlp2• 5 years ago

The language it was based on (BCPL), was originally designed to Bootstrap CPL and that was it, it is an historical accident that it got other purposes.

agent327• 5 years ago

Fortran and C started trying to do everything and they failed

You have an interesting definition of failure.

yiyus4• 5 years ago

Fortran has never been used seriously for systems programming. It got text processing capabilities and a ton of other stuff, but we do not see operating systems or web servers written in Fortran.

And C got the floating point operations B did not have, and was actually used for lots of numerical work for a while (and it still is, up to some point), but nobody was totally happy with it so we got C++, new Fortran versions, Python, now Julia... Although it always is an option due to the availability and quality of C compilers, I would not say that C succeeded in becoming the language of choice for scientific computing.

Of course, this does not mean that C or Fortran are failures.

aap_• 5 years ago

I wrote a B compiler: https://github.com/aap/b it generates the original threaded code and has a runtime for amd64, mips32 and riscv64. should get the pdp-11 one working too sometime... Documented the original pdp-7 and pdp-11 implementations here: http://squoze.net/B/

The Programming Language B (1973)

Related Stories