The Toilet Paper
Designing and developing good software is hard, and so is managing it. If you run into problems, you can try to find solutions yourself or rely on advice based on anecdotal evidence. Scientific papers offer higher-quality information, but might not necessarily be easy to read, access or discover for people outside academia. This is why The Toilet Paper provides short summaries without the “boring” sciencey details; ideal for bathroom (and other) breaks!
What’s new
The Toilet PaperDo programmers work at night or during the weekend? (2018)
It’s often thought that programmers have very irregular working hours compared to those of the general population. Claes, Mäntylä, Kuutila, and Adams analysed commit data from 86 large software projects and found that this isn’t actually the case – for most programmers.
The Toilet PaperJIT feedback – what experienced developers like about static analysis (2018)
Running static analysis tools in an integrated development environment is like having a peer next to you that continuously reviews and criticises your code. Tymchuk, Ghafari, and Nierstrasz studied whether and why developers think these tools are helpful.
The Toilet PaperMicro-clones in evolving software (2018)
Codebases often contain code clones: code fragments that are very similar or even completely identical to each other. Until now, only larger clones have been studied thoroughly – not much is known about micro-clones, which are only 1–4 lines of code. Mondai, Roy, and Schneider show that these micro-clones are quite widespread.
The Toilet PaperDeep code comment generation (2018)
Machine learning models can be used to find relevant code snippets for a natural language description. Does that mean we can also do the opposite and predict natural language descriptions for code snippets that lack comments? Hu, Li, Xia, Lo, and Jin designed a model that does just that.
The Toilet PaperDeep code search (2018)
Text search is something that (mostly) “just works”, but the same can’t be said of code search. Gu, Zhang, and Kim present a deep neural network that can be used to retrieve code snippets based on natural language queries and a proof-of-concept application that demonstrates the feasibility of this approach.
The Toilet PaperLoud and interactive paper prototyping in requirements elicitation: What is it good for? (2018)
Paper prototyping can be used to elicit requirements for user-facing applications or evaluate user interface designs. There are several ways to do paper protoyping. Shakeri, Moazzam, Lo, Lan, Frroku, and Kim investigated how interactive and “loud” paper prototyping can be combined to achieve better results.
The Toilet PaperLearning from mistakes: An empirical study of elicitation interviews performed by novices (2018)
Interviewing is one of the most versatile tools for requirements elicitation. Sadly, it’s also notoriously hard to master. Bano, Zowghi, Ferrari, Spoletini, and Donati studied interviews conducted by postgraduate students, and categorised the different types of interviewing mistakes that one should avoid.
The Toilet PaperAre 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.
The Toilet PaperAre 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.
The Toilet PaperBuilding 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.
The Toilet PaperCode 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.
The Toilet PaperPredicting 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.
The Toilet PaperFake 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.
The Toilet PaperDoes 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.
The Toilet PaperA 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.
The Toilet PaperAutomatically 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.