I disagree with Linus Torvalds about C++

I’m not defending Torvald’s assertions, which are pretty strong, particularly with respect to programmers and kinds of programmers. Nonetheless, a C programmer having a mastery of C declarations, of storage allocation and reclamation, and of the standard C library (augmented perhaps with one or two special ones, like Gnu) plus a lot of self-discipline can IMO do fine with just plain C. C++ is important to know because there are large and valuable packages and systems written in it, and even if C is the primary linking to C++ code is straightforward, as is calling C from C++.
I’m far more interested in productivity … number of non-syntactic bugs per module of C written, and time to produce. There’s little reason why people should be any more error prone in C than in any other language, although surely you won’t get as much done per unit time in C as in R for the set of quantitative things that interest me. There are other options, too, like Ch.
Some of the C vs C++ argument may be resurrecting the OO versus non issue. It is true that once having embraced OO, I’ve been regularly disappointed by its support in many programming languages other than Smalltalk, and the uses made of it by programmers. I find some of the uses of it in R remarkably good, but I do not see the pressure to use it as great as I thought years ago. This may be purely a stylistic issue on my part.
… As may be my opinion of C++. I think that if a design is functional in C, passing function parameters, and using vectors or lists of structs, some of the benefits of OO are had automatically.
Finally, my notion of self-discipline includes the absolute insistence that no messages be produced by the compiler, including warning ones, and that liberal use of the assert facility be made, both for self-checks and as semantic documentation.

Torvalds talks about “STL and Boost and other total and utter crap.” A great deal of thought has gone into the STL and to Boost by some very smart people over the course of several years. Their work has been reviewed by countless peers.

A lot of really smart people have thought for a really long time about postmodernism; a lot of smart people + a lot of effort + a bad left turn somewhere still equals an unusable mess. (/flamewar on!)

To be honest, I don’t have quite as big a problem with C++ as Torvalds seems to, but I still wouldn’t go out of my way to use it for any project I actually cared about.

Isn’t this the same argument made against FORTRAN, PHP and VB, etc.? A good programmer writes good regardless of the language. It’s like Steve McConnell wrote in Code Complete, you should write INTO a language NOT IN a language.

I agree with the previous comments. I think that Torvalds meant to say that C++ is a poorly designed language, and I believe this statement is uncontroversial. I think that John focused on programmers’ productivity, but I have to disagree with him. C++ is a sprawling, complex language that allows many programming styles. It’s difficult to read other people’s code. It is easy to make subtle mistakes. In other words, it’s a language that gets in the way, whereas C is not.

We can dissect why it came to prominence (good timing, the backing of Bell Labs, backward C compatibility) and why it’s still relevant today (large code base, a powerful STL, sunk costs for scores of programmers), but this is also beside the point. A more interesting question is: why use C++ on a new project today? I can’t see any reason. Fast numerical code? Use C or Fortran, since all stable and maintained numerical libraries are in C and Fortran, and APIs are in ANSI C (e.g., CUDA). Embedded and operating systems? Everyone uses C, for a reason. End-user applications? Java and/or Python. Server-level application programming? Python/Ruby/PHP etc. Data analysis? R or Java libraries (e.g., Weka), maybe functional languages.

Sure, you can use C++, or assembler for that sake, in all these domains. Not recommended though. The advantages of C++, C compatibility and OOP, have been eroded by the emergence of new OOP languages that allow for greater productivity.

The two areas were C++ has an intrinsic competitive advantage are videogames, although the AI and glue programming is increasingly performed by scripting languages like Lua and Python; and some performance-critical applications, e.g. DBMS engines, indexing etc., although even in these areas Java has made great strides (e.g., here and here).

The point I’m trying to make is that there are many old, terrible C++ libraries. That’s not the same thing as saying C++ is terrible.

When I write C++ using tenets of refactoring, RAII, single responsibility, composition over inheritance, and generally the SOLID principles, I can go back six months later and look at the code and smile. That’s a great feeling, and one I can’t imagine I’d ever have in straight C. It’s not to say that I don’t hope to transition to more C# in the future, but with the right techniques I find that I can be a happy camper in C++ too.

I think you hit the nail right on the head, David. I’m a fan of C++ because I’ve used it for some time and I know how to get the most out of it for my purposes. I think that Torvalds continues to be an ass about this issue because it’s just not his style, but he falsely attributes Everything Bad About Software to C++. He can do amazing things with C, and that’s great. He should continue to use it.

Despite that, though, I think that I agree with gappy that C++ isn’t necessary most of the time. I like it for “guts” work or bridge work (I should say that I have liked it), but for the most part, apps can be written in Java or some other language, and web apps these days never ever use C++.

I find that the benefit of C++ mostly lies in the STL. As far as Boost goes, everyone should learn to use shared_ptr, but that’s going in the standard now. The nice thing about other Boost libraries is that they “just work” almost all of the time, and I have rarely had a problem with them when I apply them to their intended purpose.

I have deep experience with Java and C++. Writing C++ programs using Boost and a good IDE is almos as easy (sometimes easier) than writing Java programs. The IDE I use is SunStudio IDE. Boost makes writing C++ programs very easy. C++ without Boost is hell.

I believe that C++ is the language that you make it. If you use Boost, STL, and Qt4, then C++ is about as safe as Java. Using shared_ptr objects, RAII, and actual exception handling makes C++ pretty rock solid. However, contrary to what Daniel says:

“C++ still allows me a tight low-level control. Less so than C, but enough for my needs.”

C++ is a superset of C, so therefore using C++ you can get as close to hardware as you desire. Again, though, C++ is what you make and want from it. If you want insane speed, turn off RAII, exception handling and the other tweaks you can do to make it more C-like but with a standard dialect. If you want a type-safe, object-oriented, thread-safe language…C++ can do that too. I agree with John when he says that you end up reinventing the aspects of C++ in C. I’ve got so far as implementing function calls in structs with manually managed constructors and destructors. This bastardized C++-like language wasn’t my design, but I had to code using it. A C++ compiler wasn’t available for the platform (a DSP chip) and the project dictated certain structure.

I find it sad that more didn’t make it into C++0x. I would have really liked to have seen concepts worked into the standard. It’s really amazing what the guys at Boost have done already with templates and type requirements, but it would have been really nice to extend the functionality into the language itself.

The bottom line is that C++ has the flexibility to be the language that you want. Use it as a functional language if you want. Use it as a pure, multiple-inheritance, object-oriented language if that’s your thing. The beauty of C++ is in its flexibility…yet it doesn’t lose its raw bit-smashing strength of C.

I don’t think he will, actually. His objections are irrational enough that he’d find something to object to, no matter how perfect the code was. He objects to it simply because it’s C++ and he doesn’t like it. It’s a canard.

I think this is a case of Torvalds being unable to understand or write in C++. Now what I’ve said is controversial, but at it’s core, when intelligent people like Torvalds make douche like commentary it’d due to psychological reasons, not their ability to make objective comparisons. And Torvalds has become so specialised in C writing that I truly think the guy is baffled by the language and the abstract concepts. Add to that he’s a control freak who needs to pore over every gram of code due to being an OS coder, and he would be tearing his hair out trying to understand some of the addon libraries for C++ like the STL. To be honest, though he has a point: things like the STL have tons of extra fluff you rarely -if ever- use. But when he dismisses the language he’s basically whining that he has become so specialised in C that he feels like an idiot again trying to relearn some in C++. I bet assembly coders would feel that C is stupid for the similar reasons that Torvalds is bashing C++. I also think the point about comparing great C programmers to great C++ programmers, and average to average was the crux of this issue.

After having programmed in C++ for many years professionally, I absolutely detest that language. It’s not that I don’t understand the language – I understand it very well – but the problems I always seem to get into are figuring out the inane complexities that C++ brews up in short order. There are so many ways to needlessly complicate your code to the point even you can’t work with it. There are so many non-standardized conventions that one just gets into a huge mess in short order. Trying to get multiple libraries to work together is like pulling teeth. Then, just to add insult to injury, at every spot where the design of C++ could of made it easier and more productive, the designers made sure to take the route that did the exact opposite. There are hundreds of little things that can go wrong, and this makes for a large amount of time spent fixing shit.

I’ve been using a lot of C and Objective-C lately, and just love it.

I like C++, and have programmed in it for many big projects although I don’t use it much nowadays, but STL and Boost and other total and utter crap is absolutely correct from my experience, at least the STL part. In a particular cenario where I had lots of complex and dynamic trees and lists, the STL memory managent was so bad that after half an hour of number crunching the program always ground to an halt because of memory fragmentation. I ended up dumping STL and implementing all the data structures and memory management myself. So sometimes you don’t realize the crappiness of something until you use it to its limits.

Linus is smart but too arrogant.
It would be nice to have a C++ kernel that replaces Linux. Take a look at:
http://l4ka.org/projects/pistachio

“L4Ka::Linux, a modied Linux 2.4 kernel running on top of L4Ka::Pistachio,
enables unmodied commodity applications to coexist with customized system components,
which allows a smooth migration path towards customized services, and
supports secure extensions to monolithic operating systems.”

I do not claim that C++ is perfect, but I’ve never had any desire to go back to C after I moved to C++ many years ago. I’ll grant that I’m not writing my own operating system, but neither are the vast majority of programmers. For my work, C++ is as low-level as I care to go.

Yes, not only are you not writing your own extremely high-profile operating system and distributed version control system, you’re not writing high-profile open source software either. But Linus is, and he’s defending why HE chose C for those.

One important detail that everyone forgets when entering this debate (and also the debugger debate) is that Linus’s public arguments concern his public open source projects, and the values of open source projects are going to be much different from the values professional programmers working in proprietary (shrinkwrap and custom systems) software care about.

In proprietary software projects managers try to maximize the value they receive from programmer time. Linus simply doesn’t care about your time. He routinely shuts down what would’ve been tens of thousands of dollars of work (in the form of rejected patches) on a whim.

You’re basically arguing apples vs. bicycles.

Writing good C++ code requires good dicipline, and good tools (IDE + libraries). There’s a lot of awful C++ code out there, but it’s the potential to write good code is what makes a difference. I’ve made very good C programs using good techniques and they end up very well, but I end up with many limitations that C++ does not have so I’ll always preffer C++. C++ (with STL+boost) allows me to do much more than C with very little/zero overhead so for me writting C code for what I do it’s pointless.

“I imagine gurus like Bjarne Stroustrup and Herb Sutter can write C++ as skillfully as Linus Torvalds writes C, though that is an almost pointless comparison.”

I’m afraid that might not be as obvious as you think it is. Torvald’s main goal is a high performance and portable git. Whether Stroustrup or Sutter can write C++ “skillfully” matters less than whether they can write high performance C++, and whether that code will actually build on a variety of architectures. It’s already “established” that idiomatic C++ is slower than idiomatic C via the Compiler Shootout benchmarks. Now have a look at theMozilla C++ Portability Guide and ask yourself how many rules people would follow, versus argue against. Then throw in some more rules for efficiency.

With C, Torvalds already knows the language perfectly well. And he has a community of developers on tap who know the language and his performance goals perfectly well. As you state, the lowest level you want to bother with is C++ itself, which is insufficient for anyone demanding performance. You need to occasionally look at the ASM compiler output and compare that to how fast you’d write it. So really, it sounds like his selection is working as intended: keeping people who refuse to understand low level implications away.

C++ remains the first choice for lot of developers. I have used C++ to write a Kernel from scratch. Taj OS is first operating system developed in India which is totally based on object oriented concept.

Adding functions to do allocation and deallocation need not be the same as reinventing the mess that is C++ constructors and destructors. Copy constructors, virtual destructors, non-intuitive results if someone on your team misses one, unexpected breakage because of “smart pointers” (a misnomer if ever there was one), unpredictable execution orders, static constructors depending on extensive loader/library support (making them untrustworthy in anything but a standard user-level environment on a commodity general-purpose OS), massive abuse of the stack (see previous) . . . the list of problems with the C++ interpretation of this fundamentally simple idea just goes on and on. That is, in fact, one of the defining characteristics of C++: a simple and worthwhile idea extended and made more complex and overused until the problems are greater than the benefits. The same applies to operator overloading, for example, or templates (compiler-copied code is a poor substitute for a type system that allows one to create type-agnostic collection classes *once*), or a dozen other misfeatures.

A lot of the most readable, maintainable system-level code I’ve seen is “object oriented C” – C with a set of macros/libraries/conventions that implement a much simpler kind of OOP than C++ without encouraging the bad habits that C++ practically makes inevitable. In either language, one line of code can translate into many thousands of instructions, nearly as many cache misses and pipeline stalls, maybe even a page fault or two as all the required code has to be brought in. That’s good if those thousands of instructions are doing something useful in terms of the application at hand. That’s bad if it’s just running around in circles creating and destroying ephemeral objects because the person who wrote that one line had no idea that the ten programmers before her had added so many layers of abstraction and indirection – yet that’s exactly what C++ and the books on C++ encourage. I’ve seen *very good* programmers fall prey to that. C++ makes it way too easy for programmers to work at cross purposes and create mutually incomprehensible code, whereas fully comprehending each others’ code – including its resource and performance implications – is essential to serious programming.

C++ used *very carefully* is fine, but using it that carefully is more work than building the needed constructs in C. The necessary C++ coding standards to mandate use of certain constructs and forbid others, along with the enforcement that would be required to make that standard useful, would be far more burdensome than writing the bits of C code that are needed when they’re needed. One could say that the problem is not the language but the idioms and habits that have grown up around it. There’s some truth to that, but I believe the language itself must bear some of the blame for encouraging those idioms and habits. I think Linus is wrong about a great many things – typedefs, debuggers, and specs are three software-engineering examples I’ve written about myself. I don’t agree with him out of habit, but he nailed this one. C++ is broken at such a fundamental level that it might as well be by design.

I agree with Linus C++ sucks.
I believe Bjarne Strousstrup said inside c++ there is a much cleaner simpler language struggling to get out. I agree it is called c.
C++ tries to be all things to all people and in doing so becomes overly complex and fails to be good at anything. C++ tries to be a low level system programming language and a high level language to develop apps in. These are two tasks are very disimilar task. Your working on a app trying to work at a high level of abstraction then some noob developer decides to compromise your abstraction and safety with low level programming. I have seen the converse too your working on a system programming task and some noob decides to use high level programming constructs.

You want to do low level system programming use C
Your building high level apps use Java, Python, Ruby or some other high level garbage collected language

Use the right tool for the right job, C++ is never the right tool unless constrained by legacy.

C++ is a language with a schizophrenic identity crisis and way to complex.

Although I must confess when I have to use C++ at work and school I do use STL and BOOST for convienance BOOST has a lot of incomprehensable MACRO and template TRICKS in it.
It is really hard to figure out what the hell BOOST is doing under the hood.

Troy

Jack of all trades, master of none. Several have made the point, if not in those worlds, and I think it’s the real problem many have with C++. Personally, I write a lot of code in C, mostly because it’s kernel stuff but also sometimes because it’s just the right tool for the job. I also write a lot of code in Python, because it’s the right tool for a different job. If I were learning to do some of those same jobs today and didn’t already have tools I’m used to, I might learn Ruby or Groovy. I might still learn Scala or Erlang for still different jobs. What I won’t do, and what I don’t believe any language designer should expect people to do, is use one language for all things. C succeeded because it was relatively easy to learn and to generate efficient code for. Python succeeded because it was even easier to learn. Groovy is rumored to be great for developing little domain-specific languages, while Scala and Erlang are specifically designed for complex distributed systems. None of them intended to be or do all things for all people.

John Ousterhout got it exactly right when he encouraged moving to a multi-language paradigm using the right tool for each task (http://home.pacbell.net/ouster/scripting.html) even though I don’t think Tcl is the right tool for much of anything. Even more important than the fact that C++ sucks is the fact that any one language sucks. Anybody who’s not at least thinking about which language to use for each project, or about how the functionality they’re implementing might be used from multiple languages, is a bit behind the state of the art.

Chila,

“I think GOOGLE is good.”

Your logic if flawed

The fact that good C++ programs / software exist doesn’t imply that C++ is a good tool

I myself have written C++ code that I am proud of,
I have also written some good perl code too both those languages still suck though

Smart people can build good things with bad tools.

You can write good code in any language some languages just make it harder C++ and Perl being ones I am familar with.

There is no language that it is hard to write bad code in

Besides my impression from listening to google tech talks is that they are moving away from C++ towards Java and Python if you have better info please enlighten me.

Troy

Google Chrome & Firefox are also very “good”.
What browser do you use?

If that’s the logic you learned in high school Chila, you need to go back. The only conclusion one can reach from your two axioms is that something good can be made with C++, not that C++ itself is good. To connect that conclusion with the one you stated, one must employ a second syllogism:

A1: Good things can only be made with good languages.
A2: A good thing has been made with C++ (previous conclusion).
C: C++ is a good language.

Unfortunately, as Troy already pointed out, good software can be made with bad languages. Happens all the time. It requires much more discipline and work than using good languages, but it’s quite possible. Without proof of A1, your counterexample is irrelevant. Good luck.

I guess the snarky answer would be because they don’t know any better. A little more seriously, though, it might not be the wrong tool for them. There’s value in using a language that your developers already know, that’s well supported in the tools you’re already using, that the libraries you need were written in, etc. With the proper coding standards, and proper enforcement of those standards, just about any language can be used safely and productively. Many organizations can apply that kind of discipline to their C++ coding efforts, and get good results. On the other hand, there are good reasons why even some of your examples are considering or moving toward alternatives. They believe, and not without reason, that even if their programmers have created decent software using C++ in the past and can continue to do, those same programmers can be even more productive in other languages.

or considering?

I assume that when we’re talking about Google, we’re talking about the Search Engine, not the App Engine, Android, etc. Google people use many languages to achieve their goals, but this does not mean they are “moving away” from C++.
Remember what language they’ve chosen for Chrome.

(i’ve missused the italic in my previous post)

“The HotSpot Java Virtual Machine is written in C++ (this is the leading edge, high performance replacement for Sun’s “classic JVM” which was written in C).”

http://www.research.att.com/~bs/applications.html

I’ve downloaded the Java SE 6u18 sources and it’s true: 775 .hpp vs 30 .h files and 686 .cpp vs 18 .c files) for the hotspot part.
This is the latest Java VM available, and again, C++ is the “chosen one”.

Many say that Java wants to compete with C++, this could be true, and if so, it’s very ironic that it’s core is written in this language (i’m not saying it can’t compete with it, Hotspot seems to be very fast, i’m just saying it’s ironic).

This is another example of use of this wrong tool…

I asked you for evidence that some of my examples are moving, and in the case of Google, I asumed from the begining we where always talking about the Search Engine. So if you can get me evidence that the Search Engine is moving away from C++, then I’ll say you’re right, and we could say Google is moving away from C++.

For the LHC part, check out this link:

http://www.youtube.com/watch?v=bSEv4vF5CTs
(Marjoire Shapiro talking about the LHC)

Time: 0:41:44 —> We have a multipurpose C++ framework…

For the Chrome part: There are many good libraries in C++ you can use, so come & use this wrong tool, Google did…
I’m still waiting for the java or python version of Chrome or Firefox…

What we’ve learned so far is:
- C++ with good dicipline, good libraries and tools allows you to write very good programs.
- C++ has allowed the existance of very good software, and continues to do so (JVM, Chrome, many many games you currently play, etc).
- and yet: C++ is always the wrong tool…

I never said you said so, but the other ones did (including Linus).

What you said was:
“On the other hand, there are good reasons why even some of your examples are considering or moving toward alternatives. They believe, and not without reason, that even if their programmers have created decent software using C++ in the past and can continue to do, those same programmers can be even more productive in other languages.”
But:
- You could not prove any of my examples where “moving away” from C++.
- Somehow you know what “they” (decision making people at the companies whose products I mentioned?) believe, and this is that the current C++ programmers they have can be even more productive in other languages. I don’t think this is true.
In fact, I’ve shown you that many of my “examples” are actually embracing the language.
Besides, I’m no fanatic. I like Java very much and I want to learn how to use Python.

For the agreement part: My first post was an agreement to your post, because you where right. But after that you could not hold your statements, so I could not agree with them.

Google hires Guido and then get him to work on a code review tool. Wow! Just Wow! I think he’s just another celebrity employee there. A honeytrap for graduates.

Having the experience this weekend of picking up somebody else’s C++ module and trying to get it to compile, let alone run, I must agree with the wag I read in a related C++ forum who wrote,

One of the major weaknesses of STL is trying
to figure out what is wrong when things go wrong with it.

I understand why STL is supposed to be useful and good and clever, but really ….

I cannot recreate the original build environment without essentially rebuilding an entire Linux system. I am not about to do that. I am, instead, going to write the new code afresh, hoping that it does all the old code was supposed to do.

Alas.

The old days of C++ are gone. Boost brings C++ to a new era, the era of correctness, robustness, portability, simplification and performance. More and more C++ projects are using Boost. At our company, we use C++ for many things, but Boost is a must. Otherwise it’s impossible and all the bad C++ things appear. Boost makes C++ a very suitable languaje for general application development. C++ always needed Boost, and now it’s here, for the good. C++ without Boost sucks, C++ with Boost is very good and usable (and fast, btw).

Inheritance and virtual functions are mostly unnecessary.

I was helping a physicist to modularize their C model code, and in the end we implemented a poor-man’s class system. It would be much easier to do it in C++.

C++ has a problem though for the inexperienced: design paralysis.

I’m a C++-programmer and I’m trying to learn Java. The more I know Java the more I love C++. It seems that C++ is for real programmers and most of the other languages are for people who don’t know what they are doing. Just like Java. I hate Java and all the restrictions it has.

@Coder
Well Java is a powerful language. Heard about Android? Where you need high dynamism and instant portability, C++ loses, and Java wins.

@QuantDev
That’s right. Java wins sometimes, and C++ sometimes. Nowadays with gcc and the Boost libraries, C++ use has become a lot easier. If the library uses Boost heavily, and compiles in gcc, portability is increased a lot. So the chances that doing:

- ./configure
- make install

ends in success is increased, and even more if the target system is Linux.

@QuantDev
There’s source code portability and binary (intermediate) code portability. C++ can achieve the former, Java the latter. My response was related to your statement:

“if you need a Java library, you download a JAR and that’s it”

So even thou it will never be as easy and direct as downloading and using a jar, it can become very close nowadays.
If the operating system is GNU/Linux, the chances increases since gcc and boost are primarily targeted at this OS, but I have good experience in Solaris and HP too.

“Lack of binary compatibility has profound consequences for real world applications.”
The majority of the programs you execute are not binary-compatible (your browser, your OS, etc.)

“Also, the source compatibility in C++ world is not universal.”
That’s the part that the standard and Boost are trying to solve, or better said, improve.

“That excludes the vast majority of systems that people use.” (linux)
Well, that’s changing a lot. Take for instance all the Android phones and all the servers there’re out there. Linux is growing very rapidly in general.

I love it when java programmers compare c to java. They probably don’t realize that java is mostly written in straight C with pure assembly when things need to be done better. Same concept applies to great video games too.

thats right folks–after java, c++ and all the other languages that came about from the bastardization of straight vanilla C have gone and long forgotten ansi c will still be here.

Wow, this thread has longevity. Of course, I’m continuing it.

Two points.

First, John wrote: “The set of C features not in C++ is small and mostly deprecated.” Actually, the history is a bit more complicated than that. It’s been more of a conversation than somehow C++ moving beyond C. There are things that have been put into C via C89 and C99 which were borrowed from the experience with C++, and, of course, with the ever increasing capability of hardware. An example of the latter is how to do random access of Truly Huge File Systems where you can’t know how many bits are in the handle which access them.

Second, it was MUMPS which reduced all arithmetic to strings, thus making all arithmetic portable across realizations. I think that may have been the spirit of Java in evaluating things in software. Still, what I find offensive about many people’s codes, no matter, is that they deliberately exploit peculiar libraries and don’t try to write code that’s portable. People’s buying into the GNU model as portable is really hypocritical, because there are not single realizations of that model: The model depends upon the version of the compiler, and to some extent the vendor.

I also have found that some gcc versions have optimizers which break code, and I only found these by executing the same numerical code on a Windows compiler for which I paid. (No, not Visual C.)

I’d say you are correct, John, when hardware now implements IEEE Floating Point nearly everywhere. I heartily wish, however, that we had grown up more about this and had widespread and standard libraries available everywhere for doing things like SVD and Cholesky decomposition and Warshall transitive closure. We don’t. Heck, it’s hard to find consistent and good libraries for doing great circle distances on unit spheres. Often better to write ‘em yourself. That’s sad.