This action might not be possible to undo. Are you sure you want to continue?
1. The Multi‐phase architectural style consists of processing elements and data elements
that are exchanged between processing elements. For example, the multi‐phase style for a compiler includes:
Processing elements: lexer, parser, semantor, optimizer, code generator Data elements: characters, tokens, phrases, correlated phrases, annotated
phrases, object code.
2. If the multi‐phase architectural style is organized sequentially, it also uses the following
connecting elements: • 3. Connecting elements: procedure calls and parameters. The form of an architectural style is expressed by weighted properties and relationships
among its architectural elements. Architectural styles & Patterns 4. Architectural styles only describe the overall structural frame works for applications.
Patterns for software architecture, however, exist in various ranges of scale, beginning with patterns for defining the basic structure of an application and ending with patterns that describe how to implement a particular design issue in a given programming language. 5. Architectural styles are independent of each other, but a pattern depends on the
smaller patterns it contains, on the patterns with which it interacts, and on the larger patterns in which it is contained. 6. 7. Patterns are more problem‐oriented than architectural styles. Architectural styles express design techniques form a viewpoint that is independent of
an actual design situation.
8. data abstraction. all from the viewpoint of the context in which the problem arises. A pattern expresses a very specific recurring design problem and presents a solution to it. whereas cohesion is defined by how the elements making up a module are related. Completeness and Primitiveness Separation of Policy and Implementation Separation of Interface and Implementation Single point of Reference Divide‐and‐Conquer Abstraction Abstraction is "the process of forgetting information so that things that are different can be treated as if they were the same. and control (iteration) abstraction. • Coupling and cohesion Coupling is defined as the strength of the relationships between modules. Abstraction by specification leads to three major kinds of abstraction: procedural abstraction." [Lis01] In the context of software design. • Decomposition and modularization . two key abstraction mechanisms are parameterization and specification. Construction of software is based on several fundamental principles: Enabling techniques: • • • • • • • • • • • • Abstraction Encapsulation Information Hiding Modularization Separation of concerns Coupling and Cohesion Sufficiency.
though.Decomposing and modularizing large software into a number of smaller independent ones. separate from the details of how the component is realized. known to the clients. • Encapsulation/information hiding Encapsulation/information hiding means grouping and packaging the elements and internal details of an abstraction and making those details inaccessible. and primitiveness means ensuring that a software component captures all the important characteristics of an abstraction. completeness and primitiveness Achieving sufficiency. • The similarity of these architectures is apparent in the diagrams used for systems of the respective classes. and nothing more. completeness. the most familiar example of this genre is probably the Unix pipe‐and‐filter system. However. Some variants of Data flow systems and Repositories Variants of Dataflow systems: • The dataflow architecture that repeatedly occurs in the evolution of shared information systems is the batch sequential pattern. Both decompose a task into a fixed sequence of computations. • They interact only through the data passed from one to another and share no other information. the input or output contains one complete instance of the result in some standard order. as indicated in figure. There are differences. • They assume that the components read and write the data as a whole – that is. • Sufficiency. • Separation of interface and implementation Separating interface and implementation involves defining a component by specifying a public interface. usually with the goal of placing different functionalities or responsibilities in different components. .
and the granularity is that of a database transaction. beginning to compute as soon as they consume a few input tokens Able to start producing output right away (processing is localized in the input stream) Able to provide feedback (though most shells can’t express it) Often interactive Variants of Repositories: • Repositories in general are characterized by a central shared data store couple tightly to a number of independent computations. • The independent computations interact only through the shared data. • In a database system the control is driven by the types of transactions in the input stream. and in the granularity of the operations. . in the apparatus that controls the order in which the computations are invoked. and they do not retain any significant amount of private state. pipe‐and‐filter systems are characterized as follows: • • • • Fine‐grained.Batch sequential systems have the following characteristics: o o o o Very coarse‐grained Unable to provide feedback in real time Unable to exploit concurrency Unlikely to proceed at an interactive pace On the other hand. each with its own expertise. • The variations differ chiefly in the apparatus that controls the order in which the computations are invoked. the access mechanism is usually supported by a specialized programming language. in the access mechanism that allow the computations access to the data.
or direct access • The follow wing figure s shows a repo ository that supports ind dependent t tools. . Contro ol may be determin ned by the d direct reques sts of users. or it may in n some case es be handle ed by an n event mech hanism also shared by th he tools. . and the gra anularity is that of a single pass of a com mpiler representation. Here contr rol is fixed. th he access mechanism may be full conversion of the shared data structure into a in‐memor m n an ry s.• The follow wing figure shows a progra amming langu uage compiler.
driven by the current state of the data o f on the b blackboard. • Here the independent computa ations are v various know wledge sour rces that ca an contr ribute to solv ving the pro oblem. • One prom minent repo ository has not appear red here. it is mention t ned now fo or A variety of access m methods are available. • set. The g granularity is quite e fine. • Control is completely opportunis s y stic. The abstrac model for access is direct visibilit as with many huma ct r ty. T This is the blackboar e rd architectures freq quently used d for signal‐processing a applications in artificial intelligence. . an nd the granu ularity is tha at of the too ol‐ comp pleteness‐to extend th comparison of rep he positories. • The black board is highly structu k ured represe entation esp pecially desi igned for th he repre esentations p pertinent to the applicat tion. at the level of inte erpreting a s signal segme ent as a phon neme. an experts watching each othe solve a problem at a real blackb g er a board.
Resolution of ambiguous input is a key problem. Form filling: Based on entry (usually text entry) of values for a given set of variables. The design space uses a classification proposed by Shneiderman [Shn86]: • • • • • Menu selection: Based on repeated selection from groups of alternatives. Natural language: Based on (a subset of) a human language such as English.). but each of the other classes has unique requirements. symbolic language.Basic Interactive Behavior for user‐interactive architecture: Basic interface class identifies the basic kind of interaction supported by the user‐interface system. It turns out that menu selection and form filling can be supported by similar system structures. at each step the alternatives are (or can be) displayed.( A general‐purpose system might support more than one of these classes. . Command language: Based on an artificial. Direct manipulation: Based on direct graphical representation and incremental manipulation of the program’s data. often allows extension through procedure definitions that resemble a programming language.