Subgoal: conduct an in-depth study of critical representation, operator and other choices used for evolutionary program repair at the source code level.

Subgoal: Develop models and simulations to understand Scalable RADAR principles and adapt them to computation.Subgoal: Extend evolutionary repair – whereby software bugs are automatically repaired using genetic programming, a technique inspired by evolution – towards a software immune system.

Measuring Diversity Through Information Flow

Scalable RADAR for Co-evolutionary Adaptive Environments

Biological systems search complex spaces without a “leader.”

Decentralized Search

Biological Principles

Scalable RADAR

Cells respond to environmental signals automatically.

Automated Response

Simulation and Modeling

Immune systems are composed of millions of cells.

Scalable

Redundancy, diversity, “wisdom of the crowd.”

Robust

Genes, cells, systems adapt over multiple time scales.

Adaptive

Subgoal: compare programs based on how they use inputs in control flow decisions.

Question: How do immune systems achieve such remarkable scalability, with speed and repair independent of size?Approach: Simulate lymphoid compartments, fixed circulatory networks, cytokine communication pathways and signals.

Scalability Our simulations show:

• The structure of the lymphatic network balances fast distribution of existing repairs vs. fast of recruitment of new repairs.

• Inflammatory search signals speed up immune repair by orders of by orders of magnitude, particularly in large systems.

Implement Distributed Repairin real-world platforms

BiologyObserve &

Test

SimulationModel & Analyze

Results: Distance between bubblesort and several other sorting algorithms (log scale).

while(input[i] != ‘\0’)

if(is_lowercase(input[i]))

elif(is_uppercase(input[i]))

Wes WeimerMelanie Moses

`

• Systems contain more errors and are more prone to attack than ever.

• The balance of power favors the attacker:- Software replicates are all

vulnerable to the same attack.

- System complexity precludes rapid repair.

We must rethink the current cybersecurity paradigm.

Stephanie Forrest (PI)

Jed Crandall

Insight

Problem

Animal immune systems can defeat multiple, adaptable adversaries.

• Adapt Scalable RADAR to a new, clean-slate paradigm for software development/maintenance.

• Demonstrate large, complex software systems that: - automatically detect attacks- repair themselves- evolve a diversity of solutions.

Goal

Software is a complex, evolving system.

Results: Effect of modifying fault localization and operator selection probability distributions. Such feature choices significantly impact success rate and repair time, especially on more difficult bugs. With the feature sweep-suggested improvements, we automatically repair 5 new bugs (of 105) with a 17-43% reduction in repair time on more difficult bugs.

Feature Sweep

Easy Medium Hard All0

20406080

100120

Search difficulty

Rep

air

tim

e

Easy Medium Hard 0% All0%

20%

40%

60%

80%

100%DefaultsPath Weights'Operators'

Search difficulty

Su

ccess r

ate

Question: Can our approach repair specialized embedded devices?Approach: Low-powered individual devices cooperate to find repairs more quickly.

Evolutionary Program Repair

Results: As the number of network nodes increases, a distributed repair strategy finds repairs faster and with a higher success rate (average over 16 programs).

Distributed Repair

1 2 3 40

0.2

0.4

0.6

0.8

1

1.2

Success RateRepair Time

Number of nodes

Norm

alize

d r

ate

Statically-compiled

Linux binary

Annotated assembly

trace

Branch/input

correlation matrix

Tracer (C)

DIFT (Java

)

B

A Program

Similarity

Compare

(Octave)

Approach: As the program runs, build a matrix relating input to branch points. Comparing the structure of two matrices gives a program similarity measurement.

Dynamic Information Flow Tracking

Dis

tan

ce f

rom

bu

bb

le

sort

QuicksortMerge

SelectionCocktail

Insertion

H e l l o \0

input[i] != ‘\0’ 1 1 1 1 1 0

is_lowercase(input[i])

0 1 1 1 1 0

is_uppercase(input[i])

1 0 0 0 0 0