What we're about

This group is for those who want to learn about how people in software engineering work. What makes them tick? Which practices work and which don’t?

Each meeting focuses on a single research article. Before the meeting everyone should have read the article and then we will critically evaluate and discuss it.

Please note that this meetup group (yes, the entire group) is limited to 50 members. As such I ask that any members show up to one or two meetups each quarter. Anyone who has not been attending will be removed from the group to allow others be join. My goal is to keep a group of people who are actively engaged with the topic.

Upcoming events (2)

Two Conflicting Studies on The Effect of Static vs. Dynamic Typing

Let's look at two sides of a debate that has been raging in software development for decades now. Are static or dynamic types better? This is an incredibly complex topic and so just reading two papers will not settle it. However, by reading these two papers we might get a more nuanced view about the issues involved and how such a question could ever be definitively answered (if such a definitive answer is even possible). Our discussion will be focussed on the comparision of the papers. We'll need to look at the hypothesis they are testing (is that even comparable). Are they measuring comparable phenomena? Paper 1: Do Static Type Systems Improve the Maintainability of Software Systems - An Empirical Study Abstract: Static type systems play an essential role in con- temporary programming languages. Despite their importance, whether static type systems influence human software devel- opment capabilities remains an open question. One frequently mentioned argument for static type systems is that they improve the maintainability of software systems—an often used claim for which there is no empirical evidence. This paper describes an experiment which tests whether static type systems improve the maintainability of software systems. The results show rigorous empirical evidence that static type are indeed beneficial to these activities, except for fixing semantic errors. URL: http://citeseerx.ist.psu.edu/viewdoc/download?doi= Paper 2: An Experiment About Static and Dynamic Type Systems - Doubts About the Positive Impact of Static Type Systems on Development Time Abstract: Although static type systems are an essential part in teach- ing and research in software engineering and computer science, there is hardly any knowledge about what the im- pact of static type systems on the development time or the resulting quality for a piece of software is. On the one hand there are authors that state that static type systems decrease an application’s complexity and hence its development time (which means that the quality must be improved since developers have more time left in their projects). On the other hand there are authors that argue that static type sys- tems increase development time (and hence decrease the code quality) since they restrict developers to express themselves in a desired way. This paper presents an em- pirical study with 49 subjects that studies the impact of a static type system for the development of a parser over 27 hours working time. In the experiments the existence of the static type system has neither a positive nor a negative im- pact on an application‘s development time (under the con- ditions of the experiment). URL: https://hodapple.com/files/papers/An%20experiment%20about%20static%20and%20dynamic%20type%20systems.pdf

Effectiveness of Dataflow- and Controlflow-Based Test Adequacy Criteria

This paper is one of the most cited papers in the ACM SIGSOFT collection. It examines how test coverage, in two different ways of measuring coverage, relates to finding faults in code. This is an important relationship to understand as none of us want to spend time putting together tests that don't matter. This paper should give us some understanding about how coverage relates to finding faults and some grounding for our own, personal, ways of thinking about code coverage. Abstract: This paper reports an experimental study investigating the effectiveness of two code-based test adequacy criteria for identifying sets of test cases that detect faults. The all-edges and all-DUs (modified all-uses) coverage criteria were applied to 130 faulty program versions derived from seven moderate size base programs by seeding realistic faults. We generated several thousand test sets for each faulty program and examined the relationship between fault detection and coverage. Within the limited domain of our experiments, test sets achieving coverage levels over 90% usually showed significantly better fault detection than randomly chosen test sets of the same size. In addition, significant improvements in the effectiveness of coverage-based tests usually occurred as coverage increated from 90% to 100%. However, the results also indicate that 100% code coverage alone is not a reliable indicator of the effectiveness of a test set. We also found that tests based respectively on controlflow and dataflow criteria are frequently complementary in their effectiveness. URL: https://core.ac.uk/download/pdf/22878726.pdf

Photos (1)