Software architecture


Software architecture

The software architecture of a program or computing system is the structure or structures of the system, which comprise software components, the externally visible properties of those components, and the relationships between them. The term also refers to documentation of a system's software architecture. Documenting software architecture facilitates communication between stakeholders, documents early decisions about high-level design, and allows reuse of design components and patterns between projects. [cite book|last=Bass|first=Len|coauthors=Paul Clements, Rick Kazman|title=Software Architecture In Practice, Second Edition|publisher = Addison-Wesley|date=2003|location=Boston|pages=p. 21-24|id=ISBN 0-321-15495-9]

Overview

The field of computer science has come across problems associated with complexity since its formation. [cite web|author=University of Waterloo|title= A Very Brief History of Computer Science |url=http://www.cs.uwaterloo.ca/~shallit/Courses/134/history.html |date=2006|accessdate=2006-09-23] Earlier problems of complexity were solved by developers by choosing the right data structures, developing algorithms, and by applying the concept of separation of concerns. Although the term “software architecture” is relatively new to the industry, the fundamental principles of the field have been applied sporadically by software engineering pioneers since mid 1980s. Early attempts to capture and explain software architecture of a system were imprecise and disorganized - often characterized by a set of box-and-line diagrams. [cite web|author=IEEE Transactions on Software Engineering|title= Introduction to the Special Issue on Software Architecture |url=http://csdl2.computer.org/persagen/DLAbsToc.jsp?resourcePath=/dl/trans/ts/&toc=comp/trans/ts/1995/04/e4toc.xml&DOI=10.1109/TSE.1995.10003
date=2006|accessdate=2006-09-23
] During the 1990’s there was a concentrated effort to define and codify fundamental aspects of the discipline. Initial sets of design patterns, styles, best practices, description languages, and formal logic were developed during that time.The software architecture discipline is centered on the idea of reducing complexity through abstraction and separation of concerns. To date there is still no agreement on the precise definition of the term “software architecture”. [cite web|author=SEI|title= How do you define Software Architecture?|url= http://www.sei.cmu.edu/architecture/definitions.html |date=2006|accessdate=2006-09-23]

As a maturing discipline with no clear rules on the right way to build a system, designing software architecture is still a mix of art and science. The “art” aspect of software architecture is because a commercial software system supports some aspect of a business or a mission. How a system supports key business drivers is described via scenarios as non-functional requirements of a system, also known as quality attributes, determine how a system will behave.cite web|author=SoftwareArchitectures.com|title= Intro to Software Quality Attributes |url=http://www.softwarearchitectures.com/one/Designing+Architecture/78.aspx |date=2006|accessdate=2006-09-23] Every system is unique due to the nature of the business drivers it supports, as such the degree of quality attributes exhibited by a system such as fault-tolerance, backward compatibility, extensibility, reliability, maintainability, availability, security, usability, and such other –ilities will vary with each implementation.

To bring a software architecture user's perspective into the software architecture, it can be said that software architecture gives the direction to take steps and do the tasks involved in each such user's speciality area and interest e.g. the stake holders of software systems, the software developer, the software system operational support group, the software maintenance specialists, the deployer, the tester and also the business end userFact|date=February 2007. In this sense software architecture is really the amalgamation of the multiple perspectives a system always embodies. The fact that those several different perspectives can be put together into a software architecture stands as the vindication of the need and justification of creation of software architecture before the software development in a project attains maturity.

History

The origin of software architecture as a concept was first identified in the research work of Edsger Dijkstra in 1968 and David Parnas in the early 1970s. These scientists emphasized that the structure of a software system matters and getting the structure right is critical [cite web|author=SEI|title= Origins of Software Architecture Study |url= http://www.sei.cmu.edu/architecture/roots.html |date=2006|accessdate=2006-09-25] . The study of the field increased in popularity since the early 1990s with research work concentrating on architectural styles (patterns), architecture description languages, architecture documentation, and formal methods [cite web|author=Garlan & Shaw |title= An Introduction to Software Architecture |url= http://www.cs.cmu.edu/afs/cs/project/able/ftp/intro_softarch/intro_softarch.pdf |date=1994|accessdate=2006-09-25] .

Research institutions have played a prominent role in furthering software architecture as a discipline. Mary Shaw and David Garlan of Carnegie Mellon wrote a book titled "Software Architecture: Perspectives on an Emerging Discipline" in 1996, which brought forward the concepts in Software Architecture, such as components, connectors, styles and so on. The University of California, Irvine's Institute for Software Research's efforts in software architecture research is directed primarily in architectural styles, architecture description languages, and dynamic architectures.

The Ieee 1471: ANSI/IEEE 1471-2000: Recommended Practice for Architecture Description of Software-Intensive Systems is the first formal standard in the area of software architecture, and was recently adopted by ISO as "ISO/IEC DIS 25961.

Software architecture topics

Architecture description languages

Architecture description languages (ADLs) are used to describe a Software Architecture. Several different ADLs have been developed by different organizations, including AADL (SAE standard), Wright (developed by Carnegie Mellon), Acme (developed by Carnegie Mellon), xADL (developed by UCI), Darwin (developed by Imperial College London), DAOP-ADL (developed by University of Málaga). Common elements of an ADL are component, connector and configuration.

Views

Software architecture is commonly organized in viewscite book
last = Clements
first = Paul
coauthors = Felix Bachmann, Len Bass, David Garlan, James Ivers, Reed Little, Robert Nord, Judith Stafford
title = Documenting Software Architectures: Views and Beyond
publisher = Addison-Wesley
date = 2003
location = Boston
pages = pp. 13-15
id = ISBN 0-201-70372-6
] , which are analogous to the different types of blueprints made in building architecture. Within the ontology established by ANSI/IEEE 1471-2000, "views" are instances of "viewpoints", where a viewpoint exists to describe the architecture in question from the perspective of a given set of stakeholders and their concerns.

Some possible views (actually, "viewpoints" in the 1471 ontology) are:

*Functional/logic view
*Code/module view
*Development/structural view
*Concurrency/process/thread view
*Physical/deployment view
*User action/feedback view
*Data view

Several languages for describing software architectures have been devised, but no consensus has yet been reached on which symbol-set and view-system should be adopted. The UML was established as a standard "to model systems (and not just software)," and thus applies to views about software architecture. Others believe that effective development of software relies on understanding unique constraints of each problem, and so universal notations are doomed because each provides a notational bias that necessarily makes the notation useless or dangerous for some set of tasksFact|date=February 2007. They point to the proliferation of programming languages and a succession of failed attempts to impose a single 'universal language' on programmers, as proof that software thrives on diversity and not on standards.

Architecture frameworks

*4+1
*Department of Defense Architecture Framework (DODAF)
*UK Ministry of Defence Architectural Framework (MODAF)
*The Open Group Architecture Framework (TOGAF)
*Zachman framework
*Federal Enterprise Architecture
*Reference Model of Open Distributed Processing (RM-ODP)
*Service-Oriented Modeling Framework (SOMF)

The distinction from detailed design

Software architecture, also described as strategic design, is an activity concerned with global design constraints, such as programming paradigms, architectural styles, component-based software engineering standards, design principles, and law-governed regularities. Detailed design, also described as tactical design, is an activity concerned with local design constraints, such as design patterns, architectural patterns, programming idioms, and refactorings. According to the Intension/Locality Hypothesiscite web|author=Amnon H. Eden, Rick Kazman|title=Architecture Design Implementation |url=http://www.eden-study.org/articles/2003/icse03.pdf |date=2003] , the distinction between strategic and tactical design is defined by the Locality Criterion, according to which a statement about software design is non-local if and only if a program that satisfies it can be expanded into a program which does not. For example, the Client-Server style is architectural (strategic) because a program that is built by this principle can be expanded into a program which is not client server; for example, by adding peer-to-peer nodes.

Architecture is design but not all design is architectural. In practice, the architect is the one who draws the line between software architecture (architectural design) and detailed design (non-architectural design). There aren't rules or guidelines that fit all cases.

Examples of Architectural Styles / Patterns

There are many common ways of designing computer software modules and their communications, among them:
*Blackboard
*Client-server
*Database-centric architecture
*Distributed computing
*Event Driven Architecture
*Implicit invocation
*Monolithic application
*Peer-to-peer
*Pipes and filters
*Plugin
*Representational State Transfer
*Structured (module-based but usually monolithic within modules)
*Software componentry (strictly module-based, usually object-oriented programming within modules, slightly less monolithic)
*Service-oriented architecture
*Search-oriented architecture
*Space based architecture
*Shared nothing architecture
*Three-tier model

ee also

*Computer architecture
*Architecture Tradeoff Analysis Method (ATAM) - an architecture evaluation method.
*Dependency Structure Matrix
*Enterprise architecture
*Process architecture
*Software antipatterns
*Software architect
*Software Architectural Model
*Software design patterns
*Software design
*Software system
*Standard data models
*Systems architecture / Systems architect
*Systems design
*Technical architecture
*Service-Oriented Modeling Framework (SOMF)
*Common layers in an information system logical architecture

References

Further reading

* Len Bass, Paul Clements, Rick Kazman: "Software Architecture in Practice, Second Edition". Addison Wesley, Reading 5/9/2003 ISBN 0-321-15495-9 (This book, now in second edition, eloquently covers the fundamental concepts of the discipline. The theme is centered around achieving quality attributes of a system.)
* Amnon H. Eden, Rick Kazman. [http://www.eden-study.org/articles/2003/icse03.pdf "Architecture, Design, Implementation."] On the distinction between architectural design and detailed design.
* Garzás, Javier, and Piattini, Mario. An ontology for micro-architectural design knowledge, IEEE Software Magazine, Volume: 22, Issue: 2, March-April 2005. pp. 28 – 33.
* Philippe Kruchten: "Architectural Blueprints - the 4+1 View Model of Software Architecture". In: IEEE Software. 12 (6) November 1995, pp. 42-50 (also available online at the [http://www3.software.ibm.com/ibmdl/pub/software/rational/web/whitepapers/2003/Pbk4p1.pdf Rational website] (PDF))
* Tony Shan and Winnie Hua (2006). [http://doi.ieeecomputersociety.org/10.1109/EDOC.2006.54 "Solution Architecting Mechanism"] . Proceedings of the 10th IEEE International EDOC Enterprise Computing Conference (EDOC 2006), October 2006, p23-32
*

External links

* Collection of [http://www.sei.cmu.edu/architecture/definitions.html software architecture definitions] at Software Engineering Institute (SEI), Carnegie Mellon University (CMU)
* [http://www.eden-study.org/articles/2006/abstraction-classes-sw-design_ieesw.pdf Software architecture vs. software design: The Intension/Locality Hypothesis]
* [http://www.wwisa.org/ Worldwide Institute of Software Architects (WWISA)]
* [http://www.iasahome.org/iasaweb/appmanager/home/home/ International Association of Software Architects (IASA)]
* [http://www.softwarearchitectureportal.org/ SoftwareArchitecturePortal.org] — website of IFIP Working Group 2.10 on Software Architecture
* [http://www.softwarearchitectures.com/ SoftwareArchitectures.com] — independent resource of information on the discipline
* [http://www.architecturejournal.net/ Microsoft Architecture Journal]
* [http://msdn.microsoft.com/en-us/arcjournal/cc505970.aspx/ Becoming an Architect]
* [http://www.jools.net/archives/44 Architectural Patterns]
* [http://www.ics.uci.edu/~fielding/pubs/dissertation/software_arch.htm Software Architecture] , chapter 1 of Roy Fielding's REST dissertation


Wikimedia Foundation. 2010.

Look at other dictionaries:

  • Software Architecture Analysis Method — (SAAM) is a method used in software architecture to evaluate a system architecture. It was the first documented software architecture analysis method, and was developed in the mid 1990s to analyze a system for modifiability, but it is useful for… …   Wikipedia

  • Software architecture recovery — is a set of methods for the extraction of architectural information from lower level representations of a software system, such as source code. The abstraction process to generate architectural elements frequently involves clustering source code… …   Wikipedia

  • Software Architecture Analysis Method — SAAM ist ein Akronym für Software Architecture Analysis Method . Das Verfahren wurde von Rick Kazman, Gregory Abowd, Len Bass und Paul Clements entwickelt. (Diese Abkürzung wird auch im militärischen Bereich für Surface to Air Anti missile… …   Deutsch Wikipedia

  • Functional Software Architecture — A Functional Software Architecture (FSA) is an architectural model that identifies enterprise functions, interactions and corresponding IT needs. These functions can be used as reference by different domain experts to develop IT systems as part… …   Wikipedia

  • AMD Generic Encapsulated Software Architecture — Die AMD Generic Encapsulated Software Architecture (AGESA) ist eine Software Bibliothek, welche validierte Prozessorprozeduren enthält. Mit Hilfe dieser Microcode Sammlung kann die AMD64 Technik in verschiedene Produkte integriert werden. Die… …   Deutsch Wikipedia

  • Virtual Instrument Software Architecture — Virtual Instrument Software Architecture, commonly known as VISA, is a widely used I/O API in the Test Measurement industry for communicating with instruments from a PC. VISA is an industry standard implemented by several T M (Test Measurement)… …   Wikipedia

  • Virtual Instrument Software Architecture — Pour les articles homonymes, voir VISA. Virtual Instrument Software Architecture, appelé généralement VISA, est une interface de programmation largement utilisée dans le domaine de l instrumentation et l industrie du test et de la mesure. VISA… …   Wikipédia en Français

  • Logical Integrated Software Architecture — Logical Integrated Software Architecture,   LISA …   Universal-Lexikon

  • Architecture Logicielle — L’architecture logicielle décrit d’une manière symbolique et schématique les différents composants d’un ou de plusieurs systèmes informatiques, leurs interrelations et leurs interactions. Contrairement aux spécifications produites par l’analyse… …   Wikipédia en Français

  • Software engineering — (SE) is the application of a systematic, disciplined, quantifiable approach to the development, operation, and maintenance of software, and the study of these approaches; that is, the application of engineering to software.[1] It is the… …   Wikipedia


Share the article and excerpts

Direct link
Do a right-click on the link above
and select “Copy Link”

We are using cookies for the best presentation of our site. Continuing to use this site, you agree with this.