La taille de vos solutions d'affaires logiciels. En tant que développeur, vous devriez toujours être conscient des effets que la taille et la complexité sur le développement et ce qu'il traduit. Dans les articles passés (voir fin de l'article pour les liens), j'ai regardé les signes d'alerte précoce de l'abus de design pattern, comment mieux choisir des modèles de conception qui en forme et des moyens d'améliorer votre conception de logiciels en gardant les choses simples. Dans cet article, j'explore pourquoi vous devriez penser à ce que, consciemment prestations que vous avez le code et fournir solide pour lesquelles vous devriez produire de plus petits code.
- Petits logiciel est facile à maintenir
Programmes plus modestes sont plus faciles à maintenir sur de longues périodes de temps. Pourquoi? Ils sont souvent plus faciles à comprendre et plus rapides pour les nouveaux développeurs pour ramasser et à comprendre (il ya moins de comprendre). Coding Horror a une métaphore intéressante à cet effet; TL; DR (trop long; n'a pas lu) syndrome (Ceci est particulièrement vrai quand il s'agit de la lecture et de compréhension). Le plus grand et plus quelque chose de complexe est le plus rapide vos interrupteurs cerveau dans le TL; DR syndrome. Une fois là, il est beaucoup plus difficile à inverser l'effet. Pensez à combien de fois vous êtes allé à lire quelque chose que de passer sous silence parce qu'elle était trop long pour prendre rapidement po ou lorsque vous avez tenté d'apprendre ou d'essayer quelque chose de nouveau mais a renoncé à Avant de vraiment commencer. En tant qu'êtres humains, nous voulons apprendre quelque chose, quelque chose de comprendre, de comprendre quelque chose, concrétiser les avantages de quelque chose ... .. rapidement. L'effort initial plus vous avez besoin de quelqu'un pour investir afin de comprendre votre programme le plus ils sont susceptibles de tomber dans la TL; DR syndrome de moins qu'il ya une raison convaincante pour ne rien faire. Comme la plupart des choses, il faut qu'il y ait une sorte de récompense pour leur temps et d'efforts. Conseil: Faites très attention à des hiérarchies d'héritage et de conserver vos relations aussi simple que possible. Hiérarchies d'héritage nombreuse ont tendance à exploser le nombre de classes. - Petits logiciels pose moins de risques
Petits programmes procéder intrinsèquement moins de risques. Les petits projets sont souvent:
- Plus facile à comprendre
- Plus facile à définir
- Plus facile à expliquer
- Plus facile à entretenir
- Plus facile à prédire (la prévisibilité est une grande partie des logiciels de risque)
- Porte le moins inconnues
Vous ne voulez pas de code qui est si grand que vous devez éviter le refactoring, ou ne peut pas fouiller dans de peur de quelque chose de s'effondrer. Lorsque le code arrive à cette taille, soit il commence rapidement à mourir parce qu'il n'est plus gérable ou il perd rapidement de l'appui, le code est figé dans la peur de le casser.
Petits rendements des logiciels de meilleure qualité Coding Horror préconise la relation entre les lignes de code et des bugs est totalement linéaire mais je ne sais pas si cette relation est nécessairement vrai. Certains code en raison de sa complexité algorithmique (Think Big notation O) [http://www.cs.wisc.edu/ ~ hasti/cs367-common/notes/COMPLEXITY.html] est certainement plus susceptible d'engager les bugs que moins de code complexe.
Toutefois, en règle générale, je pense qu'il serait sûr d'en déduire que moins il ya de lignes de code moins il ya de bugs. Ou avec chaque ligne de code supplémentaire, vous augmentez vos chances d'introduire des bugs.
Petits logiciels apporte des bénéfices de performance Bien qu'il ne dépend exactement de ce que votre logiciel est fait et comment informatiquement coûteuses les opérations sont, en règle générale, plus petit est plus rapide. Les moins de lignes de code requis pour exécuter une tâche, plus vite elle s'exécute. Cela est particulièrement vrai pour les petites tâches qui se répètent encore et encore. Logiquement, les économies que vous pouvez apporter sont également économisé plus encore et encore.
Petits logiciel est facile à tester Plus votre logiciel est (par rapport aux classes et fonctions), plus il est facile de tester, pour la simple raison qu'il ya moins de code qui doit être testé. L'importance de ceci est que votre couverture de test est susceptible d'être beaucoup plus élevé que si vous logiciel était assez grande nécessitant beaucoup plus de code de test.
En résumé, les petits éditeurs de logiciels est ...
Gardez votre petit logiciel, restez simple. Cela permettra de rendre votre code plus facile à comprendre et plus facile à tester (car il ya moins de lui). Vous allez vous retrouver avec un produit qui a moins de défauts, les rendements plus grande qualité et des performances améliorées en évitant les ballonnements ou de compliquer exagérément les choses qui doivent pas l'être.
