ARCHITECTURAL DESIGN.6

Disadvantages of layered architecture

completely separating each layer can be difficult to do in real life and sometimes higher levels have to interact directly with lower layers can be slower because of interpretation of different requests has to pass through each layer

Advantages of repository architecture

components are decoupled - don't have to know the existence of one another data easily manageable since it's all in one place changes to one component easily propagate to the others

Bungalows changed architecture forever because they were

cost effective more practical new technology moved across the country

circles and ovals

create a feeling of completeness

vertical lines

create height by using strength and alertness

squares and rectangles

creates a feeling of mathematic precision

When do we use client-server architecture?

data in shared database has to be accessed from a range of location may also be used when the load on a system is variable since servers can be replicated

When do we use pipe and filter architecture?

data processing applications where inputs processed in separate stages to generate related outputs

Stamp coupling

data structure passed as a parameter, but called module operates on only some of the individual components

View (in MVC pattern)

defines and manages how data is presented to user renders model requests model updates sends user events to controller

coupling

degree of interaction between two modules

Cohesion

degree of interaction within a module

Advantages to client-server architecture?

dependability - servers can be distributed across network general functionality can be available to all clients and does not need to be implemented by all services

Client-server architecture

distributed system model to show how data and processing is distributed across range of components set of stand-alone databases with their own services and the clients call on these services network allows clients to access servers

Pipe and filter architecture

each processing component (filter) is discrete and carries out one type of data transformation and the data flows (as in a pipe) from one component to another for processing

Disadvantages to client-server architecture

each server can be independently attacked and an additional point of failure management issues if different servers owned by different people performance is less dependable since it depends on the system and the network

Advantages to pipe and filter architecture?

easy to understand supports transformation reuse workflow style matches structure of many business processes evolution by adding transformations is straightforward can be implemented as either sequential or concurrent system

horizontal lines

emphasize width by expanding the perception of space

LINE

encloses space and provides the outer line or contour of forms they can produce a sense of movement or produce a greater sense of length or height gives a sense of stability

Data coupling

every argument is either simple argument or a data structure in which all elements are used by the called module

split level

follows uneven terrain stairs everywhere not as many big open spaces

Disadvantages of pipe and filter architecturre

format for data transfer must be agreed upon b/w communicating transformations each transformation must parse its input and unparse its output to the agreed form --> increased system overhead and may be impossible to reuse transformations w/ incompatible data structures

trends

general developments

LIGHT AND SHADOWS

gives a sense of depth

COLOR

hue, value, intensity bold colors advance <-> pale colors recede -><-

What is bad about logical cohesion?

interface is difficult to understand difficult to reuse code for more than one action may be intertwined

formal design

involves the complete preparation of a set of working drawings

Why is communicational cohesion bad?

less reusability

module

lexically contiguous sequence of program statements bounded by boundary elements and an aggregate identifier Examples: - Procedures, functions, objects, methods (low level) - Packages, subsystems (higher level)

BASIC ELEMENTS OF DESIGN

line form space color light and shadow texture and materials

FORM

lines joined together produce form and create space

What are the 4 architectural views?

logical view physical view development view process view

Why is data coupling good?

maintenance is easier good design has high cohesion and weak coupling

Model (in MVC pattern)

manages system data and associated operations on data encapsulates application state notifies view of state changes

Controller (in MVC pattern)

manages user interaction (i.e. key presses, mouse clicks, etc.) and passes interactions to View and Model maps user actions to model updates selects view

TEXTURE AND MATERIALS

materials: raw substances with which designers create with texture: surface finish of an object (roughness, smoothness)

eclectic design

mixed textures, time periods, styles, colors

temporal cohesion

module performs a series of actions related in time

Functional cohesion

module performs exactly one action

Coincidental cohesion

module performs multiple, unrelated functions

Informational cohesion

module performs number of actions, each with its own entry point, with independent code for each action, all performed on the same data structure

Procedural cohesion

module performs series of actions related by procedure on multiple data values

Communicational cohesion

module performs series of actions related by the procedure to be followed by product, but in addition all the actions operate on same data

Why is control coupling bad?

modules aren't independent (i.e. module b must know internal structure of module a) not as reusable

Why is functional cohesion good?

more resuable corrective maintenance is easier with fault isolation and reduced regression faults easier to extend product

one story house

no stairs 3rd most cost effective uses a lot of land (making it not super cost effective easy access simple roof

Why is stamp coupling bad?

not clear without reading entire module which fields of record are accessed or changed --> affects understandability unlikely to be reusable (other products have to use same higher level data structures) passes more data than necessary (i.e. uncontrolled data access can lead to computer crime)

What's bad about coincidental cohesion and how do we fix it?

not maintainable and module is not reusable can fix by breaking each task into a separate module

Content coupling

one module directly references contents of the other

Control coupling

one module passes an element of control to the other

basic house layouts

one story two story one and a half story split level

Examples of higher level modules

packages, subsystems

functionalism

quality of being useful (serving a purpose other than adding beauty or aesthetic value)

+1 (in 4+1 view model)

related use cases or scenarios

Disadvantages of repository architecture

repository does not allow distributed actions --> single point for failure that can affect all components in the system can be difficult to distribute repository on several computers may be slower/inefficient when organizing communication through repository

diagonal lines

restlessness or transition

Why is common coupling bad?

resulting code is unreadable b/c modules can have side-effects and must read entire module to understand difficult to reuse module exposed to more data than necessary

Model-View-Controller (MVC) pattern

separates presentation and interaction from the system data broken down into 3 components that interact with each other

repository architecture

share data held in central database or repository and may be accessed by all subsystems each sub-system maintains its own database and passes data explicitly to other sub-systems

Development view

shows how software is decomposed for development

Process view

shows how, at run-time, system is composed of interacting processes

Logical view

shows key abstractions in system as objects or object classes

Physical view

shows system hardware and how software components are distributed across the processors in the system

topography

shows the highs and lows of land

kitchen work triangle

sink, fridge, stove

curved lines

soft, graceful, flowing movements

architectural patterns

stylized description of good design practice, which has been tried and tested in different environments

SPACE

surrounds form and is contained within it

fads

temporary popular fashions

blue and green

these colors create quiet, formality, restfulness, and coolness.

red, yellow, and orange

these colors create warmth, informality, and cheer.

Common coupling

two modules have write access to the same global data

architectural design

understands how software system should be organized and what its structure should look like link between design and requirements

Layered architecture

used to model interfacing of sub systems organizes system into set of layers (or abstract machines) each of which provide set of services supports incremental dev of sub-systems in diff layers, when layer interface changes, only adjacent layers affected

informal design

when a product is made by the designer without the use of a plan

When to use repository architecture?

when large amounts of data to be shared and sub-systems must exchange data

When do we use the MVC pattern?

when there are multiple ways to view and interact with data also when future requirements for interaction and presentation of data are unknown

Levels of cohesion

1. Coincidental (worst) 2. Logical 3. Temporal 4. Procedural 5. Communicational 6. Informational 7. Functional (best)

working set order

1. site 2. elevation 3. floor plans 4. basement 5. foundation 6. framing 7. plumbing 8. electrical 9. schedules and notes

two story house

2nd cost effective more yard room stairs problems with height good for smaller lots

What is the solution for procedural cohesion?

Break it up

What are the five levels of coupling from best to worst?

Data (best) Stamp Control Common Content (Worst)

When do agile processes design system architecture and why?

Generally accepted that they design at the beginning because it's expensive to change it later

one and a half stories

MOST cost effective builds into the attic space not enough insulation so it gets hot fewer materials needer to build

Logical cohesion

One module performs multiple, related functions which is selected by a calling module

Examples of low level modules

Procedures, functions, objects, and methods

When do we use layered architecture?

When building new facilities on top of existing systems dev spread across several teams each of which is responsible for a layer of functionality requirement for multi-level security

bungalow house

a low house, with a broad front porch, having either no upper floor or upper rooms set in the roof, typically with dormer windows.

Why is procedural cohesion bad?

actions still weakly related to one another not reusable

organic design

all materials, functions, forms, and surroundings are completely coordinated and harmony with nature

Advantages of layered architecture

allow replacement of entire layers as long as interface is maintained redundant facilities can be proveded in each layer to increase dependability

Advantages of MVC pattern

allows data to change independently of representation and vice versa supports presentation of same data in different ways w/ changes made in one representation shown in all of them

Why is content coupling bad?

almost any change to module b requires changes to module a (given a directly uses data of b)

"form follows function"

any architectural form should have an intended practice purpose and should perform a function

What's bad about temporal cohesion?

code is spread out --> not maintainable or reusable actions are not directly related to each other but are more related to those in other modules

principles of design

balance rhythm repetition emphasis subordination proportion unity variety opposition transition

How can we resolve communicational cohesion

break it up

Disadvantages of MVC pattern

can involve additional code and code complexity when data model and interactions are simple