
After All These Years, the World Is Still Powered by C Programming - geospeck
http://tekhinnovation.blogspot.com/2017/03/after-all-these-years-world-is-still.html?m=1
======
TwoBit
And C++ is used in so many places on top of that. Every web browser is written
in C++. Most GUI systems are written in C++ (or Objective C). All gaming
engines are written in C++, etc.

~~~
humanrebar
It's also my understanding that the LLVM, GNU, and Microsoft __C __compilers
are technically (1) all written in C++. It 's also my experience that larger
embedded projects also tend to be C++. So maybe your microwave is written in
C, but your car's control systems are probably C++, at least in the new parts.

(1) So the gcc codebase is almost entirely C but it is compiled as C++.
Someone else might be able to explain exactly what features of C++ made this
an attractive option . My intuition tells me it has to do with better compiler
diagnostics, perhaps involving type checking. I'm on mobile or I would
research and provide more authoritative sources.

~~~
shpx
Taylor's slides list the reasons to commit to writing GCC in C++:

C++ is well-known and popular.

It's nearly a superset of C90, which GCC was then written in.

The C subset of C++ is as efficient as C.

C++ "supports cleaner code in several significant cases." It never requires
"uglier" code.

C++ makes it harder to break interface boundaries, which leads to cleaner
interfaces.

[https://lwn.net/Articles/542457/](https://lwn.net/Articles/542457/)

~~~
humanrebar
> It never requires "uglier" code.

Again, I mostly agree with everything you wrote, but this is overstating
things a little. Because exception safety can be a little more complicated
than it first appears, you _do_ end up having to do a bit more work in C++ in
certain cases.

One example of this is writing an external ABI in C++. Depending on how nice
you want to be to the consumer of your ABI, you might need to add a
try...catch(...) to every public function to make sure exceptions don't escape
the C++ code. There are also tricky subtleties around writing, say, a swap
function in the face of constructors that might throw.

~~~
stephen82
You can write exception free code since C++11. All you must do is to add
noexcept operator at the end of your function that you don't want to throw an
exception and that would do.

Also, in the article it states that cars are using C. If I'm not mistaken,
Bjarne himself in a couple of videos he has mentioned certain companies, like
BMW and Mercedes, are using C++ for their cars and of course these two
companies are not the only ones.

The good thing is that C++ committee _did_ pay attention to what people and
companies have suggested and or complained for years and fixed it with the
release of C++11.

I really love using C myself, but I wish C had the safety C++ has by default.

------
vvanders
The comparison to C++ with respect to exceptions is a bit misrepresented. In
platforms where size/perf matters they are turned off at the compiler
level(along with RTTI). This was always the first thing we did in gamedev
right after turning on W4.

Overall decent article though.

------
EvanAnderson
Immediately thought of this
[https://pastebin.com/UAQaWuWG](https://pastebin.com/UAQaWuWG) and the
accompanying discussion
[https://news.ycombinator.com/item?id=12312623](https://news.ycombinator.com/item?id=12312623)

------
intrasight
Isn't a big part of its allure that it is "close to the metal"? When learning
assembly language programming in the '80s, I would write a bit of C, and
compile to assembly. It was very easy to mentally map from the one to the
other.

~~~
steveklabnik
This is harder today due to optimizations, but if you also understand those,
you can do it.

~~~
intrasight
That I get. I doubt this would work today. Even a simple program would
generate reams of "boilerplate" and a reasonably complex program would
probably leverage branch look-ahead and other optimizations.

------
charles-salvia
Still, the thing is, I really don't buy into any arguments in favor of
starting a new project, in C, _today_. The problem is that C suffers from some
really serious disadvantages as a systems programming language, and it has no
significant advantages over C++ or Rust, apart from subjective ideas like
"it's simpler" or circumstantial issues like "my team doesn't know C++".

Firstly, apart from a simple call stack, C has no automatic resource
management. There are no automatic destructors. Thus it is _too_ easy to
forget to free some memory or unlock a mutex or decrement a ref count or
whatever, especially when many code paths are possible after a resource has
been allocated. The other options are to use the "goto cleanup" or "goto err"
idiom, which is still way more error prone than automatic destructors.

And secondly, despite being touted as so "efficient", C offers no way to write
code that is both generic _and_ free of runtime overhead, apart from
preprocessor macros (which are filled with their own issues), or automatic
code generation scripts. Both C++ and Rust have metaprogramming facilities
which provide the ability to write generic code without sacrificing
performance or maintainability.

I mean, with C++, the automatic deterministic allocation/destruction _alone_
is worth using it over C. And all of the downsides (larger binaries, etc.) can
be overcome without much effort. I concede that the extra language complexity
of C++ over C could be a disadvantage, but in my mind that doesn't outweigh
the benefits.

~~~
humanrebar
I mostly agree, but C compiles in terms of a binary interface, which makes it
unique in it's ability to provide language agnostic libraries.

You _can_ do that in C++, but by wrapping your C++ in C, more or less. Rust
might provide a compelling alternative here eventually, but it's still a young
language.

~~~
catdog
Providing no stable ABI and not being easy to bind to in general is really a
major pain point of C++ for library/framework code. In contrast everyone and
their dog is able to call into C in practice which is, I assume, a not to be
underestimated reason why it is still so popular, even for code not leveraging
its low level nature. Rust is really interesting here as they have chosen to
make it more than an afterthought to provide compatibility.

> I concede that the extra language complexity of C++ over C could be a
> disadvantage, but in my mind that doesn't outweigh the benefits.

It's a problem, C++ is so insanely complex, full of magic which is hard to
grasp and provides more ways to shoot yourself in the foot than to do it right
(modern C++ seems better in some regards but still…). C is often chosen
because people want sth. reasonable simple so I think a language fitting in
between, being richer than C but still fairly comprehensible would be nice.

------
aciliketcap
Hello,

I wrote an article about the other side of the coin, the problems I have with
a world powered by C.

[https://www.linkedin.com/pulse/c-must-retire-sinan-
akpolat?p...](https://www.linkedin.com/pulse/c-must-retire-sinan-
akpolat?published=t)

I don't want to compare C to another language. I just think that C is old.

------
recursive
cowardlydragon, your comment is marked [dead], so most won't see it. That's
unfortunate because it's pretty good.

~~~
TheAdamAndChe
What causes a [dead] mark? Is it like a shadowban?

~~~
zepolen
Yes.

------
makecheck
C and C++ are in use _but_ it has become easier than ever to bridge in higher-
level languages. It is also hard to code sanely on a large project without a
higher-level language.

Not every line of a program must be ultra-fast, and maintainability is still
huge. If you are _not_ offloading the less-critical parts of your project to
languages that are easier to program in than C++, you are doing it wrong.

------
illuminati1911
It would have been a nice article but there's just too much ridiculous hype in
it.

I'm not saying C is a shitty language or anything, but the reality is that the
only reason why C is still around is the long history it has and the dominant
position it used to have.

~~~
shaklee3
Not really. With the exception of rust, you can't match the speed of C short
of writing assembly. When you start a project you must decide what is
important to you, and if speed is the number one issue, topically you use C.
Many, many new projects start with C, mainly because so many of the fast
libraries are written in C.

~~~
goatlover
Fortran, Ada, D? I guess D is out because of the garbage collector, and I've
not heard of Fortran being used as a systems language, but it's certainly
performant with C.

However, OSes have been written in Lisp, and it has been used for embedded
programming, so it's possible to make a language with more abstractions
available similarly performant.

~~~
coldtea
> _However, OSes have been written in Lisp, and it has been used for embedded
> programming, so it 's possible to make a language with more abstractions
> available similarly performant._

You can use anything for writing an OS or an embedded program, if you expand
the scope of what people consider an OS or an embedded program.

While OSes have been written in Lisp, no mainstream OS people actually use
has. Experimental research OSes don't really count. People have written such
things in all kinds of languages, even Java.

And while you can use whatever language for "embedded" programming, actual in-
the-trenches embedded programming is done mostly in C, in chips and specs
where those other languages wouldn't really fit or be performant enough.

~~~
kazinator
> _if you expand the scope of what people consider an OS_

You mean expand it beyond "currently mainstream OS with a big installed base"
rather than in any technical sense.

> _While OSes have been written in Lisp, no mainstream OS people actually use
> has. Experimental research OSes don 't really count. People have written
> such things in all kinds of languages, even Java._

Lisp machines were shipping production hardware.

Who has shipped hardware programmed in nothing but Java? Java code taking
interrupts, programming DMA controllers, managing memory, etc.

~~~
coldtea
> _You mean expand it beyond "currently mainstream OS with a big installed
> base" rather than in any technical sense._

Well, the technical sense ("to boot some hardware and coordinate some
processes") is too low a barrier.

It's all the other stuff, managing memory efficiently, making the most of
software, being fast to make it worthy to run it, making the battery last,
etc, being a good server, etc, that make an OS an OS and not a research
vehicle/toy/expensive niche workstation (like the LISP machines).

~~~
kazinator
> _to boot some hardware and coordinate some processes_ is too low a barrier.

No it obviously isn't. If it boots and coordinates processes, it's an OS.

> _expensive niche workstation_

In the Lisp machine era, _anything_ that actually had a "real OS" was an
expensive workstation (or mini, mainframe, etc).

Affordable consumer machines had software most examples of which didn't
control processes, yet was still called some kind of OS: MS-DOS, Mac OS, and
the like.

------
j45
With the arrival of WebAssembly this might see another boost.

~~~
j45
Appreciate the downvotes, currently hiring c/c++ developers to build for the
browser/WebAssembly!

------
ben_jones
I've noticed a lot of open source projects that likely would've been written
in C ~5 years ago (like databases) are now being written in Golang. Stuff like
Caddy, Kubernetes, InfluxDB, etc.

~~~
jpineman
e.g. Docker, too.

------
socmag
Good!

It's really awesome

