Showing papers on "Reference architecture published in 2003"

Creating a Strategic IT Architecture Competency: Learning in Stages

Abstract: IT architecture is often assumed to follow business strategy, to align IT with the business's strategic objectives Increasingly, though, many business strategies depend on specific underlying IT capabilities To develop a synergy between business strategy and IT architecture, firms must develop organizational competencies in IT architecture My research has identified four IT architectural stages, each with its own requisite competencies The "application silo architecture stage" consists of IT architectures of individual applications The "standardized technology architecture stage" has an enterprise-wide IT architecture that provides efficiencies through technology standardization The "rationalized data architecture stage" extends the enterprise-wide IT standards to data and processes And the "modular architecture stage" builds onto enterprise-wide global standards with loosely coupled IT components to preserve the global standards while enabling local differences Each stage demands different organizational competencies to implement the architecture and prepare the firm to move to the next stage

From system goals to software architecture

Abstract: Requirements and architecture are two essential inter-related products in the software lifecycle. Software architecture has long been recognized to have a profound impact on non-functional requirements about security, fault tolerance, performance, evolvability, and so forth. In spite of this, very few techniques are available to date for systematically building software architectures from functional and non-functional requirements so that such requirements are guaranteed by construction. The paper addresses this challenge and proposes a goal-oriented approach to architectural design based on the KAOS framework for modeling, specifying and analyzing requirements. After reviewing some global architectural decisions that are already involved in the requirements engineering process, we discuss our architecture derivation process. Software specifications are first derived from requirements. An abstract architectural draft is then derived from functional specifications. This draft is refined to meet domain-specific architectural constraints. The resulting architecture is then recursively refined to meet the various non-functional goals modelled and analyzed during the requirements engineering process.

FARA: reorganizing the addressing architecture

Abstract: sloppy This paper describes FARA, a new organization of, network architecture concepts. FARA (Forwarding directive, Association, and Rendezvous Architecture) defines an abstract model with considerable generality and flexibility, based upon the decoupling of end-system names from network addresses. The paper explores the implications of FARA and the range of architecture instantiations that may be derived from FARA. As an illustration, the paper outlines a particular derived architecture, M-FARA, which features support for generalized mobility and multiple realms of network addressing.

Using Service-Oriented Architecture and Component-Based Development to Build Web Service Applications

Abstract: Building an enterprise-scale software system is a complex undertaking. Despite decades of technological advances, the demands imposed by today’s information systems frequently stretch to breaking point a company’s ability to design, construct, and evolve its mission-critical software solutions. In particular, few new systems are designed from the ground up. Rather, a software architect’s task is commonly that of extending the life of an existing solution by describing new business logic that manipulates an existing repository of data, presenting existing data and transactions through new channels such as an Internet browser or handheld devices, integrating previously disconnected systems supporting overlapping business activities, and so on. To assist software developers, commercial software infrastructure products are now available from vendors such as Microsoft and IBM. They form the centerpiece of the approaches to software development they advocate in their .NET and WebSphere product lines, respectively. Both approaches focus on assembly of systems from distributed services [1,2]. However, is there anything new about building enterprise-scale solutions from services? How do the lessons of component-based systems apply to construction of service-based architectures (SOA)? What are the best approaches for building high quality systems for deployment to this new generation of software infrastructure products? These important questions are the topic of this paper.

Plutarch: an argument for network pluralism

Abstract: It is widely accepted that the current Internet architecture is insufficient for the future: problems such as address space scarcity, mobility and non-universal connectivity are already with us, and stand to be exacerbated by the explosion of wireless, ad-hoc and sensor networks. Furthermore, it is far from clear that the ubiquitous use of standard transport and name resolution protocols will remain practicable or even desirable.In this paper we propose Plutarch, a new inter-networking architecture. It subsumes existing architectures such as that determined by the Internet Protocol suite, but makes explicit the heterogeneity that contemporary inter-networking schemes attempt to mask. To handle this heterogeneity, we introduce the notions of context and interstitial function, and describe a supporting architecture. We discuss the benefits, present some potential scenarios, and consider the research challenges posed.

Hierarchical Small Worlds in Software Architecture

Abstract: The components of a large software application do not interact in random ways Instead, class diagrams exhibit remarkable topological similarities to other natural and artificial systems The components of a large software application are very well connected because the mean shortest distance between them is very low in spite of having a relatively small number of connections per class In addition, these diagrams are very heterogeneous These measurements are of a general nature and are largely independent of the particular semantics of the application As shown in this paper, and irrespective of the specific features of each system analyzed, the final outcome of software evolution is a small world, hierarchical class diagram with well-defined statistical properties The consequences for software evolution are outlined

How history justifies system architecture (or not)

Abstract: The revision history of a software system conveys important information about how and why the system evolved in time. The revision history can also tell us which parts of the system are coupled by common changes: "whenever the database schema was changed, the sqlquery() method was altered, too." This "evolutionary" coupling can be compared with the coupling as imposed by the system architecture; differences indicate anomalies which may be subject to restructuring. Our ROSE prototype analyzes fine-grained coupling between software entities as indicated by common changes. It turns out that common changes are a good indicator for modularity, that evolutionary coupling should be determined between syntactical entities (rather than files or modules), and that common changes can indicate coupling between software entities and nonprogram artifacts that is unavailable to the analysis of a single version.

The Art of Software Architecture: Design Methods and Techniques

Abstract: This book synthesizes and distills information so that the practicing software architect, and especially the beginning software architect, can fill in the gaps in their understanding of software architecture design.

Evaluation of Architectures for Mobile Robotics

Abstract: In this paper we make a comparative study of some successful software architectures for mobile robot systems. The objective is to gather experience for the future design of a new robot architecture. Three architectures are studied more closely, Saphira, TeamBots and BERRA. Qualities such as portability, ease of use, software characteristics, programming and run-time efficiency are evaluated. In order to get a true hands-on evaluation, all the architectures are implemented on a common hardware robot platform. A simple reference application is made with each of these systems. All the steps necessary to achieve this are discussed and compared. Run-time data are also gathered. Conclusions regarding the results are made, and a sketch for a new architecture is made based on these results.

Quality Characteristics for Software Architecture.

Abstract: It is of general agreement that quality issues should be considered very early in the software development process, to mitigate risks and to facilitate the achievement of the overall software system. Moreover, the architecture of the system drives the whole development process. The fulfillment of nonfunctional quality requirements by a candidate architecture is crucial to select the convenient architecture on which the whole system will be articulated. This issue is very important in the construction of reliable evolutionary applications. Software development methods do not give many details on this important stage. This work deals with the specification of quality requirements for software architecture, introducing a technique based on the ISO 91261 standard. The quality characteristics of the ISO quality model are refined into attributes, which can be measured to enrich the information about the architecture. Our technique is used to help selecting a suitable architecture among a set of candidates, by comparing the values of the respective quality attributes. A case study illustrates the application of the technique on a monitoring system. Our approach facilitates the choice of the right decisions during the architecture analysis process. It could be easily integrated into a general software development process or into specific architectural design methods.

Architectural views of aspects

Abstract: Support for the incremental design of aspects themselves has been neglected, even as the use of aspects in conjunction with underlying systems is gaining acceptance. The ways in which aspects can cooperate or interfere with each other need to be made explicit at the design level. An aspect architecture, a new software architecture viewtype, is proposed, and its general principles are explained. An instantiation for extending UML is described, where designs of aspects provide maximal flexibility, and a new concern diagram is provided to show how aspects can be combined to treat different concerns of a system. An example shows aspect architecture views of a digital sound recorder.

DAOP-ADL: an architecture description language for dynamic component and aspect-based development

Abstract: Architecture description languages deal with the description, analysis and reuse of software architectures. This paper describes DAOP-ADL, a component- and aspect-based language to specify the architecture of an application in terms of components, aspects and a set of plug-compatibility rules between them. With the aim of connecting the specification of the application architecture to the implementation, we describe our language using XML and XML Schemas. The DAOP-ADL language was designed to be interpreted by DAOP, our own dynamic component- and aspect-oriented platform. DAOP provides a composition mechanism that plugs aspects into components dynamically at runtime. The software architect will use the DAOP-ADL language at design time to describe the architecture of the application. Later this architectural information is loaded into the DAOP platform, which needs it to establish the dynamic connections between autonomous components and aspects. Therefore, the use of DAOP-ADL closes the gap between design and implementation of component- and aspect-based applications.

Architecture as a coordination tool in multi‐site software development

Abstract: A widely held understanding of coordination in software development is that it focuses on coordinating development activities to achieve a common goal. Our study, a case study in an international ICT company, suggests that in multi-site environment, it is not enough to coordinate development activities to achieve a common goal. Rather, more emphasis should be put on coordinating interdependencies between activities. Shifting the interest from activities (and subsystems) toward system-level dependencies requires software architects and developers to have a common understanding of the software architecture. Our findings reflect coordination challenges in multi-site environment with geographically dispersed teams. On the basis of the findings, we claim that architecture could be used to coordinate distributed development. However, this requires that the chief architect is capable of maintaining the integrity of the architecture and of communicating it. Furthermore, we list some requirements for a development methodology that uses architecture to support the coordination. Copyright © 2004 John Wiley & Sons, Ltd.

Aligning application architecture to the business context

Abstract: Alignment of application architecture to business architecture is a central problem in the design, acquisition and implementation of information systems in current large-scale information-processing organizations. Current research in architecture alignment is either too strategic or too software implementation-oriented to be of use to the practicing information systems architect. This paper presents a framework to analyze the alignment problem and operationalizes this as an approach to application architecture design given a business context. We summarize guidelines for application architecture design and illustrate our approach and guidelines with an example.

Wireless sensor networks - new challenges in software engineering

Abstract: Software development for wireless sensor networks requires novel programming paradigms and technologies This article describes the concept of a new service oriented software architecture for mobile sensor networks With this architecture, a flexible, scalable programming of applications based on an adaptive middleware is possible The middleware supports mechanisms for cooperative data mining, self-organization, networking, and energy optimization to build higher-level service structures The purpose of our research activities is the development of a framework, which radically simplifies the development of software for sensor network applications

A quality-driven decision-support method for identifying software architecture candidates

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 underst ...

Method of modeling frameworks and architecture in support of a business

Abstract: An enterprise architecture for a business is divided into a business architecture and an information technology architecture. The business architecture is the main driver for the information technology architecture but the information technology architecture can also have an impact on the construction of the business architecture. A framework tower is built around essential and mandatory components of the enterprise architecture. The framework tower is made up of a plurality of planes representing mandatory components of the enterprise architecture. The components of the framework tower include a strategic plan, a business architecture, an information architecture, an application architecture, a technology infrastructure architecture, an enterprise information technology management architecture, and a security architecture. Each component identifies and categorizes requisite architectural components and elements of a business. Each component in the framework tower addresses the people, processes, and technology of the enterprise architecture so that strategic information technology planning and repeatable and effective information technology enabling solutions can be performed and delivered to the business.

An Empirically-Based Process for Software Architecture Evaluation

Abstract: Software systems undergo constant change causing the architecture of the system to degenerate over time. Reversing system degeneration takes extra effort and delays the release of the next version. Improved architecture is intangible and does not translate into visible user features that can be marketed. Due to a lack of representative metrics, technical staff has problems arguing that stopping degeneration is indeed necessary and that the effort will result in an improved architecture that will pay off. We believe that architectural metrics would give technical staff better tools to demonstrate that the architecture has improved. This paper defines and uses a set of architectural metrics and outlines a process for analyzing architecture to support such an argument. The paper reports on a case study from a project where we restructured the architecture of an existing client-server system written in Java while adding new functionality. The modules of the existing version of the system were “library-oriented” and had a disorganized communication structure. The new architecture is based on components and utilizes the mediator design pattern. The goal of the study is to evaluate the new architecture from a maintainability perspective. The paper describes our evaluation process, the metrics used, and provides some preliminary results. The architectural evaluation shows that the components of the system are only loosely coupled to each other and that an architectural improvement has occurred from a maintenance perspective. The process used to evaluate the architecture is general and can be reused in other contexts.

An object-oriented software architecture for 3D mixed reality applications

Abstract: This paper presents a new software architecture for 3D mixed reality applications, named Tinmith-evo5. Currently there are a limited number of existing toolkits for the development of 3D mixed reality applications, each optimized for particular feature but at the detriment of others. Complex interactive user interfaces and applications require extensive supporting infrastructure, and can be hampered by inadequate support. The Tinmith-evo5 architecture is optimised to develop mobile augmented reality and other interactive 3D applications on portable platforms with limited resources. This architecture is implemented in C++ with an object-oriented data flow design, an object store based on the Unix file system model, and uses other ideas from existing previous work.

An implementable architecture of an e-learning system

Abstract: This paper analyses current standards and proposals for e-learning system architecture. Its main objective is to contribute an original proposal for a functional architecture and service architecture for building standard-driven distributed and interoperable learning systems. The functional architecture defines components that make up an e-learning system and the objects that must be moved among these components. We implement the service model with Web Services technology to provide a standard means of communication among different Learning management systems and different content authoring tools. This paper focuses on how to integrate Web Services on the e-learning application domain. We use J2EE as our technical infrastructure to build our components and integrate with Web service.

Intelligent mechatronic components: control system engineering using an open distributed architecture

Abstract: This paper reports the results of case study on application of open distributed software architecture IEC61499 to the organization of intelligence, embedded to smart mechatronic components. The presented approach targets the issues related to integration and reconfiguration of automation systems, where the software integration plays an important role. Based on the testbed studies, a classification of "intelligence classes" is suggested. Several integration and reconfiguration scenarios are illustrated.

A Mapping of Individual Architecture Frameworks (GRAI, PERA, C4ISR, CIMOSA, ZACHMAN, ARIS) onto GERAM

Abstract: This Chapter presents the mapping of selected type 2 (life cycle) enterprise architectures and architecture frameworks onto the Generalised Enterprise Reference Architecture and Methodology (GERAM) framework. It covers aspects regarding the reference architectures (including life cycle / life history concepts and modelling frameworks) and associated modelling methodologies, languages and reference models where applicable. The Chapter builds on previous mapping efforts of established frameworks, giving a refined interpretation of those results. In addition, several emerging frameworks are also reviewed and mapped against the GERAM.

Experiences with software product family evolution

Abstract: The evolution of product family typically oscillates between growing and consolidating phases. The migration path starts from a copy/paste approach that offers the fastest time-to-market and then moves towards a mature software platform that offers a higher throughput of products. We have identified several issues that harm the evolution of the family: new requirements that can break the architectural integrity of the family, increasing level of bureaucracy in the organization and a slower process of change. We present two approaches for coping with the family evolution: architecture assessment and architecture reconstruction. We also present Nokia case studies where the methods have been successfully applied.

DARX - a framework for the fault-tolerant support of agent software

Abstract: This paper presents DARX, our framework for building applications that provide adaptive fault tolerance. It relies on the fact that multi-agent platforms constitute a very strong basis for decentralized software that is both flexible and scalable, and makes the assumption that the relative importance of each agent varies during the course of the computation. DARX regroups solutions which facilitate the creation of multi-agent applications in a large-scale context. Its most important feature is adaptive replication: replication strategies are applied on a per-agent basis with respect to transient environment characteristics such as the importance of the agent for the computation, the network load or the mean time between failures. Firstly, the interwoven concerns of multi-agent systems and fault-tolerant solutions are put forward. An overview of the DARX architecture follows, as well as an evaluation of its performances. We conclude, after outlining the promising outcomes, by presenting prospective work.

Architecture-based approaches to software reliability prediction

Abstract: With growing emphasis on reuse, the software development process moves toward component-based software design. As a result, there is a need for modeling approaches that are capable of considering the architecture of the software made out of components. This paper presents an overview of the state of the research and practice in the architecture-based approach to quantitative assessment of software systems. First, the common requirements of the architecture-based models are identified and the classification is proposed. Then, the key models in each class are described in detail with a focus on their relation and unification. Finally, a critical analysis of the underlying assumptions, limitations, and applicability of these models is provided, which should be helpful in determining the directions for future research.

VERAM: Virtual Enterprise Reference Architecture and Methodology

Abstract: Nowadays, enterprises cooperate more extensively with other enterprises during the entire product life cycle. Temporary alliances between various enterprises emerge such as those in Virtual Enterprises. However, many enterprises experience difficulties in the formation and operation of virtual enterprises, for instance concerning integration issues. This chapter lays down an architectural framework, called VERAM, which aims to support the set up and operation of virtual enterprises. The framework aims to offer handles that contribute to solving the problems that enterprises face when they want to cooperate in a Virtual Enterprise. Supported by the framework, individual enterprises might operate and set up a virtual enterprise from a dynamic, inter-enterprise network. Furthermore, this chapter shows how other chapters of this book fit into the VERAM architectural framework.

Model Driven Architecture as Approach to Manage Variability in Software Product Families

Abstract: In this paper we portrait Model Driven Architecture (MDA) as an approach to derive products in a particular class of software product families, i.e. a configurable product family. The main contribution of this paper is that we relate MDA to a configurable software product family and discuss the mutual benefits of this relation. With respect to variability management, we identify two main benefits of applying MDA to product family engineering, i.e. postponing binding time and mechanism selection to application engineering, and the independent evolution of domain concepts, product family assets and the transformation technique. In addition, we identify variability management as a solution to the problem of round-trip transformation in MDA. Keyword(s): Model Driven Architecture, Software Product Families, Variability Management

A Component Architecture for High-Performance Computing

Abstract: The Common Component Architecture (CCA) provides a means for developers to manage the complexity of large-scale scientific software systems and to move toward a ''plug and play'' environment for high-performance computing. The CCA model allows for a direct connection between components within the same process to maintain performance on inter-component calls. It is neutral with respect to parallelism, allowing components to use whatever means they desire to communicate within their parallel ''cohort.'' We will discuss in detail the importance of performance in the design of the CCA and will analyze the performance costs associated with features of the CCA.