À grande échelle de conception en Haskell?

Je parle un peu à ce sujet dans L'ingénierie de Grands Projets en Haskell et dans le La conception et la mise en Œuvre de XMonad. d'Ingénierie dans le grand est à propos de la gestion de la complexité. Le code principal de la structuration des mécanismes en Haskell pour la gestion de la complexité sont:

Le système de type

• Utiliser le type de système pour appliquer les abstractions, de simplifier les interactions.
• Appliquer les principaux invariants par types
  • (par exemple, que certaines valeurs ne peuvent pas s'échapper un peu de marge)
  • Que certains de code n'a pas d'IO, ne pas toucher le disque
• Faire respecter la sécurité: vérification des exceptions (Peut-être), Et d'éviter de mélanger les concepts (Word, Int, Adresse)
• De bonnes structures de données (comme les fermetures éclair) peut rendre certaines classes de tests inutiles, comme ils l'exclure par exemple, en dehors des limites des erreurs de manière statique.

Le profiler

• Fournir la preuve objective de votre programme de tas et des profils de temps.
• Tas de profilage, en particulier, est la meilleure façon de s'assurer qu'aucun inutile l'utilisation de la mémoire.

Pureté

• De réduire la complexité de façon spectaculaire par la suppression de l'état. Purement fonctionnelle code échelles, car il est de composition. Tous vous avez besoin est le type de déterminer comment l'utiliser un peu de code -- il ne sera pas mystérieusement pause lorsque vous modifiez une autre partie du programme.
• Utiliser beaucoup de "modèle/vue/contrôleur" style de programmation: analyser des données externes comme dès que possible, en purement fonctionnelle des structures de données, opèrent sur ces structures, puis une fois que tout le travail est fait, le rendu de rinçage//sérialiser l'extérieur. Garde la plus grande partie de votre code pur

Tests

• QuickCheck + Haskell de Couverture de Code, afin de vous assurer de tester les choses que vous ne pouvez pas vérifier avec les types.
• GHC + RTS est super de voir si vous passez trop de temps à faire des GC.
• QuickCheck peut également vous aider à identifier propre, orthogonale Api de vos modules. Si les propriétés de votre code sont difficiles à état, ils sont probablement trop complexe. Garder le refactoring, jusqu'à ce que vous avez un ensemble de propriétés qui peuvent tester votre code, que bien composer. Ensuite, le code est probablement bien conçu, de trop.

Monades pour la Structuration de

• Monades touche de capture des concepts d'architecture types (ce code d'accès matériel, ce code est d'une seule session de l'utilisateur, etc.)
• E. g. le X monade dans xmonad, capture avec précision le modèle de conception de ce que l'état est visible à ce que les composants du système.

Type de classes et existentielle types

• Le type d'utilisation des classes pour fournir une abstraction: masquer les implémentations derrière polymorphes interfaces.

Concurrence et parallélisme

• Se faufiler par dans votre programme de battre la concurrence avec facile, composable parallélisme.

Refactoriser

• Vous pouvez restructurer en Haskell beaucoup. Les types d'assurer votre des changements à grande échelle sera en sécurité, si vous êtes à l'aide de types à bon escient. Cela aidera votre code de base à l'échelle. Assurez-vous que votre refactorings va provoquer des erreurs de type jusqu'à la fin.

Utiliser les FFI à bon escient

• Les FFI le rend plus facile à jouer avec un code étranger, mais que les étrangers code peut être dangereux.
• Être très prudent dans les hypothèses sur la forme des données retournées.

Méta-programmation

• Un peu de Modèle Haskell ou génériques peuvent retirer standard.

De l'emballage et de la distribution

• Utilisation De La Cabale. Ne pas rouler votre propre système de construction. (EDIT: en Fait, vous voudrez probablement utiliser Pile maintenant pour commencer.).
• Utilisation Haddock pour la bonne API docs
• Des outils comme graphmod pouvez montrer votre module de structures.
• S'appuient sur la Plateforme Haskell versions de bibliothèques et d'outils, si possible. C'est une base stable. (EDIT: Encore une fois, ces jours, il est probable que vous souhaitez utiliser Pile pour obtenir une base stable et en cours d'exécution.)

Avertissements

• Utilisation -Wall pour garder votre code propre des odeurs. Vous pouvez également regarder Agda, Isabelle ou de Capture pour plus d'assurance. Les peluches-comme la vérification, voir la grande hlint, qui proposera des améliorations.

Avec tous ces outils, vous pouvez garder une poignée sur la complexité, la suppression plus grand nombre d'interactions entre les composants que possible. Idéalement, vous avez une très grosse base de code pur, qui est très facile à entretenir, car il est de composition. Ce n'est pas toujours possible, mais il vaut la peine de viser.

En général: décomposer les unités logiques de votre système dans le plus petit referentially composants transparents possible, puis de les mettre en œuvre dans les modules. Global ou local environnements pour les ensembles de composants (ou à l'intérieur des composants) peuvent être mappés à des monades. Utilisation des types de données algébriques pour décrire les structures de données de base. Partager ces définitions largement.

De la conception de grands programmes en Haskell n'est pas différent de le faire dans d'autres langues.
Programmation dans le grand est de la rupture de votre problème en morceaux maniables, et la façon de les intégrer ensemble; la mise en œuvre de la langue est moins important.

Cela dit, dans une conception large, il est agréable d'essayer et de l'effet de levier le type de système pour vous assurer que vous ne pouvez l'adapter à votre morceaux ensemble dans une manière qui est correct. Cela peut impliquer newtype ou types fantômes à faire des choses qui semblent avoir le même type différent.

Quand il s'agit de refactoriser le code comme vous allez le long, la pureté est une aubaine, donc, essayez de garder autant de code que possible pur. Pur code est facile à refactoriser, parce qu'il n'a pas caché interaction avec d'autres parties de votre programme.

Je suis en train d'écrire un livre avec le titre "Design Fonctionnel et de l'Architecture". Il vous offre un ensemble complet de techniques comment construire une grande application à l'aide de la pure approche fonctionnelle. Il décrit de nombreux schémas fonctionnels et des idées, tandis que la construction d'un SCADA-comme l'application "Andromède" pour le contrôle de vaisseaux spatiaux à partir de zéro. Ma première langue est l'Haskell. Le livre couvre:

• Approches de l'architecture de la modélisation à l'aide de diagrammes;
• Analyse des besoins;
• Intégré DSL domaine de la modélisation;
• DSL externe de la conception et de la mise en œuvre;
• Monades que les sous-systèmes avec des effets;
• Gratuit monades comme d'interfaces fonctionnelles;
• Arrowised eDSLs;
• Inversion de Contrôle à l'aide d'Gratuit monadique eDSLs;
• Logiciel De La Mémoire Transactionnelle;
• Lentilles;
• État, Lecteur, Écrivain, RWS, ST monades;
• Impur état: IORef, MVar, STM;
• Le Multithreading et simultanées domaine de la modélisation;
• GUI;
• Applicabilité d'intégrer des techniques et des approches telles que UML, SOLIDE, SAISIR;
• Interaction avec impur sous-systèmes.

Vous pouvez vous familiariser avec le code de la livre ici, et la 'Andromède' projet de code.

J'attends de finir ce livre à la fin de 2017. En attendant, vous pouvez lire mon article "le Design et l'Architecture dans la Programmation Fonctionnelle" (Rus) ici.

Mise à JOUR

J'ai partagé mon book en ligne (5 premiers chapitres). Voir post sur Reddit

J'ai trouvé le papier "Logiciel d'Enseignement de l'Architecture à l'Aide de Haskell" (pdf) par Alejandro Serrano utile pour la réflexion sur la structure à grande échelle Haskell.