Network-Based Software Architectures

From Computing and Software Wiki

Jump to: navigation, search

Network-Based Software Architecture is a subfield of the area of Software Architectures that deals with the conceptual structure of software systems that primarily run on networks, e.g. Apache Web Server. The distinction between general software architectures and network-based software architectures is of vital importance due to the different organizations, goals, and uses that network-based software compared to other kinds of software (e.g. control software).

Software Architecture of a Network-based application[5]


History and Introduction

As software increased in size, interaction, and sophistication, the need for a conceptual or a bird-eye-view of a software system became a central issue in software engineering research in the early 90s [4]. While the field has not reached the level of maturity that building architecture, for example, enjoys, it has started finding its way into mainstream software development, and "software architects" have become an important commodity for most software projects.

As the World Wide Web continues to infiltrate our every day life, our level of reliance on software keeps increasing significantly. This gave rise to a new specialty of software architecture; architecture of network-based software, initially introduced in Roy Fielding's PhD dissertation [2].

Parts of an Architecture

Generally, architecture descriptions contain 3 major parts: components, connectors, and storage elements [1, 2]:

  • Components: Parts of the system where most of the computation occurs. The state of the components determines the state of the system as a whole.
  • Connectors: Used to connect components to each other, used as communication paths to facilitate communication between different components.
  • Storage Elements: Used to store and retrieve data used by the software system's components.


Software architectures have been categorized by observation. Seeing how successful software evolves, researchers were able to devise a number of categories that generally describe the most ubiquitous architectures, usually called "accidental" architectures. The name "accidental architectures" has been given since the the organization of these software systems did not follow any engineering guidelines and evolved with time until they took a permanent shape. [1, 3]

The following sections explain and illustrate some categories of network-based software architectures.


One of the most widespread styles in network-based applications. Consists of client based software and server based software where the server serves a number of clients concurrently. The client software is separated from the server software and the mode of communication between them is defined.[1]

Client Server Architecture

Layered System

In a layered system, the system consists of a number of components ordered in such a way where only adjacent components are able to communicate. Each layer of the system communicates with the layer above it and the layer below it. Even though processing overhead is increased by this kind of architecture, the extensibility and reusability of system components increases. This style is used extensively in network and non-network based software.[2]

Code On Demand (COD)

In COD, the clients request the code from the server as they need it. The code is received and is executed on the client's machine. This reduces the load on the server and gives a higher quality of service to the client. [2]

Event-based Integration

In Event-based Integration architectures, the components are laid out, but the interfaces between the components are not defined. The components communicate by broadcasting messages which will trigger action in other components that are accepting messages of that kind. This gives a flexibility to the system and great separation of concerns between components, but it makes it hard to predict how other components will react to a broadcasted message, i.e. its hard to predict the state of the system. [2, 4]

Replicated Repository

Software systems having a replicated repository architecture tend to have several processes providing the same set of services. Together these processes interact in order to give the user a feel that the service is centralized. While replication improves reliability, it has the disadvantage of having to keep the systems consistent. [2]

Architectural Views

Many researchers in the field believe that architectures should be viewed from more the one perspective. One common methodology is the 4+1 views of the architecture[3]:

  • Design View: Describes the services provided by the system that implement the functional requirements.
  • Implementation View: A deeper view of the files and components the system includes.
  • Process View: How the system will be running, the threads and the processes and how they interact.
  • Deployment View: Describe the parts of the hardware where the software system will run and how they interact with the software.
  • Use Case View: Describes the software system from the perspective of the users. This includes end-users, testers and other parties using the system.

Architecture Description Langauges (ADLs)

Architecture Description Languages are used to formally describe a software system's general layout. The need for formality in software architecture arose due to the complexity of software systems and hence the complexity of their architectures. In [6], Allen and Garlan describe one of the most popular ADLs. Other ADL research projects include:


  • Software architecture expertise is essential for a successful software project
  • As more and more software is becoming network-based, the need for a distinction between general architectures and network-based ones is increasing in importance.
  • The relative immaturity of the field and the lack of tools has sparked a large number of research projects addressing the issues from different directions.


[1] Bass, Clements & Kazman, Software Architecture in Practice, Addison-Wesley 1998

[2] Fielding, Roy Thomas. Architectural Styles and the Design of Network-based Software Architectures. Doctoral dissertation, University of California, Irvine, 2000.

[3] Grady Booch. The Architecture of Web Applications. IBM Developer Works. 01 Jun 2001. IBM. Last Accessed on 13 March 2008.

[4] D. Garlan and M. Shaw. An Introduction to software architecture. In Advances in Software Engineering and Knowledge Engineering, pages 1-39, Singapore, 1993. World Scientific Publishing Company.

[5] Personal Resource Planning. Last Accessed on 3 April 2008.

[6] R. Allen and D. Garlan. A formal basis for architectural connection. ACM Transactions on Software Engineering and Methodology, 6(3), July 1997.

See also

External links

--Aws 21:38, 2 April 2008 (EDT)

Personal tools