Architecture (structure) orientée par rapport à une structure de projet orientée fonctionnalités

14

Le projet, j'ai participé, a une structure de fichiers / dossiers de projet orientée architecture:

Root
|____ Node1
    |____ Event Handlers
    |         |___ <all event handlers of project>
    |____ Events
    |         |___ <all events of project>
    |____ Request Handlers  
    |         |___ <all request handlers of project>
    |____ Requests
    |         |___ <all requests of project>
    |____ ...

C'est clair du point de vue architectural du système (a été proposé par l'équipe de développement).

C'est une structure orientée fonctionnalités qui a été proposée par l'équipe de designers:

Root
|____ Feature #1
    |____ Event Handlers
    |         |___ <all event handlers of Feature #1>
    |____ Events
    |         |___ <all events of Feature #1>
    |____ Request Handlers  
    |         |___ <all request handlers of Feature #1>
    |____ Requests
    |         |___ <all requests of Feature #1>
    |____ ...

Cette variante est plus proche des concepteurs et elle décrit clairement une fonctionnalité à mettre en œuvre.

Nos équipes ont entamé une guerre sainte: quelle est la meilleure approche. Quelqu'un pourrait-il nous aider et expliquer les inconvénients et les avantages des premier et deuxième. Il y en a peut-être un troisième qui est plus utile et bénéfique pour nous deux.

Je vous remercie.

Zzz
la source
Je ne comprends aucune de ces structures - quelle est la différence entre les événements et les demandes (et donc les gestionnaires d'événements et les gestionnaires de demandes)?
Peter Boughton
1
Question très claire - et neutre aussi!
Michael K
1
Du point de vue de l'évolutivité, la deuxième approche devrait être assez facile à mettre à l'échelle horizontalement.
CodeART

Réponses:

11

Je voterais pour le deuxième. Dans la première structure, les gestionnaires d'événements pour FeatureAsont totalement indépendants des gestionnaires d'événements pour FeatureB. Il semble que les développeurs travailleront sur une fonctionnalité à la fois, et si vous travaillez sur une FeatureXdemande, il est beaucoup plus probable que vous ayez besoin de modifier un FeatureXgestionnaire de demande que, disons, une FeatureZdemande.

Soit dit en passant, j'adore la façon dont vous avez posé cette question d'un point de vue neutre.

Note à soi - pense à un nom
la source
1
+1 avec une mise en garde: pour les petits projets, le second se traduira par une structure de fichiers plus grande qu'il n'y a de fichiers pour le mettre. J'utiliserais le premier pour ceux-ci.
Michael K
@Michael, je suis d'accord, mais dans ce cas, c'est un grand projet.
Zzz
1
+1: Et si jamais vous devez converser avec un utilisateur / client, la terminologie peut être assez cohérente.
Steven Evers
4

J'ai toujours été plus à l'aise avec la deuxième approche, mais j'ai toujours une "fonctionnalité" appelée générale ou commune pour les classes vraiment partagées / de base.

La deuxième approche permet de séparer les choses véritablement séparées, mais sans la zone «commune», elle sépare parfois les choses en zones qui ne correspondent pas bien.

Facture
la source
+1 pour commun et général (chaque projet a des utilitaires généraux, des outils ...)
Zzz
3

Pourquoi les inventeurs de fonctionnalités se soucient-ils des détails de mise en œuvre? S'il s'agit de la séparation entre les côtés de l'argument, je pense que la réponse est claire. Les personnes qui inventent des idées / fonctionnalités ne déterminent pas la structure de fichiers dont les implémenteurs ont besoin.

Il s'agit d'un problème particulièrement important lorsque l'implémentation d'une fonctionnalité s'étend sur plusieurs DLL, exes, bases de données ou autres logiciels.

John Fisher
la source
1
J'y ai pensé, mais, toutes choses étant égales par ailleurs, la deuxième approche présente des avantages philosophiques clairs pour toutes les applications, sauf les plus triviales. À tout le moins, c'est une bonne suggestion.
Robert Harvey
@Robert Harvey: Si vous parlez de l'organisation généalogique du projet, alors je devrais trouver une nouvelle réponse. Cependant, il semble qu'ils parlent de fichiers contenant du code ...
John Fisher
La clé est la séparation des fonctionnalités dans des compartiments distincts. Pour toutes les applications, sauf la plus petite, vous aurez besoin d'une sorte d'organisation comme celle-ci, que vous vous référiez à une structure de dossiers, à une structure de classes ou à une convention d'espace de noms.
Robert Harvey
1
@Robert Harvey: Qu'en est-il des problèmes de construction et de déploiement? Que diriez-vous de choses plus simples comme simplement pouvoir utiliser un IDE pour écrire et déboguer le code? Certaines de ces choses devraient avoir un impact puissant sur les structures de dossiers.
John Fisher
1

Je dois être d'accord avec la deuxième approche, compte tenu des deux options. Le premier ressemble à une goutte amorphe. Au moins le second a une forme.

Cela dépend vraiment de la taille du projet. Si les «fonctionnalités» sont grandes, elles ont chacune besoin de leur propre compartiment distinct.

Robert Harvey
la source
1

Je ne comprends pas la terminologie que vous utilisez, mais j'essaierai de répondre de toute façon, car les deux structures semblent être la mauvaise approche.

À moins que vous n'ayez qu'une poignée de fonctionnalités, vous devez les regrouper en catégories - et cela ne semble pas être pris en charge dans les deux conceptions (à moins que ce soit le but de Node1, mais le "tout X du projet" suggère sinon, et je me demande WTF c'est - y a-t-il un Node2?)

Je pourrais envisager quelque chose comme ça:

Root
|____ Event Handlers
|   |____ Category A
|   |    |___ Feature #1 EHs
|   |    |___ Feature #2 EHs
|   |    |___ Feature #3 EHs
|   |
|   |____ Category B
|   |    |___ Feature #4 EHs
|   |    |___ Feature #5 EHs
|   |
|
|____ Events
|   |____ Category A
|   |    |___ Feature #1 Events
|   |    |___ Feature #2 Events
|   |    |___ Feature #3 Events
|   |
|   |____ Category B
|   |    |___ Feature #4 Events
|   |    |___ Feature #5 Events
|   |
|

Ou ca:

Root
|____ Category A
|   |____ Event Handlers
|   |    |___ Feature #1 EHs
|   |    |___ Feature #2 EHs
|   |    |___ Feature #3 EHs
|   |
|   |____ Events
|        |___ Feature #1 Events
|        |___ Feature #2 Events
|        |___ Feature #3 Events
|   
|____ Category B
|   |____ Event Handlers
|   |    |___ Feature #4 EHs
|   |    |___ Feature #5 EHs
|   |
|   |____ Events
|        |___ Feature #4 Events
|        |___ Feature #5 Events


Mais ils font tous deux des hypothèses qui peuvent être complètement fausses - si vous pouvez mettre à jour votre question avec plus de détails, je pourrai changer d'avis. :)

Peter Boughton
la source