High-level System Architecture Research Articles

Lean Software Development: A Tutorial

To put the concept of lean software development in context, it's useful to point out similarities and differences with agile software development. Agile development methods have generally expected system architecture and interaction design to occur outside the development team, or to occur in very small increments within the team. Because of this, agile practices often prove to be insufficient in addressing issues of solution design, user interaction design, and high-level system architecture. Increasingly, agile development practices are being thought of as good ways to organize software development, but insufficient ways to address design. Because design is fundamentally iterative and development is fundamentally iterative, the two disciplines suffer if they are not carefully integrated with each other. Because lean development lays out a set of principles that demand a whole-product, complete life-cycle, cross-functional approach, it's the more likely candidate to guide the combination of design, development, deployment, and validation into a single feedback loop focused on the discovery and delivery of value.

R2D: A FRAMEWORK FOR THE RELATIONAL TRANSFORMATION OF RDF DATA

The astronomical growth of the World Wide Web has resulted in data explosion that in turn has given rise to a need for data representation methodologies and standards to present required information in a rapid and automated manner. The Resource Description Framework (RDF) is one such standard proposed by W3C to address the above need. The ubiquitous acceptance of RDF on the Internet has resulted in the emergence of a new data storage paradigm, the RDF Graph Model, which, as with any data storage methodology, requires data modeling and visualization tools to aid with data management. This paper presents R2D (RDF-to-Database), a relational wrapper for RDF Data Stores, which aims to transform, at run-time, semi-structured RDF data into an equivalent domain-specific relational schema, thereby bridging the gap between RDF and RDBMS concepts and making the abundance of relational tools currently in the market available to the RDF Stores. The primary R2D functionalities and mapping constructs, the high-level system architecture, and deployment flowchart are presented along with algorithms and performance graphs for every stage of the transformation process and screenshots of a relational visualization tool using R2D as evidence of the feasibility of the proposed work.

POETS: Process-oriented event-driven transaction systems

We present a high-level enterprise system architecture that closely models the domain ontology of resource and information flows in enterprises. It is: Process-orientedformal, user-definable specifications for the expected exchange of resources (money, goods, and services), notably contracts, are represented explicitly in the system state to reflect expectations on future events; Event-drivenevents denote relevant information about real-world transactions, specifically the transfer of resources and information between economic agents, to which the system reacts by matching against its portfolio of running processes/contracts in real time; Declarativeuser defined reporting functions can be formulated as declarative functions on the system state, including the representations of residual contractual obligations.We introduce the architecture and demonstrate how analyses of the standard reporting requirements for companies—the income statement and the balance sheet—can be used to drive the design of events that need registering for such reporting purposes. We then illustrate how the multi-party obligations in trade contracts (sale, purchase), including pricing and VAT payments, can be represented as formal contract expressions that can be subjected to analysis.To the best of our knowledge this is the first architecture for enterprise resource accounting that demonstrably maps high-level process and information requirements directly to executable specifications.

Robot-Vision Signal Processing Primitives [Applications Corner

Recent advances in vision algorithms and increases in computer performance have made new capabilities available in autonomous robotics for real-time applications. In general, computer-vision-based solutions to robotics problems employ a high-level system architecture that makes use of low-level processing blocks. While the high-level system architecture is still an active area of research, many of the underlying low-level processing blocks and their associated methods have begun to stabilize, yielding a set of operators that has been found useful in a wide variety of tasks. In this article, we will briefly review these operators, which we call robot-vision signal-processing (SP) primitives, and their associated classes of methods. Although our taxonomy is quite general and related to those used in image processing and pattern recognition, we focus on the specific use of these primitives and associated classes in robot vision for SP purposes before presenting a robot-vision example- the Stanley robot racing car.

Strengthening OV-6a Semantics With Rule-Based Meta-Models in DEVS/DoDAF Based Life-Cycle Development for Enterprise-Service Architectures

The development of a distributed testing environment would have to comply with recent DoD mandates requiring that the DoD Architectural Framework (DoDAF) be adopted to express high level system and operational requirements and architectures Unfortunately, DoDAF and DoD net-centric mandates pose significant challenges to testing and evaluation since DoDAF specifications must be evaluated to see if they meet requirements and objectives, yet they are not expressed in a form that is amenable to such evaluation. DoDAF is the basis for integrated architectures and provides broad levels of specification related to operational, system, and technical views. In our earlier work, we described an approach to support specification of DoDAF architectures within a development environment based on DEVS (Discrete Event System Specification) for semi-automated construction of the needed simulation models. The result is an enhanced system lifecycle development process that includes both development and testing in an integral manner. We also developed automated model generation using XML which paves the way for OVs to become service-providing components in the Web Services architecture. In this paper we present the semantic structure for one of the Operational View documents OV-6a that would aid the development of these semi-automated models. We will describe how OV-6a can be structured in a more generalized meta-model framework such that every rule is reducible to meaningful code which is automatedly constructed through Natural Language Processing (NLP) methods and further be reduced to DEVS based models. The paper also presents an overview of the Life-cycle development methodology for these enterprise architectures and how a common enterprise domain-model can be used in customized business/domain-specific rules and policy structures.

Extending DoDAF to Allow Integrated DEVS-Based Modeling and Simulation

A recent DoD mandate requires that the DoD Architecture Framework (DoDAF) be adopted to express high-level system and operational requirements and architectures. DoDAF is the basis for integrated architectures and provides broad levels of specification related to operational, system, and technical views. The combination of DoDAF operational views, which capture the requirements of the architecture, and systems views, which provide its technical attributes, forms the basis for semi-automated construction of the needed simulation models. Unfortunately, DoDAF doesn't mandate any simulation methodology to analyze the system or perform any pre-design feasibility studies. In this paper, we describe an approach to support specification of DoDAF architectures within a development environment based on DEVS (Discrete Event System Specification). The result is an enhanced system life cycle development process that includes both development and testing in an integral manner. We introduce two new operational views (OVs) in the current DoDAF making way for modeling and simulation as a part of the design process. We illustrate the process to build these new OVs from the existing OVs and their impact on the overall DoDAF system development process. We discuss automated model generation using XML through the introduced OVs, which paves the way for OVs to become service-providing components in the web services architecture.

Self-Organization of Complex Networks Applied to Wireless World Systems

This paper provides a brief overview of the role that self-organization can play in the next generation wireless networks (S. Dixit, WWRF 8bis Meeting, February 26–27, Beijing, China). First, we present the definition, scope, and applicability of self-organization to wireless world systems. Then we briefly articulate the need for self-organization, and some recent breakthrough advances in this emerging area of research. This is followed by high-level system architecture for future communication systems and some early mechanisms for self-organization. The paper concludes with the challenges in this new field with key research issues.

Fault tolerance in supervisory control systems: a knowledge-based approach

Fault tolerance in computerized systems involved in production has become an ever more important requirement. Existing fault tolerance approaches, wherever used, deal mainly with hardware faults. Nevertheless, the vast majority of contemporary system failures are software related. This paper introduces a knowledge-based approach to handling software related faults occurring in supervisory control systems. These systems are event driven and use data, stored in complex databases, to react to events coming from different kinds of devices by identifying, scheduling, initiating and monitoring operations. Failure of part of the supervisory control system's software to behave rationally when unexpected events occur is called an application fault. The approach introduced in this paper is based on a supervisory control system reference model which reveals the set of all possible application faults together with the major functions of the recovery processes associated with each fault, and leads to a high-level knowledge-based system architecture capable of handling every fault-related condition. This system is called PROFIT (Intelligent PROduction systems Fault Tolerance) and consists of three main components: the fault diagnosis module, the instant fault correction module and the learning module, co-ordinated by a PROFIT meta-level module. The prototype version of PROFIT is analysed and the development as well as the run-time environment that prove the applicability and effectiveness of the system are presented.