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

Reference architecture and product line architecture: a subtle but critical difference

Abstract: Currently, the size and complexity of software systems, as well as critical time to market, demand new approaches from Software Engineering discipline for building such systems In this context, the use of reference architectures and product line architectures is becoming a common practice However, both of these concepts are sometimes mistakenly seen as the same thing; it is also not clearly established how they can be explored in a complementary way in order to contribute to software development The main contribution of this paper is to make a clear differentiation between these architectures, by investigating and establishing definitions for each of them Based on this, we also propose the use of reference architectures as a basis for product line architectures As a result, a better understanding of both reference architectures and product line architectures, as well as an understanding of how to explore them jointly, can contribute to promoting more effective reuse in the development of software systems

Empirically-grounded reference architectures: a proposal

Abstract: A reference architecture describes core elements of the software architecture for systems that stem from the same domain. A reference architecture ensures interoperability of systems through standardization. It also facilitates the instantiation of new concrete architectures. However, we currently lack procedures for systematically designing reference architectures that are empirically-grounded. Being empirically-grounded would increase the validity and reusability of a reference architecture. We therefore present an approach which helps systematically design reference architectures. Our approach consists of six steps performed by the software architect and domain experts. It helps design reference architectures either from scratch, or based on existing architecture artifacts. We also illustrate how our approach could be applied to the design of two existing reference architectures found in literature.

Leveraging software architectures to guide and verify the development of sense/compute/control applications

Abstract: A software architecture describes the structure of a computing system by specifying software components and their interactions. Mapping a software architecture to an implementation is a well known challenge. A key element of this mapping is the architecture's description of the data and control-flow interactions between components. The characterization of these interactions can be rather abstract or very concrete, providing more or less implementation guidance, programming support, and static verification. In this paper, we explore one point in the design space between abstract and concrete component interaction specifications. We introduce a notion of interaction contract that expresses allowed interactions between components, describing both data and control-flow constraints. This declaration is part of the architecture description, allows generation of extensive programming support, and enables various verifications. We instantiate our approach in an architecture description language for Sense/Compute/Control applications, and describe associated compilation and verification strategies

Pinpointing data locality problems using data-centric analysis

Abstract: In modern computer architectures, access latency varies considerably between different levels in the memory hierarchy. Consequently, applications with data access patterns that don't reuse much data in fast levels of the hierarchy incur additional delays. To improve the performance of complex, data-intensive applications, developers need tools that help them understand the causes of poor memory hierarchy utilization. While most performance tools associate metrics with functions or statements, in this paper we explore data-centric analyses that associate metrics not only with data accesses but also with data objects themselves. Our contributions are three-fold. First, we propose several refinements to existing data-centric techniques that enable accurate and low-overhead measurements. Second, we combine data-centric analysis with call path profiling; this combination of techniques relates inefficient access patterns back to data objects across complete dynamic call chains. Third, we developed a graphical user interface that gracefully presents our analysis results using a multiplicity of views, which helps users identify problematic accesses and data structures. We demonstrate the utility of our approach by showing how our tool identifies problematic data access patterns in several HPC applications and a pair of the SPEC CPU2006 benchmarks.

Relating Software Requirements and Architectures

Abstract: Why have a book about the relation between requirements and software architecture? Understanding the relation between requirements and architecture is important because the requirements, be they explicit or implicit, represent the function, whereas the architecture determines the form. While changes to a set of requirements may impact on the realization of the architecture, choices made for an architectural solution may impact on requirements, e.g., in terms of revising functional or non-functional requirements that cannot actually be met.Although research in both requirements engineering and software architecture is quite active, it is in their combination that understanding is most needed and actively sought. Presenting the current state of the art is the purpose of this book. The editors have divided the contributions into four parts: Part 1 Theoretical Underpinnings and Reviews addresses the issue of requirements change management in architectural design through traceability and reasoning. Part 2 Tools and Techniques presents approaches, tools, and techniques for bridging the gap between software requirements and architecture. Part 3 Industrial Case Studies then reports industrial experiences, while part 4 on Emerging Issues details advanced topics such as synthesizing architecture from requirements or the role of middleware in architecting for non-functional requirements. The final chapter is a conclusions chapter identifying key contributions and outstanding areas for future research and improvement of practice.The book is targeted at academic and industrial researchers in requirements engineering or software architecture. Graduate students specializing in these areas as well as advanced professionals in software development will also benefit from the results and experiences presented in this volume.

Multilayer networks: an architecture framework

Abstract: We present an architecture framework for the control and management of multilayer networks and associated advanced network services. This material is identified as an "architecture framework" to emphasize its role in providing guidance and structure to our subsequent detailed architecture, design, and implementation activities. Our work is motivated by requirements from the Department of Energy science application community for real-time on-demand science-domain-specific network services and resource provisioning. We also summarize the current state of deployments and use of network services based on this multilayer network architecture framework.

Pattern-Based Architecture Reviews

Abstract: Software architecture reviews are effective in identifying potential problems in architectures, however, are expensive, time-consuming, and generally rely on extensive architecture documentation. An architecture review that accommodates projects with very short development cycles, minimal documentation, or frequently changing requirements could be useful if it identifies important architectural issues. We developed a useful, inexpensive architecture review method that uses the architecture patterns in a system to identify important issues in the achievement of quality attributes.

Automatic Tracing of Decisions to Architecture and Implementation

Abstract: Traceability requires capturing the relations between software artifacts like requirements, architecture and implementation explicitly. Manual discovery and recovery of tracing information by studying documents, architecture documentation and implementation is time-intensive, costly, and may miss important information not found in the analyzed artifacts. Approaches for explicitly capturing traces exist, but either require manual capturing or lack comprehensive tracing to both architecture and implementation. In this paper we present an approach for (semi)automatically capturing traceability relationships from requirements and design decisions to architecture and implementation. Traces are captured in a non-intrusive way during architecture design and implementation. The captured traces are integrated with a semi-formally defined architecture description model and serve as the basis for different kinds of architecture-related activities.

Service-Oriented Reference Architecture for Personalized E-learning Systems (SORAPES)

Abstract: a lot of research involves in the area of e-learning with service-oriented architecture. In e-learning systems, the challenges are increase of the complexity and more interoperability between systems in distributed environment. The lacking is reference architecture in which by reusing web services, reusing learning objects and semantics, ontology, etc. A service-oriented reference architecture describes the essence of a software architecture and the most significant and relevant aspects. Hence, it is proposed to design reference architecture to personalized e-learning systems using Web services and service- oriented architecture. The objective of this paper to design service-oriented reference architecture for personalized e- learning systems (SORAPES) and validate the architecture. Some of the existing e-learning architectures that serve as the domain model for personalized e-learning system were considered, discussed in details and finally proposed a new architecture which is called SORAPES. The SORAPES was designed by re-using web services and learning objects. It is a layered architecture and highly-scalable for personalized e- learning system. This architecture was evaluated with a list of quality attributes. Keywords-learning, Personalization, Reference Architecture, Service- Oriented Architecture, Semantic Web, Web Service, Ontology

Wireless personal area networks architecture and protocols for multimedia applications

Abstract: Wireless Personal Area Networks (WPANs) are an emerging technology for future short-range indoor and outdoor multimedia and data centric applications. Two types of WPANs have been standardized by the IEEE 802.15 working group; namely: High data Rate WPANs (HR-WPANs) and Low data Rate WPANs (LR-WPANs). These standards define the network architecture, the physical layer and the medium access control sublayer for these systems. A tremendous number of performance studies through mathematical analysis and simulation have been published. Also, many products have appeared in the market which indicate a clear sign of a quick acceptance to the published standards. An organized review of the network architecture, the physical layer specifications, the Medium Access Control (MAC) protocols and the general network operation concepts of the WPAN systems deserves time and effort to be presented in a collective manner. In this paper we describe the concept of WPANs and its applications. Then, the communication architecture and the allocated frequency spectrum for WPAN operation are explained. The developed MAC sublayer protocols in the literature are explored.

Measuring complexity of component based architecture: a graph based approach

Abstract: Component based software development (CBSD) is an evolving paradigm where emphasis is laid on reuse of existing components and effective designing of components. As complexity of software systems increases, the challenge of CBSD lies in designing highly cohesive, testable components. Researcher community is striving hard to identify the attributes characterizing component-based development and proposing metrics that may help in controlling the complexity of the component-based systems. This paper proposes a metric-based approach for the determination of complexity along with a set of architectural aspects of componentbased architectures. The Component Architecture Complexity Measurement Metrics (CACMM) has been proposed based on Component Architecture Graph (CAG), a graphical model used for representing UML component diagram. Analysis of the graph is done to measure complexity at different levels -- individual component level, component-to-component level and the complexity for the overall architecture. This metrics may be used by developers to assess the component based architecture and if required re-design to create highly cohesive components with minimal coupling. A case study is presented for deriving the complexity along with the other aspects of the architecture.

Model driven development for data-centric sensor network applications

Abstract: The primary purpose of a wireless sensor network (WSN) is to collect and disseminate sensory data and possibly perform some calculations. However, there are no convenient frameworks in place to allow instant access to this sensed information in a programming environment. Using a model-driven approach, we present a development tool to support applications development for data-centric sensor network. In this study, a domain-specific language (DSL) and corresponding meta-models are designed and implemented to specify all aspects of a sensor node application, especially for data processing tasks such as sampling, aggregation and forwarding. The language comes with tools supporting automatic model transformations to generate application code.

Exploring the use of reference architectures in the development of product line artifacts

Abstract: Software Product Line (SPL) has arisen as an approach for developing a family of software-intensive systems at lower costs, within shorter time, and with higher quality. In particular, SPL is supported by a product line architecture (sometimes also referred to as reference architecture) that captures the architectures of a product family. In another context, a special type of architecture that contains knowledge about a specific domain has been increasingly investigated, resulting in the Reference Architecture research area. In spite of the positive impact of this type of architecture on reuse and productivity, the use of existing domain-specific reference architectures as basis of SPL has not been widely explored. The main contribution of this paper is to present how and when elements contained in existing reference architectures could contribute to the building of SPL artifacts during development of an SPL. We have observed that, in fact, reference architectures could make an important contribution to improving reuse and productivity, which are also important concerns in SPL.

An architecture for

Abstract: "Web Of Things" evolved from "Internet Of Things". Lot of research has been done in designing architecture for "Web Of Things". Two main architectures are Smart gateway based architecture and embedded Web Server based architecture. These architectures address some of the basic and essential issues relating to Service Oriented Architecture for "Web Of Things". Taking into consideration the period of coexistence of IPv4 and IPv6 we propose an architecture using SOCKS protocol based IPv6/IPv4 gatewaying and refinements which facilitates smooth heterogeneous communications between the IPv6 and IPv4 enabled embedded nodes and can potentially be used to prevent security threats like Denial-of-Service (DoS) attacks on embedded devices attached to the web and increase its performance. Our architecture provides a way for caching responses from device and thereby increasing its efficiency and performance and yielding quick response times.

An efficiency-centric design methodology for mobile application architectures

Abstract: Software architecture is known as an effective solution to realize extra-functional and quality requirements. It becomes even more important in developing efficient mobile applications since the resource limitation drawback of mobile devices can be remedied with architecture design. A general guideline is to place heavy-weight functionality on server sides, however more specific and detailed guidelines for developing mobile applications architectures and for evaluating the architecture are yet to come. In this paper, we present a design methodology for mobile applications architectures. We first present different patterns of Model-View-Controller (MVC) architecture for mobile applications. And, we define design criteria for mobile applications architectures, from which design guidelines are derived. With a set of experiments, the proposed methodology is evaluated.

Data-centric multi-layer usage control enforcement: a social network example

Abstract: Usage control is concerned with how data is used after access to it has been granted. Data may exist in multiple representations which potentially reside at different layers of abstraction, including operating system, window manager, application level, DBMS, etc. Consequently, enforcement mechanisms need to be implemented at different layers, in order to monitor and control data at and across all of them.We present an architecture for usage control enforcement mechanisms that cater to the data dimension, grasping the distinction between data (e.g a picture or a song) and its representations within the system (e.g a file, a window, a network packet, etc.). We then show three exemplary instantiations at the level of operating system, application, and windowing system. Our mechanisms enforce data-related policies simultaneously at the respective levels, offering a concrete multi-layer enforcement and laying the grounds for a combined inter-layer usage control enforcement.In this demo, we consider a use case from a social network scenario. A user can, on the grounds of assigned trust values, protect his data from being misused after having been downloaded by other users. In particular, our mechanisms prevent sensitive data in the browser window from being printed, saved or copied to the system clipboard, avoid direct access to the cached copy of the file and forbid taking a screenshot of the window where data is shown.

A model for specifying rationale using an architecture description language

Abstract: Besides structural and behavioural properties, rationale plays a crucial role in defining the architecture of a software system. However, unlike other architectural features, rationale often remains unspecified and inaccessible to tools. Existing approaches for recording rationale are not widely adopted. This paper proposes a simple model for capturing rationales as part of an architecture specification and attaching them to elements in the architecture. The bi-directional links between rationales and elements enable forward and backward traceability. We describe a textual architecture description language named Grasp that implements this model, and illustrate its capabilities using an example.

Codifying architecture knowledge to support online evolution of software product lines

Abstract: A company's architecture knowledge is often personalized across specific people that share experience and knowledge in the field. However, this knowledge may be important for other stakeholders. Omitting the codification of the architecture knowledge may result in ad-hoc practices, which is particularly relevant for software evolution. In a collaboration with Egemin, an industrial manufacturer of logistic systems, we faced the problem with a lack of codified architecture knowledge in the context of the evolution of a software product line (SPL). In particular, maintainers lack the architecture knowledge that is needed to perform the evolution tasks of deployed products correctly and efficiently. Ad-hoc updates increase costs and harm the company's reputation. To address this problem, we developed an automated approach for evolving deployed systems of a SPL. Central in this approach are (1) a meta-model that codifies the architecture knowledge required to support evolution of a SPL, and (2) and algorithm that uses the architecture knowledge harvested from a deployed system based on the meta-model to generate the list of tasks maintainers have to perform to evolve the system. Evaluation of the approach demonstrates a significant improvement of the quality of system updates with respect to the correct execution of updates and the availability of services during the updates.

Conversing with drawings and buildings: from abstract to actual in architecture

Abstract: Purpose – The purpose of this paper is to describe the various movements from abstraction to actuality in the context of design, with particular reference to architecture, first in terms of the design process and second in terms of the interpretation of architecture by observers.Design/methodology/approach – The paper focuses on the designers' use of forms of representation, such as drawings, with reference to the cybernetic understanding of conversation. This account is then used to discuss the representational properties of architecture itself and to relate this back to the design process.Findings – It is argued that the forms of representation used by designers, such as drawings and physical models, have both abstract and actual properties and that this combination is important for their representational function. The ambiguity in the interpretation of drawings and models is not only useful in generating ideas but also appropriate given the ambiguity in the interpretation of the architecture they repre...

Initiating layers architecture design for Software Product Line

Abstract: Product Line Architecture is the key success of Software Product Line Engineering. Product Line Architecture prepares the design of architectures for members of product line. Architecture design is the most essential activities of a Product Line Architecture development. It prepares the corner stone of variability decision. The architecture design need to produce specific architecture from product members' assets in a Software Product Line. Representing variability explicitly is the most challenging one. Moreover, the architecture must cope to the diversity of products, and take the behaviour into account. This paper introduces some approaches to address the architecture design problems. Features' grouping with specific concern is the starting point. Then, models the component and interaction element composition, based on its capability. This paper also introduces logics that link the interaction element and component. Using layers, the product line architecture can be established.

Fifth Generation Networking Principles for a Service Driven Future Internet Architecture

Abstract: The vision of all-IP networks where IP forms the simple common layer understandable across the whole network has undeniable advantages. However, such simplicity comes as a major hurdle to flexibility and functionality to the architecture. This is evident from the increasingly numerous and complex engineering solutions and optimizations required to accommodate essential qualities like mobility, security, realtime communication support etc or to mitigate the shortcomings inherent in the `traditional Internet' architecture. While a clean slate approach to address these shortcomings is not an option in a realistic scenario, it is important to examine the architecture as a whole to address emerging network requirements and overcome existing shortcomings at the architecture level rather than engineering solutions to an existing inefficient one. This architectural re-examination should also facilitate discussion into what design principles for future generations of Network Architectures which will eventually replace the design tenets for the current Internet. While 3G and 4G systems were more focussed on convergence towards an All-IP network and some improvements in the core network, the architectural design remains stagnant with layered paradigms and inherent inefficiencies. A departure from this shackled approach could be the distinguishing feature of 5G systems and beyond. We claim that there is a pressing need to move towards a Next Generation Network architecture built to natively support requirements such as network resource abstraction, mobility, security, enhanced routing, privacy, context communications, QoS, parallel processing, heterogeneous networking etc. Instead of treating the network as just providing connectivity specified by endpoints, it is of great advantage to applications to recognise it as a service characterized by attributes, abstracted to a higher level to represent a collection of capabilities that the network offers. This uniform high level abstraction can effectively mask the heterogeneity and implementation discrepancies in the underlying infrastructure. Besides, in a network environment where an connectivity instance might transverse diverse business/ownership/capability domains, the approach proposed in this article can provide a transparent abstraction for resource negotiations across the domain to be available for end-to-end setup. This architectural change should also be manifested according to the principles of SOA to ensure interoperability, backwards compatibility and migration. In this article, we introduce a Service Oriented framework and network architecture aimed at tackling the heterogeneity of emerging requirements and proposed solutions into a coherent interoperable architecture using Web Services specifications as the basic standards. We propose to model the new architecture on relationships between entities and discuss the motivation this new architecture in the form of a new framework called ROSA.

Design and evaluation of a process for identifying architecture patterns in open source software

Abstract: Architecture patterns have a direct effect (positive or negative) on a system's quality attributes (e.g., performance). Therefore, information about patterns used in a product can provide valuable insights to, e.g., component integrators who wish to evaluate a software product. Unfortunately, this information is often not readily available, in particular for Open Source Software (OSS) products, which are increasingly used in component-based development. This paper presents the design and evaluation of a process for Identifying Architecture Patterns in OSS ("IDAPO"). The results of the evaluation suggest that IDAPO is helpful to identify potentially present patterns, and that a process framework may provide better opportunities for tailoring to the users' needs.

IODA - an Interactive Open Document Architecture

Abstract: Objective of the proposed architecture is to enable representing an electronic document as a multi-layered structure of executable digital objects, which is extensible and without a need to support any particular formats or user interfaces. IODA layers are intended to reflect document content organization levels rather then system abstraction or functional levels, as in software architecture models.

Capabilities and Features: Linking Business and Application Architectures

Abstract: Many organizations perceive the importance of linking business architecture to application architecture. It is difficult to manage the changes needed by the business and maximize the benefits from the information technology (IT) investments without this linkage. Linking the two domains require that we define the two architectures using a "common language". The architecture domain has tools and processes to define and represent the architecture, and use it to build the related processes and services. The business architecture domain, however, lacks any and/or are not matured enough to be useful for linking of the two. We address questions dealing with the linking of the business and the information/application architectures. Specifically, how do we define business architecture useful for linking? How do we represent these architectures and what "language" should we use? We propose the use Category theory related constructs and notions to represent both the business and information architecture [2]. The work reported here is primarily the current status of research in the area of business architecture, application architecture and linking these two.

A Systemic Methodology for Software Architecture Analysis and Design

Abstract: The paper outlines a new systemic methodology for analysis and design of software architecture that addresses some major limitations in the current state of the art. First and foremost, current approaches fail to recognize the contextual environment as a major driver for software architecture. The higher abstraction level of software architecture is matched poorly by the lower-level, detail-oriented paradigms that the current architectural design methods employ. Worse yet, the current prescriptive specification methods often fail to handle adequately architectural evolution in the face of inherent contextual uncertainty and to scale to the size of modern software systems. We introduce a new software architecture methodology that approaches the software architecture domain with systemic techniques and we model explicitly contextual factors in software architecture definition. We introduce the concept of patterns for the contextual environment, which serve alongside architectural patterns as the primary vocabulary for architecture description and analysis. Our analysis approach uses a probabilistic modeling and decision formalism to guide software architecture evolution. Finally, we define an evaluation framework to assess the "fitness for purpose" of a proposed software architecture.

Service composition system optimized network and service resources in E3-DCN

Abstract: While being the nearness of realization of ubiquitous society, it is expected that everything will be connected to the network. We previously presented “Ubiquitous Grid Networking Environment (uGrid)”. In uGrid, everything on the network such as devices, contents, and software is defined as “Service-Part”, and users are provided with composition of the several ServiceParts on the network. In uGrid, there are “Service-Routing” and “Service-Signaling” as the method of determining the path from source to destination and establishing the optical path by using of IP protocol. However, in uGrid, in order to provide the services for users via the specified Service-Parts, these cost of services is high. Also, since users must designate the combination of ServiceParts, it is inflexible. Then, we propose “Energy Efficient, and Enhanced-type Data Centric Network (E3-DCN)” which is based on uGrid. In the E3-DCN, users request contents name to the network and receive them from the network. If the requested contents are not found in the network, the network constructs the requested contents with Service-Parts. In addition to that, E3-DCN aims at energy efficiency. In this paper, we propose a cost reduction method by Service-Parts copy as part of E3DCN. Cost is reduced by copying the Service-Parts which have a software function to the optimal position. This method is defined as “Service-Copy”. By the evaluation using ILP (Integer Linear Programming), it is shown that the case with Service-Copy can reduce the total cost of service by about 12 ∼ 17%.

Capabilities and Features: Linking Business and Application Architectures - I

Abstract: Many organizations now perceive the importance of linking business architecture to information architecture, [1]. Without this linkage, it is difficult to manage the changes needed by the business and maximize the benefits from the information technology (IT) investments. Linking the two domains require that we define the two architectures using a "common language". The information architecture domain has developed tools and processes to define and represent the architecture, and use it to build the related processes and services. The business architecture domain, however, lacks such processes and tools and/or have not matured enough to be useful for linking of the two. In this paper we address several questions dealing with the linking of the business and the information/application architectures. Specifically, how do we define business architecture (useful for linking)? What level of details we need to represent? What view of the information architecture we should use for linking? How do we represent both these architectures and what "language" should we use? We propose the use Category theory related constructs and notions to represent both the business and information architecture [2]. The work reported here is primarily the current status of research in the area of business architecture,application architecture and linking these two.