The World Wide Web has succeeded in large part because its software architecture has been designed to meet the needs of an Internet-scale distributed hypermedia system. The Web has been iteratively developed over the past ten years through a series of modifications to the standards that define its architecture. In order to identify those aspects of the Web that needed improvement and avoid undesirable modifications, a model for the modern Web architecture was needed to guide its design, definition, and deployment. Software architecture research investigates methods for determining how best to partition a system, how components identify and communicate with each other, how information is communicated, how elements of a system can evolve independently, and how all of the above can be described using formal and informal notations. My work is motivated by the desire to understand and evaluate the architectural design of network-based application software through principled use of architectural constraints, thereby obtaining the functional, performance, and social properties desired of an architecture. An architectural style is a named, coordinated set of architectural constraints. This dissertation defines a framework for understanding software architecture via architectural styles and demonstrates how styles can be used to guide the architectural design of network-based application software. A survey of architectural styles for network-based applications is used to classify styles according to the architectural properties they induce on an architecture for distributed hypermedia. I then introduce the Representational State Transfer (REST) architectural style and describe how REST has been used to guide the design and development of the architecture for the modern Web. REST emphasizes scalability of component interactions, generality of interfaces, independent deployment of components, and intermediary components to reduce interaction latency, enforce security, and encapsulate legacy systems. I describe the software engineering principles guiding REST and the interaction constraints chosen to retain those principles, contrasting them to the constraints of other architectural styles. Finally, I describe the lessons learned from applying REST to the design of the Hypertext Transfer Protocol and Uniform Resource Identifier standards, and from their subsequent deployment in Web client and server software.

Software change requests are often formulated as requests to modify or to add a specific feature or concept. To implement these changes, the features or concepts must be located in the code. In this paper, we describe the scenarios of the feature and concept location. The scenarios utilize a computer-assisted search of software dependence graph. Scenarios are demonstrated by a case study of NCSA Mosaic source code. 1. Introduction In software maintenance and evolution, change requirements are often formulated as requests to modify or to add specific program concepts or features [2, 26]. An example of such a request is "Add a new external viewer to Mosaic web browser". Before any actual change can be made to the system, software programmers must locate the implementation of the concepts ("external viewer") in the source code. Concept location is a process that maps domain concepts to the software components. The input is the maintenance request, expressed in natural language and usin...

Software architectures have recently emerged as a level of design concerned with specifying the overall structure of a system. Traditionally, software architectures only provide static descriptions of the participants and interaction structures in a system. Dynamic software architectures, however, can be reconfigured at runtime and therefore provide support for building dynamically adaptable applications. Software architectures can be specified using architectural reflection. In this paper we introduce an architecture meta-model that realises a dynamic software architecture. The architecture meta-model reifies the configuration graph of the architecture and is automatically generated from our component definitions and implementation language sourcecode.

The description of a software architecture style must include the structural model of the components and their interactions, the laws governing the dynamic changes in the architecture, and the communication pattern. In our work we represent a system as a graph where hyperedges are components and nodes are ports of communication. The construction and dynamic evolution of the style will be represented as context-free productions and graph rewriting. To model the evolution of the system we propose to use techniques of constraint solving. From this approach we obtain an intuitive way to model systems with nice characteristics for the description of dynamic architectures and recon guration and, a unique language to describe the style, model the evolution of the system and prove properties. 1

The application of formal methods to the development of software depends on the availability of adequate models and formalisms for each of the stages of the development process. In this work, we focus on the level of design called Software Architecture. At this level, the system is described as a collection of interrelated components, and it is here where the properties derived from system’s structure can be naturally analyzed. Our approach uses process algebras as a formal basis for the description and analysis of software architectures. Process algebras are widely accepted for the specification of software systems. In particular π-calculus addresses the description of systems with a dynamic or evolving topology, and permits their analysis for bisimilarity and other interesting properties. Though bisimilarity determines the equivalence of behavior, more flexible relations are needed in the context of Software Engineering, in order to support formally the notions of conformance and refinement of behavior. In this paper we present a relation of compatibility in the context of π-calculus which formalizes the notion of conformance of behavior between software components. Our approach is enhanced with the definition of a relation of inheritance among processes. This relation preserves compatibility and indicates whether a process can be considered as a specialization or extension of another one. The suitability of our approach is shown by its application to the field of Software Architecture 1.

in software requirements. This paper presents a theoretical model for the evolution of component-based software, based on evolving interoperation graphs. The model assumes that each change consists of smaller granularity steps of change propagation, each of them being a visit to one specific component. If the component is modified, it may no longer fit with the other components because it may no longer properly interact with them. In that case secondary changes must be made in neighboring components, which may trigger additional changes, etc. The paper contains an example of evolution of a calendar program, represented in UML. 1.

This paper presents a formal approach for managing unanticipated software evolution. Labelled typed nested graphs are used to represent arbitrarily complex software artifacts, and conditional graph rewriting is used for managing evolution of these artifacts. More specifically, we detect structural and behavioural inconsistencies when merging parallel evolutions of the same software artifact. The approach is domain-independent, in the sense that it can be customised to many different domains, such as software architectures, UML analysis and design models, and software code.

A-posteriori integration of heterogeneous engineering tools supplied by different vendors constitutes a challenging task. In particular, this statement applies to incremental development processes where small changes have to be propagated --- potentially bidirectionally --- through a set of inter-dependent design documents which have to be kept consistent with each other. Responding to these challenges, we have developed an approach to tool integration which puts strong emphasis on software architecture and model-driven development. Starting from an abstract description of a software architecture, the architecture is gradually refined down to an implementation level. To integrate heterogeneous engineering tools, wrappers are constructed for abstracting from technical details and for providing homogenized data access. On top of these wrappers, incremental integration tools provide for inter-document consistency. These tools are based on graph models of the respective document classes and graph transformation rules for maintaining inter-document consistency. Altogether, the collection of support tools and the respective infrastructure considerably leverage the problem of composing a tightly integrated development environment from a set of heterogeneous engineering tools.

Abstract not found

Software architecture-based approaches provide high-level abstractions to deal with complexity and richness of modern software systems. Many software systems have been found to share organizational and interaction characteristics. Architectural styles have been proposed to codify commonly used idioms of component structures, organizations and interactions. Existing classifications of architectural styles provide empirical support for style selection, but fail to systematically characterize them and do not reveal the basis underlying them. Moreover, the mapping between software architecture and design is poorly understood. My doctoral research proposes to create an understanding of, and as a result a composition framework for architectural styles using a small set of architectural primitives that are reused across styles to produce effective style implementation infrastructures. Architectural styles can be comprehensively characterized in terms of five concern areas: external structure, topology, behavior, interaction and data flow. This hypothesis is validated based on whether the characterization captures all the invariant aspects of styles, and is further confirmed through a Delphi with software architectural experts. My current research is focused on arriving at an assembly language for software architectures, Alfa, and architectural primitives, referred to as Alfa primitives, are a step towards this goal. Alfa primitives, representing architectural style characteristics, form a small set of “atomic elements” and can be reused across styles. Lightweight formal models and Java implementations of primitives and styles are created. The number of primitives is compared with sizes of primitive sets in other areas such as microprocessors and physics. Style models composed from Alfa primitives are analyzed to validate reuse of primitives. Alfa primitives can lead to effective style implementation infrastructures in terms of fidelity, performance and flexibility. Fidelity is validated based on the mapping that exists between style characteristics and Alfa primitives in the implementation. Performance is evaluated in terms of time and memory utilization of benchmark applications that use style implementation infrastructures. Flexibility is validated in terms of the change involved in implementation infrastructure for supporting extensions of styles. The main contributions of this research will be as follows: A novel approach for style characterization and understanding, A novel approach for composition of architectural styles, A small set of architectural primitives reused across styles, Compositional, lightweight formal model of styles, and An effective implementation of style infrastructures.