I’ve been browsing the latest issue of IST and this article cought my attention. The article is written by Tommi Mikkonen, Casper Lassenius, Tomi Männistö, Markku Oivo, Janne Järvinen. It is about technology transfer from academia to industry. It’s available at: https://doi.org/10.1016/j.infsof.2017.10.013
The best point in this article is very important – the technology is NOT created in academia and transferred to industry, it is rather created either in industry or in collaboration with academia. This observation invalidates many of the technology transfer models, where the authors assume that the companies receive the results from academia.
But, has this actually happen? How often does it really happen? I guess, not very often.
The paper presents a model of collaboration, which is presented in the following link (and figure):
I’m happy to see more collaboration models for industry-academia co-creation of results!
I often tell my students that the absolute values of measures do not always say much. Take an example of McCabe cyclomatic complexity – the number of 100 (meaning 100 independent paths through a method) does not need to denote problems. It could be a large switch statement which changes locale based on the IP address type. However, it is important to monitor thresholds of measures, based on the meaning of the function and the problem at hand.
In this article from IST, “Software metrics thresholds calculation techniques to predict fault-proneness: An empirical comparison” (https://doi.org/10.1016/j.infsof.2017.11.005), we can learn three different types of finding thresholds for software measures – ROC curves, VARL, and Alves ranking (named after the author of the method). This article shows how well we can predict the fault-proneness of modules if we use thresholds rather than absolute value.
Have a nice reading!
In our research and development work, we often spend a lot of time on structuring the measurement information. As difficult as it is to do it upfront, we still manage to get something if we base our work on the ISO&IEC 15939 standard and it’s measurement information meta-model.
However, the challenge arises when we want to provide a structure over an existing database or if we want to exchange the measurement information (values, definitions, etc.).
Here, we have the Software Measurement Meta-Model to the rescue (http://www.omg.org/cgi-bin/doc?formal/16-04-04.pdf). The meta-model provides the types and relations to describe the measurement data. In the first glance, one could think that this is a meta-model to structure your measurement database, but it is not. The structure of the database needs to be much simpler, but the exchange format is to be more complex. The complexity stems from the fact that one needs to make sure that two meta-levels are transferred – the measurement data and its meta-data. It’s the meta-data that is mostly complex and therefore the entire format gets complex.
I recommend to take a look at the structure of the meta-model, so that one can understand the complexity of measurement processes.
However, there is a spoiler – this is NOT a bed-time reading!
The question of what to measure pops up very often in our work. It’s not easy to answer, but we give guidance for areas of software engineering. In this blog post, I focus on the area of software architectures.
For the software architectures, there are a few areas that are important:
- Stability of the architecture
- Complexity of the architecture
- and Quality of the architecture
These areas can be quantified with measures of – interface stability, component complexity, technical debt and similar. Based on our work with the companies in Software Center, we realized that these measures are more important than more complex measures like – architecture weight, architecture stability index or architectural debt. The reason is that the simple measures provide an immediate understanding of what can be done to improve the situation.
In our work, we also looked at how to calculate these measures based on open data sets of complexity of automotive software.
If you are interested in the details of how to use the measures, please take a look at Chapter 7 of my book:
Software development measurement programs can take many shapes and forms. They are often aligned with the goals of their organizations. In this blog post I would like to provide a short summary of the most common measurement models which can be encountered in the field of software engineering today. The set of models is naturally growing all the time, so new suggestions are more than welcome.
To put this blog post in context, let’s start from the ISO 15939 standard, which is the official standard for measurement programs in the software and systems engineering industry. The standard provides both the vocabulary and the recommended hierarchical model of information needs, indicators and measures. The strength of this model is its unification with the othe ISO standards, like the newest ISO 25000 series, and in particular the ISO 2502x parts, i.e., quality measurement division.
However, ISO 15939 is not the only standard in this field, there are others too. Some of them are more well known and some are less, but most of the standards in my list are used somewhere.
- GQM – the classical Goal Question Metric model, which is very flexible and can be used for almost any measurement program and purpose. It’s structure is similar to the structure of the measurement information model of ISO 15939, but it’s does not contain such concepts as information need and indicator.
- GQIM – the extension of the classical model to include the notion of the indicator.
- Lightweight GQM, http://publica.fraunhofer.de/eprints/urn_nbn_de_0011-n-212218.pdf – is a version of GQM for small and medium enterprises. The lightweight keyword here means that
- MIS-PyME MCMM, http://www.sciencedirect.com/science/article/pii/S0965997810000682 – a measurement maturity model, constructed in a similar manner to CMMI, but aligned with measurement needs and only about the measurement programs. To some extent, this model provides examples of measures to be used at different levels and in different areas.
- SQIP – a model based on the CMMI requirements for the measurement programs in more mature organizations, from level 2 upwards (if I remember correctly).
And this is not the end of the list, we have more, like:
- …. and some more…
These other approaches seem to be a bit more niche in both their adoption in industry and in academia. If you know, use or heard of, any other approaches, please let me know.
In 2015 I had a chance to co-organize a workshop on automotive software architectures. The workshop brought together many researchers and practitioners to discuss the issues related to designing large automotive software systems. After the workshop I realized that there is still a need to describe how to design the automotive software from the perspective of a software engineer.
Thanks to my editor, Ralf, who approached me and asked for a book on automotive software architectures, we have a possibility to show the results of it.
The book is primarily for software engineers who want to understand how the automotive software is designed, deployed and standardized.
This book introduces the concept of software architecture as one of the cornerstones of software in modern cars. Following a historical overview of the evolution of software in modern cars and a discussion of the main challenges driving that evolution, Chapter 2 describes the main architectural styles of automotive software and their use in cars’ software. In Chapter 3, readers will find a description of the software development processes used to develop software on the car manufacturers’ side. Chapter 4 then introduces AUTOSAR – an important standard in automotive software. Chapter 5 goes beyond simple architecture and describes the detailed design process for automotive software using Simulink, helping readers to understand how detailed design links to high-level design. Next, Chapter 6 presents a method for assessing the quality of the architecture – ATAM (Architecture Trade-off Analysis Method) – and provides a sample assessment, while Chapter 7 presents an alternative way of assessing the architecture, namely by using quantitative measures and indicators. Subsequently Chapter 8 dives deeper into one of the specific properties discussed in Chapter 6 – safety – and details an important standard in that area, the ISO/IEC 26262 norm. Lastly, Chapter 9 presents a set of future trends that are currently emerging and have the potential to shape automotive software engineering in the coming years.
This book explores the concept of software architecture for modern cars and is intended for both beginning and advanced software designers. It mainly aims at two different groups of audience – professionals working with automotive software who need to understand concepts related to automotive architectures, and students of software engineering or related fields who need to understand the specifics of automotive software to be able to construct cars or their components. Accordingly, the book also contains a wealth of real-world examples illustrating the concepts discussed and requires no prior background in the automotive domain.
Available at Amazon: https://www.amazon.com/dp/3319586092/sr=8-1/qid=1502048739/ref=olp_product_details?_encoding=UTF8&me=&qid=1502048739&sr=8-1
And Springer: http://www.springer.com/la/book/9783319586090
In the last few days I had the opportunity to read a great book about how to build scalable, high capacity and reusable software. The book was “Reselase it! …”, https://pragprog.com/book/mnee/release-it.
As a “former” programmer I realized that many of the ideas and good practices from the book I should have used a long time ago. Using examples from real industrial failures, Michael T. Nygard presents a set of pattern for design of high reliability software.
Even if the examples come from the domain of web applications and Java, many of them should be used in the automotive industry. The same problems will hit the automotive market very soon and therefore I recommend this to anyone who wants to start working with automotive software engineering.
Metrics research has gained a lot of attention from the Software Center and the results showed that tackling the complexity requires a holistic approach. Now, recently I’ve encountered a book which talked about the same principles, although at a more beginner level – “Your code as a Crime Scene” by Adam Tornhill.
The book uses metaphors of crime scene investigations to describe troubleshooting the code. I recommend this as the starting point. Readers who are interested in the going deeper into this topic should look at one of the recent PhD thesis from software center, by Dr. Vard Antinyan.
The thesis investigates the complexity of the software code, requirements and test cases. The conclusions from the work is that we can monitor the evolution of complexity using very common measures — e.g. McCabe complexity combined with the number of changes in the code. Dr. Antinyan provided even a number of tools to monitor the complexity.
The thesis can be found here: http://web.student.chalmers.se/~vard/files/Thesis.pdf.
In our recent work we tackled the problem of spending way too much effort on maintaining the measuring instruments (or metric tools). When the measured entity changes you need to rewrite the script and keep two or three or five billion versions of it.
So, we played with an idea of “teaching” an algorithm how to count so that everytime the entity changes we can “re-teach” the algorithm, but not re-program it.
Guess what – it worked! We played with the LOC metric and got over 90% accuracy on the first try. Cost of re-designing the measuring instrument to adjust to new information needs – almost 0 (null, nil).
Take a look at this paper of ours: https://gup.ub.gu.se/publication/249619, and the paper
Background: The results of counting the size of programs in terms of Lines-of-Code (LOC) depends on the rules used for counting (i.e. definition of which lines should be counted). In the majority of the measurement tools, the rules are statically coded in the tool and the users of the measurement tools do not know which lines were counted and which were not. Goal: The goal of our research is to investigate how to use machine learning to teach a measurement tool which lines should be counted and which should not. Our interest is to identify which parameters of the learning algorithm can be used to classify lines to be counted. Method: Our research is based on the design science research methodology where we construct a measurement tool based on machine learning and evaluate it based on open source programs. As a training set, we use industry professionals to classify which lines should be counted. Results: The results show that classifying the lines as to be counted or not has an average accuracy varying between 0.90 and 0.99 measured as Matthew’s Correlation Coefficient and between 95% and nearly 100% measured as the percentage of correctly classified lines. Conclusions: Based on the results we conclude that using machine learning algorithms as the core of modern measurement instruments has a large potential and should be explored further
I get a lot of questions about the essential readings for the area of metrics. Since the area has been active since the 1950s, the number of books is large and the number of articles is naturally even larger. Here is the list of the books that I’ve compiled for my students and colleagues from industry:
- Norman Fenton and James Bieman: Software Metrics. This is a classical position in the area of software metrics. It’s been around since 1990s and is perceived as providing the foundations of software metrics. The main audience of this book comprises software engineering students and researchers. If you want to start with the more theoretical aspects and closer to software product metrics, this is the perfect position for you.
- Alain Abran: Software Metrology and software metrics. This is the newest position in the discipline of software engineering. It provides a very good foundation in metrology and provides some examples of modern software measures. The major focus on the book is on the COSMIC FP measure. If you want to get good foundations in metrology and then move over towards estimations and measurement reference etalons, then this is the perfect position for you.
- Cheryl Jones and Beth Layman: Practical software measurement. This is a very good book for practitioners who want to apply ISO/IEC 15939 standard. The book provides a solid description of the standard which describes the measurement process. It’s a great position for everyone who wants to look into ISO/IEC 15939 and introduce it into the organization.
- Christof Ebert and Reiner Dumke: Software Measurement. This book is a classical position which provides solid foundations on the measurement theory and estimation. The book is rather long and covers multiple aspects, but it seems that the audience is mostly students.
- Christof Ebert et al. Best practices in software measurement. This book presents a number of best practices of measurement. Very good position for practitioners, but needs to be complemented with #4.
For everyone who wants to get into the measurement area, these positions are a good start. There is of course a lot of other books that are more dedicated for specific areas, and I will get back to these soon.