Dans quelle mesure la robustesse / redondance devrait mettre en œuvre des logiciels complexes?

softwareengineering.stackexchange https://softwareengineering.stackexchange.com/questions/19549

Question

Le point central de cette question: Certains effectue logiciels « travail supplémentaire » afin d'augmenter les chances d'un résultat « à terme avec succès / satisfaisant », malgré une ou plusieurs erreurs internes du logiciel, nécessite un temps d'exécution plus lorsque ces erreurs se produisent. si le résultat a réussi tous ces arriver à l'insu de l'utilisateur.

Définition de logiciels complexes:

  • contient le code écrit par (contribution de) plus de 10 développeurs sur sa durée de vie, et non écrit dans le même laps de temps
  • Dépend de plus de 10 bibliothèques externes, chacune avec des mises en garde
  • Une tâche logicielle typique (pour générer un résultat recherché par l'utilisateur) nécessite plus de 10 paramètres d'entrée, où la plupart d'entre eux ont des valeurs par défaut, mais sont configurables si l'utilisateur a besoin d'un contrôle.
  • Plus important encore, le logiciel qui a la complexité appropriée par rapport à la tâche à exécuter, à savoir pas inutilement compliqué .

Modifié: Ce qui est complexe? S'il vous plaît voir Il y a une grande différence entre complexe et compliqué. (lien direct)

Définition de redondance / Robustesse au sein de cette question :
(Ajouté Robustesse en fonction des commentaires)

  • Si une tâche du logiciel a échoué lorsque l'ensemble des paramètres en cours a été utilisé, essayer différents paramètres.
    • De toute évidence, il doit y avoir à l'intérieur de la connaissance que ces paramètres « différents » utilisent un chemin de code différent, qui peut entraîner un résultat différent (je l'espère mieux).
    • Parfois, ces différents chemin de code sont choisis en fonction des observations des bibliothèques externes.
  • A la fin, si la tâche réelle effectuée est légèrement différente de la spécification de l'utilisateur, l'utilisateur recevra un rapport détaillant l'écart.
  • Enfin, comme les paramètres, la redondance et les rapports 10-plus configurables sont également configurables.

Exemple d'un tel logiciel:

  • Migration de bases de données
    • base de données d'affaires
    • base de données de contrôle Source, etc.
  • la conversion par lots entre un document Word et un document OpenOffice, PowerPoint et OpenOffice Draw, etc.
  • Traduction automatique d'un site Web entier
  • Analyse automatique du logiciel, comme Doxygen, mais où les besoins d'analyse pour être plus fiable (à savoir non seulement un outil de documentation)
  • communication réseau, où les paquets peuvent être perdus et un certain nombre de réitérations devraient

Cette question a été inspiré de Comment vous traitez avec le code intentionnellement mauvais?
mais se concentre maintenant sur seulement l'une des causes de ballonnement du logiciel. Cette question ne traite pas d'autres causes de ballonnement de logiciels, tels que l'ajout de nouvelles fonctions.

Peut-être lié:

Était-ce utile?

La solution

Ceci est une question d'affaires, pas d'ordre technique.

Parfois, je suis le codage avec des chercheurs ou sur un prototype, donc nous allons construire quelque chose avec robustesse très faible. Si elle se casse, nous fixons. Il est inutile d'investir dans la magie supplémentaire si nous allons jeter le code bientôt.

Mais si les utilisateurs de votre système ont besoin pour être robuste, vous devez construire cette façon. Et vous devez le rendre robuste spécifiquement de la manière que vous et ils ont besoin pour maximiser le succès à long terme, tout en ignorant les types de redondance / robustesse qu'ils ne ont pas besoin.

En général, je commence rugueux puis ajouter la robustesse au fil du temps. Je fais souvent des questions comme cette partie du processus normal de planification. En général, je travail dans le style de programmation extrême, où nous faisons une longue liste de caractéristiques souhaitées, et je mets caractéristiques de robustesse là-dedans aussi. Par exemple, « système survit à la défaillance d'une seule boîte, » se mélange avec des choses comme « L'utilisateur peut se joindre à l'aide des informations d'identification Facebook. » Quel que soit on se heurte d'abord, je construis d'abord.

Autres conseils

logiciel complexe typiquement redondant comme vous le savez sans doute, mais évidemment pas parce que c'est la meilleure façon de le faire, mais parce que les développeurs ont tendance à « amure sur » le code existant plutôt que de tenter de comprendre en détail comment le logiciel fonctionne.

Cependant, si vous me demandiez combien la redondance devrait être acceptable, je dirais pas que ce soit. La redondance est l'un des nombreux effets secondaires de la complexité, la archnemesis de simplicité. On peut dire que, la simplicité devrait prendre un siège arrière si le temps est d'une plus grande importance, mais je tiens à souligner que ceux qui soutiennent que le temps est de l'essence sont rarement ceux qui prennent effectivement des soins dans le développement de logiciels. Il est généralement votre chef de projet vous egging juste faire le travail le plus rapidement possible afin que vous puissiez revenir à des questions plus pressantes, mais il est de votre devoir en tant que programmeur de savoir quand le travail est fait. Je pense que le travail ne se fait pas jusqu'à ce que vous avez intégré avec succès dans le programme tel qu'il était censé être. Peut-être que le programme est compliqué, mais au moins votre modification correspond à la tendance qui en fait un peu facile à comprendre par un programmeur habitué à voir un code similaire.

Cependant, il faut dire que ce faisant, vous pourriez avoir à produire du code redondant. Si le projet est déjà très redondant, il peut effectivement être plus simple à poursuivre le modèle en supposant bien sûr que votre patron n'a pas de semaines pour tuer vous permettant de restructurer l'ensemble du projet.

Edit: À la lumière de la reformulation de la question, je vais ajouter un peu de robustesse. À mon avis, le paramètre de vérification doit être effectuée que si A) vous acceptez un format très spécifique, comme une valeur de date comme une chaîne ou B) divers paramètres peuvent entrer en conflit les uns avec les autres ou sont mutuellement exclusifs.

A), les exigences que les paramètres correspondent à un format spécifique est généralement critique à la nécessité de la méthode (comme une conversion à une date à partir d'une chaîne). encore Techniquement, il pourrait se produire dans votre programme sans qu'il soit nécessaire, mais je vous encourage fortement à éliminer ces possibilités et accepter uniquement les paramètres que vous savez représentent le type de données que vous recherchez (Accepter une date plutôt qu'une chaîne si la le point est de ne pas convertir par exemple. Si la conversion doit être effectuée, utilisez une méthode utilitaire pour convertir la chaîne avant de passer à la méthode).

B), les paramètres mutuellement exclusifs représentent une mauvaise structure. Il devrait y avoir deux classes, l'une qui gère un cas et un autre qui gère d'une autre manière. Toutes les opérations communes peuvent se faire en une seule classe de base pour éviter la redondance.

Je commence à considérer dans les situations où le nombre de paramètres à une méthode get être 10+, un fichier de propriétés qui contient tous ces paramètres qui sont les plus susceptibles de ne pas va changer souvent. Si elles changent, vous pouvez enregistrer la valeur par défaut dans le fichier de propriétés et ajouter une méthode « setPropertyName () » qui vous permet de remplacer la valeur par défaut lors de l'exécution.

Le logiciel devrait pardonner des erreurs de l'utilisateur, et complètement intolérant des erreurs de programmeur.

Signification, le logiciel doit être très robuste et permettre une récupération en douceur pour des choses comme les erreurs de saisie de l'utilisateur et les erreurs de configuration du système. Au moins un message d'erreur convivial indiquant où l'erreur (zone d'entrée, le fichier de configuration, l'argument de ligne de commande, etc ...) et quelle contrainte a été violée ( « doit être inférieur à X caractères », « options valides sont [X , Y, Z] », etc ...) Pour la robustesse supplémentaire, le logiciel peut proposer une alternative, ou utiliser un défaut raisonnable (mais il doit toujours indiquer qu'il n'utilise pas exactement ce que l'utilisateur spécifié).

Je ne peux pas penser à beaucoup de situations où une nouvelle tentative automatique avec différents paramètres par défaut est justifiée, mais il y a certains (auto Retrying pour établir un lien de communication semble raisonnable). Je suis d'accord avec @William que ce niveau de « licenciement » est une décision buisness.

Par contre, il ne devrait pas la robustesse d'exécution contre l'erreur programmeur. S'il y a des conditions préalables pour les paramètres d'une fonction, ils doivent être vérifiés avec affirme, pas des contrôles d'exécution. Il est une énorme bête noire de la mienne pour voir errror redondante la vérification et des rapports sur le même paramètre trois ou quatre niveaux dans la pile d'appel: 

 int A(int x)
 {
   if (x==0) return -1
   ...
 }
 int B(int x)
 {
   if (x==0) return -1
   err = A(x)
   if (err) return err;
   ...
 }
 // and so on and so on....

Ceci est juste la complexité inutile supplémentaire. Vous ne devriez pas passer le moment de déterminer comment une fonction doit gérer une erreur introduite en abusant de l'autre. Si tel est le type de « robustesse » dont vous parlez - vous n'avez pas besoin. Remplacez-le par et affirme les tests d'intégration approfondie.

Il est une chose des exigences.

Y at-il une exigence de robustesse?

« Lorsque le lien de communication échoue, les paquets erronés sont mis au rebut » « Quand le lien reprend son fonctionnement, aucune transaction est traitée deux fois »

il devrait y avoir des cas d'utilisation pour la récupération d'erreur (sinon comment savez-vous comment il va se passer?)

Laissant aux programmeurs d'inventer la robustesse qu'ils vont (si nécessaire) les résultats dans les systèmes « magiques ».

Tous les systèmes magiques deviennent magiques merdique au fil du temps. correction d'erreur dans le fond des peaux l'apparition de défauts, de sorte que les défauts ne sont pas corrigés, de sorte que le système finira par se dégrader à un état de plus grande entropie; et courir comme de la merde, car il corrige les erreurs tout le temps. Vous devez avoir une limite pour arrêter le système entrer dans un état dégradé de façon permanente.

Certaines opérations justifie probablement une approche « d'essayer de nouveau », surtout si elles dépendent des ressources externes comme une base de données. Par exemple, si une base de données ne peut pas être connecté ou une requête échoue, l'opération peut être rejugé un certain nombre de fois avant d'abandonner et de jeter une erreur à un niveau supérieur. Cependant, dans une certaine logique, en essayant la même chose plusieurs fois est souvent un symptôme de mauvais code et la pensée magique qui cache des problèmes réels.

Licencié sous: CC-BY-SA avec attribution
scroll top