Bjarne Stroustrup, author of The C++ Programming Language

I like my code to be elegant and efficient. The
logic should be straightforward to make it hard
for bugs to hide, the dependencies minimal to
ease maintenance, error handling complete
according to an articulated strategy, and per-
formance close to optimal so as not to tempt
people to make the code messy with unprinci-
pled optimizations. Clean code does one thing
well.

"Clean code" is shit. It doesn't do anything well except read well to humans. Code that runs well by definition needs to deal with error handling and optimizations, not just naive algorithms that assume clean input. Stuff is broken up by stream handling and framework semantics.

If it's architected cleanly, it does all these things while being easily editable, but is no where near just describing one thing straightforwardly.

lol then why does he use sepples?

>>2
hello contrarian faggot, read some sicp

The

logic should be straightforward to make it hard
for bugs to hide,

C++
Straightfoward in any sense.

C++ parsing itself is lovecraftian monstrosity that defies analysis, a huge dump of concepts, templates and classes of extreme complexity and filled with corner cases, subtle bugs and undefined behavior behind the scenes.
The only positive aspect is that
Debugging C++ code == job security.
C++ code will always have enough bugs and opportunities to create them.

to make it hard for bugs to hide,

C++ code is pathologically opaque, easy to hide bugs behind the layers of abstraction and indirection.

>>5
this. any time I try to make a readable C++ code, it just ends up being C with basic classes and maybe vector.h. if I use C++ 'features', it ends up messy. how can you fuck up templates so badly?

>>6
The key problem is not the existence of templates, its that all Sepples libraries with few exceptions depend on them.
Compilation time skyrockets, debugging becomes much slower and impractical, nested templates interact non-intuitively with classes(concepts and variadic templates); complexity of resulting code is in tens of megabytes.
Templates are much slower to compile than any macros they suppose to replace,
Templates appear even messier than macros(especially explicit template instantiation which is suppose to lead to "Clean Code", since it so transparent,type-safe and readable).
The treachery of C++ is that even if you think you work with template-free code, behind the scenes are thousands of implicit templates being instantiated and specialized.

>>7
the thing is, I like the idea behind templates. what I don't like is template syntax. C-style preprocessor macros have many problems but in practice I like it far more than heavily templated code

>>8
C compatibility is to blame.

http://www.nobugs.org/developer/parsingcpp/

C compatibility is both the reason for C++'s success and its Achilles heel.

Check em