Nowadays, there is a broad choice of evolutionary algorithm frameworks almost in every language, and adapted to every need. From specific-purpose libraries such as GAGS (Merelo-Guervós and Prieto 1996) or lil-gp and other GP libraries (Wilson et al. 2004), nowadays libraries emphasize its general applicability and extensibility. For instance, JCLEC (Ventura et al. 2008) is a general-purpose Java evolutionary computation framework, which has been included in the KEEL data mining library (Alcalá-Fdez et al. 2009). Other well-known frameworks include ParadisEO (Cahon et al. 2004), which was initially a branch of the EO Evolving Objects library (Keijzer et al. 2002), and of course ECJ (Luke 2009), probably the most widely-used general-purpose evolutionary computation library, already in double-digit version.

The wide availability and maturity of these libraries has not been a hurdle for the creation of new ones such as Shark (Igel et al. 2008), or Watchmaker (Dyer 2008), both available as open source software. This is due to several factors: some libraries are initially created with a single problem in mind, and eventually expanded to a whole range of problems, until they become a framework. In other cases, they are simply written in a language that is not familiar to the person needing them, or do not include the features that are needed for implementing a new operator or higher-level algorithm.

Scripting languages are usually more flexible in that sense. Many things can be changed in runtime, making designs much more flexible, even at the Application Program Interface (API) level, which can in some cases be built from scratch via runtime commands. This usually comes at the cost of performance, but familiarity with language, speed of implementation, and wide (and, in the case of Perl and some other languages like Ruby, centralized) availability of programming libraries more than make up for it. That is why most of the new frameworks for evolutionary computation (such as EvoGrid, available from http://launchpad.net/evogrid) use these languages (Lee and Kim 2005; Merelo et al. 2007; Klein and Spector 2007).

Despite this flexibility, there are not many libraries that implement evolutionary algorithms in Perl (for a review on evolutionary algorithms in Perl, and a tutorial of the first versions of A::E , see Merelo-Guervós (2002); most published modules deal with genetic programming (hereafter GP) in Perl, due to the fact that it is an interpreted language, and it is very easy to evaluate expressions and statements from a program (or script). The first (as claimed by the author) paper published on the subject seems to be one by Baldi et al. (2000), but the source code itself was not published, and no hypothesis can be done on its features. From that moment on, there are several papers that describe Perl implementation of evolutionary algorithms: Kunken (2001) described an application that evolves words that “look as if they were English”, or fake English words, by trying to evolve them using the same letter pattern that English uses. The same application is also mentioned by Zlatanov (2001), who implements a genetic programming system, with source code available, to solve the same problem.

From then on, there are several papers about doing genetic programming (Koza 1992) in Perl: the first one was written by Murray and Williams (1999), which, despite its title, actually describes a genetic programming system, similar to another mentioned in the PerlMonks site [http://perlmonks.org/index.pl?node_id=31147] (a meeting place for practitioners). Several other introductions to genetic algorithms with code have been published in the same place [http://perlmonks.org/index.pl?node_id=298877, http://perlmonks.org/index.pl?node_id=330315], but the first mention to a module that implements a canonical genetic algorithm was done in Neylon (2001). This module, called Algorithm::Genetic , cannot be easily extended or adapted to new paradigms, since it is a single file with all data structures and algorithms used already built-in into the file. McCallum (2003) has also presented a system called PerlGP, used specifically in the context of bioinformatics, which has extensive facilities, including a database back-end for serialization, and its main advantage is that it uses as a programming language for doing GP in Perl itself. Its main drawback is its specificity: it is not intended for general evolutionary computation, and most data structures and methods are geared towards GP.

The most complete (apart from the one presented in this paper) and peculiar implementation of evolutionary algorithms in Perl is called myBeasties (Hugman 2003), which eventually became a module called AI::GP . This system implements different kinds of objects, that can be evolved in many possible ways; there is a language that describes these transformations. It is an interesting system, but its extensibility is not so strong, and the learning curve is also somewhat steep, since it involves learning a new language apart from Perl itself. It is mainly used for evolving Perl scripts, the same way that Genetic Programming evolves Lisp functions, not intended for the implementation of a general evolutionary computation program, which implies also learning structures unfamiliar for the EA practitioner. On the other hand, the most recent is AI::Genetic::Pro , which has recently entered version 0.34. The main objective of this module (Lukasz 2009) is to optimize speed through coding the most critical parts in C, through the Perl interface called XS that allows this. In fact, initial tests (see equivalent programs at our CVS server: http://opeal.cvs.sourceforge.net/viewvc/opeal/Algorithm-Evolutionary/benchmarks/, ai-genetic-pro.pl and bitflip.pl ) show that it is several times slower than A::E , with extensibility being also sacrificed through the use of this XS API.

The majority of those systems do not make use Perl’s capabilities to implement an object-oriented library, easily adaptable and expandable, which have been two of the objectives A::E ’s designers had in mind.

Creating an EA library is closely related to the design of a language that can be used to describe experiments in that library, so that results can be easily reported and logged, and experiment design can be done without modifying a program, and if possible from somebody who is not familiar with programming. For some time, XML has been the language of choice for representation of complex data structures; that is why it has also been employed traditionally for EAs. The first approach was the EAML language (Evolutionary Algorithm Markup Language, an XML dialect) described by Veenhuis et al. (2000). This language, specified as a set of XML tags with a defined and fixed semantics, specifies an evolutionary algorithm, from which C++ code can be generated. EAML attempts to be an exhaustive description of an evolutionary algorithm, but it does not really achieve its target, since, for instance, variation operators are tags, instead of being attribute values of a generic operator tag; this means that adding a new operator [say, a n-ary orgy operator (Eiben et al. 1995)] would require a redesign of the language’s syntax (defined through a DTD, or Data Type Dictionary). In general, using element names or tags is less flexible than using attribute values, since attributes can have any value or a constrained one (depending on how you define them in the DTD), but validated XML requires tags to be defined in its DTD first. In any case, it is a valid approach for a restricted form of an evolutionary algorithm and it is a step in the right direction. On the other hand, EvoSpec , which is used by A::E , tries to overcome these limitations. Other possible approaches are presented by García-Nieto et al. (2007), who published an application programming interface via a web service, allowing any program to interact, via the Internet, and through the interchange of messages formatted in XML; and by Ventura et al. (2008), who also used XML (in a way more similar to EAML than to EvoSpec) to represent evolutionary algorithms.

Being convenient as it is for algorithm description, serializing Perl data structures to XML is not easy, mainly due to the fact that the DTD it is mapped into has to be defined in advance; other languages, such as YAML [Yet Another Markup Language, (Ingerson et al. 2001)], have been designed with those data structures in mind, being at the same time more compact (for instance, an article by regeya (2004) notes a 10% reduction of the number of bytes from representing the same data structure with YAML or XML) and thus convenient. In the latest versions of A::E (from 0.56 on), this language has been incorporated and used within a wide variety of tasks, including serialization and program configuration.