
The Development of the C Language (1993) - dodders
http://www.bell-labs.com/usr/dmr/www/chist.html
======
bitcointicker
I love C. Perhaps this is because it's the first language I was taught. It
fascinated me. It was complex, it allowed you to do dangerous things, but once
it clicks, its like an epiphany :-)

I hardly use it much these days, it's much faster to get things done in
python, ruby or perl. Unless you need performance. I guess its like an old
song, listening to it brings back memories of what was going on in your life
when you first heard it. Reminiscing about writing my first C programs brings
back the same kind of memories.

Do other people have the same feeling about the first language they learnt? Or
is C really special? :)

~~~
pjmlp
I was able to discover the power of system programming in higher level
languages around 5 years before learning C, so it isn't any special to me.

~~~
FraaJad
curious... what languages did you use?

~~~
nickpsecurity
I was going to post his list of system languages that came before C (and were
better/safer) but can't find his post. Notable examples, before or after C,
are:

Burroughs' ALGOL's their safer OS was written in
[https://en.wikipedia.org/wiki/Burroughs_large_systems#ALGOL](https://en.wikipedia.org/wiki/Burroughs_large_systems#ALGOL)

Modula-2 with its better readability and safety invented in Lilith homebrew
system:

[http://www.cfbsoftware.com/modula2/Lilith.pdf](http://www.cfbsoftware.com/modula2/Lilith.pdf)

Hansen's Concurrent Pascal was concurrency-safe in tiny runtime; Edison was C
minimalism on same PDP-11 with cleaner, safer design

[http://brinch-hansen.net/papers/](http://brinch-hansen.net/papers/)

Modula-3 had many C++ advantages, Modula-style safety, and without C's BS:

[https://en.wikipedia.org/wiki/Modula-3](https://en.wikipedia.org/wiki/Modula-3)

Note: SPIN OS was written in it. Supported type-safe compilation and linking
of code into running kernel for acceleration.

PL/I was one of predominant languages. IBM's mainframe OS's were written in a
version of it (PL/S).

[https://en.wikipedia.org/wiki/PL/I](https://en.wikipedia.org/wiki/PL/I)

Ada was systematically and cleverly designed for safety against most issues.
Still is:

[http://www.adacore.com/knowledge/technical-papers/safe-
secur...](http://www.adacore.com/knowledge/technical-papers/safe-secure/)

Note: Army Secure OS (ASOS), MarteOS, and Muen kernel were written in Ada
leveraging its safety properties.

That should cover the ones that have been around since the 60's-80's. Doesn't
even count functional-oriented languages like Common LISP, Schemes, or
Standard ML. LISP had both OS's and CPU's made in it and for it. SML & Ocaml
kicked ass in app correctness and compiler writing. Also ignored niche-
specific ones like COBOL or Fortran that I thought weren't suitable for a C
comparison.

Safe, C variants were even made to address its problems:

[https://www.cs.uic.edu/pub/Main/PhDQualifyingExam/Sample4.pd...](https://www.cs.uic.edu/pub/Main/PhDQualifyingExam/Sample4.pdf)

Note: Cyclone concepts got rolled into Rust. So some benefit there.

There's also modern attempts like D, Go, and Rust that try to replace it to
various degrees. Wirth's Modula work lives on in Active Oberon System and Go
language. Almost all are moving in a direction with ALGOL68's features being
the baseline. That there was better stuff before C on 1960's hardware suggests
that people should've ditched it or fixed it up a long time ago when hardware
limitations weren't holding it back anymore.

And let it be known that those are the _only_ reason C was designed how it
was. BCPL author actually wanted an ALGOL variant but hardware didn't work
well enough. Rest was accidents of history. More detail that stretches further
back than OP in this link:

[http://pastebin.com/UAQaWuWG](http://pastebin.com/UAQaWuWG)

~~~
ArkyBeagle
None of this matters. One (or two) *REALLY big accident(s) of history: The
Great Flood of PeeCees came and 'C' was ensconced by Borland and then the use
of 'C' in Linux.

We waited for Ada, and she showed up decades late.

~~~
hga
Perhaps the more significant "accident" of history, occurring before IBM-PCs
with much memory got out there in large numbers, was all the vendors of 68000
based systems who didn't follow the lead of Apollo Computer and instead got a
relatively cheap UNIX(TM) licence.

As PCs got more capable and more and more people were willing to program them
in C---I don't remember Borland being a big player in this, in fact, it was
Microsoft that produced the first _really_ solid C compiler---the same sorts
of constraints that helped birth UNIX(TM) and C were in play, until it was by
and large too late to change course.

~~~
ArkyBeagle
You're correct, but before Borland 'C' ( I think to directly compete with
Microsoft ) much was done in Borland Pascal. Of course, much was done after as
well.

I think the results of Apollo's decision speaks for itself. If something is an
order of magnitude cheaper, it will propagate faster, whether it's objectively
better or not.

------
agumonkey
[https://vimeo.com/132192250](https://vimeo.com/132192250)

~~~
acqq
For those like me who prefer slides:

[http://www.pvv.org/~oma/HistoryAndSpirit_NDC_Jun2015.pdf](http://www.pvv.org/~oma/HistoryAndSpirit_NDC_Jun2015.pdf)

They are good!

------
pjmlp
"To encourage people to pay more attention to the official language rules, to
detect legal but suspicious constructions, and to help find interface
mismatches undetectable with simple mechanisms for separate compilation, Steve
Johnson adapted his pcc compiler to produce lint [Johnson 79b], which scanned
a set of files and remarked on dubious constructions."

Ignored until clang adopted static analysis as part of the compiler.

~~~
gdwatson
I'm not sure that's fair. Clang has excellent warnings, but it's not as if no
progress was made on that front between 1979 and 2007.

~~~
pjmlp
I am not speaking about the tooling, rather the macho attitude in the C
community towards static analysis.

------
neonscribe
BCPL and B were untyped languages, where the fundamental unit of the language
was a "cell" that could hold either an integer or a pointer. Also fundamental
was that memory was addressable by cells, and that adding one to a pointer
(which could also be an integer) must cause it to refer to the next cell. This
could only be implemented efficiently on a word-addressed machine. When
confronted with the byte-addressed PDP-11, they created a language where the
basic unit was a "char". Fortunately, they also added types, so that the
language could adapt to changing architectures. However, they were fortunate,
or foresighted, in that virtually every architecture after the mid-70's was
byte-addressable. C does not adapt well to word-addressed machines, but that
didn't slow its adoption because word-addressed machines disappeared rapidly
after C was born.

------
acqq
Must see: the html behind the text.

~~~
LukeShu
Why? Because it's tidy?

It's formatted like troff input. I suspect that DMR wrote the document in
troff, and had it convert to HTML.

~~~
btilly
More hints that this is true.

This paper was presented at the Second History of Programming Languages
conference, Cambridge, Mass., April, 1993. That's the same month that CERN
decided to publicly release source for the very first web server and client.

There is no conceivable way that DMR would have both found out about the web
and chosen to write in HTML at that point in history.

However at that point Dennis Richie had 20 years of experience with troff. The
only other reasonable choice at that point was TeX. And the output looks
nothing like what I would expect from TeX. So it almost certainly was troff.

