Showing papers on "Database-centric architecture published in 2000"

Architectures for netcentric computing systems

Abstract: An execution architecture, a development architecture and an operations architecture for a netcentric computing system. The execution architecture contains common, run-time services required when an application executes in the netcentric computing system. The development architecture is the production environment for one or several systems development projects as well as for maintenance efforts. The purpose of the development environment is to support the tasks involved in the analysis, design, construction, and maintenance of business systems, as well as the associated management processes. It is important to note that the environment should adequately support all the development tasks, not just the code/compile/test/debug cycle. The operations architecture is a combination of tools and support services required to keep a production system up and running efficiently.

ATAM: Method for Architecture Evaluation

Abstract: : If a software architecture is a key business asset for an organization, then architectural analysis must also be a key practice for that organization. Why? Because architectures are complex and involve many design tradeoffs. Without undertaking a formal analysis process, the organization cannot ensure that the architectural decisions made-particularly those which affect the achievement of quality attribute such as performance, availability, security, and modifiability-are advisable ones that appropriately mitigate risks. In this report, some of the technical and organizational foundations for performing architectural analysis are discussed, the Architecture Tradeoff Analysis Method (ATAM), is presented. The ATAM is a technique for analyzing software architectures that has been developed and refined in practice over the past three years.

Representing and encoding plant architecture: A review

Abstract: A plant is made up of components of various types and shapes. The geometrical and topological organisation of these components defines the plant architecture. Before the early 1970's, botanical drawings were the only means to represent plant architecture. In the past two decades, high-performance computers have become available for plant growth analysis and simulation, triggering the development of various formal representations and notations of plant architecture (strings of characters, axial trees, tree graphs, multiscale graphs, linked lists of records, object-oriented representations, matrices, fractals, sets of digitised points, etc.). In this paper, we review the main representations of plant architecture and make explicit their common structure and discrepancies. The apparent heterogeneity of these representations makes it difficult to collect plant architecture information in a generic format to allow multiple uses. However, the collection of plant architecture data is an increasingly important issue, which is also particularly time-consuming. At the end of this review, we suggest that a task of primary importance for the plant-modelling community is to define common data formats and tools in order to create standard plant architecture database systems that may be shared by research teams.

Architecture-based performance analysis applied to a telecommunication system

Abstract: Software architecture plays an important role in determining software quality characteristics, such as maintainability, reliability, reusability, and performance. Performance effects of architectural decisions can be evaluated at an early stage by constructing and analyzing quantitative performance models, which capture the interactions between the main components of the system as well as the performance attributes of the components themselves. The paper proposes a systematic approach to building layered queueing network (LQN) performance models from a UML description of the high-level architecture of a system and more exactly from the architectural patterns used for the system. The performance model structure retains a clear relationship with the system architecture, which simplifies the task of converting performance analysis results into conclusions and recommendations related to the software architecture. The proposed approach is applied to a telecommunication product for which an LQN model is built and analyzed. The analysis shows how the performance bottleneck is moving from component to component (hardware or software) under different loads and configurations and exposes some weaknesses in the original software architecture, which prevent the system from using the available processing power at full capacity due to excessive serialization.

A soft radio architecture for reconfigurable platforms

Abstract: While many soft/software radio architectures have been suggested and implemented, there remains a lack of a formal design methodology that can be used to design and implement these radios. This article presents a unified architecture for the design of soft radios on a reconfigurable platform called the layered radio architecture. The layered architecture makes it possible to incorporate all of the features of a software radio while minimizing complexity issues. The layered architecture also enables a methodology for incorporating changes and updates into the system. An example implementation of the layered architecture on actual hardware is presented.

C4ISR architectures: II. A structured analysis approach for architecture design

Abstract: A Structured Analysis based process for developing C4ISR architectures is presented. The process demonstrates the feasibility of developing architecture descriptions that conform to the C4ISR Architecture Framework based on the Structured Analysis paradigm that underlies the concepts and definitions in the Framework. Furthermore, the process incorporates the derivation of an executable model that can reveal the logical, behavioral, and performance characteristics of the architecture. The complete process is illustrated through an example involving the insertion of a new technology in a large legacy system. © 2000 John Wiley & Sons, Inc. Syst Eng 3: 248–287, 2000

Towards a UML profile for software architecture descriptions

Abstract: To formally describe architectures of software systems, specific languages called Architecture Description Languages (ADLs) have been developed by academic institutions and research labs. However, more and more research and industrial projects are using the standard Unified Modeling Language (UML) for representing software architectures of systems. In this paper, we focus on how to extend the UML by incorporating some key abstractions found in current ADLs, such as connectors, components and configurations, and how the UML can be used for modeling architectural viewpoints. Our approach is demonstrated by the software architecture of a video surveillance system. It is therefore the purpose of the paper to show that a UML profile for software architecture abstractions is needed.

Using the Architecture Tradeoff Analysis MethodSM to Evaluate a Reference Architecture: A Case Study

Abstract: : The software architecture of a system is a major determinant of software quality and one of the earliest artifacts available for evaluation. For a government acquisition organization, the ability to evaluate software architectures can have a favorable impact on the delivered system. This technical note describes the application of the Architecture Tradeoff Analysis Method (ATAM) to evaluate a reference architecture for ground-based command and control systems. The use of the term reference architecture in the context of this application is presented. A general overview of the ATAM process is provided and the results of the ATAM are explored, including the benefits of performing an ATAM-based architecture evaluation both to the acquirer and to the developer.

Analyzing Software Architectures for Modifiability.

Abstract: The software architecture plays an important role in achieving a modifiable system, but few methods for modifiability analysis exist. In this paper, we propose an analysis method for software architecture modifiability that has successfully been applied in several cases. The method consists of five main steps, i.e. goal selection, software architecture description, scenario elicitation, scenario evaluation and interpretation.

Generation of Design Suggestions for Coarse-Grain Reconfigurable Architectures

Abstract: Coarse-grain reconfigurable architectures have been a matter of intense research in the last few years. They promise to be more adequate for computational tasks due to their better efficiency and bigger speed. As the coarse granularity implies also a reduction of fiexibility, a universal architecture seems to be hardiy feasible. Based on the KressArray architecture family, a design-space exploration system is being impiemented, which supports the designer in finding an appropriate architecture for a given application domain. By analysing the results of a number of different experimental mappings, the system derives suggestions how the architecture can be enhanced. This paper presents an analyser tool, which allows the generation of such suggestions using approximate reasoning based on fuzzy logic. The tool is flexible enough to support different data gathering methods and an extensible rule set.

Around the Lab in 40 days ...

Abstract: In previous papers (11 we have argued that the LAAS architecture’ is one of the most suited for mobile robot control. This statement may seem over-optimistic, not to say pretentious and unverifiable. After all, can we compare architectures? can we set up benchmarks? or can we measure how good an architecture is compared to another? An architecture defines organization principles, integration methods and supporting tools. Comparing those tools, methods and principles may sometime end up in sterile controversies. However, we think there are means to measure the overall quality (or interest) of an architecture. Development time is for example one relevant criterion [5]. Basically, using a specific architecture, how long does it take to integrate a complete demonstration, including non trivial decisional capabilities, from the low level functional modules up to the supervisory level? This may seem a rather weak measure of an architecture quality, however, it encompasses properties such as: genericity and adaptability, ease of design and programming, extensibility and robustness. In this paper we describe our recent experience in integrating a complete demonstration from scratch in 40 days using the LAAS architecture.

Dragonfly: linking conceptual and implementation architectures of multiuser interactive systems

Abstract: Software architecture styles for developing multiuser applications are usually defined at a conceptual level, abstracting such low-level issues of distributed implementation as code replication, caching strategies and concurrency control policies. Ultimately, such conceptual architectures must be cast into code. The iterative design inherent in interactive systems implies that significant evolution will take place at the conceptual level. Equally, however, evolution occurs at the implementation level in order to tune performance. This paper introduces Dragonfly, a software architecture style that maintains a tight, bidirectional link between conceptual and implementation software architectures, allowing evolution to be performed at either level. Dragonfly has been implemented in the Java-based TeleComputing Developer (TCD) toolkit.

A Functional Architecture Approach to Neural Systems

Abstract: The technology for the design of systems to perform extremely complex combinations of real-time functionality has developed over a long period. This technology is based on the use of a hardware architecture with a physical separation into memory and processing, and a software architecture which divides functionality into a disciplined hierarchy of software components which exchange unambiguous information. This technology experiences difficulty in design of systems to perform parallel processing, and extreme difficulty in design of systems which can heuristically change their own functionality. These limitations derive from the approach to information exchange between functional components. A design approach in which functional components can exchange ambiguous information leads to systems with the recommendation architecture which are less subject to these limitations. Biological brains have been constrained by natural pressures to adopt functional architectures with this different information exchange approach. Neural networks have not made a complete shift to use of ambiguous information, and do not address adequate management of context for ambiguous information exchange between modules. As a result such networks cannot be scaled to complex functionality. Simulations of systems with the recommendation architecture demonstrate the capability to heuristically organize to perform complex functionality.

Aspect-oriented analysis for product line architecture

Abstract: In designing a product-line architecture (PLA), it is important to analyze common and variable requirements in a product family. These requirements must be analyzed not only from the functional aspect but also from aspects related to quality attributes such as performance and reliability. For example, if two products are required to attain different levels of performance, architectures for these products may be different even if they provide the same functionality. In this paper, we propose an aspect-oriented analysis method for PLA design in which we analyze product requirements from each aspect separately. In the method, we identify important factors for each quality attribute, and characterize the services in terms of the factors. Based on the characterization, we separate requirements related to each quality attribute from the original requirements. Using the method, we can examine the architecture styles required for a PLA from each aspect, which can make PLA design easier.

Issues in Analyzing the Behavior of Event Dispatching Systems

Abstract: A good architecture is a necessary condition to guarantee that the expected levels of performance, availability, fault tolerance, and scalability are achieved by the implemented system. While in the software architecture domain several approaches focus on checking static characteristics of software systems, a general approach to performance analysis, independent from a specific application domain, is still missing. In this paper we focus on the analysis of performances of an event-based middleware with two objectives in mind: first, to determine the design alternative that provides the best performances; second, to experience with statistical analysis and simulation tools in order to understand their applicability to the evaluation of software architectures.

Viable systems: the control paradigm for software architecture revisited

Abstract: An emerging class of software applications are identified as "complex" systems. They are complex in that they must adapt to a changing environment. This motivates us to revisit the "control paradigm" for software architecture. In this paper, we go beyond that approach and introduce the concept of viability as the overall characteristic of the behaviour desired in such systems. We present an architecture to guide the software engineering of this class of complex system. The architecture is based on a cybernetic model called the "viable system model". As an application of the approach, we are developing a "smart lecture room". We report on our efforts in employing the architecture to develop this application.

Incorporating Non-functional Requirements into Software Architectures

Abstract: The concept of softw are architecture has created a new scenario for incorporating non-functional and transactional requirements into the software design. Transactional and non-functional requirements can be included in an architecture-based software development through formal approaches in which first-order and temporal logic are utilised to deal with them. In this paper, we present an approach in which transactional and non-functional requirements are formally incorporated into a special class of software architectures, known as dynamic software architectures. In order to demonstrate how this proposal can be utilised in a real application, an appointment system is presented.

SAABNet: Managing qualitative knowledge in software architecture assessment

Abstract: Quantitative techniques have traditionally been used to assess software architectures. We have found that early in development process there is often insufficient quantitative information to perform such assessments. So far the only way to make qualitative assessments about an architecture, is to use qualitative assessment techniques such as peer reviews. The problem with this type of assessment is that they depend on the techniques knowledge of the expert designers who use them. In this paper we introduce a technique, SAABNet (Software Architecture Assessment Belief Network), that provides support to make qualitative assessments of software architectures.

Port-based adaptable agent architecture

Abstract: To facilitate the design of large-scale, self-adaptive systems, we have developed the Port-Based Adaptable Agent Architecture. This distributed, multiagent architecture allows systems to be created with the flexibility and modularity required for the rapid construction of software systems that analyze and dynamically modify themselves to improve performance. This architecture provides user-level access to the three forms of software adaptability: parametric fine tuning, algorithmic change, and code mobility. In this paper, we present the architecture, describe port-based agents, and outline several applications where this flexible architecture has proven useful.

Around the lab in 40 days [indoor robot navigation]

Abstract: The authors previously (1998) argued that the LAAS architecture is one of the most suitable for mobile robot control. This statement may seem over-optimistic, not to say pretentious and unverifiable. After all, can we compare architectures? can we set up benchmarks? or can we measure how good an architecture is compared to another? An architecture defines organization principles, integration methods and supporting tools. Comparing those tools, methods and principles may sometime end up in sterile controversies. However, we think there are means to measure the overall quality (or interest) of an architecture. Development time is for example one relevant criterion. Basically, using a specific architecture, how long does it take to integrate a complete demonstration, including nontrivial decisional capabilities, from the low level functional modules up to the supervisory level? This may seem a rather weak measure of architecture quality; however, it encompasses properties such as genericity and adaptability, ease of design and programming, extensibility and robustness. In this paper we describe our recent experience in integrating a complete demonstration from scratch in 40 days using the LAAS architecture.

On the design and implementation of a hierarchical, generic and scalable open architecture for the network management layer

Abstract: In this paper we address the design and implementation aspects of a generic architecture for the NML (network management layer). The focus in this paper will be on SNMP manageable ADSL/ATM networks. SNMP (simple network management protocol) is a standardized protocol which is supported by almost all current computer network devices. The architecture is compliant with the TINA (Telecommunication Information Network Architecture) recommendations and is implemented based on the CORBA (Common Object Request Broker Architecture) standard. During the design and implementation process, a lot of effort has been devoted to the performance, robustness, persistence and consistence of the distributed software under various load and fault scenarios. The most suitable distributed software techniques, like object transactions, concurrency control, event notification and naming service were used and thoroughly tested on their usability. It is also indicated how the core of the described architecture can be extended towards next-generation IP-based networks.

Evaluation and diagnosis of concurrency architectures

Abstract: Because it affects such things as the degree to which logical concurrency can be realized by physically concurrent devices, the concurrency architecture of software can have a large impact on performance. Architectural decisions such as concurrency are typically made early in the development of software, and are difficult to change once the software has begun to be fleshed out. It is therefore useful to be able to evaluate the feasibility of software concurrency architectures proposed for a set of scenarios and a set of response-time requirements which, in part, define a particular software project. Such evaluation, however, is difficult because it is hard to predict the effects of pre-emption, the amount of concurrency-related overhead generated, and which portions of scenarios will actually be performed in parallel and which will for some reason end up serialized. So that one can discover possible ways to improve a concurrency architecture, it is also useful to diagnose an architecture for causes of performance shortfalls. This thesis describes an approach (and a tool) called PERFECT which performs such evaluations and diagnoses by automatically constructing and simulating an instrumented virtual implementation which conforms to a behaviour and concurrency architecture easily specified by supplying a Use Case Map supplemented with performance information. This work focuses on software for servers. An evaluation reports, for each type of response, the fraction of responses which finish within the specified delay time. Also reported is the utilization of each device. Diagnoses include measurements of the cumulative effect of priority inversion at each point where messages are sent to a software process, lost opportunities to concurrently use multiple devices by the most urgent work, and the amounts of different types of concurrency-related overhead such as context switching. To demonstrate how the whole approach works, a number of cycles of proposing, evaluating, and diagnosing a concurrency architecture for a group communication server are presented. The first architecture cannot process requests as fast as they arrive. By remedying the diagnosed causes of performance shortfalls, an architecture is derived which meets all performance requirements. Adding concurrency not suggested by diagnoses causes performance to decline.

Prophid: A Platform-Based Design Method

Abstract: The continuing trendtowards higher integration densities of integrated circuits makesthe development of systems-on-a-chip possible. For well-definedapplication domains ``silicon platforms'' must be defined whichallow efficient, yet programmable implementations. These platformsare heterogeneous reconfigurable multiprocessor architecturessupporting a variety of communication and computation models.As a consequence designers are facing a large architecture spacewith new possibilities for new architectures. To exploit theseopportunities a better understanding of system level architecturesis necessary. A first step in this direction is to learn fromdesign exercises. Eventually this may lead towards a system leveldesign method. In this paper a multiprocessor architecture templateis presented that serves as a platform for high-throughput applications.Central to this architecture is a reconfigurable high-performanceprocessor network that uses communication concepts based on theTST-networks known from the literature. We discuss the characteristicsof the architecture template in detail. Furthermore, we willdiscuss the specification, modelling, and mapping of applicationsfor this architecture. Finally, we analyse cost and performancefigures using real implementation results.

Distributed architecture technologies

Abstract: Moving from a legacy architecture to one that uses distributed objects has both complexities and rewards. IT managers who are planning this move face several distribution issues that require them to make crucial choices involving a wide range of languages, operating systems, networking protocols, and applications. The paper presents a review of the various types of architectures.

Specification of software architecture

Abstract: Over the past several years, software architecture representation and analysis has become an active area of research. However, most approaches to software architecture representation and analysis have been informal. We postulate that through formality, the term "architecture" can be precisely defined and important properties of systems, such as semantic compatibility between connected entities, can be investigated with precision. In this paper, we use category theory and algebraic specifications to develop a formal definition of architecture and show how architecture theory can be used in the construction of software specifications.

A novel architecture of distribution management system

Abstract: This paper explores the techniques of designing an open architecture for distribution management system. By applying the object modeling technique, the distribution circuit is modeled at a basic as well as various levels of abstractions, which is capable of supporting a wide range of distribution applications. In addition, the data of the distribution circuit is defined in a well-organized structure that no data redundancy occurs when multiple simultaneous functions are invoked. Based on this model, a three-tier software architecture of DMS, which meets the standards of the open system, has been proposed. Evaluations of this architecture have also been presented in this paper.

A Software Architecture for Timetable Construction

Abstract: As timetable construction research moves beyond the limitations of single, isolated solution methods, software architectures are needed that allow the researcher to combine many different solution methods in arbitrary ways in the solution of a single problem. This paper describes a blackboard architecture, implemented as an object-oriented framework, which addresses this need. Also included is a first application of the framework, comparing two quite different solution methods on a tutor allocation problem.