Comment apprendre la bonne approche pour implémenter une demi-fonctionnalité? [fermé]

Je dirige une équipe de développement et je souhaite sortir notre produit le plus souvent possible (livraison continue).

Dans de nombreux cas, nous devons implémenter une fonctionnalité qui prend plus de temps à implémenter que le temps entre les versions. Je veux toujours que les gens engagent leur code au quotidien (intégration continue).

Plusieurs fois, la mise en œuvre d'une nouvelle fonctionnalité nécessite la modification d'une fonctionnalité existante et les fonctionnalités existantes, bien sûr, doivent encore fonctionner, même si la nouvelle fonctionnalité n'est pas encore terminée.

Si le développeur utilise la bonne approche , il peut ajuster soigneusement les fonctionnalités existantes et tout ce qui précède n'est pas un problème.

Cependant, quelle EST la bonne approche en fait? Ma propre sensibilité à la programmation me dit quoi faire pour chaque cas individuel, mais j'ai besoin d'en savoir plus et j'ai besoin de matériel de lecture que je peux lire et recommander aux membres de l'équipe de lire. Ou toute autre méthode d'apprentissage de la bonne façon d'apprendre cette approche fera l'affaire.

Voilà donc la question. Comment m'assurer que les membres de l'équipe apprennent la bonne approche pour implémenter une demi-fonctionnalité?

J'ai recherché des personnes affirmant avoir des stratégies à ce sujet, mais je ne les ai pas encore trouvées, à l'exception des personnes écrivant quelques réflexions aléatoires sur le sujet. Peut-être que je n'utilise pas les bons mots de recherche ou peut-être que personne n'a fait de directives faisant autorité à ce sujet.

J'ai déjà un point de vue différent des autres réponses ici. Je suis d'accord avec vous que vous souhaitez intégrer les changements des développeurs dès que possible et continuer à tester le mélange combiné de code.

Cependant, je ne suis pas d'accord pour dire que son code de droit d'expédition a été développé ce matin, simplement parce que nous publions cet après-midi. C'est une recette pour des clients déçus.

La solution consiste à avoir des branches dans votre arborescence de contrôle de version et à disposer d'un processus distinct pour promouvoir les deltas vérifiés de la branche de développement à la branche de publication.

De cette façon, vous obtenez le meilleur des deux mondes. Vous avez des développeurs qui font une intégration continue, et les avantages que cela apporte, vous avez un envoi de code stable régulièrement au client, et vous avez un nouveau processus qui teste les fonctionnalités terminées dans la branche développeur, et s'ils réussissent les tests, faites-les partie du produit publié .

Il y a deux outils que je connais qui supportent bien ce genre de processus. Si votre structure de développement est simple, alors git, avec git-flow implémente une bonne structure de branchement qui fonctionne bien dans les petites et moyennes équipes (peut-être 20 développeurs).

Pour les grandes équipes de développement, ou lorsqu'une stratégie de branchement plus complexe est nécessaire pour prendre en charge plusieurs «spins» de votre produit, la précision est la meilleure qui soit. Les développeurs qui ne sont pas impliqués dans la gestion des changements se plaindront que c'est plus difficile que la sous-version etc ... mais il supporte des environnements de développement complexes.

Il y a deux problèmes ici: l'un met en œuvre une demi-fonctionnalité; l'autre maintient le produit d'expédition pendant le développement continu.

Implémentation d'une demi-fonctionnalité

Une conception globale solide aidera à cela. Cela vous permet d'implémenter la fonctionnalité avec ses limites clairement définies - par exemple, des API pour des bits de code adjacents, des attentes sur les structures de données et une compréhension de la façon et du moment où le code implémenté sera appelé.

Les tests peuvent inclure des versions simulées du code pour les autres parties de la fonctionnalité; cela aide à faciliter la transition lorsque vous allez implémenter la seconde moitié.

Maintenir le produit d'expédition en état de marche

Il existe une poignée d'options ici:

1. Désactivez la fonction dans le produit expédié. Ce n'est pas parce que le code est dans le produit qu'il doit être exécuté ou présenté aux utilisateurs. L'inconvénient est que vous n'apporterez pas de valeur incrémentielle à vos utilisateurs et que vous n'obtiendrez pas de commentaires.
2. Révélez les bords de la fonctionnalité à vos utilisateurs. Montrez ce que vous avez et donnez une indication de ce qui va arriver.
3. Permettez aux utilisateurs de basculer entre les nouvelles et les anciennes fonctionnalités. Cela nécessite parfois de maintenir deux chemins de code prêts pour l'utilisateur final.

Enfin, si vous rencontrez des problèmes avec l'une de ces solutions, demandez-vous si vous avez divisé la fonction le long des bonnes limites. Si vous découpiez les choses différemment, serait-il plus facile de les séparer?

Comment m'assurer que les membres de l'équipe apprennent la bonne approche pour implémenter une demi-fonctionnalité?

En leur enseignant. (duh)

L'apprentissage impliquera l'itération: essayer quelque chose, voir comment cela fonctionne, puis modifier leur approche pour obtenir de meilleurs résultats. Pour ce genre de chose, je recommanderais des revues de conception / code. Vous pouvez voir comment la demi-fonctionnalité est conçue / implémentée et avez la possibilité de donner votre avis. "Ceci et cela ne fonctionnera pas car ils vont casser notre CI; que diriez-vous de XYZ?", "Bon travail ici, c'est vraiment propre."

Faire les évaluations en équipe aidera tout le monde à apprendre ce que vous savez déjà intuitivement.

La plus grande chose qui vous aidera ici est d'avoir une bonne séparation des préoccupations afin que, autant que possible, un domaine de code n'interfère pas avec un autre.

C'est un endroit où l'utilisation de l'injection de dépendances et de la programmation de l'interface aide vraiment, de sorte que vous puissiez avoir votre implémentation actuelle de ISupportingFeature sur le site, puis lorsque vous devez créer INewFeature qui dépend d'une implémentation différente, vous pouvez simplement développer avec le nouvelle implémentation et maintenir l'existant en production jusqu'à ce qu'il soit bien testé et prêt à être mis en service. En supposant que votre DI fonctionne sur un système de configuration quelconque, cela vous permettra d'avoir le même code en parallèle dans votre système et d'utiliser un code stable à tout moment.

En fait, cette approche de configuration est décrite par Martin Fowler comme un basculement de fonctionnalité.

Bien sûr, le problème ne se pose que si vous déployez tout le code tout le temps. C'est précisément le type de scénario pour lequel les branches de fonctionnalité ont été conçues et bien que je reconnaisse que M. Fowler les fronce les sourcils, je ne sais pas si elles sont si mauvaises, surtout si elles sont créées et utilisées dans un plan et une pensée- par voie.