Rajesh Vasa

Comparative analysis of evolving software systems using the Gini coefficient

Software metrics offer us the promise of distilling useful information from vast amounts of software in order to track development progress, to gain insights into the nature of the software, and to identify potential problems. Unfortunately, however, many software metrics exhibit highly skewed, non-Gaussian distributions. As a consequence, usual ways of interpreting these metrics — for example, in terms of “average” values — can be highly misleading. Many metrics, it turns out, are distributed like wealth — with high concentrations of values in selected locations. We propose to analyze software metrics using the Gini coefficient, a higherorder statistic widely used in economics to study the distribution of wealth. Our approach allows us not only to observe changes in software systems efficiently, but also to assess project risks and monitor the development process itself. We apply the Gini coefficient to numerous metrics over a range of software projects, and we show that many metrics not only display remarkably high Gini values, but that these values are remarkably consistent as a project evolves over time.

Software Architecture Design Reasoning: A Case for Improved Methodology Support

This paper presents the capturing and recording of reasoning behind software architecture design to encourage architects to more carefully consider design decisions and better support future maintenance.

A preliminary analysis of mobile app user reviews

The advent of online software distribution channels like Apple Inc.s App Store and Google Inc.s Google Play has offered developers a single, low cost, and powerful distribution mechanism. These online stores help users discover apps as well as leave a review. Ratings and reviews add value to both the developer and potential new users by providing a crowd-sourced indicator of app quality. Hence, for developers it is important to get positive reviews and high ratings to ensure that an app has a viable future. But, what exactly do users say on these app stores? And more importantly, what is the experience that compels a user to leave either a positive or a negative rating? Our analysis of 8.7 million reviews from 17,330 apps shows that users tend to leave short, yet informative reviews, and the rating as well as the category influences the length of a review. In this preliminary study, we found that users will leave longer messages when they rate an app poorly, and the depth of feedback in certain categories is significantly higher than for other.

A preliminary analysis of vocabulary in mobile app user reviews

Online software distribution channels such as Apple Inc.s App Store and Google Inc.s Google Play provide a platform for third-party app distribution. These online stores feature a public review system, allowing users to express opinions regarding purchased apps. These reviews can influence product-purchasing decisions via polarised sentiment (1 to 5 stars) and user expressed opinion. For developers, reviews are a user-facing crowd-sourced indicator of app quality. Hence, high ratings and positive reviews affect the viability of an apps commercial feasibility. However, it is less clear what information is contained within these reviews, and more importantly, if an analysis of these reviews can inform developers of design priorities as opposed to just influencing purchasing decisions. We analysed 8.7 million reviews from 17,330 apps on the App Store and found that the most frequently used words in user reviews lean toward expressions of sentiment despite employment of only approximately 37% of the words within the English language dictionary. Furthermore, the range of words used to express negative opinions is significantly higher than when positive sentiments are expressed.

Detecting structural changes in object oriented software systems

It is an increasingly accepted fact that software development is a non-linear activity with inherently feedback driven processes. In such a development environment, however, it is important that major structural changes in the design and/or architecture of a software system under development are introduced with care and documented accordingly. In order to give developers appropriate tools that can identify such changes, we need to have a good understanding how software systems evolve over time so that evolutionary anomalies can be automatically detected. In this paper, we present recurring high-level structural and evolutionary patterns that we have observed in a number of public-domain object-oriented software systems and define a simple predictive model that can aid developers in detecting structural changes and as a consequence, improve the underlying development processes.

Bootstrapping mobile app development

Modern IDEs provide limited support for developers when starting a new data-driven mobile app. App developers are currently required to write copious amounts of boilerplate code, scripts, organise complex directories, and author actual functionality. Although this scenario is ripe for automation, current tools are yet to address it adequately. In this paper we present RAPPT, a tool that generates the scaffolding of a mobile app based on a high level description specified in a Domain Specific Language (DSL). We demonstrate the feasibility of our approach by an example case study and feedback from a professional development team. Demo at: https://www.youtube.com/watch?v=ffquVgBYpLM.

Patterns of component evolution

Contemporary software systems are composed of many components, which, in general, undergo phased and incremental development. In order to facilitate the corresponding construction process, it is important that the development team in charge has a good understanding of how individual software components typically evolve. Furthermore, software engineers need to be able to recognize abnormal patterns of growth with respect to size, structure, and complexity of the components and the resulting composite. Only if a development team understands the processes that underpin the evolution of software systems, will they be able to make better development choices. In this paper, we analyze recurring structural and evolutionary patterns that we have observed in public-domain software systems built using object-oriented programming languages. Based on our analysis, we discuss common growth patterns found in present-day component-based software systems and illustrate simple means to aid developers in achieving a better understanding of those patterns. As a consequence, we hope to raise the awareness level in the community on how component-based software systems tend to naturally evolve.

Awesome!: conveying satisfaction on the app store

In a competitive market like the App Store, high user perceived quality is paramount, especially due to the public review system offered. These reviews give developers feedback on their own apps, as well as help provide data for competitor analysis. However, given the size of the data set, manual analysis of reviews is unrealistic, especially given the need for a rapid response to changing market dynamics. Current research into mobile app reviews has provided an insight into the statistical distributions, but there is minimal knowledge about the content in these reviews. In particular, we do not know if the aggregated numerical rating is a reliable indicator of the information within a review. This work reports on an analysis of reviews to determine how closely aligned the numerical ratings are to the textual description. We observed that short user reviews mostly contain a small set of words, and the corresponding numerical rating matches the underlying sentiment.

Reporting usability defects: do reporters report what software developers need?

Reporting usability defects can be a challenging task, especially in convincing the software developers that the reported defect actually requires attention. Stronger evidence in the form of specific details is often needed. However, research to date in software defect reporting has not investigated the value of capturing different information based on defect type. We surveyed practitioners in both open source communities and industrial software organizations about their usability defect reporting practices to better understand information needs to address usability defect reporting issues. Our analysis of 147 responses show that reporters often provide observed result, expected result and steps to reproduce when describing usability defects, similar to the way other types of defects are reported. However, reporters rarely provide usability-related information. In fact, reporters ranked cause of the problem is the most difficult information to provide followed by usability principle, video recoding, UI event trace and title. Conversely, software developers consider cause of the problem as the most helpful information for them to fix usability defects. Our statistical analysis reveals a substantial gap between what reporters provide and what software developers need when fixing usability defects. We propose some remedies to resolve this gap.

On the Resilience of Classes to Change

Software systems evolve over time incrementally and sections of code are modified. But, how much does code really change? Lehmans laws suggest that software must be continuously adapted to be useful. We have studied the evolution of several public domain object-oriented software systems and analyzed the rate as well as the amount of change that individual classes undergo as they evolve. Our observations suggest that although classes are modified, the majority of changes are minor and only a small proportion of classes undergo significant modification.