Development Of Software Architecture Research Articles

A pattern language for designing e-business architecture

The pattern language for e-business provides a holistic support for developing software architectures for the e-business domain. The pattern language contains four related pattern categories: Business Patterns, Integration Patterns, Application Patterns, and Runtime Patterns. These pattern categories organise an e-business architecture into three layers—business interaction, application infrastructure and middleware infrastructure—and provide reusable design solutions to these layers in a top–down decomposition fashion. Business and Integration Patterns partition the business interaction layer into a set of subsystems; Application Patterns provide a high-level application infrastructure for these subsystems and separate business abstractions from their software solutions; Runtime Patterns then define a middleware infrastructure for the subsystems and shield design solutions from their implementations. The paper describes, demonstrates and evaluates this pattern language.

Multimodal visualization interface for data management, self-learning and data presentation

A multimodal visualization software, called the Data Manager (DM), has been developed to increase interdisciplinary communication around the topic of visualization and modeling of various aspects of the human anatomy. Numerous tools used in Radiology are integrated in the interface that runs on standard personal computers. The available tools, combined to hierarchical data management and custom layouts, allow analyzing of medical imaging data using advanced features outside radiological premises (for example, for patient review, conference presentation or tutorial preparation). The system is free, and based on an open-source software development architecture, and therefore updates of the system for custom applications are possible.

Using ontology to support development of software architectures

In this paper we propose an approach to software development that focuses on architecture decisions and involves the use of ontology. In this approach the architecture is captured by an instance of an ontology. The ontology has four major components: architecture assets, architecture decisions, stakeholder concerns, and an architecture roadmap. We illustrate our approach through a case study involving a real-time credit-approval system and the use of Protégé, an open-source ontology development tool.

2005 EDOC: meeting the challenges of enterprise computing

An increasing demand for interoperable applications exists, sparking the real-time exchange of data across borders, applications, and IT platforms. To perform these tasks, enterprise computing now encompasses a new class of groundbreaking technologies such as Web services and service-oriented architecture (SOA); business process integration and management; and middleware support, like that for utility, grid, peer-to-peer, and autonomic computing. Enterprise computing also influences the processes for business modeling, consulting, and service delivery; it affects the design, development, and deployment of software architecture, as well as the monitoring and management of such architecture. As enterprises demand increasing levels of networked information and services to carry out business processes, IT professionals need conferences like EDOC to discuss emerging technologies and issues in enterprise computing. For these reasons, what started out as the Enterprise Distributed Object Computing (EDOC) conference has come to encompass much more than just distributed objects. So this event now used the name International EDOC Enterprise Computing Conference, to recognize this broader scope yet also retain the initial conference's name recognition.

Towards secure Grid‐enabled healthcare

AbstractThe primary focus of the UK e‐Science Programme is the development of software architectures, middleware and applications to support the end‐user scientific community in the undertaking of large‐scale research. A significant subset of e‐Science projects is concerned with the healthcare domain: as well as satisfying the needs of the end users, such projects have to consider the legal, ethical and security constraints associated with the use of sensitive patient data—these concerns are particularly relevant within the context of the U.K.'s National Health Service (NHS). In this paper we present a vision for Grid‐enabled healthcare that is sensitive to the information security requirements both of the NHS and the projects themselves. Although our motivation is principally derived from U.K.‐based e‐Health projects, this paper should be of interest to the worldwide health Grid community. By restricting ourselves to information security, we do not consider, for example, physical security or audit trail capabilities, which are outside the scope of this paper. The vision we describe is grounded in terms of experience, and reflects the challenges faced by the e‐DiaMoND project team. Copyright © 2005 John Wiley & Sons, Ltd.

Model-based a-posteriori integration of engineering tools for incremental development processes

A-posteriori integration of heterogeneous engineering tools supplied by different vendors constitutes a challenging task. In particular, this statement applies to incremental development processes where small changes have to be propagated – potentially bidirectionally – through a set of inter-dependent design documents which have to be kept consistent with each other. Responding to these challenges, we have developed an approach to tool integration which puts strong emphasis on software architecture and model-driven development. Starting from an abstract description of a software architecture, the architecture is gradually refined down to an implementation level. To integrate heterogeneous engineering tools, wrappers are constructed for abstracting from technical details and for providing homogenized data access. On top of these wrappers, incremental integration tools provide for inter-document consistency. These tools are based on graph models of the respective document classes and graph transformation rules for maintaining inter-document consistency. Altogether, the collection of support tools and the respective infrastructure considerably leverage the problem of composing a tightly integrated development environment from a set of heterogeneous engineering tools.

Empowering the business analyst for on demand computing

The tools, methods, and techniques used to create business architecture are often quite different from those used in developing software architecture. This “impedance mismatch” or gap is aggravated by volatile business requirements that need to be satisfied in operational systems. Bridging this gap not only allows a more seamless transition and faster time to market, but also enables and empowers business analysts to contribute their deep subject matter expertise at many phases of the software-development life cycle, a critical aid in fruitful application development. This paper presents a case study of a project with the U.S. Patent and Trademark Office (USPTO), which explored the potential for reducing duplication of effort among patent offices by sharing work products. IBM provided an innovative method to support the analysis, the “business compiler,” a tool that implements Grammar-oriented Object Design (GOOD). GOOD is a method for creating and maintaining dynamically reconfigurable software architectures driven by business-process architectures. The business compiler was used to capture business processes within real-time workshops for various lines of business and create an executable simulation of the processes used.

Component evolution and versioning state of the art

Emerging component-based software development architectures promise better re-use of software components, greater flexibility, scalability and higher quality of services. But like any other piece of software too, software components are hardly perfect, when being created. Problems and bugs have to be fixed and new features need to be added.This paper analyzes the problem of component evolution and the incompatibilities which result during component upgrades. We present the state of the art in component versioning and compare the different methods in component models, frameworks and programming languages. Special attention is put on the automation of processes and tool support in this area. The concluding section sketches a possible solution of these problems we are cur rently working on.

A framework for complex skill generation

The software developments used in the hybrid architectures in which reaction and deliberation are combined and coordinated have accomplished, at the present time more efficient architectures, though the solutions provided are ad-hoc. Each solution is a unique development, which make difficult the cooperation process between labs. At the present time, there exits a great interest in the development of software architectures or of generic components, with open code and which work in a different platforms, in a simpleway. This paper presents the design of a framework and its use, in order to develop complex skill in a flexible and simpleway. It is based on a set of design patterns which make easier its use and documentation. Each skill is treated as a distributed object that is used as answer for other skills request, designing each one of them as a distributed object in which the skills belonging to lower levels can be combined to obtain more complex behaviors. These skills combination as the AD architecture states, in most cases can be obtained by skill sequencing by means of a skill sequencer.

Formally analyzing software architectural specifications using SAM

In the past decade, software architecture has emerged as a major research area in software engineering. Many architecture description languages have been proposed and some analysis techniques have also been explored. In this paper, we present a graphical formal software architecture description model called software architecture model (SAM). SAM is a general software architecture development framework based on two complementary formalisms––Petri nets and temporal logic. Petri nets are used to visualize the structure and model the behavior of software architectures while temporal logic is used to specify the required properties of software architectures. These two formal methods are nicely integrated through the SAM software architecture framework. Furthermore, SAM provides the flexibility to choose different compatible Petri net and temporal logic models according to the nature of system under study. Most importantly, SAM supports formal analysis of software architecture properties in a variety of well-established techniques––simulation, reachability analysis, model checking, and interactive proving. In this paper, we show how to formally analyze SAM software architecture specifications using two well-known techniques––symbolic model checking with tool Symbolic Model Verifier, and theorem proving with tool STeP.

Adaptive secure software architecture for electronic commerce

AbstractAs Internet business exponentially grows, a need for the high security level categories that identify a group of connections or an individual transaction is manifest. Recently the development of efficient and secure software architecture has been in high demand. In this paper, we propose adaptive secure software architecture to support secure e‐commerce transactions. Our adaptive secure software architecture dynamically adapts security classes based on the nature and sensitivity of interactions among participants. Four security classes incorporate security levels of cryptographic techniques with a degree of information sensitivity. We have done extensive experiments on the performance of the proposed adaptive secure software architecture. Experimental results show that our adaptive secure software architecture provides e‐commerce transactions with high‐quality security services. Copyright © 2003 John Wiley & Sons, Ltd.

Adaptable architecture generation for embedded systems

Architecture generation is the first step in the design of software systems. Many of the qualities that the final software system possesses are usually decided at the architecture development stage itself. Thus, if the final system should be usable, testable, secure, high performance, mobile and adaptable, then these qualities or non-functional requirements (NFRs) should be engineered into the architecture itself. In particular, recently adaptability is emerging as an important attribute required by almost all software systems. Briefly, adaptability is the ability of a software system to accommodate changes in its environment. Embedded systems are usually constrained both in hardware and software. Current adaptable architecture development methods for embedded systems are usually manual and ad hoc––there are almost no comprehensive systematic approaches to consider NFRs at the architecture development stage. While there are several examples of approaches to generate architectures based on functional requirements, we believe that there are very few techniques that consider NFRs such as adaptability during the process of architecture generation. In this paper we present an automated design method that helps develop adaptable architectures for embedded systems by developing a tool called Software Architecture Adaptability Assistant (SA3). SA3 helps the developer during the process of software architecture development by selecting the architectural constituents such as components, connections, patterns, constraints, styles, and rationales that best fit the adaptability requirements for the architecture. The developer can then complete the architecture from the constituents chosen by the tool. SA3 uses the knowledge base properties of the NFR Framework in order to help automatically generate the architectural constituents. The NFR Framework provides a systematic method to consider NFRs, in particular their synergies and conflicts. We validated the architectures generated by SA3 in a type of embedded system called the vocabulary evolution system (VES) by implementing the codes from the generated architectures in the VES and confirming that the resulting system satisfied the requirements for adaptability. A VES responds to external commands through an interface such as ethernet and the vocabulary of these commands changes with time. The validation process also led to the discovery of some of the shortcomings of our automated design method.

Graphical modelling language for specifying concurrency based on CSP

A graphical modelling language for specifying concurrency in software designs is presented. The language notations are derived from the communicating sequential process (CSP) language and the resulting designs form CSP diagrams. The notations reflect both data-flow and control-flow aspects of concurrent software architectures. These designs can automatically be described by CSP algebraic expressions that can be used for formal analysis. The designer does not have to be aware of the underlying mathematics. The techniques and rules presented provide guidance to the development of concurrent software architectures. One can detect and reason about compositional conflicts (errors in design), potential deadlocks (errors at run-time), and priority inversion problems (performance burden) at a high level of abstraction. The CSP diagram collaborates with object-oriented modelling languages and structured methods.

Principles and software realization of a multimedia course on theoretical electrical engineering based on enterprise technology

The Department of Theoretical Electrical Engineering (TEE) of Technical University of Sofia has been developing interactive enterprise-technologies based course on Theoretical Electrical Engineering. One side of the project is the development of multimedia teaching modules for the core undergraduate electrical engineering courses (Circuit Theory and Electromagnetic Fields) and the other side is the development of Software Architecture of the web site on which modules are deployed. Initial efforts have been directed at the development of multimedia modules for the subject Electrical Circuits and on developing the web site structure. The objective is to develop teaching materials that will enhance lectures and laboratory exercises and will allow computerized examinations on the subject. This article outlines the framework used to develop the web site structure, the Circuit Theory teaching modules, and the strategy of their use as teaching tool.

Developing adaptable software architectures using design patterns: an NFR approach

Just about everything changes, and so should a software system accordingly in order to survive and succeed. But how can we develop such a software system? Lately, a growing number of practitioners have shown great interests in using design patterns towards the development of an adaptable system, since design patterns represent high-level abstractions that reflect the experience of no other than skilled practitioners themselves. According to a given format, design patterns describe the context, problems, solutions and consequences of making specific design decisions. This paper presents, Proteus—a framework which is intended to support the development of adaptable software architectures using design patterns. The main concepts of Proteus are illustrated by way of a home appliance control system.

Novel software architecture for rapid development of magnetic resonance applications

AbstractAs the pace of clinical magnetic resonance (MR) procedures grows, the need for an MR scanner software platform on which developers can rapidly prototype, validate, and produce product applications becomes paramount. A software architecture has been developed for a commercial MR scanner that employs state of the art software technologies including Java, C++, DICOM, XML, and so forth. This system permits graphical (drag and drop) assembly of applications built on simple processing building blocks, including pulse sequences, a user interface, reconstruction and postprocessing, and database control. The application developer (researcher or commercial) can assemble these building blocks to create custom applications. The developer can also write source code directly to create new building blocks and add these to the collection of components, which can be distributed worldwide over the internet. The application software and its components are developed in Java, which assures platform portability across any host computer that supports a Java Virtual Machine. The downloaded executable portion of the application is executed in compiled C++ code, which assures mission‐critical real‐time execution during fast MR acquisition and data processing on dedicated embedded hardware that supports C or C++. This combination permits flexible and rapid MR application development across virtually any combination of computer configurations and operating systems, and yet it allows for very high performance execution on actual scanner hardware. Applications, including prescan, are inherently real‐time enabled and can be aggregated and customized to form “superapplications,” wherein one or more applications work with another to accomplish the clinical objective with a very high transition speed between applications. © 2002 Wiley Periodicals, Inc. Concepts in Magnetic Resonance (Magn Reson Engineering) 15: 216–237, 2002

Enterprise JavaBeans

Large web-based information systems make high demands on scalability, maintainability, reliability and security. In order to ease the development of such systems appropriate software architectures are neeted. These architectures have to take into account business aspects as well as requisite tools and products. Such an architecture is offered by Sun Microsystems in tile form of tile Enterprise JavaBeans specification. Based on our experience from different projects we undertake a close examination of this architecture.

A Framework for Developing and Analyzing Software Architecture Specifications in SAM

In the past decade, software architecture research has mainly focused on the concept formulation and the development of various architecture description languages. This field has now matured enough and thus requires more emphasis on techniques for developing and analyzing software architecture specifications. SAM is a general software architecture model for developing and analyzing software architectures. In this paper, we show how to integrate high-level Petri nets and first-order temporal logic as the foundation of SAM to establish a unified framework for specifying and analyzing all aspects of a software architecture. We provide a set of heuristics, which are supported by well-defined existing methods and techniques developed by other researchers as well as our own, for software architecture development and analysis. We demonstrate the application of this framework and the heuristics with an example.

PREVENTING MISMATCH OF HOMOGENEOUS COMPONENTS IN THE DESIGN OF SOFTWARE ARCHITECTURE

The objective of this work is to examine the feasibility of, as well as to learn about, a process of developing software architecture that prevents the possibility of mismatch between homogeneous components implemented according to the architectural specification. This paper shows how the architecture can be organized, which restrictions it can use and, provided that they are used, how elaborate it should be in order to ensure that independently-developed artifacts are structurally compatible. Two components are deemed structurally compatible as long as they have appropriate code to avoid mismatch. Since the focus of the paper is on the structural forms of mismatch, the results are derived under the assumption that no run-time environment can prevent a component from executing any path in its code. The paper develops a formal model of architecture that provides a minimal set of concepts in terms of which the designers can reason about incompatibility of components. The model is used to identify the causes of structural mismatch and examine alternative ways of eliminating these causes. Following that, the paper adopts a set of architectural restrictions and shows how these restrictions can be applied in the design of software architectures to prevent the possibility of structural mismatch.

An application framework for dynamic distributed software architectures

There are compelling reasons to combine the concepts of an architecture description language with those of an object-oriented framework to provide support for the development of reusable and extensible software architectures. This paper presents C++CL, an object-oriented framework for developing reconfigurable distributed software architectures, which follows that approach. The reconfigurability of C++CL enables us to develop distributed systems, which require changes to take place during run time without having to shut the system down. Examples of systems of this kind are evident in banking, industrial control and telecommunications and are becoming more common in many other areas. The main focus of the paper is to show how C++CL supports re-usability and the evolution of distributed systems through the use of inheritance and the modelling of architectural styles. Inheritance can be applied not ony to the components of an architecture but to the description of the architectural configuration itself. An architectural style, similarly to a pattern, defines an architecture-based solution to a family of problems. The combination of those two concepts provides powerful support for re-usability of architecture descriptions.