GET Design and architecture in FP. Introduction and Part 1 / Sudo Null IT News FREE

Introduction

In the world of operative programming, there is one boastfully col, that is to say, the topic of the high-level design of biggish applications is almost not covered. I distinct for myself to study this issue. Are at that place any monumental differences in applications programme conception in the FP worldwide from that in the imperative world? What is a orthodox FP code? What are the development idioms? Does it pee-pee sentiency to talk about design patterns when applied to FP ? These and other important issues are ofttimes erupt there , here , but for the moment I do not bed a single book, similar to the Gang of Four book. Someone has believably repeated my research, but all the ameliorate: similar results will confirm the correctness, others will indicate a place in the possibility that needs to glucinium improved.

More or less Bodily

The basis of these articles is feel in developing the game "The Amoeba Mankind". The speech used is Haskell. I to begin with made the stake as part of the Ludum Daring contest # 27, just the goal was to prototype the infrastructure for another game, a larger one, whose name is Big Space. "The Amoeba Worldly concern" is just a "cat", on which I research approaches in a "functional" game dev. Competitively-oriented game has become a intellectual unveiling pad for further sentiment.

The encode for "The Amoeba World" is here . The Big Space corroboration is here . By the fashio, a long time past I was already doing something similar. It was the "Haskell Quest Teacher", as part of which I, um, likewise formed the game. If you can call it that. But it was a very five-needled subordinate material for studying the Haskell language, but present we will talk about completely different matters. Accordingly, it is assumed that the reviewer is sufficiently acquainted with the FP and the Haskell programming language.

Programme

At least the following topics should live self-addressed foster:

1. Part 1 . FP application computer architecture. Downstream intention in FP. Fighting software complexness.
2. Part 2 . Upstream design in FP. Idea is the foundation of good purpose. Antipatterns in Haskell.
3. Part 3 . Properties and laws. Scenarios Inversion of Control in Haskell.
4. Part with 4. FRP

Also, this series of articles can atomic number 4 found as a single document hither .

Part peerless

FP application architecture. Downstream design in FP. Fighting software complexity.

Bit of theory

The package development process is well-established along and across. We have been using similar techniques in our practice for a mindful clock - these are various methodologies, and software blueprint techniques, and modeling tools. For example, UML is very famous - an object-oriented (largely) design language. It is used for lengthwise growth, start with requirements and ending, if you're lucky, with code generation. What about design patterns? Now it is required to know them ready to solve typical problems in the OO computer code. And on that point is only one question - how practical is this body of noesis to the functional image? Can I come up with my own modeling language? Are patterns necessary for functional languages?

IT seems that the initial stages are the ingathering and analysis of requirements, determining the functionality of the program, writing business scenarios, will always be present in one way or another, disregarding what software is discussed. Imagine that we already know the requirements, and bound off the first stairs for nowadays, focusing on more engineering ones.

And the first truly engineering phase is the evolution of software package computer architecture, operating room, equivalently, the architectural design of software. Here we work out the issues of the high-floor structure and functioning of the program in order to financial backing all the non-practical requirements collected sooner. Choosing a programming image is also an field issue. Choosing an FP, we almost completely abandon UML in view of its object nature. So, diagrams of classes, objects and sequences practically lose their meaning. On that point are zero classes or objects in Haskell, no encapsulated mutability, but only a information transformation process. The sequence diagram needed to describe the interactions of these Lapp objects could somehow live used for irons of functions, merely the thing is that the chains themselves will atomic number 4 more readable and understandable. All other diagrams, however, quite relevant. In a large program on the FP, there are also subsystems or components, which means that the diagrams of components, packages, and communications remain in order. The state diagram is universal: processes and say machines are very common. It could equal applied symmetric in other areas, not lone in software program maturation. Finally, the use type diagram has runty to coiffure with software system excogitation; It links business requirements to system requirements during the analysis phase. the use case diagram has little to do with package design; It links business requirements to system requirements during the analysis phase angle. the use pillow slip diagram has little to do with software excogitation; It golf links business requirements to system requirements during the analysis phase.

But if you look tight at the "applicable" diagrams, you can resuscitate the conclusion that they will not help much in the superior design of the code (which is located below the architecture design), or even they can serve harm, prompt imperative thinking. For object lesson, thinking some component architecture, we recall Inversion of Ascendency . IoC solves one of the main problems of software system development - it helps to deal with complexity by highlighting abstractions. But what if you take it into service? And here we callback that in that respect is incomparable way to implement information technology - Dependency Injection. It can probably be adapted to our needs - in the following parts we bequeath search at several different solutions, such as: Empiric Types, module-level abstractions, monadic abstract, and monadic state injectant. Just in fact, having start-class functions, we dismiss wholly forget about DI, since this is a non-expression overture , since it leads (explicitly Oregon implicitly) to a put forward in the FP program. And this is non always good. Although, in fair-mindedness, I must admit that IoC is also present in FI.

And what else, if non IoC, helps in the fight against software pattern complexity? From SICP, we make out that there are three important techniques:

1. abstractions for hiding effectuation inside information ("black box");
2. public interfaces of interaction between independent systems;
3. domain-specific languages ​​(DSL, Domain Specific Languages ).

We can usurp that the first two methods are known to U.S.. Interfaces, abstraction, concealing details are altogether about unity thing, and IoC is an example. Due to the dominance of OOP languages, we have developed weapons-grade associative dealings "abstraction" => "inheritance" and "interface" => "OOP interface". As a matter of fact, this is single part of the Truth. We overly narrow the terms "interface" and "abstraction" to OOP concepts and thereby cut forth "inappropriate" paradigms. However, the ideas underlying the first two methods are more general, they are valid for all worlds, and knowledge of other approaches can in no way personify superfluous.

Regarding the tertiary proficiency, the following behind be said. In view of its nature, FY have the power to write all sorts of subject-orienting languages ​​- internal, outward. Firstly, because the binding encrypt for parsers and translators turns retired to represent short, understandable, and easily modifiable. Secondly, the syntax of FP languages ​​allows you to create integrated DSL without overloading the main code. Field-oriented languages ​​can drastically reduce course of study complexness and trim back errors. A side (operating theater maybe the main) effect of the DSL implementation is a clearer understanding of the subject area. Encode in a depicted object-orienting speech is a great deal better suited to formalizing requirements than adjunct approaches.

However, it should be acknowledged: specialized languages ​​are greatly underestimated in real life. On that point is a myth that it is difficult, difficult and expensive to support. Its reason is that an imperative programmer needs to escape of his comfort zone and imagine a different syntax, semantics, and maybe even a different paradigm to make over an external Digital subscriber line. Without knowing this, he will embody able to come up with DSL only within his own framework, which will mechanically lead him to the current code, and then to the oppugn "Why then DSL?". But that is not all. How to implement DSL? Dominant OOP languages ​​(with rare exceptions) do non offer an elegant solution compared to practical ones; Indeed, profound efforts are required in the traditional approach to outwardDSL did not growth risks. To murder risks, you need to study other paradigms and pull astir the theory; as a result, the complexity of implementing an external Digital subscriber line in a familiar language carries over to the very musical theme of ​​DSL. For some reason, this wrongdoing is considered a strong statement against ... And it is well broken aside the fact that additionally to the external DSL, there are also inner ones (built-in, embedded DSL, eDSL). For an external DSL, inexpressible with the grammar of the current language, at least a parser and a transcriber are needed, which leads to an additional serving code. But inwardDSL is within the grammar of the current language, which way that No parsers operating theatre translators are needed. However, you still indigence to rally with a different code brass; and again we came to the finis that we cannot Doctor of Osteopathy without a broad programming horizons. And this is a natural requirement for a modern software engineer. Well, Martin Fowler to help us.

What else can make up said about computer architecture equally applied to FP? An important point is that in AF pull effects are undesirable. But in any hulky program it is necessary to bring with the external worldly concern; that is, there should be some mechanisms to control lateral effects. And they are. The notorious Haskell monads are a great alternative, but IT's more of a lower purpose tool than an element of the overall architecture. So, the code for communicating with an external server can be implemented as part of the IO monas, which bequeath not disagree a lot from mood. The second solution - the code can be declared on DSL. In such a DSL in that respect are bricks with sidelong effects, in that location are bricks with pure behavior, just all of them are just a declaration, therefore, all code will make up clean and little erroneous belief prone. Probably, it wish equal understandable, flexible, combinable and manageable, in point of fact - a builder. The execution of this code can cost assigned to a state automobile working on a thin layer of a monadic IO cypher. And delight, we got a very good field of study solution, thanks to which we too reduced the complexity of formalizing our business processes.

To combat side effects, in that respect is another architectural solution best-known As reactive programming . When practical to functional languages, it's worth talking about FRP, that is, about Utility Oxidizable Programming. This concept is numerical, so it fits fortunate on FP. The essence of FRP is to propagate changes across the information model. Each element of such a model is a esteem that depends on other values ​​using the necessary formulas. Thus, a "reactive manikin" is a tree where folio values ​​can change in time, exciting a wave by recounting higher values. Sources of values ​​can be some functions, including those with sidelong effects. The manakin code testament be asserting and composable.

In general, in functional computer programming, the code written incombinatorial style as a constructor. The idea is simple: an arbitrarily large, self-relevant system is successful up of lilliputian bricks of the same type. The better the builder is fashioned, the more powerful and expressive the code. Usually combinatorial code is also some eDSL, which significantly reduces the complexity of development. Many Haskell libraries use this principle, for example: Parsec, Netwire, HaXml, Lenses ... The idea of ​​monadic parser combinators was so successful that Parsec became famous outside of Haskell. Its ports exist in F #, Erlang, Java, and another languages. It is snoopy that Parsec implements Eastern Samoa more as three ideas: combinators, DSL and monads, and every last this is organically connected in a single coherent API.

Now IT's impressible to single extinct another selfsame powerful technique for dealing with complexness (author's name):

4. Domain-specific combinators.

DSC is an eDSL whose elements are combinators. The most convenient DSCs are obtained in functional languages ​​imputable the syntax (functions are the combinators of transformations), but this is possible in ordinary languages. Course, designing a DSC is even more difficult than a simpleton DSL, which is why this approach is in all likelihood completely unknown in the mainstream.

A trifle of practice

Road from abstract thinking to practice, we turn to the project of the big game "Big Space". In short, this is a realistic blank 3D-flyer of real proportions with amply programmable game elements and, probably, with the possibility of clip travel. Curious citizenry can seem into the design document and other coreferent materials for a more than detailed acquaintance, but this description is enough for us to think over the general computer architecture of the game. Simply first, a small digression.

The beginning of some stick out lies in the thought, which, having been born, requires development and reflection. In the case of "Big Space" the important assistants in this were memory cards, which perfectly allow you to see and structure the cornerstones of a future game. Starting with generalized concepts (much As "Concept", "Space", "Motive", "Exploring the Galaxy"), you can go push down deeper until we get circumstantial elements of the game. Memory card game also help to see and weed out contradictions and inconsistencies.

Immense Space: Millimeter-01 'Concept'

Can memory cards be thoughtful an secondary to use cases? Here is an articlewhose writer raises the same question. IT follows that memory card game are a to a greater extent comprehensive tool, as they can easy contain function cases. Memory cards solution the dubiousness "what is in general, and what solutions particularly", and use cases answer the question "what is allowed to be done to solve the problem." The last mentioned is uttered in the fact that each economic consumption case is usually associated with a short story (user story), in which high changes in the system are delineated in stairs. And several of these options will be levers for which you need to pull the user so that the system takes the necessary state. We can conclude that retentiveness cards and use cases are related in the same direction as declarative (in the Prolog manner) and imperative programming are enatic. In the initial case, we describe what on the button do we want to get; in the second case, we draw how we want to accomplish this. That is, memory card game are more suitable for functional scheduling, since declaratory decisions are pleased in FI.

Replacing the use case plot in the first step put up buy the farm further. Concept cards - relatives of memory cards - are well suited for displaying requirements for rough architecture. This is achieved through three stages (copyright).

1. Map of need. Contains as man-sized blocks as possible. Links are optional, blocks are placed on the open. The map shows what the gage is supported. When designing, you penury to consider the most general requirements; for illustration, for requirements such as "vast pragmatic space", "3D graphics", "cross-political program", Cloud Computing, OpenGL and SDL blocks will be present. If you need a third-party game engine, you need to designate information technology here.
2. Map items. In the disentangled sort, we unfold the late plot without worrying nigh the structure. The next blocks are elements: "subsystem", "conception", "information", "library", "object of the field of study". The golf links show the most canonical idea of ​​how the system of rules works. You can designate the nature of the relationship, for example: "uses", "implements" and others. Blocks are divided into layers. The chart should take into score most of the conceptual requirements. It's okay if several levels of abstractedness are mixed, competing options appear, surgery something doesn't look the best. The plot only outlines the landing field of activity and offers realizable solutions, but it is not the final computer architecture of the program.
3. Subsystem map. In this diagram, specific architectural decisions are made from those proposed in the second stage. Information is structured and placed in such a fashio as to separate application layers. Libraries and implementation approaches are indicated. The plot will non describe a amply high-altitude design, but it will read important dependencies between the subsystems and help to separate them into layers.

Spacious Space: CM-01 Necessity Correspondenc

Big Space: Curium-02 Elements Map

Enceinte Space: CM-03 Subsystems Correspondenc

The last diagram shows that the game has tierce layers: Views, Game Logic, Application ( Mike McShaffry, Pun Coding Complete ). The Views and Game Logic layers are isolated from the main code by their personal bidding interpreters and eDSL facades. IT is assumed that whol game logic, with the exception of the game state, will be implemented outside the Io monad. The stake state, although it applies to game logic, is separate, since it requires shared access from views and from the applications programme side (for network communication, for oscillating information consignment, for GPGPU and cloud computing). The plot shows that the concept of Software system Transactional Memory will be used to exploit with the state of the gage.; libraries Netwire, SDL, Cloud Haskell and others are also indicated. Almost entirely game system of logic, by design, should be implemented victimization several internal and external languages. Naturally, the proposed architecture is one in a thousand, and the diagram says nothing about the lower level of design; research and prototypes are needed to find bottlenecks or miscalculations. But overall, the computer architecture looks slim and neat.

After the diagram of subsystems, you can carry on to the next stage of design. Having cognition of architecture, you can establish two models: a information model and a type model, and paint the interfaces of all public modules. Finally, the final step will be to implement these interfaces and drop a line internal libraries. Merely these final stages are already a low-level design and implementation. Partly we volition believe them in the following chapters.

Conclusion

The approach conferred therein article is downward, that is, directed from the most general to the almost particular. We saw that UML is sapless applied to FP. Consequently, we designed the top-level architecture, inventing our own diagrams and building our possess methodology. We also learned about the methods of dealing with complexness, which we will definitely need in the design of subsystems.

DOWNLOAD HERE

GET Design and architecture in FP. Introduction and Part 1 / Sudo Null IT News FREE

Posted by: whitneymusby2000.blogspot.com

Share this post