Existe-t-il des meilleures pratiques concernant le passage de l'architecture au développement?

Nous cherchons à améliorer le processus de transfert des tâches de l'architecture au développement.

À une extrémité de l'échelle, il n'y a pas de conseils d'architecture, vous risquez de devenir chaotique, chaque développeur faisant les choses à sa manière.

À l'autre extrémité de l'échelle où tout est spécifié, la spécification prend plus de temps que le développement et vous risquez d'avoir des tâches de développement très ennuyeuses.

Quelqu'un a-t-il trouvé un juste milieu optimal entre ces extrêmes? Quels artefacts fournissez-vous au développement? Par exemple: modules, structure de classe ou diagrammes de séquence?

Je commencerai par dire que le concept même d'une équipe "Architecture" séparée est un affront aux bonnes pratiques de développement logiciel. Les équipes d'architecture dans les environnements d'entreprise ont tendance à être le point culminant des pires artistes pseudo-intellectuels de la tour d'ivoire * * que l'on puisse trouver parmi le bassin de développeurs.

D'autres organisations traitent les groupes d'architecture comme une récompense politique et une justification pour un salaire massif aux membres les plus anciens, indépendamment du mérite, des connaissances ou des compétences. La plupart se composent des deux types.

Chaque développeur peut et doit être un architecte et doit être impliqué dans les conceptions de haut niveau d'une entreprise. L'idée même qu'un seul groupe a un contrôle dictatorial complet sur tous les aspects de la conception de logiciels et qui doit être transmise aux développeurs qui n'ont pas contribué à la conception, ne comprennent pas le raisonnement derrière les choix de conception et peuvent comprendre des défauts critiques dans la conception étant plus confortable et plus proche de l'implémentation réelle et du code existant, est franchement complètement vicié de son cœur, et se traduira systématiquement par l'un des trois scénarios:

• Les développeurs ne comprennent pas la conception, ou la rejettent carrément en raison des réalités de l'implémentation actuelle, et finissent par déterminer leur propre conception non documentée et l'implémentent à la place. La situation est des documents de conception formels qui ne reflètent pas la mise en œuvre du logiciel.

• Les développeurs suivent aveuglément la conception qui peut ou non prendre en compte les exigences actuelles ou les aspects uniques des user stories, ce qui entraîne un buggy et une implémentation de mauvaise qualité.

• Les développeurs intelligents qui comprennent les documents de conception et sont capables de les mettre en œuvre, s'ennuient rapidement de ne pas être impliqués dans les discussions de conception. Ils sont probablement exclus de la participation au groupe d'architecture en raison de problèmes politiques ou d'ancienneté, de sorte qu'ils deviennent frustrés, s'ennuient et partent pour des pâturages plus verts. Cela affecte négativement le projet, entraînant une fuite des cerveaux entraînant la poursuite du cercle vicieux de la mauvaise qualité des logiciels.

La meilleure façon d'atténuer ce problème est de CHANGER le groupe d'architecture et éventuellement de le placer en position de chef de file technologique. Le rôle du groupe Architecture devrait être plus ou moins une «mêlée de leads technologiques» si vous voulez. Ils ne devraient que rarement se rencontrer et discuter uniquement des questions de direction technique de plus haut niveau, par exemple. pensez à la migration de Java vers Scala, Abandon d'Oracle pour MySQL, peut-être à l'écriture de bibliothèques utilitaires communes qui imposent un certain TYPE de processus de conception à un autre, passant de StarUML à Altova UML.

La conception réelle et réelle du logiciel sera un processus communautaire impliquant TOUS les développeurs de logiciels, défini par la direction de très haut niveau du groupe Architecture.

Il y a toujours eu des problèmes dans la façon dont les informations sont transmises de l'architecture aux tests de développement et aux opérations. La façon de résoudre ces problèmes à mon humble avis dépend de plusieurs facteurs comme:

• taille du logiciel
• complexité
• la culture dans votre organisation
• croyance.

Pour certaines combinaisons de ces facteurs, une approche purement agile d'équipes interfonctionnelles avec une conception émergente est appropriée. L'information circule en travaillant ensemble. Les disciplines documentent ce dont elles ont besoin.

Pour d'autres combinaisons de ces facteurs, une petite équipe d'architectes, de testeurs, d'experts en opérations et de développeurs principaux peut commencer par des itérations d'architecture construisant lentement l'architecture, documentant et obtenant un retour immédiat sur leurs décisions d'architecture. Lentement plus de développeurs qui implémentent des fonctionnalités peuvent être ajoutés à l'équipe et l'équipe principale d'origine peut être réduite.

Surtout pour les projets gouvernementaux et financiers, il est nécessaire que davantage de documentation soit écrite à l'avance et cela peut prendre beaucoup de temps sans rétroaction réelle sur vos choix. Dans mon esprit, la principale raison pour laquelle bon nombre de ces projets échouent. Si tel est votre cas, je rédigerais la documentation pour répondre aux exigences Et utiliser l'option 1 ou 2 pour créer le logiciel et affiner / adapter la documentation.

J'espère que cela t'aides.

Je sais que ce ne sera pas très populaire, mais le commentaire que vous avez fait

À l'autre extrémité de l'échelle, si tout est spécifié, la spécification prend plus de temps que le développement. Et vous risquez d'avoir des tâches de développement très ennuyeuses.

est en fait quelque chose que vous devriez viser. Si la conception et les spécifications sont suffisamment solides pour que les tâches de développement soient ennuyeuses, le coût de développement diminue. Il est beaucoup moins coûteux de réparer une spécification que de réparer du code, et le plus gros coût des projets logiciels n'est pas la construction, c'est le support à long terme. Et le support du code basé sur une spécification solide est beaucoup moins cher.

Je ne suis pas entièrement d'accord avec la réponse de maple_shaft, mais il n'y avait pas assez de place dans le commentaire pour dire tout mon morceau! ;-)

Je suis d'accord que chaque développeur peut et doit être un architecte, mais cela ne signifie pas que chaque développeur doit être responsable de l'architecture d'un produit ou d'un système complet. De plus, je ne pense pas que vous puissiez peindre chaque équipe architecturale avec le même pinceau large, et une fois cela fait, les équipes architecturales appropriées peuvent apporter une grande valeur au processus global de développement de produits. L'idée fausse est que les architectes doivent dicter tous les aspects de la conception du système. Ils devraient plutôt se concentrer sur la conception de niveau supérieur et laisser les détails de la mise en œuvre à leurs équipes de développement. Cela ne veut pas dire cependant que les développeurs ne devraient pas être impliqués dans le processus de planification et de conception dès le départ.

Plus un produit est grand et modulaire et finalement plus complexe, plus vous trouverez probablement différentes parties du produit gérées par différentes équipes de développement. Ces équipes n'ont pas besoin de comprendre le système dans son ensemble, à condition d'avoir une compréhension complète des parties du système dont elles sont responsables. Souvent, ces équipes supplémentaires sont engagées en tant que sous-traitants dans le but spécifique de développer un module dans un domaine technologique particulier dans lequel les architectes ou d'autres équipes peuvent ne pas avoir d'expertise. Mes talents particuliers résident dans le développement d'API, et je n'ai pas encore vu une API bien factorisée qui a été développée entièrement de manière organique sans être un gâchis complet en termes de convivialité, ou qui n'exigeait pas que quelqu'un se démarque comme étant la personne qui avait assuré qu'il y avait un niveau d'uniformité entre les différents aspects de l'API. Je peux continuer à énumérer de nombreux exemples et raisons, mais je ne pense pas que ce genre de situations soit la tour d'ivoire BS que beaucoup pourraient penser qu'elles sont. Malheureusement, il existe de nombreux endroits, en particulier dans les secteurs de la défense, du médical et des finances où la paranoïa des entreprises se traduit par un développement de produits mal spécifié et encore plus mal géré du type qui, j'en suis sûr, était le plus préoccupé par maple_shaft. Ce sont des choses qui, je crois, donnent aux architectes une mauvaise réputation mal méritée (en général). Malheureusement, il existe de nombreux endroits, en particulier dans les secteurs de la défense, du médical et des finances où la paranoïa des entreprises se traduit par un développement de produits mal spécifié et encore plus mal géré du type qui, j'en suis sûr, était le plus préoccupé par maple_shaft. Ce sont des choses qui, je crois, donnent aux architectes une mauvaise réputation mal méritée (en général). Malheureusement, il existe de nombreux endroits, en particulier dans les secteurs de la défense, du médical et des finances où la paranoïa des entreprises se traduit par un développement de produits mal spécifié et encore plus mal géré du type qui, j'en suis sûr, était le plus préoccupé par maple_shaft. Ce sont des choses qui, je crois, donnent aux architectes une mauvaise réputation mal méritée (en général).

Alors, où est le terrain d'entente que le PO recherchait? La réponse est tout à fait d'ouvrir des canaux de communication. Les architectes doivent remettre des spécifications qui décrivent leurs conceptions avec suffisamment de détails afin de s'assurer que les équipes de développement comprendront où se trouvent les limites. Histoires et scénarios de fonctionnalités au sens large, où tout est considéré comme une boîte noire. Les architectes doivent ensuite s'assurer que les équipes ont accès au temps de l'architecte pour confirmer toutes les hypothèses et obtenir des réponses aux questions sur les spécifications qui semblent trop larges ou peu claires. Après cela, il s'agit vraiment de s'assurer que les équipes individuelles sont informées de ce sur quoi les autres équipes travaillent et qu'elles savent avec qui communiquer avec les autres équipes pour s'assurer que chaque partie du système jouera bien avec les autres parties. Ces équipes se rencontrent directement. Une fois que le système a été conçu au niveau le plus large, les architectes ne devraient être que les personnes vers lesquelles les équipes se tournent lorsqu'elles ont besoin d'un bilan de santé et pour s'assurer que la «vision» du produit est maintenue. Ils devraient également prendre en compte tout processus d'intégration requis et fournir une «couverture aérienne» aux équipes de développement des gestionnaires, des clients et de toutes les autres parties prenantes, tout en veillant à ce que ces différentes personnes puissent toutes se réunir pour s'entraîner entre leur expliquer comment les choses devraient fonctionner.

Les architectes à mon humble avis devraient avant tout être des facilitateurs et des communicateurs, et les concepteurs ensuite. Quant à quel niveau de spécification? Je pense que les meilleurs architectes sont ceux qui interrogent leurs équipes sur le niveau de détail souhaité par une équipe et trouvent entre eux un équilibre qui fonctionne. Différentes équipes peuvent avoir des exigences différentes en termes de quantité de documentation ou de directives requises. Les équipes seniors peuvent trouver un schéma grossièrement dessiné et une discussion rapide peut être suffisante pour commencer, tandis que les équipes remplies de développeurs relativement juniors peuvent avoir besoin d'un peu plus pour les faire avancer. Par-dessus tout, l'architecte doit encourager les développeurs à exercer leurs propres talents de conception afin d'obtenir le meilleur résultat final de chaque équipe.

Puisque vous vous efforcez d'améliorer quelque chose, vous avez déjà détecté un problème dans votre processus. La cause première de la situation spécifique peut être la suivante: les développeurs ne peuvent pas s'identifier à l'architecture, car elle leur a été imposée par quelqu'un d'extérieur. La remise de l'architecture au développement ne résoudra probablement pas cette cause profonde.

Intégrez l'architecture à l'équipe de développement. Abattez la frontière entre l'architecte et le développeur. Cela garantit que les informations circuleront. Si l'équipe de développement participe à façonner l'architecture, elle ne la considérera pas comme quelque chose d'étranger. Insufflez des connaissances sur l'architecture à l'équipe. Apprenez-leur les facteurs moteurs de l'architecture d'entreprise pour éviter le chaos que vous avez mentionné. Impliquez les développeurs lorsque des décisions architecturales doivent être prises pour éviter l'ennui que vous avez mentionné. Un transfert n'est alors plus nécessaire et vous avez rempli votre rôle d'architecte dans une équipe de développement.

Vous devez fournir autant d'informations que possible pour que la future équipe gère le code. Si vous n'avez pas de diagrammes de séquence par exemple, le développeur est obligé de suivre le code étape par étape, ce qui fait perdre du temps.

Il y a aussi de la place pour la nouvelle équipe qui fait des hypothèses qui ne sont pas valides.

En général, il devrait y avoir un document sur ce qu'est le projet, les spécifications techniques, les cas de tests unitaires et les diagrammes de séquence / classe.

Je dirais que les vues de diagrammes de classes créant un modèle ainsi que du code sont une solution. Le diagramme de classes représente la vue statique de l'architecture de votre projet. Je veux dire que vous avez des packages> classes, des interfaces, des énumérations> des attributs, des mehtods etc ...> etc. Si vous regardez bien, le métamodèle UML2 a exactement la même structure qu'un projet java ou dotnet.

Ce que nous utilisons dans nos projets sont simplement des diagrammes de classes qui sont enregistrés dans un modèle unique. Nous générons des vues du modèle si le classifieur existe déjà ou en créons un nouveau graphiquement s'il est nouveau. Les développeurs peuvent voir nos diagrammes et notre modèle car enregistrés à la racine du dossier du projet dans CVS. Ce que j'aime, c'est que le développeur peut également modéliser parce que si quelque chose est modifié au niveau du code, le modèle est automatiquement mis à jour sur CVS pour toute l'équipe.

Cela fonctionne vraiment bien et pas vraiment besoin de connaître UML car le diagramme de classes est vraiment simple et la rétro-ingénierie fera le travail et créera la vue graphique du code. Navigation simple, vues avancées et détaillées où de nombreux commentaires peuvent être ajoutés avec des diagrammes toujours à jour et visibles sur CVS directement dans le projet. Mon diagramme de classe UML est maintenant magique :-)