How effective is UML modeling ?

Modeling has become a common practice in modern software engineering. Since the mid 1990s the Unified Modeling Language (UML) has become the de facto standard for modeling software systems. The UML is used in all phases of software development: ranging from the requirement phase to the maintenance phase. However, empirical evidence regarding the effectiveness of modeling in software development is few and far apart. This paper aims to synthesize empirical evidence regarding the effectiveness of modeling using UML in software development, with a special focus on the cost and benefits.     

A Realistic Empirical Evaluation of the Costs and Benefits of UML in Software Maintenance

The Unified Modeling Language (UML) is the de facto standard for object-oriented software analysis and design modeling. However, few empirical studies exist that investigate the costs and evaluate the benefits of using UML in realistic contexts. Such studies are needed so that the software industry can make informed decisions regarding the extent to which they should adopt UML in their development practices. This is the first controlled experiment that investigates the costs of maintaining and the benefits of using UML documentation during the maintenance and evolution of a real, non-trivial system, using professional developers as subjects, working with a state-of-the-art UML tool during an extended period of time. The subjects in the control group had no UML documentation. In this experiment, the subjects in the UML group had on average a practically and statistically significant 54% increase in the functional correctness of changes (p=0.03), and an insignificant 7% overall improvement in design quality (p=0.22) - though a much larger improvement was observed on the first change task (56%) - at the expense of an insignificant 14% increase in development time caused by the overhead of updating the UML documentation (p=0.35).     

An experimental investigation of formality in UML-based development

The object constraint language (OCL) was introduced as part of the Unified Modeling Language (UML). Its main purpose is to make UML models more precise and unambiguous by providing a constraint language describing constraints that the UML diagrams alone do not convey, including class invariants, operation contracts, and statechart guard conditions. There is an ongoing debate regarding the usefulness of using OCL in UML-based development, questioning whether the additional effort and formality is worth the benefit. It is argued that natural language may be sufficient, and using OCL may not bring any tangible benefits. This debate is in fact similar to the discussion about the effectiveness of formal methods in software engineering, but in a much more specific context. This paper presents the results of two controlled experiments that investigate the impact of using OCL on three software engineering activities using UML analysis models: detection of model defects through inspections, comprehension of the system logic and functionality, and impact analysis of changes. The results show that, once past an initial learning curve, significant benefits can be obtained by using OCL in combination with UML analysis diagrams to form a precise UML analysis model. But, this result is however conditioned on providing substantial, thorough training to the experiment participants.     

Enhancing collaborative synchronous UML modelling with fine-grained versioning of software artefacts

Software development teams are composed of people with different knowledge and skills, who contribute to a project from often widely dispersed locations. Software development in geographically distributed environments creates software engineering challenges due to the interaction among members of distributed teams and the management of consistency and concurrency among project artefacts. In this paper, we propose Synchronous collaborative modelling Tool Enhanced with VErsioning management (STEVE) a collaborative tool supporting distributed Unified Modelling Language (UML) modelling of software systems. The tool provides a communication infrastructure enabling the concurrent editing of the same UML diagram at the same time by distributed developers. Complex UML diagrams are decomposed and managed in a fine-grained hierarchy of sub-artefacts, thus providing change and configuration management functionalities for both the diagram and the graphical objects. Thus, software predefined diagram components can be consistently reused and shared across different diagrams of a given project.     

A comprehensive engineering framework for guaranteeing component compatibility

Despite advances in software engineering methods and tools, understanding what software components do and ensuring that they work well together remains difficult. This is chiefly due to the lack of support for specifying component interfaces and software compositions formally. Due to these shortcomings, composed systems are subject to incompatibility errors, and software developers struggle to retrieve and understand relevant reusable entities. Constructs recently added to the Unified Modeling Language (UML) supported by validation tools can detect and solve behavioural incompatibility issues, while integrated support for characterisation using ontological techniques can describe what a component does. This paper presents a comprehensive software engineering framework that supports software composition at design time and runtime with compatibility guarantees. Our main contributions are (a) a model-driven development approach that combines UML modelling and ontology techniques for the specification of component properties, their validation and their transformation to code, (b) a middleware platform that supports component discovery, compatibility checking and deployment. Following the proposed approach gives benefits for software engineering, in particular in settings where multiple stakeholders are involved.     

Managing Software Engineering Projects: A Social Analysis

Managing software engineering projects requires an ability to comprehend and balance the technological, economic, and social bases through which large software systems are developed. It requires people who can formulate strategies for developing systems in the presence of ill-defined requirements, new computing technologies, and recurring dilemmas with existing computing arrangements. This necessarily assumes skill in acquiring adequate computing resources, controlling projects, coordinating development schedules, and employing and directing competent staff. It also requires people who can organize the process for developing and evolving software products with locally available resources. Managing software engineering projects is as much a job of social interaction as it is one of technical direction. This paper examines the social arrangements that a software manager must deal with in developing and using new computing systems, evaluating the appropriateness of software engineering tools or techniques, directing the evolution of a system through its life cycle, organizing and staffing software engineering projects, and assessing the distributed costs and benefits of local software engineering practices. Ths purpose is to underscore the role of social analysis of software engineering practices as a cornerstone in understanding what it takes to productively manage software projects.     

Coordination in co-located agile software development projects

Agile software development provides a way to organise the complex task of multi-participant software development while accommodating constant project change. Agile software development is well accepted in the practitioner community but there is little understanding of how such projects achieve effective coordination, which is known to be critical in successful software projects. A theoretical model of coordination in the agile software development context is presented based on empirical data from three cases of co-located agile software development. Many practices in these projects act as coordination mechanisms, which together form a coordination strategy. Coordination strategy in this context has three components: synchronisation, structure, and boundary spanning. Coordination effectiveness has two components: implicit and explicit. The theoretical model of coordination in agile software development projects proposes that an agile coordination strategy increases coordination effectiveness. This model has application for practitioners who want to select appropriate practices from agile methods to ensure they achieve coordination coverage in their project. For the field of information systems development, this theory contributes to knowledge of coordination and coordination effectiveness in the context of agile software development.     

A goal-driven and agent-based requirements engineering framework*

The paper presents a requirements engineering framework (REF), where advanced requirements engineering techniques are combined with software quality modelling approaches to provide an environment within which the stakeholders and the analysts can easily cooperate to discover, organise, reconcile and validate the requirements for a new system. By adopting a basic and essential graphical notation, and a clear top-down methodology, REF allows for an effective involvement of the stakeholders, assisting and driving them to an early definition of the desired system's functionalities and quality attributes, while supporting the redesign of the encompassing organisational context to better exploit the new system's capabilities. As a case study, REF is applied to support the requirements engineering process for a complex software-intensive simulation system. Results demonstrate the feasibility of REF and the benefits it offers to the requirements engineering process, but also to the subsequent system development phases. As illustrated through the case study REF can, in fact, be usefully applied as a forerunner for unified modelling language (UML)-based approaches.*Part of this work was completed while the author was Senior Research Fellow with the Computing Information Systems Engineering Group, at the Royal Military College of Science, Cranfield University (UK)     

Claims about the use of software engineering practices in science: A systematic literature review

Context: Scientists have become increasingly reliant on software in order to perform research that is too time-intensive, expensive, or dangerous to perform physically. Because the results produced by the software drive important decisions, the software must be correct and developed efficiently. Various software engineering practices have been shown to increase correctness and efficiency in the development of traditional software. It is unclear whether these observations will hold in a scientific context.Objective: This paper evaluates claims from software engineers and scientific software developers about 12 different software engineering practices and their use in developing scientific software.Method: We performed a systematic literature review examining claims about how scientists develop software. Of the 189 papers originally identified, 43 are included in the literature review. These 43 papers contain 33 different claims about 12 software engineering practices.Results: The majority of the claims indicated that software engineering practices are useful for scientific software development. Every claim was supported by evidence (i.e. personal experience, interview/survey, or case study) with slightly over half supported by multiple forms of evidence. For those claims supported by only one type of evidence, interviews/surveys were the most common. The claims that received the most support were: “The effectiveness of the testing practices currently used by scientific software developers is limited” and “Version control software is necessary for research groups with more than one developer.” Additionally, many scientific software developers have unconsciously adopted an agile-like development methodology.Conclusion: Use of software engineering practices could increase the correctness of scientific software and the efficiency of its development. While there is still potential for increased use of these practices, scientific software developers have begun to embrace software engineering practices to improve their software. Additionally, software engineering practices still need to be tailored to better fit the needs of scientific software development.     

Tool support for disseminating and improving development practices

Knowledge management in software engineering and software process improvement activities pose challenges as initiatives are deployed. Most existing approaches are either too expensive to deploy or do not take an organization’s specific needs into consideration. There is thus a need for scalable improvement approaches that leverage knowledge already residing in the organizations. This paper presents tool support for an Experience Factory approach for disseminating and improving practices used in an organization. Experiences from using practices in development projects are captured in postmortems and provide iteratively improved decision support for identifying what practices work well and what needs improvement. An initial evaluation of using the tool for organizational improvement has been performed utilizing both academia and industry. The results from the evaluation indicate that organizational characteristics influence how practices and experiences can be used. Experiences collected in postmortems are estimated to have little effect on improvements to practices used throughout the organization. However, in organizations where different practices are used in different parts of the organization, making practices available together with experiences from use, as well as having context information, can influence decisions on what practices to use in projects.     

Towards automated traceability maintenance

Traceability relations support stakeholders in understanding the dependencies between artifacts created during the development of a software system and thus enable many development-related tasks. To ensure that the anticipated benefits of these tasks can be realized, it is necessary to have an up-to-date set of traceability relations between the established artifacts. This goal requires the creation of traceability relations during the initial development process. Furthermore, the goal also requires the maintenance of traceability relations over time as the software system evolves in order to prevent their decay. In this paper, an approach is discussed that supports the (semi-) automated update of traceability relations between requirements, analysis and design models of software systems expressed in the UML. This is made possible by analyzing change events that have been captured while working within a third-party UML modeling tool. Within the captured flow of events, development activities comprised of several events are recognized. These are matched with predefined rules that direct the update of impacted traceability relations. The overall approach is supported by a prototype tool and empirical results on the effectiveness of tool-supported traceability maintenance are provided.     

Process quality costing adapted to software development

The Prevention-Appraisal-Failure and Process models of measuring quality costs, as described in BS6413, are discussed in the context of software quality costs. The Process model is selected as the better base for constructing a software quality cost model because of its suitability for application to software engineering processes. A seven-step method for modelling software quality costs is proposed and illustrated by application to a software maintenance project. Key processes in software maintenance and its quality tasks are derived from the most recently available standards-related publications. Although no results are available, a qualitative evaluation in terms of accuracy, improvement issues, measurement issues and quality costs to management concludes that the model is valid and that a greater consensus is required for identification of software quality cost elements. Implementation of quality cost measurement is not discussed save noting that there are still complex issues to be addressed.     

UML结合软件工程教学改革探讨

结合本校计算机专业的实际教学情况,深入分析UML课程教学内容,并结合软件工程教学,以汽车销售管理系统为例,通过分析汽车销售管理系统,并在设计过程中融入软件工程思想,将软件工程与UML完美结合起来。以UML作为基础,增强学生对开发项目的兴趣和感性认识,提高他们分析和解决实际问题的能力,从而达到UML与软件工程教学共赢的目的。     

Bridging the gap between business models and system models

This paper discusses links that may be made between process models and Unified Modelling Language (UML) software specification techniques, working from an argument that the whole complexity of organisational activity cannot be captured by UML alone. The approach taken is to develop a set of use cases, which would be capable of providing information support to a pre-defined organisational process. The nature of the thinking, which is necessary to derive the use cases, is outlined using the pre-defined process as a case study. The grouping of transactions and state changes into Use Cases is shown to require design choices, which may vary between particular organisational contexts. Conclusions are drawn about the direction of further investigation of links between process modelling and UML.     

On a time enriched OCL liveness template

It is increasingly recognised that non-functional requirements should be considered at the earliest stages of system development. Unified modelling language (UML), as a standard, should therefore include notation to capture such requirements. Among these, timing has received considerable attention by the modelling community with several timed extensions of UML diagrams, a UML profile and tools. However, timing constraints are, generally, not captured in a satisfactory way during design. We propose to use UML's object constraint language (OCL) for this purpose, and provide a simple time enriched liveness template for OCL. We describe the benefits of using this template. Having verification in mind, several logic-based formalisms could be chosen to underly OCL. We consider a novel real-time logic of knowledge, and argue why logics of knowledge are useful and promising in this context. We illustrate our approach with a distributed real-time system. Future work and further benefits of the knowledge-based framework are discussed at the end of the paper. Work reported here was supported by the EPSRC grants GR/R16891 and GR/N13999.     

用例模型与装配式软件系统的开发

用例是获取需求的主要工具，用例模型成了与用户交流的手段。装配式软件是一种能提高软件适应性和生命力的系统，它是建立在基于组件的工程基础之上，以便系统维护时可以按组件装配、拆卸和替换。讨论了用例模型中的用例如何与组件建立映射关系，并给出装配式软件开发的具体过程。     

The impact of UML documentation on software maintenance: an experimental evaluation

The Unified Modeling Language (UML) is becoming the de facto standard for software analysis and design modeling. However, there is still significant resistance to model-driven development in many software organizations because it is perceived to be expensive and not necessarily cost-effective. Hence, it is important to investigate the benefits obtained from modeling. As a first step in this direction, this paper reports on controlled experiments, spanning two locations, that investigate the impact of UML documentation on software maintenance. Results show that, for complex tasks and past a certain learning curve, the availability of UML documentation may result in significant improvements in the functional correctness of changes as well as the quality of their design. However, there does not seem to be any saving of time. For simpler tasks, the time needed to update the UML documentation may be substantial compared with the potential benefits, thus motivating the need for UML tools with better support for software maintenance.     

Maintaining constraints of UML models in distributed collaborative environments

Constraint maintenance plays an important role in keeping the integrity and validity of UML models in embedded software design. While constraint maintenance capabilities are reasonably adequate in existing UML modeling applications, little work has been done to address the distributed constraint maintenance issue in multi-user collaborative modeling environments. The nature of the issue is to maintain constraint consistently across distributed sites in a collaborative modeling environment in the face of concurrency. In this paper, we propose a novel solution to this issue, which can retain the effects of all concurrent modeling operations even though they may cause constraint violations. We further contribute a distributed constraint maintenance framework in which the solution is encapsulated as a generic engine that can be mounted in a variety of single-user UML modeling applications to support collaborative UML modeling and distributed constraint maintenance in embedded software design processes. This framework has been implemented in a prototype distributed collaborative UML modeling application CoRSA.     

Improving academic software engineering projects: A comparative study of academic and industry projects

A project course in software engineering is often part of the curriculum in computer engineering or computer science. This paper studies the relationship between academic and industrial projects in software engineering. The purpose is to compare the practices followed in a project-course approach with the practices of professional software engineers. The approach is to compare the measurements obtained from academic and industrial projects. The critical factors regarding the process, the people and the project are discussed. The structure of the software processes and the measurement tools are presented. The data analyses show that the academic projects are found to be strongly dominated by programming activities. Based on the data from the industrial projects, we formulate seven recommendations to improve the software engineering practices in academic projects. They are related to management, predevelopment, development, testing, reviews documentation and team activities. The concluding remarks discuss some of the actions that could be taken to improve academic projects.