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

Software Architecture: Foundations, Theory, and Practice

Abstract: Software architecture has become a centerpiece subject for software engineers, both researchers and practitioners alike. At the heart of every software system is its software architecture, i.e., "the set of principal design decisions about the system". Architecture permeates all major facets of a software system, for principal design decisions may potentially be made at any time during a system's lifetime, and potentially by any stakeholder. Such decisions encompass structural concerns, such as the system's high-level building blocks---components, connectors, and configurations; the system's deployment; the system's non-functional properties; and the system's evolution patterns, including runtime adaptation. Software architectures found particularly useful for families of systems---product lines---are often codified into architectural patterns, architectural styles, and reusable, parameterized reference architectures. This tutorial affords the participant an extensive treatment of the field of software architecture, its foundation, principles, and elements, including those mentioned above. Additionally, the tutorial introduces the participants to the state-of-the-art as well as the state-of-the-practice in software architecture, and looks at emerging and likely future trends in this field. The discussion is illustrated with numerous real-world examples. One example given prominent treatment is the architecture of the World Wide Web and its underlying architectural style, REpresentational State Transfer (REST).

Software Architecture Reconstruction: A Process-Oriented Taxonomy

Abstract: To maintain and understand large applications, it is important to know their architecture. The first problem is that unlike classes and packages, architecture is not explicitly represented in the code. The second problem is that successful applications evolve over time, so their architecture inevitably drifts. Reconstructing the architecture and checking whether it is still valid is therefore an important aid. While there is a plethora of approaches and techniques supporting architecture reconstruction, there is no comprehensive software architecture reconstruction state of the art and it is often difficult to compare the approaches. This paper presents a state of the art in software architecture reconstruction approaches.

Gordon: using flash memory to build fast, power-efficient clusters for data-intensive applications

Abstract: As our society becomes more information-driven, we have begun to amass data at an astounding and accelerating rate. At the same time, power concerns have made it difficult to bring the necessary processing power to bear on querying, processing, and understanding this data. We describe Gordon, a system architecture for data-centric applications that combines low-power processors, flash memory, and data-centric programming systems to improve performance for data-centric applications while reducing power consumption. The paper presents an exhaustive analysis of the design space of Gordon systems, focusing on the trade-offs between power, energy, and performance that Gordon must make. It analyzes the impact of flash-storage and the Gordon architecture on the performance and power efficiency of data-centric applications. It also describes a novel flash translation layer tailored to data intensive workloads and large flash storage arrays. Our data show that, using technologies available in the near future, Gordon systems can out-perform disk-based clusters by 1.5× and deliver up to 2.5× more performance per Watt.

Principles of Synthetic Intelligence: Psi: An Architecture of Motivated Cognition

Abstract: From the Foreword: "In this book Joscha Bach introduces Dietrich Dorner's PSI architecture and Joscha's implementation of the MicroPSI architecture. These architectures and their implementation have several lessons for other architectures and models. Most notably, the PSI architecture includes drives and thus directly addresses questions of emotional behavior. An architecture including drives helps clarify how emotions could arise. It also changes the way that the architecture works on a fundamental level, providing an architecture more suited for behaving autonomously in a simulated world. PSI includes three types of drives, physiological (e.g., hunger), social (i.e., affiliation needs), and cognitive (i.e., reduction of uncertainty and expression of competency). These drives routinely influence goal formation and knowledge selection and application. The resulting architecture generates new kinds of behaviors, including context dependent memories, socially motivated behavior, and internally motivated task switching. This architecture illustrates how emotions and physical drives can be included in an embodied cognitive architecture. The PSI architecture, while including perceptual, motor, learning, and cognitive processing components, also includes several novel knowledge representations: temporal structures, spatial memories, and several new information processing mechanisms and behaviors, including progress through types of knowledge sources when problem solving (the Rasmussen ladder), and knowledge-based hierarchical active vision. These mechanisms and representations suggest ways for making other architectures more realistic, more accurate, and easier to use. The architecture is demonstrated in the Island simulated environment. While it may look like a simple game, it was carefully designed to allow multiple tasks to be pursued and provides ways to satisfy the multiple drives. It would be useful in its own right for developing other architectures interested in multi-tasking, long-term learning, social interaction, embodied architectures, and related aspects of behavior that arise in a complex but tractable real-time environment. The resulting models are not presented as validated cognitive models, but as theoretical explorations in the space of architectures for generating behavior. The sweep of the architecture can thus be larger-it presents a new cognitive architecture attempting to provide a unified theory of cognition. It attempts to cover perhaps the largest number of phenomena to date. This is not a typical cognitive modeling work, but one that I believe that we can learn much from." --Frank E. Ritter, Series Editor Although computational models of cognition have become very popular, these models are relatively limited in their coverage of cognition-- they usually only emphasize problem solving and reasoning, or treat perception and motivation as isolated modules. The first architecture to cover cognition more broadly is PSI theory, developed by Dietrich Dorner. By integrating motivation and emotion with perception and reasoning, and including grounded neuro-symbolic representations, PSI contributes significantly to an integrated understanding of the mind. It provides a conceptual framework that highlights the relationships between perception and memory, language and mental representation, reasoning and motivation, emotion and cognition, autonomy and social behavior. It is, however, unfortunate that PSI's origin in psychology, its methodology, and its lack of documentation have limited its impact. The proposed book adapts Psi theory to cognitive science and artificial intelligence, by elucidating both its theoretical and technical frameworks, and clarifying its contribution to how we have come to understand cognition.

A dependency constraint language to manage object-oriented software architectures

Abstract: This paper presents a domain-specific dependency constraint language that allows software architects to restrict the spectrum of structural dependencies, which can be established in object-oriented systems. The ultimate goal is to provide architects with means to define acceptable and unacceptable dependencies according to the planned architecture of their systems. Once defined, such restrictions are statically enforced by a tool, thus avoiding silent erosions in the architecture. The paper also presents results from applying the proposed approach to different versions of a real-world human resource management system. Copyright © 2009 John Wiley & Sons, Ltd.

A classification of software reference architectures: Analyzing their success and effectiveness

Abstract: A software reference architecture is a generic architecture for a class of information systems that is used as a foundation for the design of concrete architectures from this class. We observe that certain reference architectures have become more successful than others. One of the reasons for this is the level of congruence between their goals, context, and design. In this paper, we provide a framework for the classification of reference architectures. Using our framework on a set of reference architectures, and based on experiences with reference architectures, we define five main types of reference architectures that have congruent goals, context, and design. Reference architectures that can be classified in one of these types have better chances to become a success. We illustrate our conclusions with a number of reference architectures. This research facilitates design of more effective reference architectures.

Software Architecture Review: The State of Practice

Abstract: Architecture reviews are an effective way of ensuring design quality and addressing architectural concerns. However, the software engineering community rarely adopts the methods and techniques available to support disciplined architecture review processes.

Service oriented MAS: an open architecture

Abstract: This paper defines THOMAS, an open architecture and computational model for large-scale open multi-agent systems based on a service-oriented approach, specifically addressed for the design of virtual organizations.

A reference architecture for Event Processing

Abstract: Reference architectures predefine a common frame of reference, which can be customised to obtain architectures for specific applications in a domain. Based on a general reference model, providing a common language and semantics to explain the important concepts of Event Processing (EP), we define a general reference architecture which models the abstract architectural elements of an Event Processing-based system independent of the technologies, protocols, and products that might be used to implement it.

Selecting Concurrent Network Architectures at Runtime

Abstract: The current Internet architecture nicely structures functionality into layers of protocols. While this reduces complexity, many tweaks have emerged because of the architecture's limited flexibility. Cross Layer Functionality corrodes the layer boundaries, intermediate layers had to be introduced for protocols like MPLS and IPsec, and middleboxes - like in case of NAT - further complicate the interaction of protocols. To overcome these problems, many publications have proposed modular solutions or protocol composition, allowing software engineering ideas to improve protocol design. Other publications state that instead of choosing a single common network architecture for the Future Internet, it might be advantageous to run multiple different architectures in parallel. We combine both approaches and make it possible to rapidly create and run different network architectures in parallel. While this allows for simplified Future Internet development, it requires the network architecture to be dynamically chosen. This paper not only presents a node architecture enabling the parallel operation of different network architectures but also introduces algorithms for their selection at runtime.

Malaca: A component and aspect-oriented agent architecture

Abstract: The production of maintainable and reusable agents depends largely on how well the agent architecture is modularized. Most commercial agent toolkits provide an Object-Oriented (OO) framework, whose agent architecture does not facilitate separate (re)use of the domain-specific functionality of an agent from other concerns. This paper presents Malaca, an agent architecture that combines the use of Component-based Software Engineering and Aspect-Oriented Software Development, both of which promote better modularization of the agent architecture while increase at the architectural level. Malaca supports the separate (re)use of the domain-specific functionality of an agent from other communication concerns, providing explicit support for the design and configuration of agent architectures and allows the development of agent-based software so that it is easy to understand, maintain and reuse.

A Fuzzy Method for Propagating Functional Architecture Constraints to Physical Architecture

Abstract: Modular product design has received great attention for about 10 years, but few works have proposed tools to either jointly design the functional and physical architectures or propagate the impact of evolutions from one domain to another. In this paper, we present a new method supporting the product architecture design. In new product development situations or in re-engineering projects, system architects could use this method in the early design stages to predetermine cohesive modules and integrative elements and to simulate a domain architecture by propagating architecture choices from another domain. To illustrate our approach, we present an industrial case study concerning the design of a new automobile powertrain.

CGADL: An Architecture Description Language for Coarse-Grained Reconfigurable Arrays

Abstract: The high degree of freedom in the design of coarse-grained reconfigurable arrays imposes new challenges on their description and modeling. In this paper, we introduce an architecture description language targeted to describe coarse-grained reconfigurable architecture templates. It comprises innovative key features to allow fast modeling and analysis of such architectures, i.e.: representation of processing element array (ir)regularities, and flexible and concise description of interconnection network. We demonstrate that the proposed language enables a formal validation of the described template, and it eases the analysis and estimation of hardware costs earlier in the design phase. Finally, we show how we automatically generate a SystemC-based simulator of the described architecture. Our results suggest that the semantic and technical innovations of the proposed architecture description language may have a positive impact on the productivity of the design phase.

Using Service-Oriented Architectures for Socio-Cultural Analysis

Abstract: An emergent domain that raises some unique engineering challenges is that of software architectures to convert large bodies of unstructured data to human-usable knowledge, such as in the domain of socio-cultural information analysis. We report on an architecture based on Service-Oriented Architectures that we are applying in this domain. We list the requirements that such an architecture must support, describe our architecture for addressing them, and outline what we believe are the important engineering and research issues that must still be overcome.

Haggle: a data-centric network architecture for mobile devices

Abstract: Delay-tolerant and opportunistic networks relax the traditional assumption of end-to-end connectivity. Such networks are therefore suitable for content dissemination in sparsely connected regions of the world, and for complementing existing infrastructure by operating cost-free, high bandwidth, albeit high latency, content delivery services.In this work we argue, however, that content dissemination in the above contexts requires us to revisit delay-tolerant communication at the architectural level, looking at multiple issues such as naming and addressing, congestion control and application interfaces. We propose a new architecture, called Haggle, that leverages the principles of search, as known from desktop operating systems and the Web, in order to achieve truly data-centric communication. Searching is naturally data-centric and embeds principles, such as ranking, that can be used to bind data to interested receivers and to prioritize the data to send during node encounters. We herein give an overview of the Haggle architecture and its basic design.

Layered architecture revisited — Comparison of research and practice

Abstract: Organizing a software architecture into layers has been one of the earliest architectural styles ever used. Even today layered structure is a very common architectural style used in various industrial systems. However, we have observed that the usage of layered architectural style varies greatly in different contexts. This paper aims to compare the notion of software architecture layers in research literature as well as in industrial practice. Firstly, we performed a systematic literature review of research articles on layered software architectures; we also reviewed selected books of software architecture. Secondly, to understand the practice, we investigated a number different recent architecture documents to cover the current usage of layered architectures. Our results indicate that there is very little actual research done on layered architectures. The current usage of layered structures seems to be more complex than reported before. This gap between the research and practice needs to be bridged by researchers.

Cognitive map architecture

Abstract: We have developed the Cognitive Map robot architecture that minimizes the amount of rewriting of existing legacy software for integration. The Cognitive Map can be thought of as a centralized information space for connected components to contribute both internal and environmental state information. We leverage several successfully proven concepts such as blackboard architectures and publish- subscribe based messaging to develop a flexible robot architecture that exhibits fault-tolerance, easily substituted components, and provides support for different structural paradigms such as subsumption, sense-plan-act and three-tier architectures. Our multicomponent distributed system has system components that are loosely coupled via message-passing and/or continuous data streams. This architecture was implemented on the humanoid robot ASIMO manufactured by Honda Motor Co., Ltd. We review various forms of communication middleware and component models. The "Architecture" section provides an overview of our architecture and considerations in its design. The "Scenario Design" section details the process from conceptualizing an interactive application to its instantiation in the robot architecture. The "Components" section singles out several important high-level components that play a significant role in many of our interactive scenarios. Finally, discussions and conclusions are presented.

Benefits of SOA: Evaluation of an implemented scenario against alternative architectures

Abstract: Service-oriented architecture (SOA) is based on a design principle for business software systems. The SOA movement has taken up momentum, especially because of widespread middleware vendor support, e.g. by IBM, HP, BEA, Microsoft, Sun, Software AG, TIBCO, Oracle, SAP and others. Still answers to questions of how the target architecture should look like and what the advantages over other architectures are remain open. We have implemented a scenario based on free software, which consists of a well-defined service-oriented target architecture. In this article, we compare the used service-oriented approach with other state-of-theart architectures to show that changeability and efficiency improve compared to alternative architectures.

A Structured Approach for Reviewing Architecture Documentation

Abstract: : This technical note proposes a structured approach for reviewing architecture documentation. Given the critical importance of architecture to software project success, it follows that the architecture cannot be effective unless it is effectively captured in documentation that allows the architecture's stakeholders to understand and use the architecture in the way it was intended. The approach does not assume a particular architecture methodology or a particular architecture documentation practice, although it was conceived in the context of the International Organization for Standardization (ISO) Recommended Practice for Architecture Description of Software-Intensive Systems and the SEI Views and Beyond approach to documenting software architectures. Like both of them, our approach is centered on the stakeholders of the artifact, engaging them in a focused, guided way to ensure that the documentation carries sufficient quality to enable them to do their jobs and to help them point out gaps and weaknesses. Our approach is not intended as a complete framework for architecture evaluation; rather it is meant to be used within such a framework, when one is available.

Software Architecture Evaluation in Global Software Development Projects

Abstract: Due to ever increasing system complexity, comprehensive methods for software architecture evaluation become more and more important. This is further stressed in global software development (GSD), where the software architecture acts as a central knowledge and coordination mechanism. However, existing methods for architecture evaluation do not take characteristics of GSD into account. In this paper we discuss what aspects are specific for architecture evaluations in GSD. Our experiences from GSD projects at Capgemini sd&m indicate, that architecture evaluations differ in how rigorously one has to assess modularization, architecturally relevant processes, knowledge transfer and process alignment. From our project experiences, we derive nine good practices, the compliance to which should be checked in architecture evaluations in GSD. As an example, we discuss how far the standard architecture evaluation method used at Capgemini sd&m already considers the GSD-specific good practices, and outline what extensions are necessary to achieve a comprehensive architecture evaluation framework for GSD.

Demystifying Data-Centric Web Services

Abstract: Service-oriented architecture (SOA) promotes a paradigm in which enterprise applications are implemented as reusable, interoperable, network-accessible software modules. Ambiguity is introduced when enterprise organizations devise natural language specifications to describe the service capabilities. Consequently, consumers often misinterpret operational details while using these services, resulting in unfavorable side-effects. Practical, verifiable, and reusable solutions are required to mitigate these issues.

Scenario-Based Genetic Synthesis of Software Architecture

Abstract: Software architecture design can be regarded as finding an optimal combination of known general solutions and architectural knowledge with respect to given requirements. Based on previous work on synthesizing software architecture using genetic algorithms, we propose a refined fitness function for assessing software architecture in genetic synthesis, taking into account the specific anticipated needs of the software system under design. Inspired by real life architecture evaluation methods, the refined fitness function employs scenarios, specific situations possibly occurring during the lifetime of the system and requiring certain modifiability properties of the system. Empirical studies based on two example systems suggest that using this kind of fitness function significantly improves the quality of the resulting architecture.

Context Aware Middleware Architecture for Wireless Sensor Network

Abstract: Wireless sensor networks are application specific,data centric networks where different applications run on deployed network. Each application interprets the underlying sensor network differently and each changing event has different effect on running applications.In this paper we have proposed context aware middleware architecture called as ’MidSen’. This architecture bridges the gap between multiple applications running at application level and deployed sensor networks.MidSen architecture handles static as well as dynamically changing network and application components.MidSen has adopted a rule based engine to handle system dynamics. Midsen makes applications flexible by allowing them to update their rules against knowledge base. Our experimental results show that proposed Context Aware Service Discovery (CASD)algorithm gives better recall value and precision compare to previously proposed discovery algorithms.

Architecture Design for the Large-Scale Software-Intensive Systems: A Decision-Oriented Approach and the Experience

Abstract: Software architectures are considered the key means to manage the complexity of large-scale systems from the high abstraction levels and system-wide perspectives. The traditional software design methodologies and the emerging architecture design methods still fall short of coping with the architectural complexity and difficulty in practice. The recent research on the architecture design decisions mostly focuses on its representation, providing little support for the architecture design task itself. In this paper we propose a decision-oriented architecture design approach ABC/DD, based on the decision-abstraction and issue-decomposition principles specific to the architecture level design of software. The approach models software architecture from the perspective of design decisions, and accomplishes the architecture design from eliciting architecturally significant design issues to exploiting and making decisions on the solutions for these issues. We illustrate the application of the approach with two real-life large-scale software-intensive projects, showing that the decision-oriented approach accommodates the characteristics and demands of the architecture level, and facilitates the design of architecture and the capture of the essential decisions for large complex systems.

Connecting Architecture and Implementation

Abstract: Software architectures are still typically defined and described independently from implementation. To avoid architectural erosion and drift, architectural representation needs to be continuously updated and synchronized with system implementation. Existing approaches for architecture representation like informal architecture documentation, UML diagrams, and Architecture Description Languages (ADLs) provide only limited support for connecting architecture descriptions and implementations. Architecture management tools like Lattix, SonarJ, and Sotoarc and UML-tools tackle this problem by extracting architecture information directly from code. This approach works for low-level architectural abstractions like classes and interfaces in object-oriented systems but fails to support architectural abstractions not found in programming languages. In this paper we present an approach for linking and continuously synchronizing a formalized architecture representation to an implementation. The approach is a synthesis of functionality provided by code-centric architecture management and UML tools and higher-level architecture analysis approaches like ADLs.

Exploring ontologies to support the establishment of reference architectures: An example on software testing

Abstract: Software architectures have played a significant role in determining the success of software systems. In particular, reference architectures have emerged, achieving well-recognized understanding in a specific domain, promoting reuse of design expertise and facilitating the development of systems. In another perspective, ontologies have been widely investigated aiming at representing, communicating and reusing knowledge. In spite of their relevance on directly dealing with domain knowledge, reference architectures and ontologies have been separately treated. In this paper we investigate the impact in using ontologies to the establishment of reference architectures. We illustrate our idea using an ontology of software testing to build a reference architecture for the testing domain. Preliminary results indicate that ontologies are an important and viable mechanism aiming at building reference architectures.