lasher a écrit 2738 commentaires

Concernant Clang/LLVM : il ne faut pas oublier que c'est la NSF (National Science Foundation, équivalent US de l'ANR, Agence Nationale pour la Recherche) qui a financé le projet. Les académiques US se plaignaient de n'avoir aucune infrastructure pour évaluer des stratégies de compilation dans un environnement ouvert. Ce qui a garanti le côté vraiment ouvert de Clang/LLVM, c'est justement que malgré la licence ultra permissive, il y avait un gros acteur (l'état) qui a garanti une certaine direction pour le développement, et ce, malgré l'investissement d'Apple plus tard dans cette technologie.

C'est aussi pour ça que le site de LLVM affirme qu'ils feront tout ce qu'ils peuvent pour ne pas avoir de code publié dans la branche principale de développement dépendant de brevets.

Toutes les plus grosses boites publient du code libre. Mais quasiment jamais sous GPL.

Heureusement que tu as dit « quasiment ». :) Il y a plein de boites qui publient sous GPL précisément parce que comme ça elles contrôlent leur compétition :

1. Un compétiteur qui essaierait de modifier le soft pour l'adapter à ses machines devra aussi publier les modifications qu'Intel pourra exploiter.
2. Comme Intel a le copyright sur le code initial, ils peuvent toujours produire des variantes fermées, ou accorder des licences propriétaires à d'éventuels clients : les autres sont inféodés à la licence, mais pas le propriétaire de la licence lui-même. Voir aussi : MySQL (avant que la propriété ne soit vendue à Oracle).

Non, la licence BSD existe depuis plus longtemps. La GPL a "fait" un seul Linux, quand il y a "plein" de fork de BSD.

C'est vrai. Et en même temps, la GPL peut être transposée en droit français et sera valide (d'ailleurs ça a été fait), là où il a fallut créer la CeCILL(variantes a, b, c) pour pouvoir proposer une licence compatible BSD/MIT (car certains critères légaux requis en France ne sont pas présents dans les textes originaux).

La GPL est je pense la première licence qui a réellement été pensée pour le partage de logiciels libres. Les BSD/MIT me semblent plus une façon de dire « ne me poursuivez pas en justice si vous cramez votre maison, mais n'oubliez pas de donner mon nom si vous faites de millions avec. »

Après, on peut aussi citer Gnome qui a été créé à un moment où KDE était gratuit (et je crois même que les sources étaient dispo) mais pas libre. Je trouve que c'est loin d'être un petit logiciel de gestion de bureau, quand on considère qu'il a été porté sur la plupart des systèmes UNIX de la fin des années 90/début 2000.

Faut pas trop en espérer non plus. OpenCL est plus ou moins abandonné de toutes parts. Le nouveaux frameworks qui sont en train d'être développés (notamment chez AMD) ne gardent OpenCL en back-end que pour des raisons de compatibilité. Les efforts d'optimisation sont concentrés ailleurs (cf. Vulkan).

Mais c'est là que la notion de compromis entre en jeu : tu parles des courants propres à chaque parti, et un militant à la base peut très bien avaler ces couleuvres parce qu'il a l'espoir de pouvoir élire au bureau national un des « gros » qui correspond le mieux à sa vision pour le parti (parce que ces votes-là, pour le coup, sont annoncés suffisamment à l'avance pour pouvoir se préparer).

Hum, je ne pige pas bien en quoi la façon dont l'histoire est enseignée en France est nécessairement prône à mener à une « mono-culture intellectuelle » par exemple. De ce que je me souviens du programme en France (années 90):

1. En primaire on étudie une partie des rois de France, ainsi que la 1ère guerre mondiale, et quelques autres truc
2. Au collège, on commence par la préhistoire, puis on continue avec l'Égypte antique, la montée du monothéisme avec les hébreux, puis les civilisations grecque et romaine en 6è. En 5è on continue avec la chute de l'empire romain, la montée du christianisme, et l'acheminement vers le Moyen-Âge, ainsi que la montée en puissance de l'Islam au Moyen-Orient. On continue jusqu'à la Renaissance si je ne m'abuse. En 4è, on étudie Louis XIII, Louis XIV et la montée de l'absolutisme, on passe vite fait sur Louis XV, puis on aborde la Révolution Française. On avait peu de temps ensuite (le programme d'histoire est ultra-chargé en France) et on a abordé l'Empire sous Napoléon, et je crois que nous étions censés voir la Restoration et la révolution industrielle, mais le temps a manqué pour le faire en détails. En 3è le programme commence avec le début de l'ère contemporaine (donc en gros la période juste avant la 1ère GM). Ça nous fait: mécanisme des alliances, 1è GM, et création des états des Balkans (qui du coup étaient extrêmement à-propos à l'époque en 94-96), crise de 29, montée du communisme, montée du fascisme, montée du nazisme, 2è GM, création de l'État d'Israël, instauration de la Vè République, et, si y'a le temps guerre d'Algérie (y'a JAMAIS le temps).
3. Au lycée, rebelote: 2nde, préhistoire/antiquité jusqu'au Moyen-Âge, avec une emphase différente sur les événements (en gros, programme de 6è/5è en un an). En 1ère, on part de la Révolution Française, et on fait tout le XIXè siècle (peu ou prou), y compris la révolution industrielle, etc. En Terminale, on passe très vite sur la 1ère Guerre Mondiale, mais on revient sur l'entre-deux guerres, la 2è GM, la Vè République, la reconstruction de l'Europe (y compris le plan Marshall), la guerre d'Algérie, l'URSS après la 2è GM et la Guerre Froide (qui mène à l'effondrement du bloc soviétique), et je me souviens avoir vu rapidement la montée de la Chine en tant que nouvelle puissance (en particulier le régime de Mao).

Il manque évidemment plein de trucs¹, mais le programme en lui-même est représentatif de l'histoire de France et de ses interactions avec le monde. Et évidemment, la façon dont on raconte l'histoire va être influencée par les consignes du ministère de l'éducation, le prof lui-même, etc., et ainsi alors qu'en France on va plus volontiers insister sur le fait que « le communisme » n'a jamais été réellement mis en place, car il a été démarré sur des bases trop fragiles (révolution socialiste en Russie, puis élimination des mencheviks par les bolcheviks), aux US ils ont tendance à dire que stalinisme et communisme, c'est pareil².

J'ai regardé un programme d'histoire plus récent pour la filière S (2014-2015) : les même thèmes sont peu ou prou abordés (sauf qu'apparemment on voit la guerre d'Algérie en 1ère une première fois désormais, et c'est ensuite revisité en Terminale).

L'explication la pire que je connaisse, c'est de dire que les gens sont "influencés" : par les médias, par les partis, par les entreprises, par les ET, on s'en fout, ils sont "influencés".

Du point de vue sociologique, il a été démontré maintes fois que si on répète une idée et ses dérivés suffisamment souvent, et suffisamment fort, elle finira par prendre racine dans les cerveaux d'une part de la population. Pas forcément une grosse part, mais suffisamment grande pour qu'elle mène ladite partie à mener campagne pour que cette idée se répande, etc. Le meilleur exemple est ce qui est pratiqué par les chaînes d'info en continu du côté des USA : Fox News est une machine de propagande néo-conservatrice/ultra-libérale incroyablement efficace, qui non seulement conforte les (ultra-)conservateurs (et souvent ultra-religieux) que les médias de masse sont corrompus et à la solde de la gauche (càd centre-gauche/centre-droit en termes de politique française), mais en plus pousse une idéologie émise en haut lieu en faisant répéter à ses commentateurs le même message. Ainsi, quelqu'un qui aurait Fox News en fond sonore entendra différentes voix, avec différentes variations utiliser les mêmes phrases dans un contexte à peine différent, pour véhiculer le message du jour.

Alors oui, il faut déjà mater Fox News (ou BFM TV en France). Mais nier que le matraquage politique opéré par les médias traditionnels (télé, radio) et moins traditionnels (sur le net), influence les mentalités, c'est aussi absurde que dire qu'ils sont responsables de tout.

Aujourd'hui il me semble qu'on est dans un contexte où la peur de petit groupe (faut arrêter même les plus gros partis ne représentent que des petits groupes face à la population)

C'est même pire que ça. Les élites des gros partis ont leurs intérêts propres, et tordent leurs propres systèmes internes pour forcer la main aux militants de base. Par exemple, ils vont organiser un vote au dernier moment, annoncé un jour pour prendre la décision officielle le lendemain. Ainsi, ils pourront dire que leur base avait l'opportunité de s'exprimer, et que le vote va dans le sens de ce que veut le bureau national. Évidemment, lorsqu'on est pas politicien de carrière, il n'est pas forcément toujours possible de venir voter dans sa cellule à la dernière minute…

En d'autres termes : il est même possible que la base de chaque gros parti soit représentative d'une grande partie de la population, mais comme pour toute grosse organisation, il y a (1) de l'inertie (et donc un fossé entre le bureau national d'un gros parti et sa base en termes d'idéologie), et (2) une volonté de garder le contrôle sur le siège qu'on a acquis, au mépris de ce que pense la base¹.

On m'a toujours appris que exit() quittait sans libérer la mémoire. C'est faux

C'est surtout qu'on ne sait pas. Dans un OS moderne « poids lourd » (UNIX, Linux, Windows), oui, la mémoire est libérée. Dans des OS plus anciens (DOS), ou certains OS embarqués¹ où c'est pas garanti du tout. Il y a aussi des OS bizarres, du genre de ceux qui sont utilisés dans certains supercalculateurs, où un cœur fait tourner un « OS lourd » (un Linux modifié la plupart du temps) et les autres cœurs font tourner un OS léger, qui délègue à l'OS lourd une partie de la gestion des ressources. Dans ces cas-là, je ne sais pas comment ça se passe niveau allocation/désallocation mémoire lorsqu'un programme quitte.

Ben disons que je pars du principe qu'il serait pas mal de faire une gestion un minimum correcte en cas de malloc qui échoue. Le minimum, c'est de planter « gracieusement ». Après, si tu es capable de faire une gestion plus fine, c'est cool. Dans tous les cas, supposer que malloc renvoie toujours un pointeur valide, c'est estimer que ton soft n'a pas besoin d'être maintenu au-delà de (1) Linux, et (2) une période de temps donnée (qu'est-ce qui nous dit que dans 5 ans, Linux ne va pas revenir sur sa politique optimiste actuelle, avec un nouvel algo top et plus précis?).

Tu n'a aucune espèce d'idée si ton malloc échoue ou pas et de quoi faire de bien pertinent

Ben y'a certaines choses que tu peux faire : tu peux distinguer entre les ressources critiques et les autres. Si ton soft a absolument besoin de toutes les structures de données, alors tout est critique, et tu plantes. Sinon, peut-être que tu peux désactiver certaines fonctionnalités temporairement (à moins que tu aies réellement atteint les limites de la mémoire disponible, et dans ce cas c'est plus temporaire…). De façon générale, si tu en arrives à mettre le système à genoux niveau mémoire par processus, et surtout si on parle de systèmes 64 bits, je me dis que quelque chose ne va pas (et oui, l'exemple de Firefox en est un bon).

Je suis globalement d'accord avec ce que tu racontes.

Cependant lorsque tu dis

Note que je ne dis pas qu'il faut toujours gérer car ça arriverai tout le temps (par exemple pour un prototype, un dev rapide, peu utilisé, ben ça coûte cher à gérer

C'est justement là où une gestion de type xmalloc est utile non ? Comme ça tu as au moins une idée d'où tu t'es planté, etc. D'ailleurs c'est peut-être là où une implémentation utilisant des macros peut s'avérer utile. Quelque chose du genre:

static inline void 
fatal(const char *err) {
        perror(err);
        exit(errno);
}

static inline void*
xmalloc(size_t size, const char* filename, const int lineno)
{
        void* p = malloc(size);
        if (!p) {
                fprintf(stderr, "%s, line %d:\t", filename, lineno);
                fatal("malloc");
        }
        return p;
}

#define XMALLOC(size) xmalloc((size), __FILE__, __LINE__)

Enfin, de façon générale, la norme dit que malloc peut renvoyer NULL, et donc si on veut faire du code portable, il ne faut pas s'appuyer sur ce que fait Linux seulement. Même si on ne veut être « que » portable POSIX, ce n'est pas raisonnable. Ça ne veut pas dire forcément se faire chier avec une gestion complexe des erreurs, mais dans le cas de prototypes/dév rapide que tu évoques, le code ci-dessus me semble amplement suffisant (et tu peux l'inclure dans un header de type util.h et puis c'est marre), mais il reste utile à des fins de debug (note que je sais que tu n'as pas dit que c'était inutile, mais j'étends un peu ta réponse avec mon expérience :)).

malloc (en fait l'appel système brk)

Sauf qu'en fait non, malloc appelle brk pour les allocs mémoire de moins d'une page, mais il appellera mmap si ça dépasse la taille d'une page. Donc tout dépend du type d'allocation mémoire dont on cause.

J'ai l'impression que sous linux on est foutu, on ne sait tout simplement rien faire du tout pour récupérer une situation de pénurie.

Oui et non. Il existe des softs qui se proposent de « surcharger » les allocations mémoire (par exemple un ancien collègue qui écrivait une bibliothèque de threads pour du calcul haute performance). Mon collègue utilisait les fonctions de « surcharge » de malloc pour rajouter des comportements spécifiques au moment de l'allocation mémoire. Dans ce cas on tombe sur des trucs rigolos, du genre tout un tas de logiciels GNU qui allouent presque tout l'espace mémoire adressable dans le processus car ils tablent sur l'allocation optimiste de Linux (en l'occurrence, c'est arrivé avec sort(1)). Du coup dans l'allocateur « normal » de Linux, sort te trie correctement les chaînes de caractères sans segfault car seules les pages réellement utilisées sont allouées par le système. Mais avec l'allocateur de mon collègue, tout à coup on avait des abort() et segfaults parce qu'il s'assurait que la mémoire était réellement allouée en initialisant au moins un octet pour chaque page théoriquement allouée¹.

Tout un tas de softs avec des objectifs de performance proposent leurs propres ajouts (si ce n'est leur propre allocateur) aux mécanismes de gestion de mémoire de l'OS (SGBD, environnement d'exécution multithreadés, etc.).

Je navigue à -42 → je me fiche a priori de la note si le fil de discussion m'intéresse. Par contre, lorsque je suis pressé, lorsque ça « commence mal », etc., oui, voir une note à -10, ça va m'aider à passer au fil/sous-fil suivant.

Ensuite, en ce qui concernent les gens qui se plaignent de leur note négative : à part les fâcheux coincés à -5 ou -10, justement, et qui ne sont franchement pas nombreux, je n'en vois pas beaucoup qui se plaignent. Le seul cas malheureux (et pathologique sur un site de sur le libre) c'est celui de PasBillPasGates, qui avait un score négatif pour des raisons idéologiques/religieuses, bien plus que pour des raisons de pertinence (ça ne veut pas dire qu'il n'est jamais de mauvaise foi, ou jamais agressif, etc., mais grosso modo je le trouve dans la moyenne+).

Les autres, y compris ceux qui bossent sur des technos propriétaires au moins en partie (Zenitram, Groumly, etc.), et qui en plus sont agressifs (au moins de temps en temps), ont des notes qui malgré tout ce qu'on peut leur reprocher, sont globalement positives.

Du coup, le système de notation sert principalement (pour moi) à identifier les fâcheux. J'aime bien l'idée avancée par quelqu'un d'autre de peut-être permettre d'associer plusieurs tags à quelque chose de « positif », et idem pour le « négatif », genre « pertinent / inutile » (œuf corse), mais aussi « insultant, ou « troll » (qui peut être pertinent d'un point de vue discussion, mais qui, clairement, argumente juste pour le plaisir d'argumenter et contredire, sans vraiment croire à ce qu'il raconte), et j'en oublie sans doute du côté « + » et du côté « - ». Ça ne changerait pas la façon de modifier le karma, mais ça permettrait p'tet d'identifier plus facilement un troll (qui sait très bien comment fonctionne le site) d'un nouveau (qui ne sait pas encore bien comment se comporter en termes de ton).

Et enfin, je suis encore et toujours pour la possibilité de plonker par personne. Si tu veux retirer le système de notes, il faut quelque chose pour contrebalancer. Un système de plonkage dispo nativement permettrait aussi aux admins de voir si une personne est régulièrement ignorée (ou ignorée en masse). Si on couple le plonk à une raison (« troll », « autre: il m'énerve », « spam », etc.), y'a p'tet même moyen d'aider au ménage sur le site et faire la différence entre des gens qui ne se supportent pas mais respectent les conditions d'utilisation du site, et ceux qui abusent du système.

Il y a deux choses : travailler avec des gens qui sont bons techniquement et avec qui tu t'entends bien (et sont parfois des amis); et recommander des amis. Le premier cas est facile : si tout le monde bosse comme il faut, y'a pas vraiment de tensions (exceptées celles des deadlines, etc., ce qui arrive partout). Le deuxième cas est plus compliqué.

Le bouche à oreille marche très bien, à condition d'être honnête. Que ce soit fait sur LinkedIn ou simplement dans des conversations, ça n'est pas très important.

Ami, collègue, ou étudiant, je dis toujours la même chose si on me demande d'écrire une recommandation : « Je ne mentirai pas. » Toutes mes recommandations sont « sincères », ce qui non seulement est bénéfique pour tout le monde (ma connaissance/mon ami(e), l'employeur, mais aussi moi-même), mais en plus ça fait plaisir au candidat de voir quelqu'un écrire quelque chose de positif à son égard. Et j'attends la même chose en retour.

J'ai déjà dit à quelqu'un dont j'étais le « mentor » que je lui écrirai une lettre de recommandation puisqu'il me demandait, mais que je ne cacherai pas sous le tapis ce qui ne va pas (en l'occurrence, le mec est excellent techniquement, mais il est vraiment difficile de travailler avec lui d'un point de vue social). Évidemment, je n'aurais pas été « brutal » dans ma façon de le dire, mais j'aurais indiqué clairement qu'il lui fallait travailler sur son côté social. Il l'a mal pris et m'a demandé d'oublier. Tant pis¹.

Bref : le fait d'être pote n'est pas le problème. C'est le fait de recommander des gens pour un poste parce que ce sont des potes, indépendamment de leur niveau en technique, qui peut être problématique.

Écrire avec un bon style (facilement lisible, pas trop pédant, mais pas trop simplificateur non plus, etc.), ça s'apprend, et je ne connais personne qui soit né avec (juste que certains écrivent depuis très longtemps/jeune). Il est plus facile pour moi d'écrire un article (ou un commentaire, ahem) de 10 000 signes à la volée, maintenant que j'ai écrit plusieurs dizaines d'articles scientifiques, fait des commentaires constructifs de bien plus, etc.

Plus tu écris, plus ton style va évoluer dans un certain sens. Si en plus tu tiens compte des commentaires et critiques (parfois dures, mais si elles sont constructive ça vaut le coup quand même), alors ton style va vraiment s'améliorer. Du coup, à supposer que tu ne sois pas trop « territorial », la tribune de rédaction peut être un très bon endroit pour apprendre à structurer tes écrits et même voir comment reformuler des passages peu clairs.

Néanmoins, C++ est multiparadigme (et donc, C++ n’est pas un langage « orienté objet », il est un langage intégrant parmi d’autres le paradigme objet),

Bon, je me suis demandé s'il fallait que je pinaille, JUSTEMENT à cause de ça. :) J'ai raccourci, mais si tu veux, de même que OCaml est connu pour être un langage fonctionnel, il est lui aussi multi-paradigme. C'est juste que le paradigme impératif et objet me semble quand même plus secondaire quand on discute de ce langage. Même chose pour C++ : oui, il permet la prog générique, procédurale, objet, etc. Mais superficiellement, C++ est quand même largement associé à la programmation objet.

EDIT: Tiens d'ailleurs, lorsque je dis que C++ est un langage orienté objet, je ne dis pas qu'il n'est que cela, ET TOC.

(j'aime pas avoir tort, ça se voit ?)

Ton problème, c’est que soit tu trolles de mauvaise foi, […]
En même temps, par définition, un troll de mauvaise foi. Ceci étant dit, je suis d'accord avec ce que tu dis sur le côté troll de Kantien (mais comme il disait, il trolle ouvertement, du coup je lui pardonne à moitié :-)). Cependant :

Si tu connaissais un peu le C++, tu verrais qu’il y a beaucoup de choses qui relèvent de la programmation fonctionnelle dès qu’on fait de la métaprogrammation. Il y a même une syntaxe presque aussi horrible que celle d’Haskell :) (dans un style différent, certes).

Le langage de templates (qui est Turing complet, d'ailleurs), est un langage fonctionnel (affectation unique, etc.). C++ lui-même, en tant que langage n'est pas fonctionnel, mais offre quelques mécanismes permettant d'écrire des programmes dans un style fonctionnel. C'est quand même différent d'un langage fonctionnel par nature.

Lorsque je dis que C++ est un langage orienté objet, c'est parce qu'il offre des mécanismes qui me permettent directement d'exprimer un programme selon les concepts de la POO : niveau d'encapsulation (privé, protégé, public, etc.), héritage, groupement des données et des messages (méthodes/fonctions) qui leur sont associés, etc.

De même, lorsque je dis qu'un langage est fonctionnel, je m'attends à ce que les fonctions soient des objets de première classe, mais aussi que je puisse naturellement compter sur une expression de mes programmes en termes de valeurs (« immutable ») et pas de variables ( « mutables », et qui offrent donc des effets de bord), d'être capable d'exprimer des fonctions imbriquées dans d'autres fonctions si j'en ai le besoin, etc. La notion de récursivité (du code, des types, etc.) est inhérente au paradigme fonctionnel. Ce n'est pas le cas en C++. Oui, on peut jouer avec const, boost::function (et maintenant les lambdas), et même avec de la méta-programmation pour contraindre le système et forcer un style fonctionnel, mais ça ne fait pas de C++ un langage fonctionnel. De même que ce n'est pas parce qu'on peut programmer dans un style objet en C que ça en fait un langage orienté objet.

J'en déduis donc que selon toi un langage fonctionnel digne de ce nom doit être faiblement typé. Ou au moins doit avoir un type racine qui peut contenir n'importe quoi. C++ ne sera donc jamais un langage fonctionnel digne de ce nom.

Je pense que tu as tort. D'une part, il existe un lambda-calcul typé, dont se servent les langages fonctionnels (et LISP, par exemple, est fortement typé, mais le typage est dynamique). D'autre part, je ne vois pas ce qui te fait dire que l'exemple donné par Kantien est faiblement typé. Simplement l'application de l'opération (+=) sera adaptée au type contenu dans un élément spécifique du tableau, mais le typage est statique et fort en OCaml.

Premièrement je suis d'accord pour dire que malgré toutes ses améliorations, C++ ne prend pas réellement de fonctions comme objets de première classe. Les lambdas et autres types d'inférences limités sont extrêmement bienvenus, mais on reste dans le domaine d'un langage impératif (avec désormais plus d'opportunités pour avoir un style fonctionnel). Je renvoie à l'article de John Carmack pour une exploration de style fonctionnel en C++. Ceci étant dit :

P.S: Bon, le lambda-calcul ça date de 1936, et on a du attendre C++11 pour en avoir un ersatz à lire tes exemples

Histoire de troller un chouïa : étant donné que Church et son thésard, un inconnu du nom de Alan… Alan… Alan T-quelque chose, sont les deux piliers qui ont permis de créer les fondations de l'informatique théorique telle qu'on la connaît, j'ai envie de dire que crâner à propos du lambda calcul « créé en 1936 »¹, alors que les principes de la machine universelle de Turing, qui sont certes arrivés plus tard (ce qui est somme toute logique), ont eux été mis en œuvre dès les années 40, c'est quand même rigolo. :-)

Ensuite, juste pour dire, le bouquin de B. Pierce sur les types montre qu'il est parfaitement possible d'implémenter un système de typage fort à base de lambda-calcul (il propose un mini-Java comme exemple, et un mini-ML aussi).

Je pense que l'ajout de trucs types lambdas à Java et C++ vient surtout du fait que lorsque tu as un écosystème populaire, il faut d'abord composer avec ce que les utilisateurs veulent (et fabricants de compilateurs proposent). Jusqu'au début des années 90, les compilateurs de production étaient franchement médiocres en termes d'optimisation (à quelques exceptions près, en particulier pour les compilateurs Fortran à destination de machines vectorielles, genre les Cray-I, etc.). Du coup, avec un langage procédural genre C, on pouvait au moins donner une forme au code qui permettait d'optimiser l'utilisation des registres, et d'être proche de la machine. Pendant très longtemps, les langages de programmation fonctionnelle a été considérée comme inefficaces en termes de performances. Ça commencé à sérieusement changer lorsque les compilateurs ont commencé à proposer des optimisations très agressives, mais même ainsi, les algorithmes (géniaux) qui sont derrière l'inférence de type de ML, et ceux qui gèrent la curryfication par exemple, ont tendance à mener à de la compilation via continuation, ce qui peut être très bien ou terrible en fonction de l'implémentation (y'a un excellent bouquin d'A.Appel sur la compilation de ML avec continuations soit dit en passant). Bref.

Jusqu'à il y a peu, la programmation fonctionnelle était considérée comme un truc d'académicien². L'un des rares langages procéduraux à avoir intégré des bouts de programmation fonctionnelle était Perl: il est possible de passer des blocs de code et de créer des lambdas, tout un tas de fonctions « built-in » (genre map, grep, etc.) sont directement tirées de CLISP et ses copines, … Mais c'était aussi parce que Perl était à la base optimisé pour le traitement de fichiers textuels, et que les entrées-sorties étaient ce qui était bloquant de toute manière. Donc niveau perf, l'utilisation de fonctions de haut-niveau avec un coût à l'exécution était OK.

Quand OCaml, Scala, Haskell, etc., on enfin émergé et commencé à prouver qu'ils pouvaient, eux aussi, proposer des performances raisonnables (pas forcément comparé à C/C++, mais au moins par rapport à Java), tout en proposant une grande puissance d'expression, on a vu Java et C# (par exemple) commencer à se doter d'aspects fonctionnels. Encore une fois, c'est entre autres parce que les développeurs/utilisateurs du langage ont vu ce que pouvaient faire les voisins et ont réclamé ces fonctionnalités.

D'ailleurs c'est le cas de la plupart des setters/getters, non ?

LLVM est un projet de recherche pour fournir une infrastructure de compilation modulaire (ils ont eu des sous de la national science foundation, l’équivalent US de l'agence nationale pour la recherche) pour favoriser la recherche et l’expérimentation en compilation. Clang a effectivement été créé ca cause des problèmes de licence et de l'architecture du front-end de GCC (qui lie (liait?) artificiellement le front-end et le back-end pour des raisons plus politiques que techniques). La complexité artificielle liée au maintien de clang-gcc comme front-end a (de ce que j'ai compris) plus contribué a la création de Clang que le front-end de Xcode (apres tout, Xcode n'avait pas forcément beaucoup de mal a utiliser le front-end de GCC avant ça : ils s'en servaient depuis des années…).

Maintenant, Apple a adopté LLVM a cause des problèmes de licence liées a la GPL 3 pour GCC (c'est pour ça que pendant la transition, les OS d'Apple étaient coincés avec GCC 4.2 ou 4.3) d'une part, et le fait que le comité de GCC refusait d'intégrer un moyen d'ajouter des passes d'optimisation depuis l'extérieur (ils ont depuis changé d'avis, entre autres grâce au succès et l'adoption de LLVM/Clang par de plus en plus de monde). L'intégration avec Xcode est une des raisons techniques, ainsi que l'avancement limité pour ObjC dans GCC, mais je ne suis franchement pas convaincu que ça a été la raison principale (la politique/le légal a tendance a avoir un poids plus important dans ces cas-la).

Pour en revenir a mon point initial : Zenitram et Groumly se disputaient a propos du "langage phare" d'Apple (qui change environ tous les 10-15 ans). Entre autres Zenitram ironisait sur le fait que malgré son langage phare, Objective C, et maintenant Swift, Apple continuait le support d'un compilateur pour C et C++. Je ne faisais que rappeler que Apple a en priorité supporté LLVM, qui contient un middle-end et un back-end. Ils ont ensuite rajouté Clang quand d'autres soucis techniques et légaux se sont rajoutés. Sauf que, a la base, Apple a utilisé LLVM pour optimiser ses codes OpenGL (écrits en C), avant de passer au codage du futur iOS, etc. D'autre part, OS X est toujours écrit en C (au moins la partie Darwin), ce qui nécessite un compilateur C. Enfin, Objective C est complètement compatible avec les binaires C sur le même système (par conception). Il se trouve que, tout comme GCC il y a 10-15 ans, Clang est en train de diversifier le nombre de langages qu'il gère--quelque part c'est logique : maintenant que l'infrastructure est la, autant l'utiliser.

J'ai lu tes commentaires bien après avoir écrit ma réponse (je suis arrivé bien après la bataille ;-)). Ton argumentation m'a convaincu (enfin dans sa majorité).

Ceci dit, de meme que string est un conteneur "special" avec des méthodes propres (mais qui conserve une grande partie des fonctions des conteneurs "normaux") je ne vois pas pourquoi vector, qui est très clairement une structure de données faite pour être indexée, ne pourrait pas avoir un jeu de fonctions qui, elles aussi, permettraient de manipuler les données en fonction des indices. Apres tout, c'est déjà ce que font operator[] et vector::at, non ?

Concernant le cas pratique d'utilisation, tu noteras que je n'ai pas dit que j’étais d'accord, mais bien que

Si c'est une operation récurrente, et considérée comme utile, […]

J'utilise C++ assez régulièrement, mais dans un contexte particulier qui fait que je n'utilise que des parties très particulières et restreintes du langage (un peu de templates, parfois avec meta-programmation; un peu de POO; et rarement des cas vraiment tordus - meme si ca arrive quand meme).

Bref. Non, je n'ai pas besoin de ce genre de feature dans mon cas d'utilisation (si j'avais fréquemment besoin de supprimer un element a l'indice i dans un vecteur dans le contexte de mon boulot, je me demanderais sans doute si je n'avais pas peut-être mal choisi ma structure de données).

Dans le cas qui nous occupe, un intervenant dit qu'il a besoin de cette operation (et visiblement pour lui c'est un besoin récurrent). Quelqu'un lui répond, et donne une solution qui est quand meme plus compliquée que ce que veut l'intervenant original (mais qui peut sans doute être écrite une fois pour toutes sous forme de fonction template, certes). Et surtout, jusqu'à ton post, personne n'a demandé la fréquence d'utilisation d'une telle fonction (et c'est une question très pertinente). Ma réponse n'était pas une validation du besoin, mais une façon de montrer encore une fois comment lorsque quelqu'un dit "je veux faire X simplement" on lui répond "T'as qu'a écrire f(Z,Y,W) et ca te donnera X". :-)

A propos du support de C++ par Apple : il faut le voir differemment. Apple supporte le developpement de LLVM, qui n'est pas un compilateur C++. Il se trouve que Clang a aussi obtenu des financements de la part d'Apple entre autres parce qu'ils avaient besoin de compiler de l'OpenGL, et Objective C etant aussi compile nativement vers C, etc.

Bref, le vrai projet soutenu par Apple, c'est LLVM. Clang/Clang++ sont quasiment finances par effet de bord (de ce que j'ai compris--n'hesitez pas a me corriger si je me trompe).

Techniquement avec la fonctionalite de Co-Array, Fortran 2015 (et meme 2008 je crois) est mieux arme pour faire de la programmation parallele (pas trop concurrente) avec un haut niveau d'abstraction. Ceci etant dit, meme si tu as raison de rappeler que F77 c'est vieux, c'est aussi (avec du F90) ce que j'ai vu le plus souvent utilise dans des labos ET dans des boites qui produisent des outils de simulation numerique (avec des solveurs iteratifs).

Le problème c'est que je n'ai jamais vu ces bonnes pratiques décrites de manière un minimum formelle

Pourtant, entre les bouquins de Myers et de Sutter/Alexandrescu, y'a de quoi faire niveau bonnes pratiques recommandees et acceptees assez largement.

et qu'il faut composer avec l'existant.

Ca oui, et tu n'as pas le controle sur l'existant. Le mieux que tu puisses faire, c'est de changer petit a petit le code pour le rendre plus sain a mesure que tu effectues des operations de maintenance dessus. Ca inclut aussi le fait de rajouter -std=c++14 (ou au moins -std=c++11) sur la ligne de compilation. Et donc que ta boite a un processus qui le permette.