The document discusses software architecture and its key concepts. It defines software architecture as the structure or structures of the system, which comprises elements, their properties, and the relationships between them. An architecture describes a system through different views, like module, component-connector, and allocation views, which expose different structural properties. Common architectural styles include pipe-and-filter, shared-data, and client-server styles. The document also discusses best practices for documenting an architecture design.
The document discusses architectural design and provides information on architectural design decisions, views, patterns, and levels of abstraction. It describes architecture in the small as concerned with individual programs, while architecture in the large refers to complex enterprise systems. There are advantages to explicitly designing architecture such as stakeholder communication, system analysis, and large-scale reuse. Architectural views include logical, process, development, and physical views. Design decisions depend on requirements like performance, security, safety, availability, and maintainability. Common patterns include model-view-controller and layered architectures.
The document discusses architectural design in software engineering. It covers topics like architectural design decisions, views, patterns, and application architectures. Architectural design involves identifying major system components and their communications in order to represent the link between specification and design processes. Common architectural patterns discussed include model-view-controller, layered architectures, repositories, client-server, pipes and filters. The document also provides examples of architectures for different types of applications like transaction processing systems and information systems.
The document discusses architectural design and provides examples of different architectural patterns and application architectures. It begins with defining architectural design and its role in the system design process. It then covers topics such as architectural views, patterns like Model-View-Controller and layered architectures. Examples are given of different application architectures for transaction processing and information systems. Key decisions in architectural design and documenting architectures are also summarized.
The document discusses architectural design and key concepts:
- Architectural design determines the subsystems of a system and how they communicate. It represents the link between specification and design.
- Views and patterns are used to document architectures. Common views include logical, process, development, and physical views. Patterns like MVC and layered architectures organize systems.
- Architectural design involves decisions like the application architecture, distribution, styles, decomposition, and documentation. Views and non-functional requirements influence these decisions.
The document provides an overview of architectural design topics including:
- Architectural design decisions involve choices around application architecture, distribution, styles, and documentation.
- Architectural views provide different perspectives of a system's modules, runtime processes, and distribution.
- Architectural patterns like MVC and layered architectures capture proven design solutions.
- Application architectures provide templates for transaction processing, language processing, and information systems.
The document discusses architectural design and provides information on architectural design decisions, views, patterns, and levels of abstraction. It describes architecture in the small as concerned with individual programs, while architecture in the large refers to complex enterprise systems. There are advantages to explicitly designing architecture such as stakeholder communication, system analysis, and large-scale reuse. Architectural views include logical, process, development, and physical views. Design decisions depend on requirements like performance, security, safety, availability, and maintainability. Common patterns include model-view-controller and layered architectures.
The document discusses architectural design in software engineering. It covers topics like architectural design decisions, views, patterns, and application architectures. Architectural design involves identifying major system components and their communications in order to represent the link between specification and design processes. Common architectural patterns discussed include model-view-controller, layered architectures, repositories, client-server, pipes and filters. The document also provides examples of architectures for different types of applications like transaction processing systems and information systems.
The document discusses architectural design and provides examples of different architectural patterns and application architectures. It begins with defining architectural design and its role in the system design process. It then covers topics such as architectural views, patterns like Model-View-Controller and layered architectures. Examples are given of different application architectures for transaction processing and information systems. Key decisions in architectural design and documenting architectures are also summarized.
The document discusses architectural design and key concepts:
- Architectural design determines the subsystems of a system and how they communicate. It represents the link between specification and design.
- Views and patterns are used to document architectures. Common views include logical, process, development, and physical views. Patterns like MVC and layered architectures organize systems.
- Architectural design involves decisions like the application architecture, distribution, styles, decomposition, and documentation. Views and non-functional requirements influence these decisions.
The document provides an overview of architectural design topics including:
- Architectural design decisions involve choices around application architecture, distribution, styles, and documentation.
- Architectural views provide different perspectives of a system's modules, runtime processes, and distribution.
- Architectural patterns like MVC and layered architectures capture proven design solutions.
- Application architectures provide templates for transaction processing, language processing, and information systems.
The document discusses architectural design and provides examples of different architectural styles and application architectures. It covers topics such as:
- Architectural styles like layered architecture, model-view-controller, client-server, pipe and filter, and repository patterns.
- Generic application architectures for transaction processing systems and language processing systems. Examples given include ATMs, reservation systems, compilers, and command interpreters.
- Information system architectures often use a layered style with layers for the user interface, communications, retrieval, and database.
- Web-based information systems have interfaces implemented through a web browser.
This document discusses architectural design and provides examples of architectural views, patterns, and decisions. It covers topics such as the 4+1 view model, layered architecture pattern, model-view-controller pattern, and how architectural decisions impact system characteristics such as performance, security, and maintainability. Key points are that architectural design represents a link between specification and design, and that views, patterns, and decisions are important aspects of documenting and designing software architectures.
The document discusses architectural design and software architecture. It covers topics like architectural design decisions, views, patterns, and application architectures. Architectural design represents the link between specification and design and involves identifying major system components and their communications. Common architectural representations include box and line diagrams, while views provide different perspectives of the system. Architectural patterns like Model-View-Controller and layered architectures help structure systems and promote reuse.
This document provides an overview of architectural design. It discusses that architectural design organizes a system's overall structure and identifies main components and their relationships. It also describes architecture in the small of individual programs and architecture in the large of complex enterprise systems. Key architectural design decisions consider functional and non-functional requirements. Common architectural views and patterns like MVC, layered architecture, repository architecture, and client-server architecture are also outlined.
This document provides an overview of architectural design. It discusses that architectural design organizes a system's overall structure and identifies main components and their relationships. It also describes architecture in the small of individual programs and architecture in the large of complex enterprise systems. Key architectural design decisions are discussed as well as common architectural views and patterns like layered architecture, repository architecture, client-server architecture, and MVC. Performance, security, and maintainability are some important non-functional requirements related to architectural design.
The document discusses software design concepts and principles including:
1. Software design is an iterative process that translates requirements into a system blueprint. Initial designs have a high level of abstraction that is refined through iterations.
2. Key design concepts include abstraction, modularity, architecture, patterns, and information hiding. Architectural styles include data-centered, data flow, call-and-return, and object-oriented.
3. The design process involves representing the system context, defining archetypes, refining the architecture into components, and describing system instantiations. Architectural mapping uses data flow diagrams to guide the design structure.
Architectural design establishes the framework for software development by examining requirements and designing a model that specifies system components, their inputs/outputs/functions, and interactions. It can be represented using structural, dynamic, process, functional, or framework models. The outputs are an architectural design document and various project plans. Architectural design decisions impact non-functional requirements and common decisions include architectural style and system decomposition.
The document summarizes key aspects of architectural design for software systems. It defines software architecture as the structure of system components and relationships between them. Architecture is important for analyzing design effectiveness, considering alternatives, and managing risks. Key architectural styles described include data-centered, data flow, call and return, object-oriented, and layered. The document also discusses defining architectural context diagrams, archetypes, and components to design system architecture.
Lecture-_-5-_SDA_software design and architecture.docesrabilgic2
This lecture discusses software architecture. It begins by explaining that software architecture refers to the structure of a system, including its software elements, their properties, and relationships. An example diagram is shown but it is noted that the diagram alone does not represent the full architecture. Common architectural structures like patterns, reference models, and reference architectures are introduced. The lecture emphasizes that architecture is important because it enables communication between stakeholders, represents early critical design decisions, and can provide reusable abstractions of systems.
UNIT 3-DEMONSTRATING A COMPREHENSIVE UNDERSTANDING OF SOFTWARE DESIGN.pptxLeahRachael
This document outlines key concepts in software design, including:
- The three types of design activities are external, architectural, and detailed design.
- Fundamental design concepts include abstraction, information hiding, structure, modularity, concurrency, verification, and aesthetics.
- Modules should have loose coupling and high cohesion. Design notations include data flow diagrams and structure charts.
This document discusses component, deployment, persistent and UI models in object oriented design. It provides details on component diagrams, describing how they represent high-level reusable parts of a system and their inter-relationships. Deployment diagrams depict the physical resources in a system including nodes, components, and connections. Persistent modeling involves mapping object-oriented class diagrams to relational database schemas. User interface design should match user skills/experience and consider human factors like memory, preferences and preventing errors.
The document discusses software architecture, where it comes from, and what it is. Architectures are influenced by system stakeholders and their requirements, the developing organization, and the architects' experience. An architecture defines elements, their relationships, and properties. It is important because it represents early design decisions, dictates implementation, organizational structure, and quality attributes. Architectural patterns, reference models, and reference architectures capture common architectural elements but are not full architectures themselves.
Architectural design involves identifying major system components and their communications. Architectural views provide different perspectives of the system, such as conceptual, logical, process, and development views. Common architectural patterns include model-view-controller, layered, client-server, and pipe-and-filter architectures. Application architectures define common structures for transaction processing, information, and language processing systems.
This document provides an introduction to software architecture. It discusses what software architecture is, popular architecture styles, quality attributes of a system, and architecture design guidelines. The key points are:
- Software architecture is the high-level design of a system that guides its construction and development. It defines the relationship between major structural elements.
- Popular architecture styles include layered, pipes and filters, and event-based. Each style has advantages and disadvantages for certain quality attributes.
- Quality attributes include implementation attributes like maintainability, runtime attributes like performance and availability, and business attributes like time to market. There are often tradeoffs between attributes.
- Architecture design guidelines include thinking about requirements before design, using abstraction, considering non-
Software Archtecture.
Software design is a process to transform user requirements into some suitable form, which helps the programmer in software coding and implementation.
Software design is the important step in SDLC (Software Design Life Cycle), which moves the concentration from problem domain to solution domain. It tries to specify how to fulfill the requirements mentioned in SRS.
Software design plays an important role in developing software: during software design, software engineers produce various models that form a kind of blueprint of the solution to be implemented
Software Architecture in Architecture design .pptguruswamyd785
The document discusses software architecture and architectural design. It begins by defining software architecture as the high-level decisions that determine a system's structure and components and their relationships. It discusses why systems are decomposed into parts and common architectural decisions involving mapping software to hardware and system decomposition. It describes key architectural concerns like system decomposition, cross-cutting concerns, and conceptual integrity. It outlines common views for documenting architectures like module, dependency, layered, and component-connector views. Finally, it discusses well-known architectural styles like client-server, layered, and REST and provides examples of each.
Function-oriented design views a system as modules with clearly defined behaviors that interact to meet requirements. It discusses various design methodologies including structured design methodology which involves identifying inputs/outputs and transformations, and factoring modules into submodules. Design quality can be evaluated using metrics related to cohesion, coupling, complexity, and information flow.
software design is very crusial thing to manage therfore software 'software design is very crusial thing to manage therfore software software design is very crusial thing to manage therfore software software design is very crusial thing to manage therfore software
The document discusses object-oriented design and its role in software development. It describes how design builds upon analysis to provide implementation details. Key aspects of object-oriented design include defining a multilayered architecture, specifying subsystems and components, describing classes and objects, and defining communication mechanisms. The input to design comes from artifacts created in analysis like use cases and class models. The output of design serves as a blueprint to guide construction.
This lecture discusses inter-process communication and classical problems related to IPC. It covers the concepts of critical regions, mutual exclusion, semaphores, mutexes, and message passing. Classical IPC problems discussed include the dining philosophers problem, readers-writers problem, and producer-consumer problem.
The document discusses the importance of properly analyzing and specifying software requirements, including the need to produce a high-quality Software Requirements Specification (SRS) document. It describes the requirements process, characteristics of a good SRS, components that should be included in an SRS, and provides examples of using use cases to specify functional requirements for different systems like an online auction site. The use of use cases is presented as an effective technique for specifying functionality in the SRS by describing interactions between actors and the system through scenarios.
The document discusses architectural design and provides examples of different architectural styles and application architectures. It covers topics such as:
- Architectural styles like layered architecture, model-view-controller, client-server, pipe and filter, and repository patterns.
- Generic application architectures for transaction processing systems and language processing systems. Examples given include ATMs, reservation systems, compilers, and command interpreters.
- Information system architectures often use a layered style with layers for the user interface, communications, retrieval, and database.
- Web-based information systems have interfaces implemented through a web browser.
This document discusses architectural design and provides examples of architectural views, patterns, and decisions. It covers topics such as the 4+1 view model, layered architecture pattern, model-view-controller pattern, and how architectural decisions impact system characteristics such as performance, security, and maintainability. Key points are that architectural design represents a link between specification and design, and that views, patterns, and decisions are important aspects of documenting and designing software architectures.
The document discusses architectural design and software architecture. It covers topics like architectural design decisions, views, patterns, and application architectures. Architectural design represents the link between specification and design and involves identifying major system components and their communications. Common architectural representations include box and line diagrams, while views provide different perspectives of the system. Architectural patterns like Model-View-Controller and layered architectures help structure systems and promote reuse.
This document provides an overview of architectural design. It discusses that architectural design organizes a system's overall structure and identifies main components and their relationships. It also describes architecture in the small of individual programs and architecture in the large of complex enterprise systems. Key architectural design decisions consider functional and non-functional requirements. Common architectural views and patterns like MVC, layered architecture, repository architecture, and client-server architecture are also outlined.
This document provides an overview of architectural design. It discusses that architectural design organizes a system's overall structure and identifies main components and their relationships. It also describes architecture in the small of individual programs and architecture in the large of complex enterprise systems. Key architectural design decisions are discussed as well as common architectural views and patterns like layered architecture, repository architecture, client-server architecture, and MVC. Performance, security, and maintainability are some important non-functional requirements related to architectural design.
The document discusses software design concepts and principles including:
1. Software design is an iterative process that translates requirements into a system blueprint. Initial designs have a high level of abstraction that is refined through iterations.
2. Key design concepts include abstraction, modularity, architecture, patterns, and information hiding. Architectural styles include data-centered, data flow, call-and-return, and object-oriented.
3. The design process involves representing the system context, defining archetypes, refining the architecture into components, and describing system instantiations. Architectural mapping uses data flow diagrams to guide the design structure.
Architectural design establishes the framework for software development by examining requirements and designing a model that specifies system components, their inputs/outputs/functions, and interactions. It can be represented using structural, dynamic, process, functional, or framework models. The outputs are an architectural design document and various project plans. Architectural design decisions impact non-functional requirements and common decisions include architectural style and system decomposition.
The document summarizes key aspects of architectural design for software systems. It defines software architecture as the structure of system components and relationships between them. Architecture is important for analyzing design effectiveness, considering alternatives, and managing risks. Key architectural styles described include data-centered, data flow, call and return, object-oriented, and layered. The document also discusses defining architectural context diagrams, archetypes, and components to design system architecture.
Lecture-_-5-_SDA_software design and architecture.docesrabilgic2
This lecture discusses software architecture. It begins by explaining that software architecture refers to the structure of a system, including its software elements, their properties, and relationships. An example diagram is shown but it is noted that the diagram alone does not represent the full architecture. Common architectural structures like patterns, reference models, and reference architectures are introduced. The lecture emphasizes that architecture is important because it enables communication between stakeholders, represents early critical design decisions, and can provide reusable abstractions of systems.
UNIT 3-DEMONSTRATING A COMPREHENSIVE UNDERSTANDING OF SOFTWARE DESIGN.pptxLeahRachael
This document outlines key concepts in software design, including:
- The three types of design activities are external, architectural, and detailed design.
- Fundamental design concepts include abstraction, information hiding, structure, modularity, concurrency, verification, and aesthetics.
- Modules should have loose coupling and high cohesion. Design notations include data flow diagrams and structure charts.
This document discusses component, deployment, persistent and UI models in object oriented design. It provides details on component diagrams, describing how they represent high-level reusable parts of a system and their inter-relationships. Deployment diagrams depict the physical resources in a system including nodes, components, and connections. Persistent modeling involves mapping object-oriented class diagrams to relational database schemas. User interface design should match user skills/experience and consider human factors like memory, preferences and preventing errors.
The document discusses software architecture, where it comes from, and what it is. Architectures are influenced by system stakeholders and their requirements, the developing organization, and the architects' experience. An architecture defines elements, their relationships, and properties. It is important because it represents early design decisions, dictates implementation, organizational structure, and quality attributes. Architectural patterns, reference models, and reference architectures capture common architectural elements but are not full architectures themselves.
Architectural design involves identifying major system components and their communications. Architectural views provide different perspectives of the system, such as conceptual, logical, process, and development views. Common architectural patterns include model-view-controller, layered, client-server, and pipe-and-filter architectures. Application architectures define common structures for transaction processing, information, and language processing systems.
This document provides an introduction to software architecture. It discusses what software architecture is, popular architecture styles, quality attributes of a system, and architecture design guidelines. The key points are:
- Software architecture is the high-level design of a system that guides its construction and development. It defines the relationship between major structural elements.
- Popular architecture styles include layered, pipes and filters, and event-based. Each style has advantages and disadvantages for certain quality attributes.
- Quality attributes include implementation attributes like maintainability, runtime attributes like performance and availability, and business attributes like time to market. There are often tradeoffs between attributes.
- Architecture design guidelines include thinking about requirements before design, using abstraction, considering non-
Software Archtecture.
Software design is a process to transform user requirements into some suitable form, which helps the programmer in software coding and implementation.
Software design is the important step in SDLC (Software Design Life Cycle), which moves the concentration from problem domain to solution domain. It tries to specify how to fulfill the requirements mentioned in SRS.
Software design plays an important role in developing software: during software design, software engineers produce various models that form a kind of blueprint of the solution to be implemented
Software Architecture in Architecture design .pptguruswamyd785
The document discusses software architecture and architectural design. It begins by defining software architecture as the high-level decisions that determine a system's structure and components and their relationships. It discusses why systems are decomposed into parts and common architectural decisions involving mapping software to hardware and system decomposition. It describes key architectural concerns like system decomposition, cross-cutting concerns, and conceptual integrity. It outlines common views for documenting architectures like module, dependency, layered, and component-connector views. Finally, it discusses well-known architectural styles like client-server, layered, and REST and provides examples of each.
Function-oriented design views a system as modules with clearly defined behaviors that interact to meet requirements. It discusses various design methodologies including structured design methodology which involves identifying inputs/outputs and transformations, and factoring modules into submodules. Design quality can be evaluated using metrics related to cohesion, coupling, complexity, and information flow.
software design is very crusial thing to manage therfore software 'software design is very crusial thing to manage therfore software software design is very crusial thing to manage therfore software software design is very crusial thing to manage therfore software
The document discusses object-oriented design and its role in software development. It describes how design builds upon analysis to provide implementation details. Key aspects of object-oriented design include defining a multilayered architecture, specifying subsystems and components, describing classes and objects, and defining communication mechanisms. The input to design comes from artifacts created in analysis like use cases and class models. The output of design serves as a blueprint to guide construction.
This lecture discusses inter-process communication and classical problems related to IPC. It covers the concepts of critical regions, mutual exclusion, semaphores, mutexes, and message passing. Classical IPC problems discussed include the dining philosophers problem, readers-writers problem, and producer-consumer problem.
The document discusses the importance of properly analyzing and specifying software requirements, including the need to produce a high-quality Software Requirements Specification (SRS) document. It describes the requirements process, characteristics of a good SRS, components that should be included in an SRS, and provides examples of using use cases to specify functional requirements for different systems like an online auction site. The use of use cases is presented as an effective technique for specifying functionality in the SRS by describing interactions between actors and the system through scenarios.
The document discusses software design and structured design methodology. It covers key concepts like modularity, coupling, cohesion, and the open-closed principle. Modularity is achieved through low coupling between modules and high cohesion within modules. Coupling is defined for both procedural and object-oriented systems. Cohesion is assessed based on the relationship between a module's elements. Structured design methodology views software as a transformation function and aims to specify modular functions and connections through a stepwise process including drawing data flow diagrams and factoring the design. The goal is a design with low coupling and high cohesion.
The document discusses planning a software project. It covers key tasks in project planning including effort estimation, scheduling, quality planning, and risk management. Effective project planning is important to predictably deliver projects on time and on budget by properly estimating effort, creating a schedule, and managing risks and quality.
The document discusses various software development processes and models. It describes the waterfall model as a linear sequential process and discusses its advantages of being conceptually simple and disadvantages of not allowing feedback. It then covers iterative development processes like prototyping and iterative enhancement that allow for feedback. Timeboxing and the Rational Unified Process (RUP) model are also summarized, with RUP dividing the process into phases with milestones and core workflows.
The document discusses various aspects of coding, including:
- Structured programming aims to simplify program structure and control flow to make programs easier to understand and verify.
- Information hiding hides data structures behind access functions to reduce coupling.
- Coding standards provide guidelines for naming conventions, file organization, and other practices to enhance readability.
- Incremental development involves writing code in parts and testing each part before moving on. Test-driven development writes tests before code.
- Source code control and refactoring help manage evolving code by versioning changes and improving design over time.
- Unit testing verifies code by programmers through automated test cases and drivers to check functionality and catch bugs.
The document discusses key differences between student programs and industrial strength software. Industrial strength software requires higher quality, documentation, reliability, and is more expensive to develop. It also discusses how software engineering aims to develop large, complex industrial software with high productivity and quality through methods that can accommodate change and scale to large problems.
Best Digital Marketing Strategy Build Your Online Presence 2024.pptxpavankumarpayexelsol
This presentation provides a comprehensive guide to the best digital marketing strategies for 2024, focusing on enhancing your online presence. Key topics include understanding and targeting your audience, building a user-friendly and mobile-responsive website, leveraging the power of social media platforms, optimizing content for search engines, and using email marketing to foster direct engagement. By adopting these strategies, you can increase brand visibility, drive traffic, generate leads, and ultimately boost sales, ensuring your business thrives in the competitive digital landscape.
Explore the essential graphic design tools and software that can elevate your creative projects. Discover industry favorites and innovative solutions for stunning design results.
2. Software Architecture 2
Background
Any complex system is composed of
sub-systems that interact
While designing systems, an approach
is to identify sub-systems and how they
interact with each other
Sw Arch tries to do this for software
A recent area, but a lot of interest in it
3. Software Architecture 3
Background…
Architecture is the system design at the
highest level
Choices about technologies, products to use,
servers, etc are made at arch level
Not possible to design system details and then
accommodate these choices
Arch must be created accommodating them
Is the earliest place when properties like
rel/perf can be evaluated
4. Software Architecture 4
Architecture
Arch is a design of the sw that gives a very
high level view of parts and they relate to
form the whole
Partitions the sys in parts such that each part can
be comprehended independently
And describes relationship between parts
A complex system can be partitioned in many
diff ways, each providing a useful view
Same holds true of software also
There is no unique structure; many possible
5. Software Architecture 5
Architecture
Defn: Software arch is the structure or
structures which comprise elements, their
externally visible properties, and relationships
among them
For elements only interested in external properties
needed for relationship specification
Details on how the properties are supported is not
important for arch
The defn does not say anything about whether an
arch is good or not – analysis needed for it
An arch description describes the different
structures of the system
6. Software Architecture 6
Key Uses of Arch Descriptions
Understanding and communication
By showing a system at a high level and
hiding complexity of parts, arch descr
facilitates communication
To get a common understanding between
the diff stakeholders (users, clients,
architect, designer,…)
For negotiation and agreement
Arch descr can also aid in understanding of
existing systems
7. Software Architecture 7
Uses…
Reuse
A method of reuse is to compose systems from
parts and reuse existing parts
This model is facilitated by reusing components at
a high level providing complete services
To reuse existing components, arch must be
chosen such that these components fit together
with other components
Hence, decision about using existing components
is made at arch design time
8. Software Architecture 8
Uses..
Construction and evolution
Some structures in arch descr will be used to
guide system development
Partitioning at arch level can also be used for work
allocation to teams as parts are relatively
independent
During sw evolution, arch helps decide what needs
to be changed to incorporate the new
changes/features
Arch can help decide what is the impact of
changes to existing components on others
9. Software Architecture 9
Uses…
Analysis
If properties like perf, reliability can be determined
from design, alternatives can be considered during
design to reach the desired perf levels
Sw arch opens such possibilities for software
(other engg disciplines usually can do this)
E.g. rel and perf of a system can be predicted
from its arch, if estimates for parms like load etc is
provided
Will require precise description of arch, as well as
properties of the elements in the description
10. Software Architecture 10
Architectural Views
There is no unique arch of a sys
There are different views of a sw sys
A view consists of elements and relationships
between them, and describes a structure
The elements of a view depends on what the
view wants to highlight
Diff views expose diff properties
A view focusing on some aspects reduces its
complexity
11. Software Architecture 11
Views…
Many types of views have been proposed
Most belong to one of these three types
Module
Component and Connector
Allocation
The diff views are not unrelated – they all
represent the same system
There are relationships between elements of diff
views; this rel may be complex
12. Software Architecture 12
Views…
Module view
A sys is a collection of code units i.e. they
do not represent runtime entitites
I.e. elements are modules, eg. Class,
package, function, procedure,…
Relationship between them is code based,
e.g. part of, depends on, calls,
generalization-specialization,..
13. Software Architecture 13
Views…
Component and Connector (C&C)
Elements are run time entities called
components
I.e. a component is a unit that has identity
in executing sys, e.g. objects, processes,
.exe, .dll
Connectors provide means of interaction
between components, e.g. pipes, shared
memory, sockets
14. Software Architecture 14
Views…
Allocation view
Focuses on how sw units are allocated to
resources like hw, file system, people
I.e. specifies relationship between sw
elements and execution units in the env
Expose structural properties like which
process runs on which processor, which file
resides where, …
15. Software Architecture 15
Views…
An arch description consists of views of diff
types, each showing a diff structure
Diff sys need diff types of views depending on the
needs
E.g. for perf analysis, allocation view is necessary;
for planning, module view helps
The C&C view is almost always done, and has
become the primary view
We focus primarily on the C&C view
Module view is covered in high level design,
whose focus is on identifying modules
16. Software Architecture 16
Component and Connector View
Two main elements – components and connectors
Components: Computational elements or data stores
Connectors: Means of interaction between comps
A C&C view defines the comps, and which comps are
connected through which connector
The C&C view describes a runtime structure of the
system – what comps exist at runtime and how they
interact during execution
Is a graph; often shown as a box-and-line drawing
Most commonly used structure
17. Software Architecture 17
Components
Units of computations or data stores
Has a name, which represents its role, and
provides it identity
A comp may have a type; diff types rep by
diff symbols in C&C view
Comps use ports (or interfaces) to
communicate with others
An arch can use any symbols to rep
components; some common ones are shown
19. Software Architecture 19
Connectors
Interaction between components happen
through connectors
A connector may be provided by the runtime
environment, e.g. procedure call
But there may be complex mechanisms for
interaction, e.g http, tcp/ip, ports,…; a lot of
sw needed to support them
Important to identify them explicitly; also
needed for programming comps properly
20. Software Architecture 20
Connectors…
Connectors need not be binary, e.g. a
broadcast bus
Connector has a name (and a type)
Often connectors represented as protocol –
i.e. comps need to follow some conventions
when using the connector
Best to use diff notation for diff types of
connectors; all connectors should not be
shown by simple lines
22. Software Architecture 22
An Example
Design a system for taking online survey of
students on campus
Multiple choice questions, students submit online
When a student submits, current result of the
survey is shown
Is best built using web; a 3-tier architecture
is proposed
Has a client, server, and a database components
(each of a diff type)
Connector between them are also of diff types
24. Software Architecture 24
Example…
At arch level, details are not needed
The connectors are explicitly stated,
which implies that the infrastructure
should provide http, browser, etc.
The choice of connectors imposes
constraints on how the components are
finally designed and built
25. Software Architecture 25
Extension 1
This arch has no security – anyone can
take the survey
We want that only registered students
can take the survey (at most once)
To identify students and check for one-only
submission, need a authentication server
Need to use cookies, and server has to be
built accordingly (the connector between
server and auth server is http with cookies)
27. Software Architecture 27
Extension 2
It was found that DB is frequently down
For improving reliability, want that if DB
is down, student is given an older
survey result and survey data stored
The survey data given can be outdated
by at most 5 survey data points
For this, will add a cache comp, which
will store data as well as results
29. Software Architecture 29
Example…
One change increased security, 2nd
increased performance and reliability
I.e. Arch level choices have a big impact
on system properties
That is why, choosing a suitable arch
can help build a good system
30. Software Architecture 30
Architectural Styles for C&C View
Diff systems have diff C&C structure
Some structures are general and are useful
for a class of problems – architectural styles
An arch style defines a family of archs that
satisfy the constraint of that style
Styles can provide ideas for creating arch for
a sys; they can be combined also
We discuss a few common styles
31. Software Architecture 31
Pipe and filter
Well suited for systems that mainly do data
transformations
A system using this style uses a network of
transforms to achieve the desired result
Has one component type – filter
Has one connector type – pipe
A filter does some transformation and passes
data to other filters through pipes
32. Software Architecture 32
Pipe and Filter…
A filter is independent; need not know the id
of filters sending/receiving data
Filters can be asynchronous and are
producers or consumers of data
A pipe is unidirectional channel which moves
streams of data from one filter to another
A pipe is a 2-way connector
Pipes have to perform buffering, and
synchronization between filters
33. Software Architecture 33
Pipe and filter…
Pipes should work without knowing the
identify of producers/consumers
A pipe must connect the output port of
one filter to input port of another
Filters may have indep thread of control
34. Software Architecture 34
Example
A system needed to count the
frequency of different words in a file
One approach: first split the file into a
sequence of words, sort them, then
count the #of occurrences
The arch of this system can naturally
use the pipe and filter style
36. Software Architecture 36
Shared-data style
Two component types – data repository and
data accessor
Data repository – provides reliable permanent
storage
Data accessors – access data in repositories,
perform computations, and may put the
results back also
Communication between data accessors is
only through the repository
37. Software Architecture 37
Shared-data style…
Two variations possible
Black board style: if data is posted in a
repository, all accessors are informed; i.e.
shared data source is an active agent
Repository style: passive repository
Eg. database oriented systems; web
systems; programming environments,..
38. Software Architecture 38
Example
A student registration system of a
university
Repository contains all the data about
students, courses, schedules,…
Accessors like admin, approvals,
registration, reports which perform
operations on the data
40. Software Architecture 40
Example..
Components do not directly
communicate with each other
Easy to extend – if a scheduler is
needed, it is added as a new accessor
No existing component needs to be
changed
Only one connector style in this –
read/write
41. Software Architecture 41
Client-Server Style
Two component types – clients and servers
Clients can only communicate with the server,
but not with other clients
Communication is initiated by a client which
sends request and server responds
One connector type – request/reply, which is
asymmetric
Often the client and the servers reside on
different machines
42. Software Architecture 42
Client-server style…
A general form of this style is the n-tier
structure
A 3-tier structure is commonly used by
many application and web systems
Client-tier contains the clients
Middle-tier contains the business rules
Database tier has the information
43. Software Architecture 43
Some other styles
Publish-subscribe style
Some components generate events, and others
subscribe to them
On an event, those component that subscribe to it
are invoked
Peer-to-peer style
Like object oriented systems; components use
services from each other through methods
Communication processes style
Processes which execute and communicate with
each other through message passing
44. Software Architecture 44
Architecture and Design
Both arch and design partition the system
into parts and their org
What is the relationship between design and
arch?
Arch is a design; it is about the solution domain,
and not problem domain
Can view arch as a very high level design focusing
on main components
Design is about modules in these components that
have to be coded
Design can be considered as providing the module
view of the system
45. Software Architecture 45
Contd…
Boundaries between architecture and design
are not clear or hard
It is for designer and architect to decide
where arch ends and design begins
In arch, issues like files, data structure etc
are not considered, while they are important
in design
Arch does impose constraints on design in
that the design must be consistent with arch
46. Software Architecture 46
Preserving the Integrity of
Architecture
What is the role of arch during the rest of the
development process
Many designers and developers use it for
understanding but nothing more
Arch imposes constraints; the implementation must
preserve the arch
I.e. the arch of the final system should be same as
the arch that was conceived
It is very easy to ignore the arch design and go
ahead and do the development
Example – impl of the word frequency problem
47. Software Architecture 47
Documenting Arch Design
While designing and brainstorming,
diagrams are a good means
Diagrams are not sufficient for
documenting arch design
An arch design document will need to
precisely specify the views, and the
relationship between them
48. Software Architecture 48
Documenting…
An arch document should contain
System and architecture context
Description of architecture views
Across view documentation
A context diagram that establishes the sys
scope, key actors, and data sources/sinks can
provide the overall context
A view description will generally have a
pictorial representation, as discussed earlier
49. Software Architecture 49
Documenting…
Pictures should be supported by
Element catalog: Info about behavior,
interfaces of the elements in the arch
Architectural rationale: Reasons for making
the choices that were made
Behavior: Of the system in different
scenarios (e.g. collaboration diagram)
Other Information: Decisions which are to
be taken, choices still to be made,..
50. Software Architecture 50
Documenting…
Inter-view documentation
Views are related, but the relationship is not clear
in the view
This part of the doc describes how the views are
related (eg. How modules are related to
components)
Rationale for choosing the views
Any info that cuts across views
Sometimes views may be combined in one
diagram for this – should be done if the
resulting diagram is still easy to understand
51. Software Architecture 51
Evaluating Architectures
Arch impacts non-functional attributes like
modifiability, performance, reliability,
portability, etc
Attr. like usability etc are not impacted
Arch plays a much bigger impact on these
than later decisions
So should evaluate a proposed arch for these
properties
Q: How should this evaluation be done?
Many different ways
52. Software Architecture 52
Evaluating Architectures…
Procedural approach – follow a sequence of
steps
Identify the attributes of interest to different
stakeholders
List them in a table
For each attribute, evaluate the architectures
under consideration
Evaluation can be subjective based on experience
Based on this table, then select some arch or
improve some existing arch for some attribute
53. Software Architecture 53
Summary
Arch of a sw system is its structures
comprising of elements, their external
properties, and relationships
Arch is a high level design
Three main view types – module, component
and connector, and allocation
Component and connector (C&C) view is
most commonly used
54. Software Architecture 54
Summary…
There are some C&C styles that are
commonly used, e.g. pipe-and-filter,
shared data, client server,....
An arch description should document
the different views and their
relationship – views can be combined
Rationale and other supporting
information should also be captured
55. Software Architecture 55
Summary…
Arch can be analyzed for various non-
functional attributes like performance,
reliability, security, etc
ATAM is one approach for analyzing
architectures, which evaluates attributes
of interest under different scenarios