Formalizing and analyzing service oriented software architecture style

The aspect-oriented software architectural weaving mechanism, to integrate aspectual components that encapsulate crosscutting behaviors and features into components and connectors constituting software architecture (SA), contributes to analyze and verify overall behaviors and quality attributes of SA. This paper proposes a new kind of weaving process and rules, which offer the measure to transform the unwoven SA model into the woven SA model. The unwoven SA model is described in a special aspect-oriented architecture description language, called AC2-ADL, and specifies the locations, times and constrains of injection. Then a woven SA model only containing components and connectors is acquired after weaving, and easier to analyze and verify.

Software architecture is widely recognized as one of the most fundamental concepts in software engineering, because of the fact, that today’s software systems are assembled from components with different characteristics: for example heterogenous, legacy or distributed systems. At the software architecture level, designers combine subsystems into complete systems using different techniques, e.g. “Architecture Description Languages” (ADLs). There exists a number of ADLs, each of which is specialized for one or more architectural styles. They are designed by different research groups with different goals in mind corresponding to their mental model on how software architecture can be expressed in the most efficient and elegant way. As a result, ADLs are not compatible with each other, so that it is difficult to present a homogeneous view of the software architecture of a system assembled from different components. This paper presents an approach how architectural styles can be combined using a concept of ADL-interchange.KeywordsSoftware ArchitectureDescription LanguageArchitectural StyleService LayerAbstract State MachineThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Architectural styles represent composition patterns and constraints at the software architectural level and are targeted at families of systems with shared characteristics. While both style-specific and style-neutral modeling environments for software architectures exist, creation of such environments is expensive and frequently involves reinventing the wheel. This paper describes the rapid design of a style-neutral architectural modeling environment, ViSAC. ViSAC is based on Alfa, a framework for constructing style-based software architectures from architectural primitives, and is obtained by configuring Vanderbilt University's generic modeling environment (GME). Users can define their own styles in ViSAC and, in turn, use them to design software architectures. Moreover, ViSAC supports the hierarchical design of heterogeneous software architectures, i.e., using multiple styles. The rich user interface of GME and support for domain-specific semantics enable interactive design of well-formed styles and architectures.

With the growing use of UML diagrams for software architecture description and the importance of non-functional requirements evaluation at software architecture level, filling the scientific gap between architect and requirement analyst is considered to be significant. Software architects are not usually familiar with non-functional requirement analysis and are not able to analyze such requirements easily. On the other hand, non-functional requirements cannot be evaluated directly by UML diagrams. Therefore, the architect should annotate additional information of the nonfunctional requirements to software architecture description and then an executable model can be produced. These executable models can be petri nets, queuing networks, stochastic process algebra and etc. One kind of the UML diagrams that can be used to describe software architecture is component diagram. In this paper, we propose a new algorithm that enables an architect to transform a component diagram into an executable model based on different extensions of petri nets. Moreover, we show how to use this petri net model for performance evaluation and simulation and the implications of this transformation are described completely. Finally, to represent the usage of our proposed algorithm, we consider a case study as an example.

Software performance based on performance models can be applied at early phases of the software development cycle to characterize the quantitative behavior of software systems. We propose an approach based on queueing networks models for performance prediction of software systems at the software architecture level, specified by UML. Starting from annotated UML Use Case, Activity and Deployment diagrams we derive a performance models based on multichain and multiclass Queueing Networks (QN). The UML model is annotated according to the UML Profile for Schedulability, Performance and Time Specification. The proposed algorithm translates the annotated UML specification into QN performance models, which can then be analyzed using standard solution techniques. Performance results are reported back at the software architecture level in the UML diagrams. As our approach can be fully automated and uses standard UML annotations, it can be integrated with other performance modeling approaches. Specifically, we discuss how this QN-based approach can be integrated with an existing simulation-based performance modeling tool.

There is a plethora of models, techniques and tools that support model-and component-based software development of vehicular distributed embedded systems. However, a large majority of them have a limited or no support to model and specify end-to-end resource reservations on the software architectures of these systems. Resource reservations allow flexibility during the development and execution of such complex systems without jeopardizing their predictable behavior. As a result, several applications in the system that share the same hardware platform can be developed independently. In this paper we identify several requirements that any existing component model should fulfill in order to support the modeling of end-to-end resource reservations on the software architectures of such systems. As a proof of concept, we extend the Rubus Component Model (RCM) by fulfilling these requirements. RCM is used for the development of control functionality in vehicular embedded systems by several international companies. We also provide a technique to extract execution models from the software architectures of these systems with resource reservations. In order to show the usability of our technique, we model a vehicular distributed embedded system with the extended component model and extract the execution model from the software architecture augmented with end-to-end resource reservations.

Regression testing can be systematically applied at the software architecture level in order to reduce the cost of retesting modified systems, and also to assess the regression testability of the evolved system. With the advent of model-based specification and analysis of software architectures, regression testing at the architectural level can be handled by analyzing how the architectural model evolves when moving from an initial to a subsequent version. This paper analyzes how model differencing, a recent research topic in the model-based community, can be employed for implementing model-based architecture-level regression testing.

Requirements for cost-effective high-quality software are becoming more and more stringent both in Safety-Critical and in Complex Software Development Environments. Stimulated in part by recent issues from the UK Ministry of Defence, the use of Formal Mathematical Methods is going to be taken into greater consideration also in industrial contexts due to their descriptive and analytical capabilities. Nevertheless, there is a little guidance as to the manner in which formal techniques should be effectively used. In the area of Software Engineering several methodologies can be found which effectively support the software development process in terms of costs and productivity, but, unfortunately, not in terms of quality and reliability. In this paper we propose to integrate the Z formal specification notation with the HOOD object-oriented design methodology (i.e. the standard European Space Agency design method). A twofold benefit is produced: on the one hand the structuring principles of HOOD compensate a class of problems which are peculiar to formal specifications in general and, on the other hand, the behaviour of a HOOD object can be formally described allowing us to rigorously verify some properties. Also, like a “Troian” horse, this could be a promising approach for promoting industrial use of formal methods.KeywordsOperation SchemaSoftware Development ProcessParent ObjectPredicate PartMaster CopyThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Web services are increasingly used to enable interoperability and flexible integration of e-business systems. In this paper we focus on measurement-based performance analysis of an e-commerce application which uses Web services components to execute business operations. In our experiments we use a session-oriented workload generated by a tool developed accordingly to the TPC-W specification. The empirical results are obtained for two different user profiles, Browsing and Ordering, under different workload intensities. Unlike the previous work which was focused on the overall server response time and throughput, we present Web interaction, software architecture, and hardware resource level analysis of the system performance. In particular, we propose a method for extracting component level response times from the application server logs and study the impact of Web services and other components on the server performance. The results show that the response times of Web services components increase significantly under higher workload intensities when compared to other components. From the hardware resource measurements it is obvious that the higher response times of Web services components are due to parsing XML messages and contention for database resources. The results of our study identify software components and hardware resources which are potential bottlenecks in the system and thus provide valuable information for capacity planning of e-commerce applications

Interest in software architecture as an area of research, education, and practice within software engineering has been growing steadily over the past decade. Software architecture is concerned with the principled study of large-grained software components, including their properties, relationships, and patterns of combination. It is becoming clear that one key to the effective development, operation, and evolution of software systems is the design and evaluation of appropriate architectures.As a complement to the Fourth Symposium on the Foundations of Software Engineering (FSE-4), whose theme was software architecture, the Second International Software Architecture Workshop (ISAW-2) brought together practitioners and researchers for two intense days of discussion and work. The ISAW-2 proceedings [6] were published in the Joint Proceedings of the SIGSOFT '96 Workshops, ACM Press, ISBN 0-89791-867-3.The participants were organized into three parallel working groups each focused on a different topic within software architecture.• Styles and Patterns ---Techniques and models for centering software architecture activities on generally useful design methods, components, and assemblages of components.• Architecture Description ---Languages and methods for the capture of architectural designs.• Tools and Methods ---Automated aids for designing, evaluating, validating, implementing, and evolving software architectures.Tying these work groups together was the use of a common case study derived from a real-world architecture found in industry. Each working group studied this architecture from its particular perspective and, to a greater or lesser extent, used the case study to organize their discussions. It is interesting to note, for example, that the three groups created specialized depictions of the architecture for their discussion (see figures 6, 8, and 10).The case study was the architecture of the Call Center Customer Care (C4) System, which was developed by Andersen Consulting. A description of the architecture and some of its more interesting challenges appears in Section 2. It is reproduced here in the hopes that it might be prove of continued use to the community.Also appearing here are reports from each working group. The Styles and Patterns Working Group was led by Frances Paulisch, of Siemens, and Mary Shaw, of CMU. The group tried to uncover the styles and patterns that underlay various components of the C4 architecture. In the process, they defined a new kind of architectural style that they named the Data Ooze. The Architectural Description Working Group was led by Paul Clements, of the SEI, and Jeff Magee, of Imperial College. The group concentrated on identifying critical aspects of architectures that require description and on identifying important areas where further work in architectural description is needed. The Tools and Methods Working group was led by William Griswold, of UCSD, and Philippe Kruchten, of Rational. The group pretended to go through a development cycle for the C4 system in order to uncover various architectural tool and method needs.At the conclusion of the workshop, the working group chairs held a panel session in which each group asked a "challenge" question of the other two groups. The questions and responses appear in Section 5.2.We hope that these succeedings capture at least some essence of the very fruitful discussion that occurred at the workshop. Of course, this report cannot replace the benefits of actual attendance. The workshop will indeed continue, and we hope that the reader will be interested in attending a future ISAW.

Software architectures are high-level design representations of software systems that focus on composition of software components and how those components interact. Software architectures abstract the details of implementation and allow the designer to focus on essential design decisions. Regardless of notation, designers are faced with the task of making good design decisions, which demands a wide range of knowledge of the problem and solution domains. Argo is a software architecture design environment that supports designers by addressing several cognitive challenges of design. In this paper we describe how Argo supports decision making by automatically supplying knowledge that is timely and relevant to decisions at hand.

Software architecture is being widely used today to describe a very high-level design methodology of large software systems. Software architecture represents the overall structure of a system in an abstract, structured manner. A good architectural representation scheme holds the key to the effectiveness of a software architecture description and usage. In this work we look at architectural styles and architectural representation schemes. We propound the idea that the layered architectural model is a suitable candidate for a generalized architectural style and that it can cater to many different problem domains, other than the message-passing systems it has traditionally been used to model. We propose some rules by which the layered architectural style can be improved and modified in order to be able to model a wider problem domain. Then we evaluate different methods of architectural representations that have been used to model software architecture and analyze their strengths and shortcomings. We propose the use of a modified data flow diagram architecture representation scheme. This scheme is called AND-OR DFD method and is introduced and developed in this thesis. The main concept introduced here is a combination of components to form action groups to support multiple workflows and the relationships among them, without significant increase in the architectural complexity. Finally, we look at UML as a prospect for a generalized architecture description language and discuss its merits and demerits with examples.

This paper provides an introduction to the field of software engineering requires facility in architectural software design. The goal is to demonstrate the current state of the discipline and examine the ways in which architectural design can impact soft-ware design. Software architecture is used to describe a high level design methodology of large software systems. It provides the overall structure of a system in an abstract and structured fashion. A smart architectural demonstration holds the key to the effectiveness of a software architecture description and usage. This paper focuses on criterion to select appropriate architecture style for software system. It also gives overview of definition, goals and requirements of software architecture with various architecture styles, their benefits and applications. The authors have also described the requirements and goals of robotic software architecture. The proposal for layered robotic software architecture for a distributed system is also presented.

The construction of the software architecture (SA) is a key aspect in component-based software development (CBSD). The SA can characterize the system design at a high level, and focus on the computing units as well as their interactions. Nowadays, software runs in an open, dynamic and changeable environment, which requires the SA should be dynamic and able to adapt to changes. The inconsistency of the software architecture caused by adapting to changes may lead to architecture mismatching, which becomes a new challenge for the software development. In this paper, we try to ensure the correctness of architecture matching in two ways. On one hand, we extend the meta-model of xADL 2.0 by adding explicit matching features. Based on these features, we use OCL to verify whether the SA meta-model matches the requirement. On the other hand, we refine the interaction by specifying action abstractions from an implicit behavior view. With these two methods, we can weave matching properties to the SA meta-model at the design stage, which helps to guide the whole software system development.

A key challenge of component-based software engineering is to preserve extra-functional properties such as security when composing the software architecture from individual components. Previous work in this area does not consider specific characteristics of cyber-physical systems like asynchronous message passing, real-time behavior, or so-called feedback composition with two-way communication. Thereby, a composition of secure components might lead to insecure architectures with undetected information leaks. In this paper, we address the preservation of information flow security on composition of cyber-physical systems, taking the above characteristics into account. We refine security policies during the architectural decomposition, and outline a compositional verification approach that checks the security of individual components against their refined policies. On composition of secure components, our approach preserves security and thereby enables the design of secure software architectures. We give a proof of concept using a component-based software architecture of a cyber-manufacturing system.