Are developers aware of the architectural impact of their changes? (2017)
Architecturally clean systems are easier to maintain. Changes to a system therefore shouldn’t degrade its architecture. Paixao, Krinke, Han, Ragkhitwetsagul, and Harman studied four large projects to better understand whether and how developers take the system’s architecture into account when making changes.
Are code examples on an online Q&A forum reliable? A study of API misuse on Stack Overflow (2018)
Many posts on Stack Overflow contain code snippets that show how a library can be used to achieve a certain task. Zhang, Upadhyaya, Reinhardt, Rajan, and Kim mined GitHub for API usage “best practices” and conclude that it’s probably not a good idea to reuse online code snippets verbatim.
Building a theory of job rotation in software engineering from an instrumental case study (2016)
Managers sometimes move employees to new projects once in a while, as it’s thought to be beneficial to them and the company. Santos, Da Silva, De Magalhães, and Monteiro conducted a case study at a Brazilian software company that systematically applies job rotation, and describe how this practice actually impacts workers.
Code smells for model-view-controller architectures (2018)
Code smells are poor design and implementation choices that hinder comprehensibility and maintainability of code. Aniche, Bavota, Treude, Gerosa, and Van Deursen introduce a catalog of six code smells in Web applications that make use of the model-view-controller pattern.
Predicting estimated time of arrival for commercial flights (2018)
Arrival times for commercial flights are currently estimated using deterministic models that fail to account for many variables that affect flight time. Ayhan, Costas, and Samet created a model that leverages these traditionally overlooked variables to make more accurate arrival time predictions.
Fake news vs satire: A dataset and analysis (2018)
Social media platforms have a moral obligation to prevent the spread of fake news, while still allowing users to freely share satire. This can only be achieved using advanced content filters. Golbeck et (many, many) al. compiled a dataset of fake news and satire, and built a simple classifier that can tell the two types of stories apart.
Does goal-oriented requirements engineering achieve its goal? (2017)
Building things right is important, but so is building the right thing. There’s plenty of research that suggests that goal-based thinking helps create better requirements, but practitioners don’t appear to be entirely convinced yet. Mavin et al. tried to better understand this gap between academia and industrial practice.
A large-scale empirical study on linguistic antipatterns affecting APIs (2018)
Last week’s summary showed that it’s hard to quantify understandability of code. This week we look at a much simpler problem: the consequences of having bad method names in an API. Aghajani, Nagy, Bavota, and Lanza found that badly named methods have some impact on bugs, but it’s not clear yet why.
Automatically assessing code understandability: How far are we? (2017)
Programmers spend much of their time reading code, so it’s important that it’s easy to understand. It would be nice if we could automatically calculate the understandability of code – unfortunately, Scalabrino et al. discovered that existing metrics aren’t good at predicting code understandability.
Software development waste (2017)
It’s not always easy to eliminate waste in software development, not least because it can be hard to identify. Sedano, Ralph, and Péraire collected well over two years’ worth of data from interviews and observations at Pivotal, and discovered nine types of waste in software development.
Belief & evidence in empirical software engineering (2016)
Programmers can hold very strong beliefs about certain topics. Devanbu, Zimmermann, and Bird conducted a case study on such beliefs at Microsoft, and found that they are mostly based on personal experience rather than empirical evidence, and don’t necessarily correspond with what happens in reality.
How not to structure your database-backed web applications: A study of performance bugs in the wild (2018)
By abstracting away the details of querying databases, Object Relational Mapping (ORM) frameworks allow us to build Web applications efficiently. Sadly, those same abstractions can also prevent them from running efficiently. Yang, Subramaniam, Lu, Yan, and Cheung identified 9 performance anti-patterns and ways to mitigate them.