Database-centric architecture

About: Database-centric architecture is a research topic. Over the lifetime, 1799 publications have been published within this topic receiving 48836 citations.

Distributed or Monolithic? A Computational Architecture Decision Framework

Abstract: Distributed architectures have become ubiquitous in many complex technical and socio-technical systems because of their role in improving uncertainty management, accommodating multiple stakeholders, and increasing scalability and evolvability. This departure from monolithic architectures provides a system with more flexibility and robustness in response to uncertainties that it may confront during its lifetime. Distributed architecture does not provide benefits only, as it can increase cost and complexity of the system and result in potential instabilities. The mechanisms behind this tradeoff, however, are analogous to those of the widely-studied transition from integrated to modular architectures. In this paper, we use a conceptual decision framework that unifies modularity and distributed architecture on a five-stage systems architecture spectrum. We add an extensive computational layer to the framework and explain how this can enhance decision making about the level of modularity of the architecture. We then apply it to a simplified demonstration of the Defense Advanced Research Projects Agency (DARPA) fractionated satellite program. Through simulation, we calculate the net value that is gained (or lost) by migrating from a monolithic architecture to a distributed architecture and show how this value changes as a function of uncertainties in the environment and various system parameters. Additionally, we use value at risk as a measure for the risk of losing the value of distributed architecture, given its inherent uncertainty.

Using real options to select stable middleware-induced software architectures

Abstract: The requirements that force decisions towards building distributed system architectures are usually of a non-functional nature. Scalability, openness, heterogeneity, and fault-tolerance are examples of such non-functional requirements. The current trend is to build distributed systems with middleware, which provide the application developer with primitives for managing the complexity of distribution, system resources, and for realising many of the non-functional requirements. As non-functional requirements evolve, the 'coupling' between the middleware and architecture becomes the focal point for understanding the stability of the distributed software system architecture in the face of change. It is hypothesised that the choice of a stable distributed software architecture depends on the choice of the underlying middleware and its flexibility in responding to future changes in non-functional requirements. Drawing on a case study that adequately represents a medium-size component-based distributed architecture, it is reported how a likely future change in scalability could impact the architectural structure of two versions, each induced with a distinct middleware: one with CORBA and the other with J2EE. An option-based model is derived to value the flexibility of the induced-architectures and to guide the selection. The hypothesis is verified to be true for the given change. The paper concludes with some observations that could stimulate future research in the area of relating requirements to software architectures.

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.

PRIMAmob-UML: a methodology for performance analysis of mobile software architectures

Abstract: Different paradigms (client-server, mobility based, etc.) have been suggested and adopted to cope with the complexity of designing the software architecture of distributed applications for wide area environments, and selecting the "best" paradigm is a typical choice to be made in the very early software design phases. Several factors should drive this choice, one of them being the impact of the adopted paradigm on the application performance. Within this framework our contribution is as follows: we apply an extension of UML to better modelling the possible adoption of mobility-based paradigms in the software architecture of an application; we extend classical models, like queueing networks models and execution graphs, to cope with mobile architectures; we introduce a complete methodology that, starting from a software architecture described using this extended notation, generates a performance model (namely an Extended Queueing Network augmented with mobility features) that allows the designer to evaluate the convenience of introducing logical mobility into a software application.