Software Carpentry

Books

	David J. Agans: Debugging. Amacom, 0814474578, 2006. A simple guide to debugging programs, organized around nine simple rules. More and larger examples would have been welcome, but it is still a good place for novices to start.
	Dean Allemang and James Hendler: Semantic Web for the Working Ontologist: Effective Modeling in RDFS and OWL. Morgan Kaufmann, 0123735564, 2008. A detailed introduction to the semantic web’s approach to modeling data. You won’t find a lot of code in the traditional sense in this book; instead, the authors present one real-world data management problem after another, and show how to represent and solve it using RDF, SPARQL, and related technologies.
	Mike Andrews and James A. Whittaker: How to Break Web Software: Functional and Security Testing of Web Applications and Web Services. Addison-Wesley, 0321369440, 2006. One of a trilogy of introductory books on software testing, this book also serves as a good guide to what you can do wrong in your own web applications.
	Daniel Arbuckle: Python Testing: Beginner’s Guide. Packt Publishing, 1847198848, 2010. A good up-to-date look at testing tools for Python programs that also has some good ideas about testing in general.
	Adam Barr: Find the Bug: A Book of Incorrect Programs. Addison-Wesley, 0321223918, 2004. A workbook that presents buggy programs in several languages, and challenges the reader to figure out what’s wrong. The author provides hints for each exercise to help readers along before revealing the final solution.
	Jennifer Campbell, Paul Gries, Jason Montojo, and Greg Wilson: Practical Programming: An Introduction to Computer Science Using Python. Pragmatic Bookshelf, 1934356271, 2009. An introduction to programming using Python that includes material on building GUIs, working with databases, and a few other useful things.
	David Cross: Data Munging With Perl. Manning, 1930110006, 2001. A good guide to what Perl does best: transform data from one form to another.
	Michael Feathers: Working Effectively with Legacy Code. Prentice Hall PTR, 0131177052, 2004. If code is exercised by unit tests, changes can be made quickly and safely; if it isn’t, they can’t, so your first job when you inherit legacy code should be to write some. That’s where this book comes in. What to know three different ways to inject a test into a C++ class without changing the code? Or which classes or methods to focus testing on, or how to break inter-class dependencies in Java so that you can test one module without having to configure the entire application? It’s all here, along with lots of other useful information.
	Chris Fehily: SQL. Peachpit Press, 0321118030, 2002. Describes the 5% of SQL that covers 95% of real-world needs. While it moves a little slowly in some places, the examples are exceptionally clear.
	Karl Fogel: Producing Open Source Software: How to Run a Successful Free Software Project. O’Reilly Media, 0596007590, 2005. This book is an excellent guide to how open source projects actually work. Every page offers practical advice on how to earn commit privileges on a project, get it more attention, or fork it in case of irreconcilable differences.
	Martin Fowler: Refactoring: Improving the Design of Existing Code. Addison-Wesley Professional, 0201485672, 1999. Presents patterns that recur when programs are being reorganized. Some of these are well-known, such as placing common code in a utility method. Others, such as replacing temporary objects with queries, or replacing constructors with factory methods, are subtler, but no less important. Each entry includes a section on motivation, the mechanics of actually carrying out the transformation, and an example in Java.
	Elisabeth Freeman and Eric Freeman: Head First Design Patterns. O’Reilly Media, 0596007124, 2004. Many people will find this book’s cartoon-ish format and awkward jokes annoying, but it’s still one of the most readable introductions to design patterns around.
	Steve Freeman and Nat Pryce: Growing Object-Oriented Software, Guided by Tests. Addison-Wesley, 0321503627, 2009. A solid introduction to the idea of test-driven development, this book’s strongest feature is the extended example presented in the second of its three sections.
	Jeffrey E. F. Friedl: Mastering Regular Expressions. O’Reilly, 0596528124, 2006. Definitely not for beginners, this book explores all the dark corners and surprising capabilities of regular expressions.
	Noah Gift and Jeremy M. Jones: Python for Unix and Linux System Administration. O’Reilly, 0596515820, 2008. Most Unix sys admins rely on shell scripts to automate everyday tasks. This book shows how to accomplish the same things more readably and more portably using Python.
	Robert L. Glass: Facts and Fallacies of Software Engineering. Addison-Wesley Professional, 0321117425, 2002. Most of us have heard know that maintenance consumes 40-80% of software costs, but did you know that roughly 60% of that is enhancements, rather than bug fixes? Or that if more than 20-25% of a component has to be modified, it is more efficient to re-write it from scratch? Those facts, and many more, are in this little book, along with references to the primary literature to back up every claim it makes.
	Kevin Howard Goldberg: XML: Visual QuickStart Guide. Peachpit Press, 0321559673, 2008. Aimed at people who really need to understand the XML standard, and how to process XML data, this book covers schemas, DTDs, XSL, and related technologies.
	Mark J. Guzdial and Barbara Ericson: Introduction to Computing and Programming in Python: A Multimedia Approach. Prentice Hall, 0136060234, 2009. An excellent introduction to programming using Python. More importantly, this book shows readers how to work with images, audio, and video right from the start.
	Jeff Johnson: GUI Bloopers 2.0: Common User Interface Design Don’ts and Do’s. Morgan Kaufmann, 0123706432, 2007. Presents case study after case study: what’s wrong with this dialog? What should its creators have done instead. And, most importantly, why? The net effect is to teach the same design principles that other books try to, but in a grounded, understandable way.
	Jeff Johnson: Designing with the Mind in Mind: Simple Guide to Understanding User Interface Design Rules. Morgan Kaufmann, 012375030X, 2010. A slim summary of the psychological underpinnings of user interface design.
	Brian W. Kernighan and P. J. Plauger: The Elements of Programming Style. Mcgraw-Hill, 0070342075, 1978. It may be older than most people reading this web site, but it is still a useful guide to making programs readable and maintainable.
	Brian W. Kernighan and P.J. Plauger: Software Tools in Pascal. Addison-Wesley Professional, 0201103427, 1981. Page by patient page, it explained the workings of the world’s most successful software component system: pipes, redirection, text streams, and all the rest. It remains one of the best descriptions anywhere of a complete programming toolkit.
	Brian W. Kernighan and Rob Pike: The Unix Programming Environment. Prentice Hall, 013937681X, 1984. This book is the real secret to Unix’s success. It doesn’t just show readers how to use Unix—it explains why the operating system is built that way, and how its “lots of little tools” philosophy keeps simple tasks simple, while making hard ones doable.
	Henrik Kniberg: Scrum and XP from the Trenches. InfoQ, 1430322640, 2007. As the title suggests, this is a practitioner’s reflections on two popular agile development methodologies.
	Steve Krug: Rocket Surgery Made Easy: The Do-It-Yourself Guide to Finding and Fixing Usability Problems. New Riders, 0321657292, 2009. An easy-to-read book about lightweight usability testing that packs a surprising amount of useful information into not very many pages.
	Hans Petter Langtangen: Python Scripting for Computational Science. Springer, 3540739157, 2007. The book’s aim is to show scientists and engineers with little formal training in programming how Python can make their lives better. Regular expressions, numerical arrays, persistence, the basics of GUI and web programming, interfacing to C, C++, and Fortran: it’s all here, along with hundreds of short example programs.
	Hans Petter Langtangen: A Primer on Scientific Programming with Python. Springer, 3642024742, 2009. An introduction to scientific computing using Python.
	Gordon S. Linoff: Data Analysis Using SQL and Excel. Wiley, 0470099518, 2007. The author shows how to construct complex SQL queries to select, reorganize, and analyze data, and how to visualize the results using Excel charts. While the examples are all about business data, the techniques are just as applicable to science.
	Mark Lutz: Learning Python. O’Reilly, 0596158068, 2009. Covers the core of the language, and enough of its advanced features and libraries to give readers a feeling for just how powerful Python is.
	Norman Matloff and Peter Jay Salzman: The Art of Debugging with GDB, DDD, and Eclipse. No Starch Press, 1593271743, 2008. Describes three power tools for debugging that are freely available on many platforms.
	Steve McConnell: Code Complete: A Practical Handbook of Software Construction. Microsoft Press, 0735619670, 2004. This classic handbook covers everything from how to avoid common mistakes in C to how to set up a testing framework, how to organize multi-platform builds, and how to coordinate the members of a team.
	Brett D. McLaughlin, Gary Pollice, and Dave West: Head First Object-Oriented Analysis and Design. O’Reilly Media, 0596008678, 2006. Many people will find this book’s cartoon-ish format and awkward jokes annoying, but it’s a very good introduction to the Unified Modeling Language (UML) and how and when to use it.
	Robert Mecklenburg: Managing Projects with GNU Make. O’Reilly, 0596006101, 2004. A good book about an infuriating, but often essential, software tool.
	Gerard Meszaros: xUnit Test Patterns: Refactoring Test Code. Addison-Wesley, 0131495054, 2007. Catalogs patterns in the way unit tests are written. Most content is presented twice (once as explanation, once for reference).
	Michael Nygard: Release It!: Design and Deploy Production-Ready Software. Pragmatic Bookshelf, 0978739213, 2007. This book is about designing applications to deal with the things that don’t happen in the classroom or the lab: load fluctuations, power outages, upgrades, tangled configurations, and everything else you have to worry about when scaling up applications to work in the real world. As an example, the chapter on capacity patterns talks about connection pooling, the importance of building a flush mechanism into every cache, when precomputing content will pay off, why you should tune garbage collection, and why object pooling no longer makes sense (if in fact it ever did). The rest of the book is equally practical, and just as well written.
	Russ Olsen: Design Patterns in Ruby. Addison-Wesley, 0321490452, 2007. The best hands-on introduction to design patterns around: every pattern is illustrated with examples taken from the standard Ruby libraries.
	Andy Oram and Greg Wilson (editors): Making Software: What Really Works, and Why We Believe It. O’Reilly, 0596808321, 2010. Leading software engineering researchers take a chapter each to describe key empirical results and the evidence behind them. Topics range from the impact of programming languages on programmers’ productivity to whether we can predict software faults using statistical techniques.
	Dan Pilone and Russ Miles: Head First Software Development. O’Reilly Media, 0596527357, 2008. Many people will find this book’s cartoon-ish format and awkward jokes annoying, but it’s still a good hype-free introduction to agile development practices.
	Deborah S. Ray and Eric J. Ray: Unix and Linux: Visual QuickStart Guide. Peachpit Press, 0321636783, 2009. A gentle introduction to Unix, with many examples.
	Robert Sedgewick: Algorithms in C. Addison-Wesley Professional, 0201756080, 2001. These books are a guide to all the other conceptual tools that working programmers ought to have at their fingertips, from sorting and searching algorithms to different kinds of trees and graphs. The analysis is far more accessible than that of many other textbooks, and while the author’s use of C may seem old-fashioned in an age of Java and C , it does ensure that nothing magical is hidden inside an overloaded operator or virtual method call.
	Steve Souders: High Performance Web Sites: Essential Knowledge for Front-End Engineers. O’Reilly, 0596529309, 2007. Written while the author was head of performance engineering at Yahoo!, this book explains what makes web sites slow, and how to fix them.
	Diomidis Spinellis: Code Reading: The Open Source Perspective. Addison-Wesley Professional, 0201799405, 2003. Walks through hundreds of examples of C, C++, Java, and Perl, drawn from dozens of open source projects such as Apache and NetBSD to illustrate how programs are organized. How do people represent multi-dimensional tables in C? How do people avoid nonreentrant code in signal handlers? How do they create packages in Java? By the end, readers will know how to navigate large code bases in (almost) any language.
	Diomidis Spinellis: Code Quality: The Open Source Perspective. Addison-Wesley Professional, 0321166078, 2006. A complement to the same author’s book on reading code, this one explores how we can measure (or at least judge) the quality of software.
	Herbert Thompson and Scott Chase: The Software Vulnerability Guide. Charles River Media, 1584503580, 2005. My current favorite guide to computer security for programmers, this books walks through each major family of security holes in turn: faulty permission models, bad passwords, macros, dynamic linking and loading, buffer overflow, format strings and various injection attacks, temporary files, spoofing, and more.
	James A. Whittaker: How to Break Software: A Practical Guide to Testing. Addison-Wesley, 0201796198, 2002. One of a trilogy of introductory books on software testing, this book covers basic ideas and techniques that apply to testing any program.
	James A. Whittaker and Herbert H. Thompson: How to Break Software Security. Addison-Wesley, 0321194330, 2003. One of a trilogy of introductory books on software testing, this volume shows readers how to find vulnerabilities in programs, and by implication, how to avoid creating them.
	Greg Wilson: Data Crunching: Solve Everyday Problems Using Java, Python, and More. Pragmatic Bookshelf, 0974514071, 2005. A multilingual look at how to handle text, XML, relational data, and other common formats.
	Andreas Zeller: Why Programs Fail: A Guide to Systematic Debugging. Morgan Kaufmann, 0123745152, 2009. A report from the front lines on current and next-generation debugging tools. Some are old friends, like bug trackers and symbolic debuggers. Others are new: there’s a detailed look at the pro’s and con’s of replay debugging, an automatic divide-and-conquer tool that can strip test cases down to their essentials, and a whole chapter on how dependency analysis and program slicing can be used to isolate faults.

Other Material

1. Jonathan B. Buckheit and David L. Donoho: “WaveLab and Reproducible Research.” 1995.
2. Paul F. Dubois: “Maintaining Correctness in Scientific Programs.” Computing in Science & Engineering, May–June 2005.
3. David Goldberg: “What Every Computer Scientist Should Know About Floating-Point Arithmetic.” ACM Computing Surveys, 23(1), March 1991.
4. Jo Erskine Hannay, Hans Petter Langtangen, Carolyn MacLeod, Dietmar Pfahl, Janice Singer, and Greg Wilson: “How Do Scientists Develop and Use Scientific Software?” Proc. 2009 ICSE Workshop on Software Engineering for Computational Science and Engineering,2009.
5. Evan Robinson: “Why Crunch Mode Doesn’t Work: 6 Lessons.” http://www.igda.org/why-crunch-modes-doesnt-work-six-lessons (last accessed January 2012).
6. Rebecca Sanders and Diane Kelly: “Dealing with Risk in Scientific Software Development.” IEEE Software, July–August 2008.
7. Gregory V. Wilson: “Where’s the Real Bottleneck in Scientific Computing?” American Scientist, January–February 2005.
8. Greg Wilson: “Software Carpentry: Getting Scientists to Write Better Code by Making Them More Productive.” Computing in Science & Engineering, November–December 2006.
9. Greg Wilson: “Those Who Will Not Learn From History…” Computing in Science & Engineering, May–June 2008.
10. Gregory Wilson: “How Do Scientists Really Use Computers?” American Scientist, September–October 2009.
11. Laura Wingerd and Christopher Seiwald: “High-level Best Practices in Software Configuration Management.” http://www.perforce.com/perforce/papers/bestpractices.pdf (last accessed October 2010).
12. Yale Law School Roundtable on Data and Code Sharing: “Reproducible Research: Addressing the Need for Data and Code Sharing in Computational Science.” Computing in Science & Engineering, September–October 2010.