This page presents the material related to the course on Automatic Software Repair that I'll give at Escuela de Ciencias Informáticas 2015 (ECI 2015). The course will be a mix of lecture, DIY and student presentations.
Don't hesitate to ask me questions in advance by email.
–Martin (who am I?, what have I done in this field?)
Course goals
The course is a success if:
You know the key concepts of automatic software repair.
You implement a simple repair system in your language of choice.
You give good presentations about automatic software repair papers.
Major topics:
Automatic patch generation
Runtime repair
Code transformation and repair
Crash analysis
Code Synthesis for repair (if time permits)
Course Format
Teaching Philosophy
I'm an adept of active learning, where "active" for you means reading, preparing and giving a presentation, asking questions, writing code, etc.
In particular, I value inquiry-based learning. The best course is when it is only driven by student's questions.
Grading
The grading will be done 50% of the presentations and 50% on the prototyping.
Course Notes
http://www.monperrus.net/martin/introduction-to-automatic-software-repair.pdf
Presentations
Each session ends with student's presentation. You can do the exercise alone or in pair. The rules are as follow. You read a paper whose topic is the one of the session, you present the paper 5 minutes, the presentation is followed by questions and discussions. You can prepare slides.
I give you a carefully selected list of papers, but you can choose another one if you'd like too, I'd love to be surprised, I'd love to discover new papers.
Day #1: Introduction
Outline:
Martin's Presentation
yourself's presentation: why are you here? what are you looking for? what about grades?
course presentation
discussion about fundamental concepts
reading
presentation & discussion
Papers (or also other papers cited in the course notes):
Automated Patching Techniques: The Fix Is In (CACM 2010)
Patching program errors (CACM 2008)
Automated bug fixing (ACM Ubiquity, 2015)
GenProg: A Generic Method for Automatic Software Repair (TSE 2012)
Automatic Detection and Repair of Errors in Data Structures (OOPSLA 2003)
Open questions for end-of-session discussion:
When has this research thread started? Why not before? (What are the oldest papers mentioning those ideas?)
Is it hard? What are the main challenges?
What are the mentioned bug oracle and regression oracle?
Day #2: Automatic Patch Generation
Papers:
GenProg: A Generic Method for Automatic Software Repair (TSE 2012)
Automated repair of HTML generation errors in PHP applications using string constraint solving
Presentation template:
What fault class is targeted? Is it critical? Common?
What is the specification used?
What is the bug oracle? what is the regression oracle?
How is it evaluated? Does it work in practice?
Day #3: Runtime Repair
Papers:
Enhancing server availability and security through failure-oblivious computing
Changing Java's Semantics for Handling Null Pointer Exceptions
Day #4: Do It Yourself
You're free to choose the topic. Use your language of choice for maximum productivity. For both patch generation and runtime repair, you need a way to transform existing programs (aka meta-programming). For Java, I recommend Spoon (full disclosure: I'm the lead maintainer :-). For other languages, I may have some pointers.
DIY prototypes done during the course:
Afix (by Brian J. Cardiff) fixes Crystal program using a metaprogramming repair approach. Afix is able to fix one real bug in a Markdown parser (https://github.com/bcardiff/afix).
failsafeblocks (by Iván Pondal) fixes errors at runtime by selecting alternative implementations in Java, in a way that is similar to recovery blocks (https://github.com/ivanpondal/failsafeblocks)
ANPER (by Simón Gutiérrez Brida and Gastón Scilingo) fixes null pointer exceptions in Java (https://github.com/gastonscilingo/ANPER).
Astorus (by Francisco DeMartino) fixes off by one errors and bad condition errors in Python code (https://github.com/franciscod/astorus)
ASRE (by Nicolas Rivasi and Pablo Herrero) fixes Ruby programs by replacing methods.They exploit that may mutations are indeed method changes in Ruby using polymorphic methods: eg. '<' and '<=', select by reject, etc. (https://github.com/pabloh/automatic_software_repair_eci).
Code Fixer (by Carlos Fau and Alejandro Russel) explores the combinations of condition operator changes that enable a test suite to pass (https://github.com/totemcaf/code-fixer/)
Day #5: Discussion and Advanced Concepts of Automatic Repair
Papers: