Showing papers on "Reference architecture published in 2002"

Principled design of the modern Web architecture

Abstract: 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 application. The modern Web architecture 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. In this article we introduce the Representational State Transfer (REST) architectural style, developed as an abstract model of the Web architecture and used to guide our redesign and definition of the Hypertext Transfer Protocol and Uniform Resource Identifiers. We 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. We then compare the abstract model to the currently deployed Web architecture in order to elicit mismatches between the existing protocols and the applications they are intended to support.

GATE, a General Architecture for Text Engineering

Abstract: This paper presents the design, implementation and evaluation of GATE, a General Architecture for Text Engineering.GATE lies at the intersection of human language computation and software engineering, and constitutes aninfrastructural system supporting research and development of languageprocessing software.

Behavior protocols for software components

Abstract: In this paper, we propose a means to enhance an architecture description language with a description of component behavior. A notation used for this purpose should be able to express the "interplay" on the component's interfaces and reflect step-by-step refinement of the component's specification during its design. In addition, the notation should be easy to comprehend and allow for formal reasoning about the correctness of the specification refinement and also about the correctness of an implementation in terms of whether it adheres to the specification. Targeting all these requirements together, the paper proposes employing behavior protocols which are based on a notation similar to regular expressions. As proof of the concept, the behavior protocols are used in the SOFA architecture description language at three levels: interface, frame, and architecture. Key achievements of this paper include the definitions of bounded component behavior and protocol conformance relation. Using these concepts, the designer can verify the adherence of a component's implementation to its specification at runtime, while the correctness of refining the specification can be verified at design time.

Towards architecture-based self-healing systems

Abstract: Our approach to creating self-healing systems is based on software architecture, where repairs are done at the level of a software system's components and connectors. In our approach, event-based software architectures are targeted because they offer significant benefits for run-time adaptation. Before an automated planning agent can decide how to repair a self-healing system, a significant infrastructure must be in place to support making the planned repair. Specifically, the self-healing system must be built using a framework that allows for run-time adaptation, there must be a language in which to express the repair plan, and there must be a reconfiguration agent that can execute the repair plan once it is created. In this paper, we present tools and methods that implement these infrastructure elements in the context of an overall architecture-based vision for building self-healing systems. The paper concludes with a gap analysis of our current infrastructure vs. the overall vision, and our plans for fulfilling that vision.

Perceptual Components for Context Aware Computing

Abstract: In this paper we propose a software architecture for observing and modeling human activity. This architecture is derived from an ontology for context awareness. We propose a model in which a user's context is described by a set of roles and relations. Different configurations of roles and relations correspond to situations within the context. The components of a context model are used to specify processes for observing activity. The ontology for context modeling is derived from both a bottom up system's perspective and a topdown users' perspective. As we define each element, we describe the corresponding components of a process-based software architecture. Using these components, a context is translated into a federation of observational processes. This model leads to an architecture in which reflexive elements are dynamically composed to form federations of processes for observing and predicting the situations that make up a context.

A Framework and Architecture for Multi-Robot Coordination

Abstract: In this paper, we present a framework and the software architecture for the deployment of multiple autonomous robots in an unstructured and unknown environment, with applications ranging from scouting and reconnaissance, to search and rescue, to manipulation tasks, to cooperative localization and mapping, and formation control. Our software framework allows a modular and hierarchical approach to programming deliberative and reactive behaviors in autonomous operation. Formal definitions for sequential composition, hierarchical composition, and parallel composition allow the bottom-up development of complex software systems. We demonstrate the algorithms and software on an experimental testbed that involves a group of carlike robots, each using a single omnidirectional camera as a sensor without explicit use of odometry.

Relating software requirements and architectures using problem frames

Abstract: Problem frames provide a means of analyzing and decomposing problems. They emphasise the world outside of the computer, helping the developer to focus on the problem domain, instead of drifting into inventing solutions. However, even modestly complex problems can force us into detailed consideration of the architecture of the solution. This is counter to the intention of the problem frames approach, which is to delay consideration of the solution space until a good understanding of the problem is gained. We therefore extend problem frames, allowing architectural structures, services and artifacts to be considered as part of the problem domain. Through a case study, we show how this extension enhances the applicability of problem frames in permitting an architecture-based approach to software development. We conclude that, through our extension, the applicability of problem frames is extended to include domains with existing architectural support.

Reliability prediction and sensitivity analysis based on software architecture

Abstract: Prevalent approaches to characterize the behavior of monolithic applications are inappropriate to model modern software systems which are heterogeneous, and are built using a combination of components picked off the shelf, those developed in-house and those developed contractually. Development of techniques to characterize the behavior of such component-based software systems based on their architecture is then absolutely essential. Earlier efforts in the area of architecture-based analysis have focused on the development of composite models which are quite cumbersome due to their inherent largeness and stiffness. In this paper we develop an accurate hierarchical model to predict the performance and reliability of component-based software systems based on their architecture. This model accounts for the variance of the number of visits to each module, and thus provides predictions closer to those provided by a composite model. The approach developed in this paper enables the identification of performance and reliability bottlenecks. We also develop expressions to analyze the sensitivity of the performance and reliability predictions to the changes in the parameters of individual modules. In addition, we demonstrate how the hierarchical model could be used to assess the impact of changes in the workload on the performance and reliability of the application. We illustrate the performance and reliability prediction as well as sensitivity analysis techniques with examples.

A comprehensive product line scoping approach and its validation

Abstract: Product Line Engineering is a recent approach to software development that specifically aims at exploiting commonalities and systematic variabilities among functionally overlapping systems in terms of large scale reuse. Taking full advantage of this potential requires adequate planning and management of the reuse approach as otherwise huge economic benefits will be missed due to an inappropriate alignment of the reuse infrastructure.Key in product line planning is the scoping activity, which aims at focussing the reuse investment where it pays. Scoping actually happens on several levels in the process: during the domain analysis step (analysis of product line requirements) a focusing needs to happen just like during the decision of what to implement for reuse. The latter decision has also important ramifications for the development of an appropriate reference architecture as it provides the reusability requirements for this step.In this paper, we describe an integrated approach that has been developed, improved, and validated over the last few years. The approach fully covers the scoping activities of domain scoping and reuse infrastructure scoping and was validated in several industrial case studies.

A reference architecture for adaptive hypermedia applications

Abstract: composite, 42 abstract concept, 42 accessor function, 17 Activation Graph (AG), 70 active rule, 61 adaptation description, 36 adaptation engine (AE), 57 adaptation goals, 21 adaptation model (AM), 50 adaptation rules, 50 adaptive hypermedia application, 60 additional explanations, 30 AHA, 127 AHAM, 40 AHAM-CA semantics, 78 AHAM-CA syntax, 72 AHS, 19 aid, 18 altering fragments, 31 AM-InterBook, 111 anchor, 18 anchoring, 16 atomic component, 18 atomic concepts, 42 avalue, 18

PASASM: a method for the performance assessment of software architectures

Abstract: Architectural decisions are among the earliest made in a software development project. They are also the most costly to fix if, when the software is completed, the architecture is found to be inappropriate for meeting quality objectives. Thus, it is important to be able to assess the impact of architectural decisions on quality objectives such as performance and reliability at the time that they are made.This paper describes PASA, a method for performance assessment of software architectures. It was developed from our experience in conducting performance assessments of software architectures in a variety of application domains including web-based systems, financial applications, and real-time systems. PASA uses the principles and techniques of software performance engineering (SPE) to determine whether an architecture is capable of supporting its performance objectives. The method may be applied to new development to uncover potential problems when they are easier and less expensive to fix. It may also be used when upgrading legacy systems to decide whether to continue to commit resources to the current architecture or migrate to a new one. The method is illustrated with an example drawn from an actual assessment.

Strategic technology architecture roadmap

Abstract: The preferred embodiments relate to a system and method for creating an end-to-end e-business system for an enterprise. In some embodiments, a strategic architecture roadmap includes: a) an upper infrastructure layer having a service-driven architecture, with a virtual application layer having a distributed component architecture, and with a an application infrastructure layer having an n-tiered architecture; and b) a lower infrastructure layer having a network-centric architecture, with a compute server infrastructure layer having an adaptive compute architecture, and with a data storage infrastructure layer having a storage network architecture.

Exploiting architectural design knowledge to support self-repairing systems

Abstract: In an increasing number of domains software is now required to be self-adapting and self-healing. While in the past such abilities were incorporated into software on a per system basis, proliferation of such systems calls for more generalized mechanisms to manage dynamic adaptation. General mechanisms have the advantage that they can be reused in numerous systems, analyzed separately from the system being adapted, and easily changed to incorporate new adaptations. Moreover, they provide a natural home for encoding the expertise of system designers and implementers about adaptation strategies and policies. In this paper, we show how current software architecture tools can be extended to provide such generalized dynamic adaptation mechanisms.

HW/SW partitioning and code generation of embedded control applications on a reconfigurable architecture platform

Abstract: This paper studies the use of a reconfigurable architecture platform for embedded control applications aimed at improving real time performance. The hw/sw codesign methodology from POLIS is used. It starts from high-level specifications, optimizes an intermediate model of computation (Extended Finite State Machines) and derives both hardware and software, based on performance constraints. We study a particular architecture platform, which consists of a general purpose processor core, augmented with a reconfigurable function unit and data-path to improve run time performance. A new mapping flow and algorithms to partition hardware and software are proposed to generate implementations that best utilize this architecture. Encouraging preliminary results are shown for automotive electronic control examples.

On Architectural Stability and Evolution

Abstract: Many organizations are now pursuing software architecture as a way to control their software development and evolution costs and challenges. A software architecture describes a system's structure and global properties and thus determines not only how the system should be constructed but also guides its evolution. An important challenge is to able to evaluate the "goodness" of a proposed architechture. I suggest stability or resilience as a primary criterion for evaluating an architecture. The stability of an architecture is a measure of how well it accomodates the evolution of the system without requiring changes to th architecture. As opposed to traditional predictive approaches to architecture evalution, I suggest retrospective analysis for evaluating architectural stability by examining the amount of change applied in successive releases of a software product. I review the results of a case study of twenty releases of a telecommunication software system containing a few million lines of code to show how retrospective analysis may be performed.

Integrating hundred's of products through one architecture - the industrial IT architecture

Abstract: During the last few years, software product line engineering has gained significant interest as a way for creating software products faster and cheaper. But what architecture is needed to integrate huge amounts of products, from different product lines? This paper describes such an architecture and its support processes and tools. Through cases, it is illustrated how the architecture is used to integrate new --- and old --- products in such diverse integration projects as vessel motion control, airport baggage handling systems, pulp&paper and oil&gas, in a very large organization. However, in a large organization it is a challenge to make everyone follow an architecture. Steps taken to ensure global architectural consistency are presented. It is concluded that a single architecture can be used to unify development in a huge organization, where the distributed development practices otherwise may prohibit integration of various products.

A scalable architecture for supporting interactive games on the internet

Abstract: This paper presents a scalable architecture for supporting large-scale interactive Internet games. In order to support a large number of participants and to divide the workload, the virtual world is divided into partitions. Each partition is then assigned to a server. A client (i.e., a player or a participant) will join a server according to the position of the avatar it controls. Compared to a centralized architecture, this distributed client-server architecture is more scalable. In addition, compared to a fully distributed, peer-to-peer architecture, it also provides a means for detecting cheating in distributed games. Since interactions and accounting information must be forwarded directly to one of the servers for qualification and verification, cheating amongst distributed players of the game will be minimized. To support secured communication for interactions and accounting information as well as to speedup periodic update messages (e.g., position updates), a hybrid communication scheme using both TCP and IP multicast is used between clients and the associated server. The communication among servers is enabled by the Run-Time Infrastructure (RTI) services. The High Level Architecture (HLA) Data Distribution Management (DDM) is employed to limit the amount of communication between the servers. In addition, the Ownership Management (OM) is also employed to implement the need for transferring the avatars between servers. In this paper, the design detail of the architecture will be presented. An experimental interactive Internet game realized using the architecture will be also described in the paper.

Privacy-enabled services for enterprises

Abstract: The IBM Enterprise Privacy Architecture (EPA) is a methodology for enterprises to provide an enhanced and well-defined level of privacy to their customers. EPA is structured in four building blocks. The privacy regulation analysis identifies and structures the applicable regulations. The management reference model enables an enterprise to define and enforce an enterprise privacy strategy and the resulting privacy practices. The privacy agreement framework is a methodology for privacy-enabling business process re-engineering. It outputs a detailed model of the privacy-relevant players and activities as well as the privacy policies that govern these activities. The technical reference architecture defines the technology needed for implementing the identified practices.

Generic RAM-based architecture for two-dimensional discrete wavelet transform with line-based method

Abstract: In this paper, by using line-based methods, a generic RAM-based architecture is proposed to construct the corresponding two-dimensional architectures efficiently for any given hardware architecture of one-dimensional wavelet filters, including conventional convolution-based and advanced lifting-based architectures. The categories of line buffer and the strategy to optimize the size of internal memory are also described. For multi-level two-dimensional discrete wavelet transforms, the recursive pyramid algorithm is adopted to turn our proposed architecture into another efficient architecture. According to the comparison results, the proposed architecture outperforms previous arts in the aspects of memory size, control complexity, and flexibility.

Software Architecture Reconstruction: Practice Needs and Current Approaches

Abstract: : Software architectures serve as the blueprints for systems, and they are central to the development of software product lines and the design of component-based systems. In existing systems, the architecture often must be reconstructed to reflect the as-built system accurately. This report presents the concept of practice scenarios for architecture reconstruction, which outline common problem/solution pairs that can be used in the strategic application of architecture reconstruction at Department of Defense (DoD) and commercial organizations. Based on an investigation of already developed and presented reconstruction approaches, the report describes deficiencies that have been uncovered in several practice scenarios and proposes improvements.

A method for understanding quality attributes in software architecture structures

Abstract: To sustain the qualities of a software system during evolution, and to adapt the quality attributes as the requirements evolve, it is necessary to have a clear software architecture that is understood by all developers and to which all changes to the system adheres. This software architecture can be created beforehand, but must also be updated as the domain of the software, and hence the requirements on the software system evolves. Creating an architectural structure for a system or part of a system so that the architecture fulfils the desired quality requirements is often hard. In this paper we propose a decision support method to aid in the understanding of different architecture structure candidates for a software system. We propose a method that is adaptable with respect to both the set of potential architecture structures, and quality attributes relevant for the system's domain to help in this task. The method creates a support framework, using a multi-criteria decision method, supporting comparison of different software architecture structures for a specific software quality attribute and vice versa. Moreover, given a prioritization of quality attributes for the software system, or part thereof, the most suitable software architecture structure can be indicated using the created framework.

Large-Scale Software Architecture: A Practical Guide using UML

Abstract: The purpose of large-scale software architecture is to capture and describe practical representations to make development teams more effective In this book the authors show how to utilise software architecture as a tool to guide the development instead of capturing the architectural details after all the design decisions have been made * Offers a concise description of UML usage for large-scale architecture * Discusses software architecture and design principles * Technology and vendor independent

Four metaphors of architecture in software organizations: finding out the meaning of architecture in practice

Abstract: Current literature, research, and practice provide ambiguous meanings for the concept of architecture in the context of software and systems development. This qualitative and grounded theory based study delves into the practice of architecture design and description in three software-producing organizations. Nineteen architects, designers, and managers are interviewed and the general meanings of architecture in practical real-life situations are distilled and analyzed The ambiguity of the concept of architecture receives its explanation. Architecture emerges as a plastic concept including diverging and simultaneous connotations for different stakeholders. The research process produces four general metaphors for architecture, "architecture as blueprint", "architecture as literature", "architecture as language", and "architecture as decision". These metaphors and the research process are presented and discussed in detail.

Less is more with minimalist architecture

Abstract: Architecture and governance bring an element of control that can rub people the wrong way. Architectural decisions should be focused where the payoff is highest to maximize the likelihood of success. The minimalist approach to architecture involves sorting out the highest-priority architectural requirements, and then doing the least you possibly can to achieve them! That is, keep the architecture decision set as small as possible, while ensuring that the technical staff meets key system priorities.

Multi-language, open-source modeling using the Microsoft .Net architecture

Abstract: This presentation reports on the opportunities and limitations of Microsoft .Net architecture for supporting the development of a common, open-source, multi-language platform for simulation software support. While the paper supporting the presentation focuses on the underlying foundation within the .Net architecture, the conference presentation represents an important milestone in the OpenSML project corresponding to the first release of a common library supporting the C#, VB.Net and Java/J# languages.