Why do C++ folks make things so complicated?

http://www.johndcook.com/blog/2011/06/14/why-do-c-folks-make-things-so-complicated/

by prog • 15 years ago

36 33 15 years ago

mrich• 15 years ago

C# comes to mind when he is talking about top/bottom C++. They got this right, plus added some neat high-level features.

JoachimSchipper• 15 years ago

Actually, the commenters are arguing about what languages are best used in those roles; e.g. C as "bottom C++", Python as "top C++" - or, indeed, C# as "Top C++".

C# is nice, but I wouldn't want to write a kernel in it.

profquail• 15 years ago

C# is nice, but I wouldn't want to write a kernel in it.

Why not? :)

http://singularity.codeplex.com/

When C# is combined with Code Contracts / static verification, you get fairly clean/performant code and strong safety guarantees. I think that'd be quite nice for kernel programming.

rch3• 15 years ago

Not so sure about that... Consider the Template Numerical Toolkit: extending it would be Bottom while using it would be Top (reference counting, overloaded for for both row-major or column-major array access, etc.).

C# takes things several steps further down the road.

http://math.nist.gov/tnt/

eru2• 15 years ago

By the way, why do C++ people seem to think that reference counting is a good idea?

dedward• 15 years ago

Simply a combination of it's nature - it's C++, and It's been around a long time. It's easy to make messy stuff with it.

microtonal• 15 years ago

If you want to make such a distinction, Qt is probably what would come close to top-C++. It offers dynamic binding via signals/slots, Java-like iterators, simple multi-threading/parallelization, signal/slot-driven networking, database access, and some automatic memory management (deletion via parent widgets, and auto-pointers). It only misses the proposed compiler warnings to indicate that 'bottom-C++' is used.

Still, for the average programmar 'top-C++' makes a miserable language. Want to write a simple class? You have to make a separate header file and decide what methods to inline/make virtual, etc. Want (binary) compatibility? You'll have to worry about things such as PIMPL and d-pointers.

It's a low-level language, and low-level issues will always leak into higher-level subsets. And why should one go through the effort? The old mantra "write in a higher language, rewrite what is too slow in C/C++" works fine.

blub2• 15 years ago

Performance is a cross-cutting concern, you should factor it into the design of the application and not remember it when doing field tests and noticing that the software is too slow.

This doesn't mean that you must use C or C++, but assuming that you can always rewrite the slow parts in C or C++ is inviting disaster.

jpablo• 15 years ago

Doesn't that go against all we have learned in CS? Early optimization being the root of all evil. And don't optimize what you think will be slow, but what you have measured to be slow?

jerf• 15 years ago

We all know the caveats on http://shootout.alioth.debian.org/u32/which-programming-lang... , but I would point out over the last few years, more and more languages are creeping up into the < 3x range on C. Go and Haskell I have some hopes that within a year or two they may well show up in < 2x, Scala's there, and Mono's putting up credible numbers in C# and F#. Given how much even "performance critical" code is still IO-bound nowadays, and how much not-IO-bound code is moving to the GPU anyhow, the age of "We have to use C++ for the performance" should be rapidly coming to a close. The last bit missing is just the people bit, now.

I don't know what the first non-C practical OS will look like, but I hope I live to see it. I can't believe in 2011 my OS is still getting buffer overflows and memory mismanagement and all of the foibles that despite everyone loudly declaring is all the programmer's fault and not the langoage's fault, still seems to follow the language around like dog poo stuck on its shoe.

cullenking• 15 years ago

With most modern languages having the easy capability of writing an extension in C, this is poor advice. You can 100% quickly mock up whatever in ruby, python etc, and when you need to, write a module in C that is plug and play. I have done this several times for calculating metrics on geodata. I wrote a ruby class to do the work, used it in production until we got a good enough amount of users (load), then rewrote it in C. My main code wasn't even touched since I had already abstracted the calculations into their own class. All this requires is you think ahead and pull out any heavy-lifting code into its own class, and you can just swap that out down the road.

Derbasti• 15 years ago

I have written applications both in Qt and PyQt and found out that in the real world, Pythons performance is more than apt for creating a UI.

Even more so, the PyQt application had a NumPy backend and again, it performed flawlessly. The Qt application had a C++ backend that did similar computations as the Numpy backend, but with a much more painful programming process.

So in that line of thinking, I am a big proponent of having a dynamic language as frontend for low level libraries. Both Qt and the Numpy core are plenty fast for what they need to do and having a dynamic language like Python as a frontend makes programming very convenient. The best of both worlds, really.

I have never experienced Python being the bottleneck of my algorithms using these libraries.

cageface2• 15 years ago

C++ already contains "top" and "bottom" C++. You can write boost-style code, with heavy use of smart_ptr and STL algorithms & functors, or you can stay pretty close to the "C with classes" layer.

16s• 15 years ago

That's the thing I like most about C++. I can do any type of programming in it (OOP, functional, procedural, templates, etc.). I can roll my own data structures or use the built-in STL containers while working with low-level C-like code. I'm not sure why so many people complain about it. Once I began using it, it quickly became my primary programing tool on Unix, Windows and Macs.

derleth• 15 years ago

"Beware the Turing Tarpit, where everything is possible but nothing of interest is easy." -- Alan Perlis

C++ is, for many people, a Turing Tarpit: Ask yourself why you wouldn't write something in assembly, and that's why they wouldn't write it in C++.

In specific, C++ doesn't have built-in support for real garbage collection. This means a lot of the idioms I take for granted in languages like Common Lisp and Haskell, to pick two very different languages that have true gc in common, are effectively impossible in C++.

For example, I can't reliably pass complex data structures around using function composition (think f(g(h(x)))) because I can't rely on them existing from one function call to the next; an allocation may have failed somewhere up the line and now what? Adding in all the code needed to handle that isn't just a pain, it obscures the algorithm to the point I'm not programming the same way anymore. I'm not even thinking the same way anymore.

Now for a purely personal anecdote: I quite like C. I can do certain things in C about as fast as I can think of them (mostly, things involving the POSIX API and no really complex data structures). I occasionally get the notion to add some C++ to my bag of tricks; not C-With-Classes, but C++ with Boost and the STL and whatever else g++ can handle these days. I might as well learn to swim by jumping in 500 feet upstream of Niagara Falls; there's "hitting the ground running", there's "hitting the ground doing back-flips and double-somersaults", and then there's "hitting the ground juggling sharpened sabres and gently convincing hungry wolves to not eviscerate you." Honestly, it wasn't this hard to learn how to write macros in Common Lisp. I don't know if the problem is just me or if it really is that bizarre in C++-land.

michaelfeathers• 15 years ago

I think that the main reason that C++ is so complicated is because they've had to maintain compatibility with C's model. The declaration/definition and value/reference dichotomies double up a lot of work. When you add the fact that they wanted to base STL on pointeresque semantics (iterators) and people started using template meta-programming to deal with the lack of reflection, well, it all got complicated.

Why do C++ folks make things so complicated?

Related Stories