You can't really have a totally safe systems programming language (correct me if I'm wrong here).
You can't really have a totally safe systems programming language (correct me if I'm wrong here).
This is a million times wrong. It's not about humans being smart or stupid, it's about humans being bad at being careful millions and millions of times without error.
The answer isn't to tell them to be more careful. They can be more careful, but they are human, so they will still make mistakes. The answer is for them to use higher level languages that eliminate whole classes of errors.
He doesn't seem to think that others would be better.
It depends what you mean by totally safe, but Cyclone (http://cyclone.thelanguage.org/) is a type and memory safe dialect of C. It works by adding additional information to the type of every pointer, e.g. if it can be NULL, if it's NUL terminated, if you know the length, the scope it was allocated in, the location on the stack it's from, etc...
This all happens at compile time, and it runs about the same speed as C, so I think it qualifies.
From what I've read, this has had more of an influence on programming language designers/implementers (rust, possibly c++11, probably more), than on anybody else, though.
edit: NULL -> NUL
* "Mechanical" issues like dangling pointers, buffer overflows, integer overflows, etc.
* Design errors
Unfortunately, C makes the first class exceedingly easy to create, and makes the second class exceedingly hard to prevent.
As for design errors, they are hard to prevent anywhere.
I have two problems with this reasoning. First, C is being used for more than writing device drivers; most programs written in C are not device drivers. Second, and more important, is that low-level memory access and the sort of bit-twiddling you are talking about can be done in Common Lisp, and I doubt that you would be shocked to know that the operating systems written in Lisp for Lisp Machines had device drivers. It is possible for any high-level language to expose a low-level pointer type, and doing so will not force programmers to use such low-level constructs in higher-level code.
"As for design errors, they are hard to prevent anywhere."
While true, they are much harder to prevent in C because of the complicated semantics, the enormous amount of undefined behavior, and the plethora of edge cases one must account for. When something as simple as incrementing a counter forces you to deal with edge cases and potentially undefined behavior, it is pretty hard to verify that a C program actually implements a design, even when that design was formally specified and checked. The lack of high-level features and constructs worsens this situation by inflating the number of lines of code in an implementation.
Like any systems programming language, nothing special about C.
Couldn't be more wrong though.
The people that wrote UNIX and its whole C userland were far from idiots -- more like geniuses. People like K&R, Bill Joy, etc (and until the 90s they weren't even that many, mainly people from elite computing schools and research centers).
It's not like some moron high school dropout, "Learn C in 24 hours"-reading people wrote UNIX and the common server stuff we use (Bind, Sendmail, etc).
I disagree about sendmail though - that was a stinking turd and I have been ever grateful since postfix arrived on the scene :)
However, there are pratical considerations (e.g performance impact and stuff like that) which make such approaches unattractive for production use.
Languages like Ada and Modula-2, just to cite two examples from many, allow for safer coding while having similar performance.
The people that cite the performance impact of bound checking and other features, usually tend to ignore that they can be disabled if required for performance reasons, because it suits their arguments that no other language can achieve C like performance.
Or they like to forget that the industry has invested more in optimizing compilers for C than for other languages. So they end up discussing languages without regard for the implementations.
While I believe you could write an operating system in Haskell, for instance, I don't know nothing about it's performance. However, microkernels, even though are safer, have some performance drawbacks.