It is a fundamental book about Software Design in statically typed functional languages, such as Haskell, F#, OCaml, PureScript, Elm, Scala. The main idea of this book is to provide a comprehensive source of knowledge, and a complete methodology for building real-world applications with functional ideas and patterns.

• Info page about both editions
• Functional Design and Architecture (First Edition, self-published)
• Functional Design and Architecture (Second Edition with Manning Publications)

• Functional architectures
• Functional design patterns and functional idioms
• Accidental and essential complexity of FP programs
• Design principles (SOLID, Low coupling / High cohesion; KISS etc.)
• Architecture modeling, requirements analysis, subsystems design from FP point of view
• Embedded and external DSLs in domain modeling (as a part of Domain-Driven Design)
• Monads as subsystems with effects
• Free monads as functional interfaces
• Other types of functional interfaces
• Inversion of Control in FP (using Free monadic eDSLs)
• Applicability of mainstream techniques and approaches such as UML
• Interaction with impure subsystems
• Command-line applications and backend applications
• Type-level programming
• Various testing approaches including property-based, functional, unit, integration etc.
• Approaches to build functional real-world concurrent application frameworks

This article introduces Functional Declarative Design (FDD), a counterpart to Object-Oriented Design (OOD).

Functional Declarative Design: A Comprehensive Methodology for Statically-Typed Functional Programming Languages

This is a showcase project demonstrating an approach to white-box testing. I've developed this approach for Juspay. It has its place in the Presto.Backend and EulerHS frameworks. The approach can be used for regression testing and not only.

The idea is that Free monadic scenarios can be recorded into a JSON file (recording) which can then be replayed against a new version of the code. Recordings represent a full footprint of a scenario and thus replaying it will immediately spot changes and bugs.

Automatic White-Box Testing Showcase

This is the first project created specially for the book. It demonstrates the ideas from the book in a standalone application simulating a SCADA system for spaceships.

Andromeda SCADA-like system

N.B. The project is quite outdated. Haskell has changed a lot since then. I'm working on its resurrection currently.

The Hydra project is the second project created for the book. It's an application framework for building multithreaded and concurrent applications in Haskell using the approaches and patterns from the book. The project has three different engines: Final Tagless, Free Monad, and Church Encoded Free Monad, - and you can see the differences between these approaches by checking the different implementations of the same application.

This is a modern, full-fledged Free monad-based Haskell framework for building web backends and console applications built by my team. EulerHS is an "older brother" of the Hydra framework and also is based on my ideas from the book. EulerHS is a default option for all the new projects at the financial company Juspay (Bangalore, India).

EulerHS

Before EulerHS, we have created two other Free monadic frameworks:

• Juspay's PureScript Presto
• Juspay's PureScript Presto.Backend

The Presto.Core framework is used for building mobile apps. It was the first Free monadic framework I designed for Juspay using my ideas (with the participation of other people).

Presto.Backend is intended for building web backends. It derives the design of components directly from Presto.Core. Presto.Backend was by my teammates, not me; although I've designed a recording-replying mechanism for white-box testing and improved the framework in various places.

Another project I was working on with some other great Indian developers was about distributed persistable resumable and typed workflows, in PureScript, Node.JS, and RabbitMQ. This project is not published yet, but it is also based on the Free Monad architecture. Persistency of workflows and the ability to pause them at any time is achieved due to special interpreters utilizing the RecorderT transformer.

The Node is the most advanced production code in Haskell based on the ideas of this book.

The Node Framework makes the building of distributed applications simple. It allows handling concurrent state (with STM), working with the KV database, host TCP, UDP, and JSON-RPC servers, writing network clients, interactive CLIs, and more. The code of the nodes will be testable, safe, and well-maintainable.

This framework can be a reasonable replacement for Cloud Haskell. I've written a detailed post about framework usage and architecture:

Building network actors with Node Framework

References List