Etiquette Open Source

J'ai commencé à travailler sur mon premier projet open source sur Codeplex et suis tombé sur un code terrible. (J'ai appris que C # a toujours la déclaration "goto") J'ai commencé à ajouter des fonctionnalités que le "propriétaire" voulait et après avoir exploré la base de code et vu de quoi il s'agissait (par exemple en utilisant "goto"), je voulais le nettoyer un peu. Mais je suis un peu inquiet et c'est pourquoi je me tourne vers vous tous: est-ce une bonne étiquette pour moi de "corriger" le "mauvais code" ou dois-je le laisser et travailler sur de nouvelles fonctionnalités? Comme je l'ai déjà dit, je suis nouveau sur toute la scène OSS et je travaille dans une équipe en général, donc je ne voudrais pas tout gâcher.

C'est bon de faire ça, si vous êtes modeste à ce sujet et que cela ne casse rien . Vous ne pouvez pas contourner le formatage du code et introduire des bogues. At-il de bons tests unitaires? Sinon, je commencerais à contribuer en ajoutant des tests unitaires, puis je corrigerais la structure plus tard.

Le but de l'open source est d'avoir plus de regards sur un projet et de l'améliorer. Cela inclut l'amélioration du code. Cela dit, il est bon d'annoncer sur la liste ce que vous avez l'intention de faire. Vous pouvez obtenir un certain recul, ou vous pouvez obtenir un tas de +1. Ces gotodéclarations pourraient bien être là parce que l'auteur original ne pouvait pas penser à une meilleure façon de faire le travail. Si vous êtes repoussé, il est bon d'ouvrir une boîte de dialogue pour savoir d'où vient la pression. Essayez de ne pas le laisser devenir personnel et essayez de répondre aux préoccupations.

En bout de ligne, les tests unitaires parlent plus fort que le dogme. Si vous pouvez prouver que le code fonctionnera mal dans certains cas comme il l'est maintenant, vous obtiendrez le pouce levé ou l'auteur d'origine ira et réparera les choses.

N'oubliez pas qu'en open source, la communauté est plus importante que le code. S'il n'y a pas de communauté (à la fois d'utilisateurs et de développeurs), alors il n'y a pas de projet.

Les gens qui sont jalousement défensifs à propos de leur code ne le publient généralement pas pour que le monde l'examine, et s'ils le font, la communauté autour de lui ne durera pas très longtemps. Soyez délicat, mais ne vous inquiétez pas que vous blesserez vos sentiments.

Dites-leur simplement ce que vous voulez faire avant d'y consacrer trop de temps. Parfois, il y a des raisons historiques pour des choses qui ne sont pas évidentes. La raison pour laquelle les gotos sont évités est qu'ils peuvent produire des chemins imprévus à travers le code. En conséquence, le danger de supprimer les gotos est que vous ne remarquez pas l'un des chemins bénéfiques et que vous l'omettez accidentellement du refactor.

D'un autre côté, peut-être que l'auteur original ne pouvait tout simplement pas penser à une façon plus propre de l'écrire à l'époque. C'est là que le code parle plus fort que les mots, car ils peuvent ne pas croire que cela peut être fait plus propre jusqu'à ce que vous les montriez. L'une de mes premières contributions open source a été un correctif de pile d'annulation qui a considérablement amélioré les performances, mais que certains développeurs principaux ont dit sembler trop complexe lorsque je l'ai décrit pour la première fois. Un court échantillon de code les a embarqués.

S'il s'avère qu'il y a vraiment de bonnes raisons de le laisser, je pousserais au moins pour un commentaire expliquant ces raisons.

Parlant d'expérience ...

Le premier projet Open Source auquel j'ai contribué, j'étais plein de pisse et de vinaigre quand j'ai commencé aussi.

Ce que j'ai immédiatement fait, c'est de parcourir un tas de fichiers source et de commencer à styliser les choses selon mes préférences personnelles, de créer un énorme patch et de le soumettre.

Si vous travaillez avec quelqu'un qui est «bon» (comme moi), il rejettera immédiatement le patch. Principalement parce que, lorsque vous contribuez à un projet open source, vous êtes censé décomposer vos correctifs en morceaux de taille de bouchée qui répondent à un seul problème. 'Supprimé tous les gotos' n'est pas un bon exemple de commit atomique. Même si vous le divisez en commits plus petits et bien documentés, il peut tout de même être rejeté.

La raison en est, parce que le code est travaillé par plusieurs personnes (avec des styles différents) au fil du temps, il n'est pas vraiment possible d'accepter des modifications sur l'ensemble de la bibliothèque pour convenir au style d'un développeur. S'il était possible de changer de style pour le style, alors chaque projet open source ne progresserait jamais car le code serait constamment édité pour s'adapter aux différents styles de développement.

La refactorisation du code et l'ajout de fonctionnalités (ou la suppression de la déchirure obsolète) ont généralement priorité sur le «nettoyage» du code.

La partie la plus difficile et la plus gratifiante du travail sur un projet open source est, on vous demandera pourquoi vous proposez d'apporter les modifications que vous soumettez. Si vous pouvez donner une bonne raison, il y a de meilleures chances que votre patch soit envoyé.

Mon conseil est de faire quelques-unes de ces modifications sur un fichier source pour donner un avant-goût de ce que vous essayez de faire en premier. Si les changements sont bien justifiés et acceptés, demandez si d'autres changements comme celui-ci amélioreraient la qualité du projet. De cette façon, vous ne perdrez pas beaucoup d'efforts pour rien si vos correctifs sont rejetés à l'avenir.

Développer l'open source, c'est plus qu'écrire du code. Vous travaillez à construire une relation de confiance car les gardiens (les développeurs qui contrôlent l'accès push) feront ce qu'ils doivent pour protéger l'intégrité du projet. Lorsque vous soumettez plus de correctifs, le portier aura une meilleure idée de votre style et vous n'aurez pas à justifier autant vos modifications.

C'est un processus qui prend du temps mais c'est très enrichissant. Non seulement vous apprendrez beaucoup en étant capable de regarder et de critiquer le code de quelqu'un d'autre, mais vous serez critiqué sur votre propre style.

Avant de perdre beaucoup de temps à essayer de `` corriger l'injustice des erreurs du style de codage des autres '', demandez-vous ceci:

Les changements que vous proposez sont-ils basés sur l'ajout de valeur au projet ou sont-ils basés sur votre propre religion stylistique interne.

Il y a beaucoup de religion sur Stack Overflow (et les sites Stack Exchange associés). Je veux dire beaucoup . Les gens pensent et parlent sans cesse du style, comme si plus vous en parliez, plus vous vous rapprochiez du style de codage `` parfait, idéal, indestructible, infaillible ''. J'en parle beaucoup trop surtout parce que c'est amusant.

Dans le monde Open Source, le style n'est pas si important. La fonction est .

Remarque: Tous ces conseils supposent que votre contrôleur d'accès est un programmeur raisonnable et talentueux. Si tel est le cas, comptez-vous chanceux de ne pas être coincé avec l'un des b @ & # & es pleurnichards dont la seule préoccupation est de protéger leur «bébé». Ils n'existent dans la nature, alors ne soyez pas surpris si vous rencontrez un.

Qualité> Etiquette

À mon avis, vous ne devriez pas vous soucier de modifier le code des autres dès que vous découvrez qu'il est de mauvaise qualité. Pour obtenir une bonne qualité logicielle, il vous suffit de prendre soin d'un code propre. Je ne vois aucun problème à apporter des améliorations au code d'autres personnes, d'autres personnes devraient être conscientes et reconnaissantes qu'il existe des codeurs qui travaillent sur leur code.

Si vous pouviez trouver une meilleure façon de résoudre le problème sans utiliser "goto", alors je vous suggère d'y aller. Un petit effort pour améliorer le code aujourd'hui peut vous faire économiser beaucoup plus d'efforts à l'avenir.

Communiquer avec l'auteur d'origine est également une bonne idée.

Il n'y a rien de mal implicitement goto. Regardez le code d'assemblage - beaucoup de gotos (sauts et branches) partout.

La raison pour laquelle gotoune mauvaise réputation ces jours-ci est due à la déclaration Go To du journal Dijkstra considérée comme nuisible qui a identifié la déclaration goto comme une très mauvaise chose.

Notez qu'il y a 50 ans, le génie logiciel n'était même pas encore nommé, et la plupart des langages de programmation étaient essentiellement des abstractions de la machine sous-jacente, de sorte que le langage machine contenait goto, tout comme eux. Vous pouvez essayer d'en programmer certains dans Microsoft Basic (l'original, sur Apple] [ou Commodore 64) pour avoir une idée de l'état d'esprit.

Ce que Dijkstra faisait valoir était que pour garder les choses simples, ne sautez pas partout, mais gardez plutôt un chemin de programme plus simple avec une fin commune. Par exemple, un retour d'une méthode. En d'autres termes - seulement des sauts locaux, pas globaux.

C'était une étape vers l'introduction de choses comme des appels de méthode avec des arguments, la modularisation du code, des packages, etc. qui ont tous été introduits pour apprivoiser la complexité du développement logiciel. La déclaration goto n'était que le premier spectateur de cette guerre.