Abstract This paper presents our experiences in building a UML‐based approach for maintaining software products of a large‐scale industrial product family. It enables software architects to define rules and constraints for a product family architecture to be enforced on individual product architectures. The target system of our study was the Nokia ISA platform for a mobile phone product family, a complex software system comprising thousands of components and several million lines of code. We outline our approach and the accompanying tools, and report our experiences and lessons learned in assessing the architectural integrity of 10 ISA platform releases and the associated products. Copyright © 2009 John Wiley & Sons, Ltd.

Abstract Software architecture contains, in addition to its structural part, interaction patterns that can be regarded as part of the architectural solution of the system. The interaction patterns define architecturally significant behavior of the software system. In this paper we propose a visual modeling language, behavioral profiles, for specifying architecturally significant behavioral rules for an application. The language is built on the Unified Modeling Language (UML), which is a visual language widely used in software development. We show how behavioral profiles can be used to support software designers in creating behavioral models that conform to some predefined rules and for ensuring that an application behaves correctly with respect to the rules given in the profiles. A tool called Bebop was built to support software engineers in behavioral profile‐based design and analysis of program behavior. To evaluate the approach and the tools in different application domains, they are utilized in three cases. The size of the applications used in the cases varies from small to quite large software systems, and from academic to industrial ones. The examples demonstrate how the approach presented can be used in practice for different steps in a software engineering process. The examples cover specializing an application framework and monitoring the program execution in run‐time. In addition, they show how behavioral profiles can be used to support guided program comprehension and to validate program execution by analyzing execution traces. Copyright © 2010 John Wiley & Sons, Ltd.

Service oriented architecture (SOA) is currently supported by an infrastructure that facilitates model driven development, but reuse issues have received less attention. A key problem in reuse is variability management: how to support the specification and usage of the variation points of the system. In this paper, we propose an approach for model-level variability management, assuming UML activity diagrams as the notation for service composition models in SOA. The approach is based on specifying variation points using so-called specialization patterns, which have been originally developed to support task-driven specialization of application frameworks. We demonstrate the approach with a prototype tool and an example. The approach leads to a guided model customization process focusing on the variation points, making it easy to produce a variant of a basic model.

Representational State Transfer (ReST) architecture provides a set of constraints that drive design decisions towards architectural properties such as interoperability, evolvability and scalability. Designing a ReSTful service API involves finding resources and their relationships, selecting uniform operations for each resource, and defining data formats for them. It is often a non-trivial exercise to refine a functional specification, expressed in terms of arbitrary actions, to a resource-oriented, descriptive state information content. We argue that this process can be described as a series of model transformations, starting from service functionality and gradually refining the phase products until a ReSTful service API is reached. This paper outlines the process phases, transformations and intermediate models based on our experiences in developing ReSTful services and service APIs at Nokia Research Center. The process captures our understanding on how to systematically transform functional specifications into ReSTful Web service interfaces.

The development of services-based systems starts from defining goals for business processes to be implemented, e.g., as a Web service orchestrations specified in WS-BPEL. In this paper, we propose a scenario-driven approach for modeling business processes. We aim for simplicity in the notation and leverage example-like modeling principles in order to improve process sketching. The first step in our approach is to identify the essential business requirements and model them using a simple scenario notation. The scenarios, given as UML sequence diagrams, are synthesized into a state machine, which is translated into a WS-BPEL flavored process skeleton given as UML activity diagram. The process skeleton can be further refined into executable process model.

Abstract In the current trend of software engineering, patterns and profiles lend themselves as two powerful complementary mechanisms for documenting and enforcing design rules. In this paper, we study how unified tool support can be achieved for patterns and profiles by interpreting them as role‐based structural descriptions and exploiting existing tool support for role modeling. The approach is realized using so‐called design profiles, which allow both validation and generation of models according to rules expressed in the patterns and profiles. A prototypical tool environment supporting the approach has been developed. The practical applicability of the approach is demonstrated by specifying design rules of the enterprise Java beans (EJB) platform and by producing an environment for designing EJB‐based applications. We also discuss possible usage scenarios in the context of this case study. Copyright © 2008 John Wiley & Sons, Ltd.

In this work we summarise our approaches to improve software quality in a commercial organisation. We present different aspects of software quality that span across the organisation and which are not limited only to the software development. We present the approaches at design, tool, and process levels. We also present the future directions of our research. All the presented approaches add up to a small-step way of tackling software quality issues in a company.

Web services are becoming an integral part of service and workflow systems even within mobile devices. A mobile business process is a special case of a business process where most of the human interaction is performed using mobile devices. Mobile business processes should be adaptable to different mobile devices and to support user interaction with different client applications. Requirements coming from mobility of devices addresses new challenges and interaction models to business process modeling and development. A proper tool support for process development is needed. Furthermore, while mobile business processes emphasize user interaction, a development process should support also creation of user interfaces based on process descriptions. In this paper, we identify characteristics of mobile business processes and propose a model-driven development (MDD) approach, which allows customization of user interfaces.

Template meta-programming techniques can be used to increase efficiency in software development. These techniques have traditionally been used with textual programming languages, such as C++. In this paper, we discuss how corresponding techniques can be used with visual languages. The visual language under study in this paper is function block language (FBL). FBL is used in Metso Automation for writing automation control programs that are executed in realtime distributed environments. Efficient development of high quality programs and easy customizability of existing programs are key requirements in practical customer projects. These requirements have been one of the main motivations to develop template meta-programming support in FBL discussed. In this paper, we focus both on the technical aspects and on the lessons learnt from programmers' experiences and ways to work with templates. FBL and the programming techniques proposed have been used in hundreds of real-world projects at Metso Automation.

Software development relies heavily on reusable libraries and software components. For correct use of the provided API, proper documentation is needed. API usage is often demonstrated by giving example applications and code samples. In this paper we propose an approach for mining such usage scenarios from run-time communication between sample applications and the API. This is done automatically by first monitoring the API usage of sample applications, then filtering the generated traces, and finally synthesizing the sequence diagrams and illustrating them in a well-formed way as UML2 sequence diagrams. Such usage scenarios support the software engineer in comprehending the usage of the API. With proper tool support they can also be used for validating other applications' API usage and for generating code for a new application using the same API.

A concern-based approach to support software comprehension and analysis is proposed. Concerns represent various aspects of a system, like features, architectural solutions, units of work, etc., which are interesting for some stakeholders. Using concern-based queries on the software artefacts, new derived information on the system can be exposed. The results of the queries are also represented as concerns and added to the concern repository. The approach thus supports the analyzer in gradually building up an understanding on the subject system to be analyzed.

When reusing an existing software component, the software developer needs to understand the functionality and possible extension points of the component, as well as constraints and rules to be taken into account when using it. In addition to structural rules, the software component may imply interaction rules that must be followed in application development. In this paper we discuss behavioral profiles, given in UML, used to capture and illustrate architecturally significant behavioral rules. The behavioral rules may capture interaction rules to be obeyed when reusing an existing software component. They can also be used to support runtime analysis of existing systems: with a proper tool support, the validity of extracted interaction models can be automatically checked against the behavioral rules given in the profiles. Moreover, the profiles can be used to prune the size of the interaction trace to include only the information relevant from the point of view of the behavioral rules. In this paper we discuss such tool support and demonstrate the usefulness of the approach by applying behavioral profiles to define and illustrate behavioral rules relevant for applications using the graphical editing framework (GEF). Moreover, we analyze a sample GEF application by validating its run-time behaviour with respect to the defined behavioral rules

Web services are software systems designed to support interoperable machine-to-machine interaction over a network. WSDL descriptions, often characterized as IDLs for Web services, are a key for Web service interoperability. Therefore, special care should be taken in designing WSDL descriptions. We present an approach that provides UML-based support to design and validate WSDL descriptions. To promote Web service interoperability, WS-I organization provides a basic profile that defines clarifications, refinements, interpretations and amplifications of Web service specifications, including WSDL. We propose UML-based profiles to define structural rules of WSDL documents as well as basic profile recommendations for WSDL descriptions. These profiles can be used to guide the user in designing correct and basic profile compliant WSDL descriptions and to check the validity of existing WSDL descriptions. We propose a method and tools for such validity checking, and demonstrate the applicability of the approach with a case study.

This paper proposes a UML-based software maintenance process. The process is guided by architectural descriptions and existing architectural models. The descriptions are given as variants of UML profiles describing the styles and rules relevant for a particular application domain. A reverse engineering subprocess, combining top-down and bottom-up reverse engineering activities, aims at constructing the architectural models. Resulting models are investigated in a model analysis subprocess. The models are checked against the profiles to find violations against the given architectural rules when maintaining and developing the subject system, and they are further analyzed using a set of UML model processing operations. The proposed approach is applied for maintaining a large-scale product platform architecture and real-life product-line products built on top of this platform. The model analysis results of the case study are discussed.

We present the work of establishing an integrated environment that facilitates architecture design, reconstruction, and maintenance in the entire life cycle of a software product line. This architecting environment (ART environment) has been used in modeling and analysis of both the designed platform architecture model and the reverse-engineered product implementation architecture models of different releases in a big product line of Nokia mobile terminals. ART environment comprises tools for architecture model validation, architecture model analysis and processing, and reverse architecting. The ART environment fits the current software development process inside Nokia, and is integrated with the design and documentation tools that have already been used by Nokia software architects. UML, after being customized with UML profiles for architecture design, is used as the architecture modeling language in ART environment.

Following the success of the "First Workshop on Scenarios and State Machines: Models, Algorithms, and Tools" held at ICSE 2002 in Orlando [1], this workshop aims at bringing together researchers and practitioners to build a shared understanding on the relation between scenarios and state machines and to gain insight into techniques and tools that may leverage the combination of these approaches to enhance our means for behavior modeling.

No abstract available.

The Unified Modeling Language (UML) provides several diagram types, viewing a system from different perspectives. In this research, we exploit the logical relationships between different UML models. We propose operations to compare, merge, slice and synthesize UML diagrams based on these relationships. In a formal demonstration, we show how statechart diagrams can be synthesized semi-automatically from a set of sequence diagrams using an interactive algorithm called MAS. We also demonstrate how a class diagram, annotated with pseudocode presentations of key operations, can be synthesized from sequence diagrams, and how class diagrams and sequence diagrams can be sliced against each other.

The Minimally Adequate Synthesizer (MAS) is an interactive algorithm that synthesizes UML statechart diagrams from sequence diagrams. It follows D. Angluin's (1987) framework of a minimally adequate teacher to infer the desired statechart diagram by consulting the user. To minimize the number of consultations needed, MAS keeps track of the interaction with the user. Together with its general knowledge about sequence diagrams, this makes MAS operate mostly without the user's help, but allowing him to guide the process at critical points. In this paper, we discuss the MAS algorithm and its practical implementation, integrated with a real-world UML modeling tool, the Nokia TDE ("The Design Environment"). Moreover, we discuss the interaction between the algorithm and the user as a medium for improving the algorithm and for further reducing the number of user consultations needed. Furthermore, we show how MAS can be used to incrementally synthesize sequence diagrams into an edited or a manually constructed statechart diagram. Totally automatic synthesis algorithms may result in a state machine that contains undesired generalizations. Because MAS consults the user during the synthesis process, the user can be confident that such generalizations do not appear in the resulting statechart diagram.

Abstract Shimba is a reverse engineering environment to support the understanding of Java software systems. Shimba integrates the Rigi and SCED tools to analyze and visualize the static and dynamic aspects of a subject system. The static software artifacts and their dependencies are extracted from Java byte code and viewed as directed graphs using the Rigi reverse engineering environment. The run‐time information is generated by running the target software under a customized SDK debugger. The generated information is viewed as sequence diagrams using the SCED tool. In SCED, statechart diagrams can be synthesized automatically from sequence diagrams, allowing the user to investigate the overall run‐time behavior of objects in the target system. Shimba provides facilities to manage the different diagrams and to trace artifacts and relations across views. In Shimba, SCED sequence diagrams are used to slice the static dependency graphs produced by Rigi. In turn, Rigi graphs are used to guide the generation of SCED sequence diagrams and to raise their level of abstraction. We show how the information exchange among the views enables goal‐driven reverse engineering tasks and aids the overall understanding of the target software system. The FUJABA software system serves as a case study to illustrate and validate the Shimba reverse engineering environment. Copyright © 2001 John Wiley & Sons, Ltd.