Sujet Le pub des programmeurs

Citation : Oui mais en caricaturant un peu, ce que vous dites, c'est que du code bien ecrit est lisible, et que du code mal ecrit est illisible, une lapalissade, quoi.

Citation : La question, c'est plus de savoir a quel point un langage te permet d'exprimer des constructions de haut niveau sans que le langage gene. En C++, l'exemple typique, pour moi, c'est boost et la STL. Ca rend tres rapidement le code illisible des qu'on utilise des trucs non triviaux

Citation :
Je ne suis pas trop d'accord avec toi : si on utilise bien les STL (notamment avec des typedef et des noms bien choisis) ça peut rester très clean.

Citation :
On parlait de la lisibilité du code des machines à voter.

Citation :
Worse than reading good C++ code is reading bad C++ code. One of the big problems with C++ is not so much that it has a lot of features, but that its features aren't particularly orthogonal. There are a lot of cases where there is more than one way to do something, but its not particularly obvious which way is better, so the programmers pick at random and without strong team discipline, everyone will inevitably pick differently.

Even something really basic like passing a string around becomes needlessly complicated. In almost any substantially-sized C++ code base, there will be at least three string representations: char*, std::string, and a custom string class. And of course there is the eternal choice between references and pointers, declaring procedures virtual or non-virtual, declaring base classes virtual or non-virtual, and needless other crap.

And the lack of GC encourages a whole bunch of other brain-damage. Consider something simple like a function that enumerates what plug-ins are available in an application. In a GC'ed language, you stuff the objects into a list, return it, and call it a day. In C++, you can:

- Return std::list, which implies copying every element.
- Return a pointer to a list, and depend on the client to call free().
- Use an iterator pattern, at the cost of turning a single operation into several functions (ie: getStart() and getNext() or something).
- Use a reference-counted data structure, which implies using your own custom reference-counting infrastructure.
- Wrap the data structure in some sort of smart-pointer.
- Have the client allocate the result buffer, and write into it, turning a single operation again into multiple calls.

None of these solutions are obviously right, so C++ code ends up using all of them, in different places. The lack of GC is why you have utterly brain-damaged (from a memory management point of view) interfaces like sysctl, CORBA's C++ mapping, reference-counted anything, etc.