Genetic Programming (GP) has recently seen a growing application in the area of writing and improving computer programs. Generally, for experiments in this area, bespoke tools are constructed to perform research. In this paper, it is demonstrated that GP behaviour can be achieved via process fuzzing, and an implementation of the adaptation of ASTs for GP behaviour in the process fuzzing tool PyDySoFu is described.
Genetic Programming (GP) is a very well-established and promising
eld which has returned impressive results in a number of areas. The
eld has spawned a number of similar approaches which, while based
on the same underlying concept, attempt an evolution-based solution
in novel ways. Cartesian GP[
Generally, variants of GP present methods for improving
mathematicallooking functions against some tness function. However, variants
have begun to arise which, rather than mutating some abstract
representation of a program, mutate the program itself. Stack-based GP
in the Push family of languages[
Indeed, approaches involving the alteration of source code have
garnered a growing amount of attention: in the improvement of Java
programs alone, several tools for the improvement of a codebase have
arisen[
Ultimately, Genetic Programming relies on the mutation and
evaluation of a representation of a problem's solution. Process fuzzing
allows for this to be achieved for imperative code, by modifying
and rewriting it prior to execution. A tool implementing this is
PyDySoFu[
There is a clear link between the requirement for mutation in GP and the functionality provided by a fuzzer. Some work is required, however, to represent GP-like interactions within the tool. Speci cally: 1. Multiple variants must be generated and their outputs tracked, so they can be compared to each other, and ranked. 2. This ranking must be done by some function appropriate for the problem domain at hand | GP's \ tness functions". 3. Once variants are ranked, it must be possible to recombine successful ones and use these in future generations. 1 An Abstract Syntax Tree is a tree representation of an expression in a language with a formal grammar, such as programming languages. 2.2
PyDySoFu was originally unable to keep track of multiple variants, nor record the return values of the variants it produced. The solution was to extend PyDySoFu's underlying mechanism into a more fully featured aspect orientation framework, capable of more sophisticated code weaving.
This extension became an aspect orientation framework, ASP[
Critically, aspects in ASP can be objects. When fuzzers are written as instances of aspect classes, they can use instance variables to keep track of the variants they generate between invocations. Also, because ASP is capable not only of including behaviour before method invocation, but also after, PyDySoFu can utilise this to catch the output from the method call, and use this to rank variants. This satis es the rst of the three earlier criteria.
When instances of fuzzers are created, a success metric2 can be passed to its constructor, and this is kept within the object's state | this can then be used in the ranking of variants in a round, ful lling the second of the above criteria.
Recombination of variants can be done by combining modi ed
ASTs from variants in the previous round when constructing a new
one | this ful ls the third of the above criteria, and is implemented
in such a way as to make recombination easily tailored to individual
problem domains via subclasses. Source for the GeneticImprover
implementation of these improvements can be found in the project's
repository[
Use of PyDySoFu as a GP solution has a number of advantages. First, it is under active development, meaning that the tool can 2 Improvements to PyDySoFu were not originally developed with GP speci cally in mind. Therefore, generations are referred to as \rounds", and tness functions as \success metrics". be expected to improve. Users can anticipate PyDySoFu to be a fertile ground for new research, where process fuzzing can be used to separate concerns in a variety of elds.
Importantly, PyDySoFu is not just a tool for implementing solutions to GP problems. Its versatility is a second bene t: its most active area of study, socio-technical variance, provides a plethora of problem domains where GP might nd applications. Performing this research without a cross-disciplinary tool would require lots of ancillary work, but PyDySoFu bridges this gap.
Further, PyDySoFu is able to fuzz code as it is run (\dynamic fuzzing"). This functionality can be used to perform experiments with GP solutions which might | for example | use dynamic fuzzing to represent solutions which operate in an unreliable real world, such as an unreliable network or anomalies in animal populations. 3
PyDySoFu is a new entrant into tools for running experiments within
GP, with the unusual trait that its suitability for evaluating GP
problems comes from its versatility, meaning that PyDySoFu is
positioned to be an unusually e ective tool in a variety of elds. Many
things can be done to increase PyDySoFu's e ectiveness as a GP
tool, and to exploit it's versitility to explore new research
possibilities, including:
{ A wider array of GP-style fuzzers can be implemented, building
on the broad array of code-improving GP approaches surfacing
in the literature. These could also be used to replicate previous
work in the eld.
{ Further exploration of GP using AST-style program mutation for
codebase improvement can also be explored in Python using
PyDySoFu, which, combined with the other research opportunities,
makes it an exciting alternative to existing solutions.
{ Given PyDySoFu naturally links socio-technical modelling and
GP, experiments involving GP solutions to socio-technical
problems are now feasible. A major contribution of GP interactions in
PyDySoFu is that the tool's versitility allows GP to be explored
within socio-technical problem domains[
This paper has given a brief overview of recent development of PyDySoFu, a process fuzzing tool which is now capable of GP-style interactions. While GP-style interactions arising from process fuzzing is an interesting result of its own, the availability of the tool should inspire further genetic metaprogramming work, and encourage researchers to make use of its potential across a variety of domains.
The authors would like to thank Obashi Technology for helping to fund this research, and Rob Dekkers for his help reviewing this work.