| 1. |
- Antinyan, Vard, 1984, et al.
(författare)
-
A Complexity Measure for Textual Requirements
- 2016
-
Ingår i: Proceedings of 2016 Joint Conference of the International Workshop on Software Measurement and the International Conference on Software Process and Product Measurement (Iwsm-Mensura). - : IEEE. - 9781509041473 - 9781509041480
-
Konferensbidrag (refereegranskat)abstract
- Unequivocally understandable requirements are vital for software design process. However, in practice it is hard to achieve the desired level of understandability, because in large software products a substantial amount of requirements tend to have ambiguous or complex descriptions. Over time such requirements decelerate the development speed and increase the risk of late design modifications, therefore finding and improving them is an urgent task for software designers. Manual reviewing is one way of addressing the problem, but it is effort-intensive and critically slow for large products. Another way is using measurement, in which case one needs to design effective measures. In recent years there have been great endeavors in creating and validating measures for requirements understandability: most of the measures focused on ambiguous patterns. While ambiguity is one property that has major effect on understandability, there is also another important property, complexity, which also has major effect on understandability, but is relatively less investigated. In this paper we define a complexity measure for textual requirements through an action research project in a large software development organization. We also present its evaluation results in three large companies. The evaluation shows that there is a significant correlation between the measurement values and the manual assessment values of practitioners. We recommend this measure to be used with earlier created ambiguity measures as means for automated identification of complex specifications.
|
|
| 2. |
- Antinyan, Vard, 1984, et al.
(författare)
-
Defining technical risks in software development
- 2014
-
Ingår i: Joint Conference of the 24th International Workshop on Software Measurement, IWSM 2014 and the 9th International Conference on Software Process and Product Measurement, Mensura 2014; ss RotterdamRotterdam; Netherlands; 6 October 2014 through 8 October 2014. - : IEEE. - 9781479941742
-
Konferensbidrag (refereegranskat)abstract
- Challenges of technical risk assessment is difficult to address, while its success can benefit software organizations appreciably. Classical definition of risk as a 'combination of probability and impact of adverse event' appears not working with technical risk assessment. The main reason of this is the nature of adverse event's outcome which is rather continuous than discrete. The objective of this study was to scrutinize different aspects of technical risks and provide a definition, which will support effective risk assessment and management in software development organizations. In this study we defined the risk considering the nature of actual risks, emerged in software development. Afterwards, we summarized the software engineers' view on technical risks as results of three workshops with 15 engineers of four software development companies. The results show that technical risks could be viewed as a combination of uncertainty and magnitude of difference between actual and optimal design of product artifacts and processes. The presented definition is congruent with practitioners view on technical risk. It supports risk assessment in a quantitative manner and enables identification of potential product improvement areas.
|
|
| 3. |
|
|
| 4. |
- Antinyan, Vard, 1984, et al.
(författare)
-
Identifying Complex Functions : By Investigating Various Aspects of Code Complexity
- 2015
-
Ingår i: Proceedings of 2015 Science and Information Conference (SAI). - : IEEE Press. - 9781479985470 - 9781479985487 - 9781479985463 ; , s. 879-888
-
Konferensbidrag (refereegranskat)abstract
- The complexity management of software code has become one of the major problems in software development industry. With growing complexity the maintenance effort of code increases. Moreover, various aspects of complexity create difficulties for complexity assessment. The objective of this paper is to investigate the relationships of various aspects of code complexity and propose a method for identifying the most complex functions. We have conducted an action research project in two software development companies and complemented it with a study of three open source products. Four complexity metrics are measured, and their nature and mutual influence are investigated. The results and possible explanations are discussed with software engineers in industry. The results show that there are two distinguishable aspects of complexity of source code functions: Internal and outbound complexities. Those have an inverse relationship. Moreover, the product of them does not seem to be greater than a certain limit, regardless of software size. We present a method that permits identification of most complex functions considering the two aspects of complexities. The evaluation shows that the use of the method is effective in industry: It enables identification of 0.5% most complex functions out of thousands of functions for reengineering.
|
|
| 5. |
- Antinyan, Vard, 1984, et al.
(författare)
-
Identifying risky areas of software code in Agile/Lean software development: An industrial experience report
- 2014
-
Ingår i: 2014 Software Evolution Week - IEEE Conference on Software Maintenance, Reengineering, and Reverse Engineering, CSMR-WCRE 2014 - Proceedings. - : IEEE. - 9781479941742
-
Konferensbidrag (refereegranskat)abstract
- Modern software development relies on incremental delivery to facilitate quick response to customers' requests. In this dynamic environment the continuous modifications of software code can cause risks for software developers; when developing a new feature increment, the added or modified code may contain fault-prone or difficult-to-maintain elements. The outcome of these risks can be defective software or decreased development velocity. This study presents a method to identify the risky areas and assess the risk when developing software code in Lean/Agile environment. We have conducted an action research project in two large companies, Ericsson AB and Volvo Group Truck Technology. During the study we have measured a set of code properties and investigated their influence on risk. The results show that the superposition of two metrics, complexity and revisions of a source code file, can effectively enable identification and assessment of the risk. We also illustrate how this kind of assessment can be successfully used by software developers to manage risks on a weekly basis as well as release-wise. A measurement system for systematic risk assessment has been introduced to two companies. © 2014 IEEE.
|
|
| 6. |
- Antinyan, Vard, 1984, et al.
(författare)
-
Monitoring Evolution of Code Complexity and Magnitude of Changes
- 2014
-
Ingår i: Acta Cybernetica. - 0324-721X. ; 21:3, s. 367-382
-
Tidskriftsartikel (refereegranskat)abstract
- Background: Complexity management has become a crucial activity in continuous software development. While the overall perceived complexity of a product grows rather insignificantly, the small units, such as functions and files, can have noticeable complexity growth with every increment of product features. This kind of evolution triggers risks of escalating fault-proneness and deteriorating maintainability. Goal: The goal of this research was to develop a measurement system which enables effective monitoring of complexity evolution. Method: An action research has been conducted in two large software development organiza-tions. We have measured three complexity and two change properties of code for two large industrial products. The complexity growth has been measured for five consecutive releases of products. Different patterns of growth have been identified and evaluated with software engi-neers in industry. Results: The results show that monitoring cyclomatic complexity evolution of functions and number of revisions of files focuses the attention of designers to potentially problematic files and functions for manual assessment and improvement. A measurement system was developed at Ericsson to support the monitoring process.
|
|
| 7. |
- Antinyan, Vard, et al.
(författare)
-
Monitoring evolution of code complexity and magnitude of changes
- 2014
-
Ingår i: Acta Cybernetica. - : University of Szeged, Institute of Informatics. - 0324-721X. ; 21:3, s. 367-382
-
Tidskriftsartikel (refereegranskat)abstract
- Complexity management has become a crucial activity in continuous software development. While the overall perceived complexity of a product grows rather insignificantly, the small units, such as functions and files, can have noticeable complexity growth with every increment of product features. This kind of evolution triggers risks of escalating fault-proneness and deteriorating maintainability. The goal of this research was to develop a measurement system which enables effective monitoring of complexity evolution. An action research has been conducted in two large software development organizations. We have measured three complexity and two change properties of code for two large industrial products. The complexity growth has been measured for five consecutive releases of the products. Different patterns of growth have been identified and evaluated with software engineers in industry. The results show that monitoring cyclomatic complexity evolution of functions and number of revisions of files focuses the attention of designers to potentially problematic files and functions for manual assessment and improvement. A measurement system was developed at Ericsson to support the monitoring process.
|
|
| 8. |
- Antinyan, Vard, 1984, et al.
(författare)
-
Monitoring Evolution of Code Complexity in Agile/Lean Software Development - A Case Study at Two Companies
- 2013
-
Ingår i: 13th Symposium on Programming Languages and Software Tools, SPLST 2013 - Proceedings. - 9789633062289 ; , s. 1-15
-
Konferensbidrag (refereegranskat)abstract
- One of the distinguishing characteristics of Agile and Lean software development is that software products “grow” with new functionality with relatively small increments. Continuous customer demands of new features and the companies’ abilities to deliver on those demands are the two driving forces behind this kind of software evolution. Despite the numerous benefits there are a number of risks associated with this kind of growth. One of the main risks is the fact that the complexity of the software product grows slowly, but over time reaches scales which makes the product hard to maintain or evolve. The goal of this paper is to present a measurement system for monitoring the growth of complexity and drawing attention when it becomes problematic. The measurement system was developed during a case study at Ericsson and Volvo Group Truck Technology. During the case study we explored the evolution of size, complexity, revisions and number of designers of two large software products from the telecom and automotive domains. The results show that two measures needed to be monitored to keep the complexity development under control - McCabe’s complexity and number of revisions.
|
|
| 9. |
- Antinyan, Vard, 1984, et al.
(författare)
-
Mythical Unit Test Coverage
- 2018
-
Ingår i: IEEE Software. - 0740-7459. ; 35:3, s. 73-79
-
Tidskriftsartikel (refereegranskat)abstract
- It is a continuous struggle to understand how much a product should be tested before its delivery to the market. Ericsson, as a global software development company, decided to evaluate the adequacy of the unit-test-coverage criterion that it had employed for years as a guide for sufficiency of testing. Naturally, one can think that if increasing coverage decreases the number of defects significantly, then coverage can be considered a criterion for test sufficiency. To test this hypothesis in practice, we investigated the relationship of unit-test-coverage measures and post-unit-test defects in a large commercial product of Ericsson. The results indicate that high unit-test coverage did not seem to be any tangible help in producing defect-free software.
|
|
| 10. |
- Antinyan, Vard, 1984
(författare)
-
Proactive Software Complexity Assessment
- 2017
-
Doktorsavhandling (övrigt vetenskapligt/konstnärligt)abstract
- Large software development companies primarily deliver value to their customers by continuously enhancing the functionality of their products. Continuously developing software for customers insures the enduring success of a company. In continuous development, however, software complexity tends to increase gradually, the consequence of which is deteriorating maintainability over time. During short periods of time, the gradual complexity increase is insignificant, but over longer periods of time, complexity can develop to an unconceivable extent, such that maintenance is no longer profitable. Thus, proactive complexity assessment methods are required to prevent the gradual growth of complexity and instead build quality into developed software. Many studies have been conducted to delineate methods for complexity assess-ment. These focus on three main areas: 1) the landscape of complexity, i.e., the source of the complexity; 2) the possibilities for complexity assessment, i.e., how complexity can be measured and whether the results of assessment reflects reality; and 3) the practicality of using complexity assessment methods, i.e., the successful integration and use of assessment methods in continuous software development. Partial successes were achieved in all three areas. Firstly, it is clear that com-plexity is understood in terms of its consequences, such as spent time or re-sources, rather than in terms of its structure per se, such as software character-istics. Consequently, current complexity measures only assess isolated aspects of complexity and fail to capture its entirety. Finally, it is also clear that existing complexity assessment methods are used for isolated activities (e.g., defect and maintainability predictions) and not for integrated decision support (e.g., con-tinuous maintainability enhancement and defect prevention). This thesis presents 14 new findings across these three areas. The key findings are that: 1) Complexity increases maintenance time multifold when software size is constant. This consequential effect is mostly due to a few software characteristics, and whilst other software characteristics are essential for software development, they have an insignificant effect on complexity growth; 2) Two methods are proposed for complexity assessment. The first is for source code, which represents a combination of existing complexity measures to indicate deteriorating areas of code. The second is for textual requirements, which represents new complexity measures that can detect the inflow of poorly specified requirements; 3) Both methods were developed based on two critical factors: (i) the accuracy of assessment, and (ii) the simplicity of interpretation. The methods were integrated into practitioners’ working environments to allow proactive complexity assessment, and prevent defects and deteriorating maintainability. In addition, several additional key observations were made: Primarily the focus should be in creating more sophisticated software complexity measures based on empirical data indicative of the code characteristics that most influence com-plexity. It is desirable to integrate such complexity assessment measures into the practitioners’ working environments to ensure that complexity is assessed and managed proactively. This would allow quality to be built into the product rather than having to conduct separate, post-release refactoring activities.
|
|
