Episode 379: Claire Le Goues on Automated Program Repair
Claire Le Goues, Associate Professor at Carnegie Mellon University discusses her area of research: automated program repair – the ability of programs to fix bugs in other programs. Host Felienne spoke with Le Goues about how these techniques work. The techniques include: applying ‘sensible’ edits (moving blocks of code, adding null checks automatically) and then running tests to see if the change happens to solve the program. The show also covers: how program repair is being applied in industry, and what developers can do to make their code bases as suitable as possible for program repair tools.
Related Links
- [Blog SapFix, https://code.fb.com/developer-tools/finding-and-fixing-software-bugs-automatically-with-sapfix-and-sapienz/]
- [Paper SapFix, https://research.fb.com/publications/sapfix-automated-end-to-end-repair-at-scale/]
- [Blog Getafix, https://code.fb.com/developer-tools/getafix-how-facebook-tools-learn-to-fix-bugs-automatically/]
- [Paper Getafix: https://arxiv.org/abs/1902.06111]
- [Bibliography, http://program-repair.org/ ]
- [“Choose Your Own Adventure” reading list, https://clairelegoues.com/2016/09/16/my-original-pwlconf-reading-list-on-patch-generation/]
- [Claire’s PWL talk, https://www.youtube.com/watch?v=sRkfMe0_5cA&feature=youtu.be]
- [CMU’s PhD in Software Engineering:,https://se-phd.isri.cmu.edu/]
- [Program-repair.org’s “Tools” page, http://program-repair.org/]
SE Radio theme music: “Broken Reality” by Kevin MacLeod (incompetech.com)
Licensed under Creative Commons: By Attribution 3.0
Podcast: Play in new window | Download
Subscribe: Apple Podcasts | RSS
Tags: assertions, programming languages, testing
SE Radio Alerts
A very interesting show!
This topic corresponds very nicely to my own thoughts about the (far) future of programming: Computers will be able to write the code for us, given that we’ll write tests first. Clearly, we won’t need to write all the tests in advance, but to do it iteratively, just like in TDD, but the computer will write the code for us. Even though Claire mentioned research about automatically writing tests, IMHO tests can only be generated automatically by deriving them from the actual application’s behavior. I cannot see how a machine will be able to know what we *expect* from the program. As programming is all about innovation, I’m very skeptic that AI will be able to write code without people defining the tests or other kind of formal specification. (AI may help us find trivial bugs that don’t require domain knowledge and formal specification). So learn TDD today if you want to stay relevant in the future 🙂
Another related topic that I find interesting is automated refactoring. I also believe that this should be an easier thing to do. Many refactorings can be automated today (e.g. extract method, extract super class, etc.), but the programmer still chooses when and where to apply them. I can foresee a future where a tool will suggest (and maybe even do without our approval) a complete sequence of refactorings that simplify our code. This will help reduce technical debt and make code easier to maintain. Automated refactoring doesn’t even need tests, as each step can be proven to leave the behavior intact. Though naming will probably still be one of the two toughest problems in computer science (cache invalidation, naming, and off-by-1 errors :-))