totof2000 a écrit 9656 commentaires

Tu crees pas un #define quand tu fais "var = valeur - 1;"

Tout dépend d'ou sort le -1.

ni quand tu fais un "originX = (view.frame.size.width - label.frame.size.width) / 2.0f;".

Si, touit dépend d'ou sort le 2.0f. S'il a une signification particulière, je fais un define qui sera plus parlant à la lecture pour la personne qui reprendra le code. C'est parfois bien plus lisible qu'un commentaire.

Sinon, pourquoi a-t-on défini une constante pour Pi par exemple ?

Effectivement, mais un code qui ne fonctionne pas (qui ne fait pas ce pourquoi il a été écrit) a beau être lisible, ça ne sert pas à grand chose :) Ce n'est pas le seul critère permettant de juger d'un "bon code", mais ç'est quand même un critere essentiel.

Ah, au fait : mon attaque n'est pas "gratuite" comme tu peux le penser.

Je n'attaque pas : je constate : un composant essentiel d'un système sur lequel je peux être ammené à faire tourner des services sensibles (c'est mon boulot) peut potentiellement être buggé en raison d'un code "sale". Ce n'est pas une hypothèse farfelue : on a disuté ici de bugs qui n'ont pas été vu potentiellement à cause de code mal écrit. Tu prétends peut-être que je n'ai pas de légitimité à critiquer systemd ? Ben si, parce que des distributions Linux quer j'utilise ( pour des besoins pro - et pour lesquelles mon employeur ou mon client paient pour l'avoir, donc ce n'est pas gratuit) risquent de se trouver compromises. Si je n'utilisais pas ces distributions professionnelement, je m'en ficherais de systemd. Je resterais sous NetBSD, ou j'utiliserais Linux sans rien dire.

En retour, un tas de personnes se mettent à me dire 'circulez, ya rien à voir, t'es pas le développeur de systemd, tu n'as pas à critiquer le code' ou même 'mon,tre moi le code que tu écris avant de critiquer'. Pourquoi ? Comme dis plus haut, si tu étais utilisateur ou mainteneur de mon code, je le montrerais, tu le verrais, tu pourrais le critiquer et même m'insulter si tu voyais des anomalies ou erreurs qu'un étudiant ne commetrais même pas. Là par rapport à moon code tu n'es rien, ni un utilisateur, ni un développeur. Donc ton avis ….

Personnellement, ton avis sur mon code, je m'en fiche royalement. Ce qui m'intéresse c'est l'avis de ceux qui ont repris ce code, et de ceux qui utilisent le code en question pour se simplifier la vie. S'ils ont des critiques à faire sur mon code je suis prêt à les écouter pour écrire du code encore meilleur la prochaine fois.
Si je pouvais te montrer le code que j'écris (en gros s'il m'appartenait), je le ferais sans hésiter, surtout si tu es ammené à utiliser le code en question ou à le maintenir.

Moi, mon avis, c'est que ceux qui me critiquent sur la critique du code sont ceux justement qui écrivent du code crade, mais qui ne veulent pas se remettre en question. Ils pensent que d'autres sont là pour nettoyer leur code. A mon avis ce sont des gens qui ne veulent pas écrire de code propre, soit disant pour "gagner du temps". mais le temps passé à écrire du code propre se récupère très vite dans la vie d'un projet.

L'analogie avec le cuisinier je la vois plutôt comme ça :
- je vous ai préparé un plat à moitié cuit, à moitié assaisonné et sur lequel il risque d'y avoir des ingrédients périmés qui vous rendront malades. Je l'ai laissé dans la marmite, servez-vous, et débrouillez-vous pour la présentation. Mais ne vous inquiétez pas, il est mangeable quand même. Si ça ne vous plait pas, reprenez le plat et améliore-le. Enlevez ce qui ne vous plait pas, ce qui pourrait être périmé, et ajoutez ce qui vous plait. Mettez-le dans l'assiette de la façon qui vous plait. Moi je m'en vais préparer un autre plat à moitié fini, ça ne m'intéresse plus de finir celui-là.

Les gars, vous êtes trop des surdoués, vous voyez les problèmes partout chez les autres.
Et si on jouait à ce que vous proposiez un patch pour mieux sécuriser le bousin, pour voir?

Parce que je ne suis pas payé pour faire ça mais pour faire autre chose : notamment utiliser leur code.

A ce demander pourquoi eux sont payés (cher) pour faire le taf et pas vous… Vous méritez ieux que votre salaire actuel! (ou pas)

Justement : on peut s'attendre à mieux pour des personnes payées à plein temps pour coder. Je t'assure que ça me démange de réécrire ce code, mais je ne peux pas le faire pour le moment. A moins que Redhat ne me paye poyur le faire.

Dans l'autre cas, on parle d'un processus utilisateur avec des problématiques de sécurité, vu que ça gère des mots de passes.

Je n'ai pas choisi ce bout de code au hasard.  ;). Mais je vous laisse le soin de le démonter : je n'aime pas systemd, c'est connu ici, et si d'autres personnes mettent en avant les problèmes de ce code, ça sera plus crédible je pense.

Soit je suis seul à avoir vu de l'ironie dans ce commentaire

Je ne pense pas

je ne comprends alors pas son moinsage

Moi je le comprends, même avec l'ironie

soit je suis le seul à ne pas avoir compris que tu étais sérieux…

Disons que c'est de la caricature : une exagération de ce que je pense être la réalité et c'est pour ça que ça ne plaît pas. Pour être plus précis : je ne pense pas que ce soit la réalité vraie, mais c'est la façon dont je perçois les messages qu'envoient les devs de systemd.

La constante va eloigner la definition de l'utilisation de la constante. Ca force a une indirection si on veut verifier la valeur de la constante, et si y'a pas de bonnes raisons pour que la valeur change un jour, ca fait pas une grosse difference que la constante soit dans Constants.h, perdue au milieu de 450 autres constantes, ou dans implementation.c.

On a inventé des IDE qui savent retrouver facilement ce genre d'infos, donc ton argument ne tient plus.

Je ne peux pas te montrer le code que j'ai écrit ces derniers temps vu que je ne l'ai pas écrit pour moi et qu'il n'était pas libre. Ce n'étit pas du C mais du Perl. Je ne pense pas que ce soit du code parfait, mais il était lisible pour ceux qui l'ont repris après (et qui n'étaient pas des développeurs Perl aguerris).

Le code que j'écris fonctionne en général. Dans le cas ou il faut le maintenir pour ajouter des fonctionnalités, ou corriger un bug (je l'ai dit, mon code n'est pas parfait), ceux qui le font s'en sortent très bien.

Je ne cherche pas le code parfait mais là c'est assez moche et difficile à maintenir, digne du code que j'écrivais quand j'étais étudiant.

Il faudra un jour que les développeurs comprennent qu'un code qui marche ne suffit pas, il faut qu'il soit maintenable. Et dans le fait d'être maintenable, il faut penser au fait qu'il doit être assez facilement lisible pour quelqu'un qui ne sait pas forcément ce que tu veux faire.

Pour ceux qui trouvent ce code pas si moche que ça, je vous conseille d'aller lire le livre "coder proprement" de Robert C. Martin chez Pearson. C'est un livre plutôt orienté Java, mais beaucoup des conseils qui y sont donnés sont applicables à tous les langages. Il y a même des exemples de réécriture complet de code un peu comme celui que j'ai montré ici.

La solution, c'est plutôt, lorsqu'on se prétend développeur, d'écrire un code propre et maintenable avant de diffuser.

Je crois qu'il faut avoir passé beaucoup de temps à rechercher des erreurs tordus, même dans du code bien écrit pour comprendre cette évidence.

Personnellement, à une époque j'écrivais du code aussi crade que celui-là, mais j'ai vite arrêté, parce qu'au bout d'un moment, je ne pouvais plus y toucher sans tout casser.

Là c'est pareil. Un jour quelqu'un fera une modif qui introduira un bug subtil. Pour un truc aussi sensible que systemd, je trouve ça inacceptable.

Non, systemd est fait pour tout le meonde, mais tout le monde n'est pas fait pour systemd …

man ironie … ;)

Yen a qui ont du mal à comprendre que ce n'est pas un détail relevé par-ci par-là qui est dangereux, mais l'accumulation de ces petits détails qui fait que ça risque de sauter.

Mais tu n'as pas encore compris ? TU DOIS FAIRE COMME SYSTEMD TE DIT DE FAIRE.

Si tu veux gérer ta distrib autrement, c'est que tu es stupide, et résistant au changement.

Oui mais l'utilisateur n'a pas à savoir pourquoi et quand sa machine se vautre. C'est réservé aux développeurs. L'utilisateur, quand il voit des caractères s'afficher sur sa machine, il a peur (même si c'est un sysadmin dont c'est le boulot de décoder ces messages cabalistiques). Donc pour cacher ça à l'utilisateur et à l'admin, on a inventé le splash screen et le mode quiet au boot. Très pratique et très utile sur un serveur.

C'est un peu moche, mais c'est de la tambouille interne.

Une tambouille interne aussi moche pour un élément aussi critique que systemd, ce n'est pas anodin.

En même temps, le bloc où p est assigné fait 3 lignes et est juste au dessus du free. Ce n'est pas terrible mais pas non plus catastrophique.

Et c'est comme ça qu'on invente un générateur dfe bugs : si on ajoute du code entre deux, ça devient tout de suite moins clair.

Perso, ça me rappelle juste à quel point C doit être évité pour toute appli hors kernel, embarqué, compilo, ou composant critique du système.

Il faut surtou t que les gens qui développent soient conscients de la dangerosité de manipuler le C, et que si on a pas un code très propre, ça risque de pêter. Un peu comme des explosifs : très puissant mais à maniipuler avec précaution.

Exemple : ligne 123 à 234, avec un mélange de if avec blogcs entre {}, et sans {}, des else if imbriqués dans tous les sens, qui fait qu'on a du mal à voir ce qui se passe. C'est à ce genre de code que l'on doit des bugs qui ont fait beaucoup parler d'eux ces temps-ci. Certaines parties du code sont plus propres (hereusement d'ailleurs), mais celle-ci me fait un peu peur. Ca manque de cohérence dans le style, ça fait mal rangé.

A mon avis ce code est trop long et aurait du être splitté en plusieurs fonctions.

            for (;;) {
                    int sleep_for = -1, j;

                    if (until > 0) {
                            usec_t y;

                            y = now(CLOCK_MONOTONIC);

                            if (y > until) {
                                    r = -ETIME;
                                    goto finish;
                            }

                            sleep_for = (int) ((until - y) / USEC_PER_MSEC);
                    }

                    if (flag_file)
                            if (access(flag_file, F_OK) < 0) {
                                    r = -errno;
                                    goto finish;
                            }

                    if ((j = poll(pollfd, notify > 0 ? 2 : 1, sleep_for)) < 0) {

                            if (errno == EINTR)
                                    continue;

                            r = -errno;
                            goto finish;
                    } else if (j == 0) {
                            r = -ETIME;
                            goto finish;
                    }

                    if (notify > 0 && pollfd[POLL_INOTIFY].revents != 0)
                            flush_fd(notify);

                    if (pollfd[POLL_SOCKET].revents == 0)
                            continue;

                    if ((k = read(fd, buffer + p, sizeof(buffer) - p)) <= 0) {
                            r = k < 0 ? -errno : -EIO;
                            goto finish;
                    }

                    p += k;

                    if (p < 1)
                            continue;

                    if (buffer[0] == 5) {

                            if (accept_cached) {
                                    /* Hmm, first try with cached
                                     * passwords failed, so let's retry
                                     * with a normal password request */
                                    free(packet);
                                    packet = NULL;

                                    if (asprintf(&packet, "*\002%c%s%n", (int) (strlen(message) + 1), message, &n) < 0) {
                                            r = -ENOMEM;
                                            goto finish;
                                    }

                                    if ((k = loop_write(fd, packet, n+1, true)) != n+1) {
                                            r = k < 0 ? (int) k : -EIO;
                                            goto finish;
                                    }

                                    accept_cached = false;
                                    p = 0;
                                    continue;
                            }

                            /* No password, because UI not shown */
                            r = -ENOENT;
                            goto finish;

                    } else if (buffer[0] == 2 || buffer[0] == 9) {
                            uint32_t size;
                            char **l;

                            /* One ore more answers */
                            if (p < 5)
                                    continue;

                            memcpy(&size, buffer+1, sizeof(size));
                            size = le32toh(size);
                            if (size+5 > sizeof(buffer)) {
                                    r = -EIO;
                                    goto finish;
                            }

                            if (p-5 < size)
                                    continue;

                            if (!(l = strv_parse_nulstr(buffer + 5, size))) {
                                    r = -ENOMEM;
                                    goto finish;
                            }

                            *_passphrases = l;
                            break;

                    } else {
                            /* Unknown packet */
                            r = -EIO;
                            goto finish;
                    }
            }

            r = 0;
    ```

ça donne envie de tenter une amorce de récursivité,

C'était le but, il ne faut pas prendre ma remarque au premier degré.

C'est plus ou moins ça : le parlement a donné son avis : il est favorable à la neutralité. Le conseil doit lui se prononcer pour que ce principe soit définitivement adopté (enfin jusqu'à la prochaine proposition de loi oui de directive qui l'écornerait).

"Je n'ai pas trouvé de cas où le parlement s'est assis sur la position du parlement"

Je suppose que tu voulais dire "de cas où le parlement conseil s'est assis sur la position du parlement", a moins que le parlement soit schizophrène, ou après une élection …