Notes on the Empirical Studies of Programmers, Fifth Workshop

April 26, 2009

Beyond Program Understanding: A Look at Programming Expertise in Industry

Lucy M. Berlin

In industry, programmers learn via apprenticeship.

I include the below because I feel it supports my belief that CS education needs to move as close as possible to an apprenticeship model.

The study proposes a view of programming expertise that ascribes their effectiveness not only to their knowledge of generic programming concepts and strategies, but to detailed knowledge of how these are expressed in their programming languages; the principles, design rationale, history and the quirks of the software framework they work within; proficiency in the use of broad range of ancillary tools; and knowledge of and appropriate use of human and written information resources.

This more encompassing view of programming expertise may help explain the great individual differences in programming productivity. It suggests that use of expert mentors may substantially reduce the time and effort required to retool oneself from one environment to another, and that the experts’ mentorship role is an extremely important one in an organization.

Externalising information during coding activities: Effects of expertise, environment and task

Simon P. Davies

When the display of code is restricted, experts write down more low-level details such as code snippets, whereas novices write down more high-level details such as architecture diagrams or control-flow diagrams. Novices rely on their diagrams to perform transformations in the problem space. Experts rely on their notes to mentally simulate code.

Tales of Debugging from The Front Lines

Marc Eisenstadt

An informal survey of debugging anecdotes revealed:

  1. Top reasons why bugs are difficult to find
    1. Large temporal or spatial gap between bug cause and bug symptom
    2. Breaking debugging tools
    3. Programmer has faulty perception, e.g. misleading syntax
    4. Programmer has broken semantic model
    5. Excessively ugly code
  2. Top methods for finding them
    1. Data-gathering
      1. Inserting print statements or other debugging code
      2. Step through in a debugger
      3. Comparing good and bad core dumps
      4. Debugger breakpoints
      5. Specialist tools
    2. Hand simulation of code or other thinking procedures
    3. Recognition of bug symptoms from memory
  3. Top root causes
    1. Memory overwrites
    2. Vendor hardware/software faults
    3. Incorrect logic
    4. Incorrect initializations
    5. Syntax problem

Learning Computer Programming: A Route to General Reasoning Skills?

Adrienne Y. Lee, Nancy Pennington

Advanced programming skills don’t transfer to other domains. Debugging skills transfer as general diagnostic skills.

Comparing the Comprehensibility of Textual and Graphical Programs: The Case of Petri Nets

Thomas G. Moher, David C. Mak, Brad Blumenthal, Laura M. Leventhal

This reproduction of an earlier study agreed that graphical program representations are no better and sometimes worse than textual.

A juicy morsel:

Not only is no single representation best for all kinds of programs, no single representation is even best for all tasks involving the same program.

Positive Test Bias in Software Testing by Professionals: What’s Right and What’s Wrong

Positive test bias is confirmation bias applied to computer programming: It’s the creation of too many tests that the program operates correctly on correct input and insufficient tests that it operates properly on incorrect input.

Better specifications and a lack of feedback from errors mitigate positive test bias.

Incidentally, I happen to believe that security bugs are instances of positive test bias.

%d bloggers like this: