Episode 10 — Software Carpentry

Software is an important component in the toolkit of nearly every engineer. Chris and Jeff talk with Greg Wilson about how engineers and scientists can improve their programming skills.

  • Jeff’s first programming language was Pascal.
  • Intended to encourage good programming practices, Pascal gained wider acceptance as the basis for Borlands’s Turbo Pascal.
  • Programming in the 1970’s was not carried out at a terminal, but required punching data cards on a keypunch machine, then feeding the cards into a card reader. Yes, that huge stack of spinning “magnetic disks” at the 1:14 mark is an early hard drive.

  • Our guest for this episode is Greg Wilson, who is the founder and director of Software Carpentry, an outreach and training program that helps scientists and engineers be more effective by teaching them “best-practices” for software programming.
  • Greg’s work with Software Carpentry is currently funded by the Sloan Foundation in the United States, and he is an employee of the Mozilla Foundation.
  • Software Carpentry seeks to reach the majority of researchers, scientists, and engineers who build “small” data projects, rather than the relatively few that work on “huge” data sets using supercomputers.
  • A typical Software Carpentry workshop consists of a two-day course, with blocks of instruction addressing the Unix shell, Python, version control, unit testing and SQL. The two-day workshop is often followed up with about six weeks of online instruction.
  • Greg says that if participants come away with nothing else, they should learn the value of version control, so that the provenance of scientific data can be tracked and analyzed.
  • The Software Carpentry team has found screencasts to be “a lousy way to teach,” as personal interaction is an important component of learning.
  • Greg has found engineers to have a bit more “hands-on” experience than scientists, and to be more MATLAB-oriented, but perceives relatively little difference in their understanding of software issues.
  • Considerable empirical research has been conducted about programming effectiveness, but little of this information is shared with students in college courses.
  • Greg has co-edited a book about software programming practices, titled Making Software: What Really Works, and Why We Believe It.
  • One of the most critical indicators of how well individuals can work together in a corporate programming project is not their geographical separation, or language differences, but how far apart they are in the company’s organization chart.
  • Pair programming is an effective method for reducing software errors, but it has an important caveat: it only keeps working if you keep shuffling the coding partners.
  • The single most effective way to find bugs is code review. Don’t compile the code, or run it, but have someone else read through the code. You’ll find 60-90% of the bugs in the first reading. Review Board is an open-source web-based tool designed to help in such efforts. A commercial product for this purpose is available from Smart Bear Software.
  • Mark Guzdial has been using “worked examples” to teach programming at Georgia Tech, and has found it to deliver more learning in less time.
  • A flipped classroom has students watch instructional videos for homework, and then spend class time working problems.
  • In a 2009 blog post, Greg talked about “real” engineers becoming more like software engineers, rather than the other way around.
  • Greg believes that higher quality software is possible, if the right incentives are offered to programming organizations.
  • Even if we can’t review code line-by-line, we can at least verify the methodology and processes used to create it.
  • There is a comprehensive reading list available on the Software Carpentry website.
  • Greg is suspicious about the effectiveness of self-guided learning programs like Codeacademy.
  • On the horizon are programming tools such as Mozilla Towtruck, which allows for collaborative editing of web pages.
  • As an introduction to programming methods, Greg recommends the book Facts and Fallacies of Software Engineering by Robert Glass.
  • Greg can be reached by email at info@software-engineering.org. You can find more information about the programming workshops on the Software Carpentry website.

Thanks to Jon Lim for granting permission to use his image of Greg and a young programmer at the Hive Toronto Youth Hack Jam in February 2012.

Untitled Photo: Jon Lim © 2012, all rights reserved.

6 thoughts on “Episode 10 — Software Carpentry”

  1. Your guest makes a powerful point about liability. PE’s who are responsible charge and put their stamp on docs are personally liable. My wife has to have professional liability insurance b/c anything she does with her law license she is personally liable for: a corporate veil won’t protect her. Doctors face the same issue.

    Engineers have the “industrial exemption” that allows us to practice without a license. When we work on projects that don’t require licensure, we are not personally liable. If I make it clear that my LLC is contracting to do the work, they can only sue the LLC. If I work as a W-2 employee, people can only sue my employer.

    I have mixed feelings about this. Professional licensure is supposed to protect the public, but I think it often like a cartel that limits competition and supports prices. I like to think that’s why my wife bills about twice what I do.

    I’ve talked to people specifying wire gauge on projects that require licensure, and they bill are large amount relative to the complexity of the work and the amount of knowledge required. The theory goes, “these wires affect public safety so you have to pay extra for a licensed engineer who’s personally responsible if things go wrong.” Okay, but why doesn’t that logic hold for software and hardware used in vehicles or medical devices. FDA regulates the companies; they make lots of money on medical. But the engineers don’t need licensure, so they make typical engineering pay commensurate with the complexity of what they’re working on.

    While we’re at it, we might add this responsibility to things like law enforcement. Every officer would be aware they’ll be personally responsible if they make an error that, say, results in psychological trauma to a child who was nowhere near a crime scene.

    I have mixed feelings, though, because I’m unclear how much professional licensure protects the public and to what extent it serves the interests of members of the profession.

  2. Chris, at Case in 1989 CMPS 131 (freshman computer programming) was taught in Pascal, as well as ECMP 251 (numerical methods). C was primarily taught for Computer Science and Engineering majors and C++ wasn’t in use (at least for undergrads).

    1. I learned Pascal in high school. Then I did C in college and on real projects. I don’t do much software, so sometimes I try to use Pascal when doing something in C.

  3. My programming experience is much like Jeffs in that most of what I learned I taught myself. I used Matlab in college and took one C++ course. While my programming may not be “design smart”, it gets the job done and thats usually what I need for small projects.

    Most basic programming books that I have used convey information on organization and structure (though not version control).

Comments are closed.