| 1. |
|
|
| 2. |
- Andam, Berima, 1986, et al.
(author)
-
Florida: Feature LOcatIon DAshboard for extracting and visualizing feature traces
- 2017
-
In: Proceedings of the Eleventh International Workshop on Variability Modelling of Software-intensive Systems, VaMoS 2017. - New York, NY, USA : ACM. ; Part F126227, s. 100-107
-
Conference paper (peer-reviewed)abstract
- © 2017 Copyright held by the owner/author(s). Features are high-level, domain-specific abstractions over implementation artifacts. Developers use them to communicate and reason about a system, in order to maintain and evolve it. These activities, however, require knowing the locations of features - a common challenge when a system has many developers, many (cloned) variants, or a long lifespan. We believe that embedding feature-location information into software artifacts via annotations eases typical feature-related engineering tasks, such as modifying and removing features, or merging cloned features into a product line. However, regardless of where such annotations stem from - whether embedded by developers when writing code, or retroactively recovered using a feature-location technique - tool support is needed for developers to exploit such annotations. In this tool demonstration, we present a lightweight tool that extracts annotations from software artifacts, aggregates and processes them, and visualizes feature-related information for developers. Views, such as which files implement a specific feature, are presented on different levels of abstraction. Feature metrics, such as feature size, feature scattering, feature tangling, and numbers of feature authors, are also presented. Our tool also incorporates an information-retrieval-based feature-location technique to retroactively recover feature locations.
|
|
| 3. |
- Bainomugisha, Engineer, et al.
(author)
-
Emerging Software Engineering Research Networks in (East) Africa
- 2021
-
In: ACM SIGSOFT Software Engineering Notes. - : Association for Computing Machinery (ACM). - 0163-5948. ; 46:2, s. 18-22
-
Journal article (other academic/artistic)abstract
- Software engineering (SE) researchers and research networks from emerging communities are often not visible in already established Software Engineering venues for a multitude of reasons. This limits the opportunities and mutual bene ts that can arise from collaborations between global and emerging Software Engineer- ing networks. This article focuses on a rst attempt to provide a map of the African software engineering research community with focus on the networks of two big East African Universities. We hope that this very initial mapping e ort will help to raise aware- ness in the international community about the variety of software engineering research in Africa. We formulate some suggestions for making our academic Software Engineering community more inclusive.
|
|
| 4. |
- Bainomugisha, Engineer, et al.
(author)
-
Message from Chairs of SEiA 2018
- 2018
-
In: Proceedings - International Conference on Software Engineering. - New York, NY, USA : ACM. - 0270-5257. ; 2018, s. x-xi
-
Conference paper (other academic/artistic)
|
|
| 5. |
- Bainomugisha, Engineer, et al.
(author)
-
Sustainable Capacity Building in Software Engineering Research in Africa: The Example of the BRIGHT Project
- 2020
-
In: ACM SIGSOFT Software Engineering Notes. - : Association for Computing Machinery (ACM). - 0163-5948. ; 45:3
-
Journal article (other academic/artistic)abstract
- The software industry is a key engine of economic growth in Africa, which calls for sustainable and innovative approaches to build capacities in software engineering research and education for the continent. This paper presents the BRIGHT project as an example for a collaboration that aims to build such capacity. The collaboration includes institutions in Sweden and Uganda. The goal of the collaboration is to train faculty in software en- gineering and to build a supporting research environment, which includes the creation of networks with the software engineering community at a global scale as well as connecting academia and the local software industry. So far, the project has resulted in 50 publications, a software engineering research centre, software engineering summer schools, and conferences.
|
|
| 6. |
- Bergel, Alexandre, et al.
(author)
-
FeatureVista: interactive feature visualization
- 2021
-
In: SPLC '21: Proceedings of the 25th ACM International Systems and Software Product Line Conference. - New York, NY, USA : ACM. - 9781450384698 ; Volume A:September 2021, s. 196-201
-
Conference paper (peer-reviewed)abstract
- Comprehending and characterizing the spread and interaction of features in a software system is know to be difficult and error-prone. This paper presents FeatureVista, a lightweight tool providing interactive, glyph-based, and iconic visualization concepts designed to visually characterize the feature locations in software assets (source code). FeatureVista supports navigating between software components and features in an equal fashion. Our pilot study indicates that FeatureVista is intuitive and supports comprehending features. It helps to precisely characterize relations among features in large software systems and to contrast explicit software component definitions (e.g., package, class, method) with annotated feature portions---which so far was a largely manual and error-prone activity, albeit essential to get an adequate understanding of a software system. We suggest research directions for true, feature-oriented interfaces that can be used to manage software assets.
|
|
| 7. |
- Berger, Christian, 1980, et al.
(author)
-
Model-based, Composable Simulation for the Development of Autonomous Miniature Vehicles
- 2013
-
In: Mod4Sim'13: 3rd International Workshop on Model-driven Approaches for Simulation Engineering at SCS/IEEE Symposium on Theory of Modeling and Simulation in conjunction with SpringSim 2013. - 0735-9276. - 9781627480321 ; 45, s. 118-125
-
Conference paper (peer-reviewed)abstract
- Modern vehicles contain nearly 100 embedded control units to realize various comfort and safety functions. These vehicle functions consist of a sensor, a data processing, and an actor layer to react intelligently to stimuli from their context. Recently, these sensors do not only perceive data from the own vehicle but more often also data from the vehicle's surroundings to understand the current traffic situation. Thus, traditional development and testing processes need to be rethought to ensure the required quality especially for safety-critical systems like a collision prevention system. On the example of 1:10 scale model cars, we outline our model-based and composable simulation approach that enabled the virtualized development of autonomous driving capabilities for model cars to compete in an international competition.
|
|
| 8. |
- Berger, Christian, 1980, et al.
(author)
-
Open Issues in Reuse of Certified Components in Cyber Physical Systems
- 2013
-
In: Proceedings International Workshop on Critical Software Component Reusability and Certification across Domains.
-
Conference paper (other academic/artistic)abstract
- In this paper we will discuss challenges and directions for component certification in cyber physical systems. Our experiences are based on a decade of research in this area in both more fundamental and more practically oriented projects. While the notion of Component-based Software Engineering has been coined half a century ago, practical use of components is still challenging. There has been much advancement in understanding component-technology. Also the problem of predictable assembly (how to predict properties of systems based on properties of its components) has been successfully solved for a variety of extra-functional properties. In this paper we distinguish embedded systems and cyber-physical systems. Embedded systems area a broad category of systems which include computer systems that are not visible to the end user. Cyber-physical system (CPS) is special category of embedded systems that feature a significant degree of autonomous action in a physical environment. Examples of cyber-physical systems can be found in areas as diverse as aerospace, automotive, civil infrastructure, healthcare, transportation.
|
|
| 9. |
- Bergström, Gustav, et al.
(author)
-
Evaluating the layout quality of UML class diagrams using machine learning
- 2022
-
In: Journal of Systems and Software. - : Elsevier BV. - 0164-1212. ; 192
-
Journal article (peer-reviewed)abstract
- UML is the de facto standard notation for graphically representing software. UML diagrams are used in the analysis, construction, and maintenance of software systems. Mostly, UML diagrams capture an abstract view of a (piece of a) software system. A key purpose of UML diagrams is to share knowledge about the system among developers. The quality of the layout of UML diagrams plays a crucial role in their comprehension. In this paper, we present an automated method for evaluating the layout quality of UML class diagrams. We use machine learning based on features extracted from the class diagram images using image processing. Such an automated evaluator has several uses: (1) From an industrial perspective, this tool could be used for automated quality assurance for class diagrams (e.g., as part of a quality monitor integrated into a DevOps toolchain). For example, automated feedback can be generated once a UML diagram is checked in the project repository. (2) In an educational setting, the evaluator can grade the layout aspect of student assignments in courses on software modeling, analysis, and design. (3) In the field of algorithm design for graph layouts, our evaluator can assess the layouts generated by such algorithms. In this way, this evaluator opens up the road for using machine learning to learn good layouting algorithms. Approach.: We use machine learning techniques to build (linear) regression models based on features extracted from the class diagram images using image processing. As ground truth, we use a dataset of 600+ UML Class Diagrams for which experts manually label the quality of the layout. Contributions.: This paper makes the following contributions: (1) We show the feasibility of the automatic evaluation of the layout quality of UML class diagrams. (2) We analyze which features of UML class diagrams are most strongly related to the quality of their layout. (3) We evaluate the performance of our layout evaluator. (4) We offer a dataset of labeled UML class diagrams. In this dataset, we supply for every diagram the following information: (a) a manually established ground truth of the quality of the layout, (b) an automatically established value for the layout-quality of the diagram (produced by our classifier), and (c) the values of key features of the layout of the diagram (obtained by image processing). This dataset can be used for replication of our study and others to build on and improve on this work. Editor's note: Open Science material was validated by the Journal of Systems and Software Open Science Board.
|
|
| 10. |
- Chaudron, Michel, 1969, et al.
(author)
-
A Vision on a New Generation of Software Design Environments
- 2015
-
In: First International Workshop on Human Factors in Modeling (HuFaMo 2015). CEUR-WS. - 1613-0073. ; Vol-1522, s. 11-16
-
Conference paper (peer-reviewed)abstract
- In this paper we illustrate our vision for a new generation software design environment. This environment aims to generalize existing modeling tools in several ways – some key extensions are: integration of rigorous and informal notations, and support for multiple modes of interaction. We describe how we can consolidate the environment by integrating it with other software engineering tools. Furthermore, we describe some methods which could permit the environment to provide a flexible collaborative medium and have a practical and inspiring user experience.
|
|
| 11. |
- Chaudron, Michel, 1969, et al.
(author)
-
An Empirical Study into the Accuracy of IT Estimations and its Influencing Factors
- 2013
-
In: International journal of software engineering and knowledge engineering. - 0218-1940. ; 23:4, s. 409-432
-
Journal article (peer-reviewed)abstract
- This paper is the result of two related studies done on the estimation of IT projects at a large Dutch multinational company. The first one is a study about the accuracy of different dimensions of IT project estimating: schedule, budget and effort. [Note: This paper is an extension of the paper published by the authors as "An analysis of accuracy and learning in software project estimating" [28].] This study is based on a dataset of 171 projects collected at the IT department of the company. We analyzed the estimation error of budget, effort and schedule. Also, we analyzed whether there is any learning (improvement) effect over time. With the results of the first study we proceeded to research what is causing the current estimation error (inaccuracy). The results of our first study show that there is no relation between accuracy of budget, schedule and effort in the company analyzed. Besides, they show that over time there is no change in the inaccuracy (effectiveness and efficiency of the estimates). In our second study we discovered that the sources of this inaccuracy are: (IT estimation) process complexity, misuse of estimates, technical complexity, requirements redefinition and business domain instability. This paper reflects and provides recommendations on how to improve the learning from historical estimates and how to manage the diverse sources of inaccuracy inside this particular company and also in other organizations.
|
|
| 12. |
- Chaudron, Michel, 1969, et al.
(author)
-
Automated Prioritization of Metrics-based Design Flaws in UML Class Diagrams
- 2014
-
In: 2014 40th Euromicro Conference Series on Software Engineering and Advanced Applications (Seaa 2014). - : IEEE. - 1089-6503. ; , s. 369-376
-
Journal article (peer-reviewed)abstract
- The importance of software architecture in software development prolongs throughout the entire software life cycle. This is because quality of the architectural design defines the structural aspects of the system that are difficult to change, and hence will affect most of the subsequent development and maintenance activities. This paper considers software design flaws (related to the system structure) and not flaws identified at run time (by testing). These design flaws are akin to what is described in the literature as anti-patterns, bad smells or rotting design. Recently, two tools that have been developed for quality assurance of software designs represented in the UML notation: SDMetrics and MetricView. However these tools are not considered practical because they report many design flaws which are not considered by developers (false positives). This paper explores an approach that tries to identify which design flaws should be considered important and which are not. To this end, we propose an approach for automated prioritization of software design flaws (BX approach), to facilitate developers to focus on important design flaws more effectively. We designed and implemented a tool (PoSDef) that implements this approach. The BX approach and the PoSDef tool have been validated using two open source projects and one large industrial system. Our validation consists of comparing our approach and tool with the existing design flaw tools. The evaluation has shown that the proposed approach could facilitate developers to identify and prioritize important design flaws effectively.
|
|
| 13. |
- Chaudron, Michel, 1969, et al.
(author)
-
Diversity in UML modeling explained: Observations, classifications and theorizations
- 2018
-
In: Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics). - Cham : Springer International Publishing. - 1611-3349 .- 0302-9743. ; 10706 LNCS, s. 47-66
-
Conference paper (peer-reviewed)abstract
- Modeling is a common part of modern day software engineering practice. Little evidence exists about how models are used in software development and how they help in producing better software. In this talk we introduce a classification-matrix and a theoretical framework that helps explain the large variety of models and modeling styles found in industrial practice. As part of this explanation, we will explore empirical findings on the uses of UML modeling in practice. We intersperse this paper with some insights about modeling in software development that may be common to some, but certainly not generally accepted throughout the software engineering community.
|
|
| 14. |
- Chaudron, Michel, 1969
(author)
-
Empirical Studies into UML in Practice: Pitfalls and Prospects
- 2017
-
In: IEEE/ACM 9th International Workshop on Modelling in Software Engineering (MiSE), 21-22 May 2017, Buenos Aires, Argentina. - : IEEE. - 2575-4467. - 9781538604267
-
Conference paper (peer-reviewed)abstract
- A key open question in the area of software modeling is which costs and benefits it brings to software development and maintenance. For answering this question, better empirical studies into software modeling are needed. In this paper I focus on what I believe are the pitfalls in-and prospects for such types of studies. This paper is an abstract for an invited keynote at the Modeling in Software Engineering (MiSE) workshop at ICSE 2017.
|
|
| 15. |
- Chaudron, Michel, 1969, et al.
(author)
-
Interactive Surfaces for Collaborative Software Design
- 2016
-
In: Proceedings of the Nordichi '16: The 9th Nordic Conference on Human-Computer Interaction - Game Changing Design. - New York, NY, USA : ACM. - 9781450347631 ; , s. Article number a143-
-
Conference paper (peer-reviewed)abstract
- Large drawing boards have long been software engineers' tools of choice for collaborative software design. Recently, traditional design tools such as whiteboards and flip charts are being replaced by large interactive surfaces such as touch-sensitive wall-mounted displays or interactive tabletops. This workshop explores the novel opportunities that these interactive modeling tools offer for collaborative software engineering, as well as the technical and cognitive challenges that they introduce.
|
|
| 16. |
- Chaudron, Michel, 1969, et al.
(author)
-
Proceedings of the 2nd Workshop on Experiences and Empirical Studies in Software Modelling
- 2012
-
In: Research Reports in Software Engineering and Management. - Göteborg : University of Gothenburg.
-
Conference paper (other academic/artistic)abstract
- The International Workshop on Experiences and Empirical Studies in Software Modelling (EESSMod) is a satellite event of the ACM/IEEE International Conference on Model Driven Engineering Languages and Systems (MoDELS), with professionals and researchers interested in software modelling as intended audience, and with the bjective to 1) build a better understanding of the industrial use of modelling techniques, languages and tools; 2) start building theories about the effectiveness of modelling approaches; 3) identify directions for future research in the field; 4) facilitate and encourage joint research and experimentation in software modelling.The report contains the proceedings of the 2nd edition of the workshop, held in Innsbruck, Oct 2, 2012.
|
|
| 17. |
- Etemaadi, R., et al.
(author)
-
Combinations of antipattern heuristics in software architecture optimization for embedded systems
- 2013
-
In: CEUR Workshop Proceedings. - 1613-0073. ; 1084
-
Conference paper (peer-reviewed)abstract
- A large number of quality properties need to be addressed in nowadays complex embedded systems by architects. Evolutionary algorithms can help architects to find optimal solutions which meet these conicting quality attributes. Also, architectural patterns and antipatterns give the architect knowledge of solving design bottlenecks. Hence, antipatterns heuristics have been used as domain-specific search operators within the evolutionary optimization. However, these heuristics usually improve only one quality attribute and using them in multiobjective problem is challenging. This paper studies the extent to which heuristic-based search operators can improve multiobjective optimization of software architecture for embedded systems. It compares various combinations of heuristic-based operators in a real world automotive system case study.
|
|
| 18. |
- Etemaadi, R., et al.
(author)
-
New degrees of freedom in metaheuristic optimization of component-based systems architecture: Architecture topology and load balancing
- 2015
-
In: Science of Computer Programming. - : Elsevier BV. - 0167-6423. ; 97, s. 366-380
-
Journal article (peer-reviewed)abstract
- Today's complex systems require software architects to address a large number of quality attributes. These quality attributes can be in contradiction with each other. In practice, software architects manually try to come up with a set of different architectural designs and then try to identify the most suitable one. This is a time-consuming and error-prone process. Also, this process may lead the architect to suboptimal designs. To tackle this problem, metaheuristic approaches for automating architecture design have been proposed by researchers. Metaheuristic approaches, such as genetic algorithms (GA), use degrees of freedom to automatically generate new alternative solutions. In this paper, we present two novel degrees of freedom for the optimization of system architectures. These two degrees of freedom: (i) the topology of the hardware platform, and (ii) load balancing of software components, can improve the results of the optimization algorithm. Our approach is implemented as part of the AQOSA (Automated Quality-driven Optimization of Software Architectures) framework. The AQOSA framework aids architects by automatically synthesizing optimal solutions by using multi-objective evolutionary algorithms and it reports the trade-offs between multiple quality properties as output. We analyze the effectiveness of our proposed degrees of freedom, by running a computationally-intensive optimization experiment using an industrial case study from automotive domain. The results show that two new degrees of freedom, (i) architecture topology and (ii) load balancing, help the evolutionary algorithm to find better solutions by enlarging the search space.
|
|
| 19. |
- Etemaadi, Ramin, et al.
(author)
-
Quality-Driven Optimization of System Architecture : Industrial Case Study on an Automotive Sub-System
- 2013
-
In: Journal of Systems and Software. - : Elsevier BV. - 0164-1212 .- 1873-1228. ; 86:10, s. 2559-2573
-
Journal article (peer-reviewed)abstract
- Due to the complexity of today's embedded systems and time-to-market competition between companies developing embedded systems, system architects have to perform a complex task. To design a system which meets all its quality requirements becomes increasingly difficult because of customer demand for new innovative user functions. Methods and tools are needed to assist the architect during system design. The goal of this paper is to show how metaheuristic optimization approaches can improve the process of designing efficient architectures for a set of given quality attributes. A case study is conducted in which an architecture optimization framework is applied to an existing sub-system in the automotive industry. The case study shows that metaheuristic optimization approaches can find efficient solutions for all quality attributes while fulfilling given constraints. By optimizing multiple quality attributes the framework proposes revolutionary architecture solutions in contrast to human architects, who tend to propose solutions based on previous architectures. Although the case study shows savings in manual effort, it also shows that the proposed architecture solutions should be assessed by the human architect. So, the paper demonstrates how an architecture optimization framework complements the domain knowledge and experience of the architect.
|
|
| 20. |
- Fernandez-Saez, A. M., et al.
(author)
-
An industrial case study on the use of UML in software maintenance and its perceived benefits and hurdles
- 2018
-
In: Empirical Software Engineering. - : Springer Science and Business Media LLC. - 1382-3256 .- 1573-7616. ; 23:6, s. 3281-3345
-
Journal article (peer-reviewed)abstract
- UML is a commonly-used graphical language for the modelling of software. Works regarding UML's effectiveness have studied projects that develop software systems from scratch. Yet the maintenance of software consumes a large share of the overall time and effort required to develop software systems. This study, therefore, focuses on the use of UML in software maintenance. We wish to elicit the practices of the software modelling used during maintenance in industry and understand what are perceived as hurdles and benefits when using modelling. In order to achieve a high level of realism, we performed a case study in a multinational company's ICT department. The analysis is based on 31 interviews with employees who work on software maintenance projects. The interviewees played different roles and provided complementary views about the use, hurdles and benefits of software modelling and the use of UML. Our study uncovered a broad range of modelling-related practices, which are presented in a theoretical framework that illustrates how these practices are linked to the specific goals and context of software engineering projects. We present a list of recommended practices that contribute to the increased effectiveness of software modelling. The use of software modelling notations (like UML) is considered beneficial for software maintenance, but needs to be tailored to its context. Various practices that contribute to the effective use of modelling are commonly overlooked, suggesting that a more conscious holistic approach with which to integrate modelling practices into the overall software engineering approach is required.
|
|
| 21. |
|
|
| 22. |
- Fernández-Sáez, Ana M., et al.
(author)
-
Are forward designed or reverse-engineered UML diagrams more helpful for code maintenance?: a controlled experiment
- 2013
-
In: EASE 2013. Proceedings of the 17th International Conference on Evaluation and Assessment in Software Engineering. - New York, NY, USA : ACM. - 9781450318488 ; , s. 60-71
-
Conference paper (peer-reviewed)abstract
- Context: UML has been the de facto standard notation for modeling object-oriented software systems since its appearance in 1997. UML diagrams are important for maintainers of a system, especially when the software was developed by a different team. These diagrams of the system are not always available, however, and are commonly recovered using Reverse Engineering (RE) techniques. When obtained through RE, UML diagrams have a high level of detail as compared to those developed in the forward design activity. Method: In this paper we report on a comparison of the attitude and performance of maintainers when using these two kinds of diagrams during the maintenance of source code. Our findings were obtained by carrying out a controlled experiment with 40 students of a Master's degree in Computer Science. Results: The results show a preference for forward design diagrams but do not display significant differences in task performance. The post-experiment survey results have led us to conclude that the subjects did not consider RE diagrams helpful; they found them difficult to understand, particularly the sequence diagrams. In the case of forward design diagrams, subjects considered sequence diagrams as useful, but they did not really employ them. Conclusions: Based on our findings, as regards performance of maintainers, there are no objective results which favor the use of one of these types of diagram in particular, i.e., UML diagrams which come from forwards design, on the one hand, and diagrams obtained from RE, on the other. Subjective opinions do, however, lead us to recommend the use of diagrams created during design. Nevertheless, we realize that the results should be considered as preliminary ones; further replications of this experiment are planned, using students and professionals, the aim being to obtain more conclusive results.
|
|
| 23. |
- Fernandez-Saez, A. M., et al.
(author)
-
Are Forward Designed or Reverse-Engineered UML diagrams more helpful for code maintenance?: A family of experiments
- 2015
-
In: Information and Software Technology. - : Elsevier BV. - 0950-5849. ; 57, s. 644-663
-
Journal article (peer-reviewed)abstract
- Context: Although various success stories of model-based approaches are reported in literature, there is still a significant resistance to model-based development in many software organizations because the UML is perceived to be expensive and not necessarily cost-effective. It is also important to gather empirical evidence in which context and under which conditions the UML makes or does not make a practical difference. Objective: Our objective is to provide empirical evidence as to which UML diagrams are more helpful during software maintenance: Forward Designed (FD) UML diagrams or Reverse Engineered (RE) UML diagrams. Method: We carried out a family of experiments which consisted of one experiment and two replications with a total of 169 Computer Science undergraduate students. Results: The individual data analysis and the meta-analysis conducted on the whole family, show a tendency in favor of FD diagrams and are significantly different as regards the effectiveness and efficiency of the subjects who participated and played the role of maintainers. The analysis of the qualitative data, collected using a post-experiment survey, reveals that the subjects did not consider RE diagrams helpful. Conclusions: Our findings show that there are some objective results (descriptive statistics or statistical tests) related to the maintenance effectiveness and efficiency in favor of the use of FD UML diagrams during software maintenance. Subjective opinions also lead us to recommend the use of UML diagrams (especially class diagrams) created during the design phase for software maintenance because they improve the understanding of the system in comparison with RE diagrams. Nevertheless, we can only assume that these results are valid in the context of Computer Science undergraduate students when working with small systems related to well-known domains, and other contexts should be explored in order to reaffirm the results in an industrial context by carrying out replications with professionals.
|
|
| 24. |
- Fernandez-Saez, A. M., et al.
(author)
-
Does the level of detail of UML diagrams affect the maintainability of source code? A family of experiments
- 2016
-
In: Empirical Software Engineering. - : Springer Science and Business Media LLC. - 1382-3256 .- 1573-7616. ; 21:1, s. 212-259
-
Journal article (peer-reviewed)abstract
- Although the UML is considered to be the de facto standard notation with which to model software, there is still resistance to model-based development. UML modeling is perceived to be expensive and not necessarily cost-effective. It is therefore important to collect empirical evidence concerning the conditions under which the use of UML makes a practical difference. The focus of this paper is to investigate whether and how the Level of Detail (LoD) of UML diagrams impacts on the performance of maintenance tasks in a model-centric approach. A family of experiments consisting of one controlled experiment and three replications has therefore been carried out with 81 students with different abilities and levels of experience from 3 countries (The Netherlands, Spain, and Italy). The analysis of the results of the experiments indicates that there is no strong statistical evidence as to the influence of different LoDs. The analysis suggests a slight tendency toward better results when using low LoD UML diagrams, especially if used for the modification of the source code, while a high LoD would appear to be helpful in understanding the system. The participants in our study also favored low LoD diagrams because they were perceived as easier to read. Although the participants expressed a preference for low LoD diagrams, no statistically significant conclusions can be drawn from the set of experiments. One important finding attained from this family of experiments was that the participants minimized or avoided the use of UML diagrams, regardless of their LoD. This effect was probably the result of using small software systems from well-known domains as experimental materials.
|
|
| 25. |
- Fernández-Sáez, Ana M., et al.
(author)
-
Empirical studies concerning the maintenance of UML diagrams and their use in the maintenance of code: A systematic mapping study
- 2013
-
In: Information and Software Technology. - : Elsevier BV. - 0950-5849. ; 55:7, s. 1119-1142
-
Research review (peer-reviewed)abstract
- Context: The Unified Modelling Language (UML) has, after ten years, become established as the de facto standard for the modelling of object-oriented software systems. It is therefore relevant to investigate whether its use is important as regards the costs involved in its implantation in industry being worthwhile. Method: We have carried out a systematic mapping study to collect the empirical studies published in order to discover "What is the current existing empirical evidence with regard to the use of UML diagrams in source code maintenance and the maintenance of the UML diagrams themselves? Results: We found 38 papers, which contained 63 experiments and 3 case studies. Conclusion: Although there is common belief that the use of UML is beneficial for source code maintenance, since the quality of the modifications is greater when UML diagrams are available, only 3 papers concerning this issue have been published. Most research (60 empirical studies) concerns the maintainability and comprehensibility of the UML diagrams themselves which form part of the system's documentation, since it is assumed that they may influence source code maintainability, although this has not been empirically validated. Moreover, the generalizability of the majority of the experiments is questionable given the material, tasks and subjects used. There is thus a need for more experiments and case studies to be performed in industrial contexts, i.e., with real systems and using maintenance tasks conducted by practitioners under real conditions that truly show the utility of UML diagrams in maintaining code, and that the fact that a diagram is more comprehensible or modifiable influences the maintainability of the code itself. This utility should also be studied from the viewpoint of cost and productivity, and the consistent and simultaneous maintenance of diagrams and code must also be considered in future empirical studies. © 2013 Elsevier B.V. All rights reserved.
|
|
| 26. |
|
|
| 27. |
- Hebig, Regina, et al.
(author)
-
Identifying Metrics' Biases When Measuring or Approximating Size in Heterogeneous Languages.
- 2015
-
In: Empirical Software Engineering and Measurement (ESEM 2015), ACM/IEEE International Symposium on.. - 1938-6451 .- 1949-3789 .- 1949-3770. - 9781467378994
-
Conference paper (peer-reviewed)abstract
- To compare the effectiveness of development techniques, the size of compared software systems needs to be taken into account. However, in industry new development techniques often come with changes in the applied programming languages. Goal: Our goal is to investigate how different size metrics and approximations are biased towards the languages c and c++. Further, we investigate whether triangulation of metrics has the potential to compensate for biases. Method: We identify crucial preconditions for a triangulation and investigate on 34 open source projects, whether a set of 16 size metrics fulfills these preconditions for the languages c and c++. Results: We identify how metrics differ in their biases and find that the preconditions for triangulation are fulfilled. Conclusion: Triangulation has the potential to address language biases, but high variance among metrics and tools need to be taken into account, too.
|
|
| 28. |
- Hebig, Regina, 1984, et al.
(author)
-
The quest for open source projects that use UML: mining GitHub.
- 2016
-
In: Proceedings of the ACM/IEEE 19th International Conference on Model Driven Engineering Languages and Systems (MODELS '16). - New York, NY, USA : ACM. - 9781450343213 ; , s. 173-183
-
Conference paper (peer-reviewed)abstract
- Context: While industrial use of UML was studied intensely, little is known about UML use in Free/Open Source Software (FOSS) projects. Goal: We aim at systematically mining GitHub projects to answer the question when models, if used, are created and updated throughout the whole project's life-span. Method: We present a semi-automated approach to collect UML stored in images, .xmi, and .uml files and scanned ten percent of all GitHub projects (1.24 million). Our focus was on number and role of contributors that created/updated models and the time span during which this happened. Results: We identified and studied 21 316 UML diagrams within 3 295 projects. Conclusion: Creating/updating of UML happens most often during a very short phase at the project start. For 12% of the models duplicates were found, which are in average spread across 1.88 projects. Finally, we contribute a list of GitHub projects that include UML files.
|
|
| 29. |
- Ho-Quang, Truong, et al.
(author)
-
Automatic classification of UML Class diagrams from images
- 2014
-
In: Proceedings of the 21st Asia-Pacific Software Engineering Conference, APSEC 2014. - 1530-1362. - 9781479974252
-
Conference paper (peer-reviewed)abstract
- - Graphical modelling of various aspects of software and systems is a common part of software development. UML is the de-facto standard for various types of software models. To be able to research UML, academia needs to have a corpus of UML models. For building such a database, an automated system that has the ability to classify UML class diagram images would be very beneficial, since a large portion of UML class diagrams (UML CDs) is available as images on the Internet. In this study, we propose 23 image-features and investigate the use of these features for the purpose of classifying UML CD images. We analyse the performance of the features and assess their contribution based on their Information Gain Attribute Evaluation scores. We study specificity and sensitivity scores of six classification algorithms on a set of 1300 images. We found that 19 out of 23 introduced features can be considered as influential predictors for classifying UML CD images. Through the six algorithms, the prediction rate achieves nearly 96% correctness for UML-CD and 91% of correctness for non-UML CD.
|
|
| 30. |
- Ho-Quang, Truong, 1989, et al.
(author)
-
Challenges and directions for a community infrastructure for Big Data-driven research in software architecture
- 2020
-
In: Model Management and Analytics for Large Scale Systems. - : Elsevier. ; , s. 13-35
-
Book chapter (other academic/artistic)abstract
- Research into software architecture and design has become more and more prominent since the 1990s. Since then, companies have reported how software architecting helped them to tackle various challenges in system design, especially related to system-level quality properties such as scalability and maintainability. Academic research in software architecture has focused on several areas, including architecture description through views and architecture description languages, and on methods for evaluating architectural designs. While much of the contribution of research in software architecture was inspired by industrial experiences, little of the research was validated beyond individual case studies. Many scientific disciplines are currently harvesting fruits from large-scale data collection about their subjects of study. Therefore, this chapter contributes a discussion of challenges and directions for Big Data-driven studies of software architecture. Given the large amount of effort that is needed for this type of research, a promising direction is to look into a community-based infrastructure for enabling and supporting this type of research. We share lessons learned through building various tools that could form building blocks in such an infrastructure. Based on these, we synthesize a reference architecture for creating such a community-wide infrastructure for Big Data-based research in software architecture.
|
|
| 31. |
- Ho-Quang, Truong, 1989, et al.
(author)
-
Interactive Role Stereotype-Based Visualization to Comprehend Software Architecture
- 2020
-
In: Proceedings - 8th IEEE Working Conference on Software Visualization, VISSOFT 2020. ; , s. 122-132
-
Conference paper (peer-reviewed)abstract
- Motivation: Software visualization can be helpful in comprehending the architecture of large software systems. Traditionally, software visualisation focuses on representing the structural perspectives of systems. In this paper we enrich this perspective by adding the notion of role-stereotype. This rolestereotype carries information about the type of functionality that a class has in the system as well as the types of collaborations with other classes that it typically has. Objective: We propose an interactive visualization called RoleViz, that visualizes system architectures in which architectural elements are annotated with their role-stereotypes. Method: We conducted a user-study in which developers use RoleViz and Softagram (a commercial tool for software architecture comprehension) to solve two separate comprehension tasks on a large open source system. We compared RoleViz against Softagram in terms of participant's: (i) perceived cognitive load, (ii) perceived usability, and (iii) understanding of the system. Result: In total, 16 developers participated in our study. Six of the participants explicitly indicated that visualizing roles helped them complete the assigned tasks. Our observations indicate significant differences in terms of participant's perceived usability and understanding scores. Conclusion: The participants achieved better scores on completing software understanding tasks with RoleViz without any cognitive-load penalty. Demo: https://youtu.be/HqCUAlai4qw?t=258
|
|
| 32. |
- Ho Quang, Truong, 1989, et al.
(author)
-
Interactive user-oriented views for better understanding software systems
- 2015
-
In: CEUR Workshop Proceedings. - 1613-0073. ; 1820, s. 48-53
-
Conference paper (peer-reviewed)abstract
- Understanding software artefacts is a crucial task for people who want to participate in any software development process. However, because of the large amount of detailed and scattered information in software artefacts, understanding them is usually time-consuming and vulnerable to human errors and subjectivities. A system that aids practitioners to investigate understanding about software artefacts could reduce the vulnerabilities and speed up software development/maintenance process. Our research focuses on building a comprehensive view of software system in order for developers to achieve the two goals: (i) to save the time spending on searching and navigating on source code; and (ii) to gain better understanding about software artefacts regarding to domain-specific tasks. To achieve these goals, we propose an emprical approach in which the visualisation and the generation of high-level design and architectural views from source code and design documentations have been played central roles. The research is on-going and could potentially be extended to different software artefacts (such as requirements, use-cases, test-cases, revision logs).
|
|
| 33. |
- Ho-Quang, Truong, et al.
(author)
-
Practices and perceptions of UML use in open source projects
- 2017
-
In: Proceedings - 2017 IEEE/ACM 39th International Conference on Software Engineering: Software Engineering in Practice Track, ICSE-SEIP 2017.
-
Conference paper (peer-reviewed)abstract
- © 2017 IEEE. Context: Open Source is getting more and more collaborative with industry. At the same time, modeling is today playing a crucial role in development of, e.g., safety critical software. Goal: However, there is a lack of research about the use of modeling in Open Source. Our goal is to shed some light into the motivation and benefits of the use of modeling and its use within project teams. Method: In this study, we perform a survey among Open Source developers. We focus on projects that use the Unified Modeling Language (UML) as a representative for software modeling. Results: We received 485 answers of contributors of 458 different Open Source projects. Conclusion: Collaboration seems to be the most important motivation for using UML. It benefits new contributors and contributors who do not create models. Teams use UML during communication and planning of joint implementation efforts.
|
|
| 34. |
- Ho-Quang, Truong, 1989, et al.
(author)
-
Role stereotypes in software designs and their evolution
- 2022
-
In: Journal of Systems and Software. - : Elsevier BV. - 0164-1212. ; 189
-
Journal article (peer-reviewed)abstract
- Role stereotypes are abstract characterisations of the responsibilities of the building blocks of software applications. The role a class plays within a software system reflects its design intention. Wirfs-Brock introduced the following six role stereotypes: Information Holder, which knows information, Structurer, which maintains object relationships, Service Provider, which offers computing services, Coordinator, which delegates tasks to others, Controller, which directs other's actions, and Interfacer, which transforms information. Knowledge about class role stereotypes can help various software development and maintenance tasks, such as program understanding, program summarisation, and quality assurance. This paper presents an automated machine learning-based approach for classifying the role-stereotype of classes in Java projects. We analyse this approach's performance against a manually labelled ground truth for three open source projects that contain 1,500+ Java classes altogether. The contributions of this paper include: (i) a machine learning (ML) approach to address the problem of automatically inferring role-stereotypes of classes in Object-Oriented Programming Languages, (ii) the manually labelled ground truth, (iii) an evaluation of the performance of the classifier, (iv) an evaluation of the generalisability of the approach, and (v) an illustration of new uses of role-stereotypes. The evaluation shows that the Random Forest algorithm yields the best classification performance. We find, however, that the performance of the ML-classifier varies a lot for different role stereotypes. In particular, its performance degrades when classifying rarer stereotypes. Among the 23 features that we study, features related to the classes’ collaboration characteristics and complexity stand out as the best discriminants of role stereotypes.
|
|
| 35. |
- Ho-Quang, Truong, 1989, et al.
(author)
-
Towards an infrastructure for empirical research into software architecture: Challenges and directions
- 2019
-
In: Proceedings - 2019 IEEE/ACM 2nd International Workshop on Establishing a Community-Wide Infrastructure for Architecture-Based Software Engineering, ECASE 2019. ; , s. 34-41
-
Conference paper (peer-reviewed)abstract
- While the software engineering community at large has embraced empirical studies of source code, empirical studies of software architecture are lacking. In order to increase the possibility and relevance of studies into software architecture, an infrastructure for sharing empirical data on software architecture is essential. This paper contributes by discussing needs and challenges in empirical studies of software architecture. Based on lessons learned we propose CoSARI - a community-wide infrastructure for empirical research into software architecture.
|
|
| 36. |
- Jolak, Rodi, et al.
(author)
-
Dissecting design effort and drawing effort in UML modeling
- 2017
-
In: Proceedings - 43rd Euromicro Conference on Software Engineering and Advanced Applications, SEAA 2017. - 9781538621424 - 9781538621400
-
Conference paper (peer-reviewed)abstract
- One argument in the discussion about the adoption of UML in industry is the supposedly large effort it takes to do modeling. Our study explores how the creation of UML models can be understood to consist of different cognitive activities: (i) designing: thinking about the design (ideation, key-design decision making), (ii) notation expression: expressing a design in a modeling notation and (iii) layouting: the spatial organization of model elements in a diagram. We explain that these different subactivities relate to different short-term and long-term benefits of modeling. In this study we present two controlled experiments with a total of 100 subjects creating models for a small system. In these experiments we focus on software models as represented through UML class diagram. Our results show that at least 56% of the effort spent on creating a class model is actually due to designing. Notation expression is around 41% of the model creation effort and layouting is in the order of 3%. This finding suggests that a significant part of creating models is devoted to design thinking about the problem.
|
|
| 37. |
|
|
| 38. |
- Jolak, Rodi, 1985, et al.
(author)
-
Model-based software engineering: A multiple-case study on challenges and development efforts
- 2018
-
In: Proceedings - 21st ACM/IEEE International Conference on Model Driven Engineering Languages and Systems, MODELS 2018. - New York, NY, USA : ACM. - 9781450349499 ; , s. 213-223
-
Conference paper (peer-reviewed)abstract
- A recurring theme in discussions about the adoption of Model-Based Engineering (MBE) is its effectiveness. This is because there is a lack of empirical assessment of the processes and (tool-)use of MBE in practice. We conducted a multiple-case study by observing 2 two-month MBE projects from which software for a Mars rover were developed. We focused on assessing the distribution of the total software development effort over different development activities. Moreover, we observed and collected challenges reported by the developers during the execution of projects. We found that the majority of the effort is spent on the collaboration and communication activities. Furthermore, our inquiry into challenges showed that tool-related challenges are the most encountered.
|
|
| 39. |
- Jolak, Rodi, 1985, et al.
(author)
-
OctoBubbles: A Multi-view interactive environment for concurrent visualization and synchronization of UML models and code
- 2018
-
In: 25th IEEE International Conference on Software Analysis, Evolution and Reengineering, SANER 2018 - Proceedings. - 9781538649695 ; 2018-March, s. 482-486
-
Conference paper (peer-reviewed)abstract
- The process of software understanding often requires developers to consult both high-and low-level software artifacts (i.e. models and code). The creation and persistence of such artifacts often take place in different environments, as well as seldom in one single environment. In both cases, software models and code fragments are viewable separately making the workspace overcrowded with many opened interfaces and tabs. In such a situation, developers might lose the big picture and spend unnecessary effort on navigation and locating the artifact of interest. To assist program comprehension and tackle the problem of software navigation, we present OctoBubbles, a multi-view interactive environment for concurrent visualization and synchronization of software models and code. A preliminary evaluation of OctoBubbles with 15 professional developers shows a high level of interest, and points out to potential benefits. Furthermore, we present a future plan to quantitatively investigate the effectiveness of the environment.
|
|
| 40. |
- Jolak, Rodi, et al.
(author)
-
Software engineering whispers: The effect of textual vs. graphical software design descriptions on software design communication
- 2020
-
In: Empirical Software Engineering. - : Springer Science and Business Media LLC. - 1382-3256 .- 1573-7616. ; 25, s. 4427-4471
-
Journal article (peer-reviewed)abstract
- Context Software engineering is a social and collaborative activity. Communicating and sharing knowledge between software developers requires much effort. Hence, the quality of communication plays an important role in influencing project success. To better understand the effect of communication on project success, more in-depth empirical studies investigating this phenomenon are needed. Objective We investigate the effect of using a graphical versus textual design description on co-located software design communication. Method Therefore, we conducted a family of experiments involving a mix of 240 software engineering students from four universities. We examined how different design representations (i.e., graphical vs. textual) affect the ability toExplain,Understand,Recall, andActively Communicateknowledge. Results We found that the graphical design description is better than the textual in promotingActive Discussionbetween developers and improving theRecallof design details. Furthermore, compared to its unaltered version, a well-organized and motivated textual design description-that is used for the same amount of time-enhances the recall of design details and increases the amount of active discussions at the cost of reducing the perceived quality of explaining.
|
|
| 41. |
- Jolak, Rodi, 1985, et al.
(author)
-
The influence of software design representation on the design communication of teams with diverse personalities
- 2022
-
In: Proceedings - 25th ACM/IEEE International Conference on Model Driven Engineering Languages and Systems, MODELS 2022. - New York, NY, USA : ACM. ; , s. 255-265
-
Conference paper (peer-reviewed)abstract
- Software is the main driver of added-value in many of the systems that surround us. While its complexity is increasing, so is the diversity of systems driven by software. To meet the challenges emerging from this combination, it is necessary to mobilize increasingly large and heterogeneous multidisciplinary teams, comprising software experts, as well as experts from various domains related to the systems driven by software. Hence, the quality of communication about software between stakeholders of different domains and with different personalities is becoming a key issue for successfully engineering software-intensive systems. The goal of this study, thus, is to investigate the effect of the representation of software design models on the communication of design decisions between stakeholders with diverse personality traits. As a result, this study finds that graphical representations of software design models are better than textual representations in enhancing the communication and increasing the productivity of stakeholders with diverse personalities.
|
|
| 42. |
|
|
| 43. |
- Karasneh, Bilal, et al.
(author)
-
Extracting UML models from images
- 2013
-
In: 2013 5th International Conference on Computer Science and Information Technology, CSIT 2013 - Proceedings. - : IEEE. - 9781467358255
-
Conference paper (peer-reviewed)abstract
- Software modeling is an active field of research. In this field, UML is considered the standard for software modeling. Studying UML models is important to understand their effectiveness in software development. Ideally, researchers want to study UML models from documentations from industrial software projects. Given their limited availability, we resort to collecting UML models from internet. A big problem for studies of UML models is that UML models are published mostly in image formats (such as JPEG). These images do not include the model information that is available for UML models when saved in a CASE (Computer Automated Software Engineering) tool format or the XML-based version of the UML interchange format: XMI. Current CASE tools cannot recognize information from images. In this paper we propose the Img2UML tool to solve this problem. The Img2UML extracts UML Class models from images such that these models can be loaded into CASE tools for further study. The Img2UML tool exports UML Class models into XMI files which can be read with the StarUML CASE tool. We performed a validation which shows that Img2UML successfully handles a large class of UML Class images. © 2013 IEEE.
|
|
| 44. |
- Liebel, Grischa, 1987, et al.
(author)
-
Ready for Prime Time, - Yes, Industrial-Grade Modelling Tools can be Used in Education
- 2015
-
Reports (other academic/artistic)abstract
- It has been stated that industrial-grade modelling tools are unsuitable for teaching modelling. In this paper, we present our experience with a university course on software modelling. In the first year of the course, we used a commercial modelling tool, in the second year the open-source alternative Papyrus. Both tools are considered to be of industrial grade and used in industry. Our quantitative analysis shows that the industrial-grade modelling tools with all their complexity did not have a negative impact on the students' experience of modelling. This shows that industrial-grade modelling tools can be used in the classroom. We analyse why our experience differs from published accounts and conclude that the availability of a tool champion and tailored instruction material is key. From this, we derive recommendations for teacher support from tool-providers (vendors and open source), research directions for researchers and teachers, and for training efforts in the industry.
|
|
| 45. |
- Martini, Antonio, 1982, et al.
(author)
-
Architecture Technical Debt: Understanding Causes and a Qualitative Model
- 2014
-
In: 40th Euromicro Conference on Software Engineering and Advanced Applications. - 1089-6503. - 9781479957958 ; , s. 85-92
-
Conference paper (peer-reviewed)abstract
- A known problem in large software companies is to balance the prioritization of short-term with long-term responsiveness. Specifically, architecture violations (Architecture Technical Debt) taken to deliver fast might hinder future feature development, which would hinder agility. We conducted a multiple-case embedded case study in 7 sites at 5 large companies in order to shed light on the current causes for the accumulation of Architectural Technical Debt that causes effort. We provide a taxonomy of the factors and their influence in the accumulation of debt, and we provide a qualitative model of how the debt is accumulated and recovered over time.
|
|
| 46. |
- Martini, Antonio, 1982, et al.
(author)
-
Investigating Architectural Technical Debt accumulation and refactoring over time: A multiple-case study
- 2015
-
In: Information and Software Technology. - : Elsevier BV. - 0950-5849. ; 67, s. 237-253
-
Journal article (peer-reviewed)abstract
- Context A known problem in large software companies is to balance the prioritization of short-term with long-term feature delivery speed. Specifically, Architecture Technical Debt is regarded as sub-optimal architectural solutions taken to deliver fast that might hinder future feature development, which, in turn, would hinder agility. Objective This paper aims at improving software management by shedding light on the current factors responsible for the accumulation of Architectural Technical Debt and to understand how it evolves over time. Method We conducted an exploratory multiple-case embedded case study in 7 sites at 5 large companies. We evaluated the results with additional cross-company interviews and an in-depth, company-specific case study in which we initially evaluate factors and models. Results We compiled a taxonomy of the factors and their influence in the accumulation of Architectural Technical Debt, and we provide two qualitative models of how the debt is accumulated and refactored over time in the studied companies. We also list a set of exploratory propositions on possible refactoring strategies that can be useful as insights for practitioners and as hypotheses for further research. Conclusion Several factors cause constant and unavoidable accumulation of Architecture Technical Debt, which leads to development crises. Refactorings are often overlooked in prioritization and they are often triggered by development crises, in a reactive fashion. Some of the factors are manageable, while others are external to the companies. ATD needs to be made visible, in order to postpone the crises according to the strategic goals of the companies. There is a need for practices and automated tools to proactively manage ATD.
|
|
| 47. |
- Mellegård, Niklas, 1971, et al.
(author)
-
Impact of Introducing Domain-Specific Modelling in Software Maintenance: An Industrial Case Study
- 2016
-
In: Ieee Transactions on Software Engineering. - : Institute of Electrical and Electronics Engineers (IEEE). - 0098-5589 .- 1939-3520. ; 42:3, s. 248-263
-
Journal article (peer-reviewed)abstract
- Domain-specific modelling (DSM) is a modern software development technology that aims at enhancing productivity. One of the claimed advantages of DSM is increased maintainability of software. However, current empirical evidence supporting this claim is lacking. In this paper, we contribute evidence from a case study conducted at a software development company. We study how the introduction of DSM affected the maintenance of a legacy system. We collected data about the maintenance phase of a system that was initially developed using manual programming, but which was gradually replaced by DSM development. We performed statistical analyses of the relation between the use of DSM and the time needed to resolve defects, the defect density, and the phase in which defects were detected. The results show that after introducing DSM the defect density is lower, that defects are found earlier, but resolving defects takes longer. Other observed benefits are that the number of developers and the number of person-hours needed for maintaining the system decreased, and the portability to new platforms increased. Our findings are useful for organizations that consider introducing DSM and would like to know which benefits can be realized in software maintenance.
|
|
| 48. |
- Nugroho, Ariadi, et al.
(author)
-
The impact of UML modeling on defect density and defect resolution time in a proprietary system
- 2014
-
In: Empirical Software Engineering. - : Springer Science and Business Media LLC. - 1573-7616 .- 1382-3256. ; 19:4, s. 926-954
-
Journal article (peer-reviewed)abstract
- Background: The contribution of modeling in software development has been a subject of debates. The proponents of model-driven development argue that a big upfront modeling requires substantial investment, but it will payoff later in the implementation phase in terms of increased productivity and quality. Other software engineers perceive modeling activity as a waste of time and money without any real contribution to the final software product. Considering present advancement of model-based software development in software industry, we are challenged to investigate the real contribution of modeling in software development. Objective: We analyze the impacts of UML modeling, specifically the production of class and sequence diagrams, on the quality of the code, as measured by defect density, and on defect resolution time. Method: Using data of a proprietary system, we conduct post-mortem analyses to test the difference in defect density between software modules that are modeled and not modeled. Similarly, we test the difference in resolution time between defects that are related to modeled and not modeled functionality. Result: We have found that the production of UML class diagrams and sequence diagrams reduces defect density in the code and the time required to fix defects. These results are obtained after controlling for the effects of co-factors such as code coupling and complexity. Conclusion: The results confirm that not only does the production of UML class diagrams and sequence diagrams possibly help improve the quality of software, but also it possibly help increase the productivity in software maintenance.
|
|
| 49. |
|
|
| 50. |
- Osman, M.H., et al.
(author)
-
An analysis of machine learning algorithms for condensing reverse engineered class diagrams
- 2013
-
In: IEEE International Conference on Software Maintenance, ICSM. - : IEEE. - 1063-6773.
-
Conference paper (peer-reviewed)abstract
- There is a range of techniques available to reverse engineer software designs from source code. However, these approaches generate highly detailed representations. The condensing of reverse engineered representations into more high-level design information would enhance the understandability of reverse engineered diagrams. This paper describes an automated approach for condensing reverse engineered diagrams into diagrams that look as if they are constructed as forward designed UML models. To this end, we propose a machine learning approach. The training set of this approach consists of a set of forward designed UML class diagrams and reverse engineered class diagrams (for the same system). Based on this training set, the method 'learns' to select the key classes for inclusion in the class diagrams. In this paper, we study a set of nine classification algorithms from the machine learning community and evaluate which algorithms perform best for predicting the key classes in a class diagram. © 2013 IEEE.
|
|
