M. Copé a reconnu les propos mais a précisé qu'il s'agissait d'une "conversation à baton rompu transformée en interview artificielle".

I'd like to think that I'm quite sane, and I'd like to say that I think C++ is a horrible language.
 
I'm just a few months shy of programming professionally for 10 years. In that time, I've written substantial commercial projects in Visual Basic 3-6, C, C++, Java, C#, Python, Ruby, Bash, JavaScript, and CoffeeScript. I've also written non-trivial hobby projects in Scheme, Clojure, Scala, UnrealScript, Lua, Prolog, Ocaml, F#, and Haskell. I've probably forgotten a few from that list as well. And those are just "general purpose languages"! Never mind all the other ancillary languages like SQL, CSS, HTML, hundreds of config formats, XSLT, and on and on and on.
 
And out of all those general purpose languages.... C++ is probably my least favorite. I can feel the negative impact it has on my thought process. My brain is just so pre-occupied with C++isms, that I can't think about the problem domain. There is no problem that C++ can solve, that can't be better solved by C and [higher-level-language-of-choice-with-decent-c-interop].
 
One thing you'll note from my lists of languages above: I haven't done any professional/commercial projects in functional languages. I've only really been experimenting with functional programming for about two years now. And in that time, I've slowly begun to understand what it is about C++ that makes me hate it so much: it encourages an unsustainable style.
 
I've recently developed the opinion that object-oriented programming became popular because it is a way to enable people to isolate the complexity of mutable state. You can write a class to maintain some invariants on a composite datatype. Thanks to encapsulation, data-hiding, all that jazz, you can write a class which is easier to use than a big bag of functions because you can assume the object's invariants will hold, even if you pass the object to some potentially hostile function (that is, any function written by one of your dumber colleagues). But easier != simpler != better. See Rich Hickey's talk on simple vs easy.
 
When you write C, less is guaranteed for you, so you better read the damn comment or the code itself. You have to actually think and make decisions. Sometimes, it's to your advantage for it to be a little bit harder to do things because then you have to stop and think if it's actually the right thing to do before you waste your time doing something stupid. You simply can't reason about all the magic that can happen with operators, conversions, copy constructors, template metaprogramming, macros, and on and on, in C++. You have to assume that whoever wrote the class you're using is not evil because otherwise you'd spend a year reading every single line of your program over and over again just to make sure that there isn't a gotcha lurking out there for you. The language is too complicated to reasonable allow anyone to reason exhaustively about the semantics of any particular line of code.
 
So you start writing everything as objects. And you start stashing all this various mutable state off into various different objects. And then the C++isms kick in and you have new incidental complexity from object ownership and reference semantics, and value copying, and consts and all that nonsense. So now you have these objects which are mutable because it's so easy to make them mutable, and it's so natural to think about them in that way, that you build these huge class hierarchies out of a sense of liberation from actually having to reason about your programs and data structures.
 
And before you know it, you want to change your mind about something. But you can't. Because you don't actually know anything about how anything works in your program. Everything is hidden behind interfaces and invariants and levels of indirection. You wind up decoupling things that didn't need to be de-coupled. And when you realize that they are actually inherently intertwined, too many other parts of your program have already taken implicit dependencies on hidden invariants. Your nice, well-factored program becomes harder to change because of just how carefully every little piece was neatly designed to fit with each other neatly designed piece.
 
C++ is a horrible language because it occupies too much space in your brain. C++ deprives your mind of the oxygen it needs to think about your problem. Then it introduces tools to help you over-engineer a solution long before you've had time to think about the solution. Then those tools introduce incidental complexity that further suffocates you, stifling your ability to think about the problem, and not whether or not it's safe to assign that variable, or if that's going to copy some thing and leak memory and explode when the moon is full.