Plushi

2002

Push is a programming language designed for the expression of evolving programs within an evolutionary computation system. This article describes Push and illustrates some of the opportunities that it presents for evolutionary computation. Two evolutionary computation systems, PushGP and Pushpop, are described in detail. PushGP is a genetic programming system that evolves Push programs to solve computational problems. Pushpop, an "autoconstructive evolution" system, also evolves Push programs but does so while simultaneously evolving its own evolutionary mechanisms.

He received a B.A. in Philosophy from Oberlin College in 1984 and a Ph.D. from the Department of Computer Science at the University of Maryland in 1992. His areas of teaching and research include genetic and evolutionary computation, quantum computation, and a variety of intersections between computer science, cognitive science, evolutionary biology, and the arts. He is the Editor-in-Chief of the journal Genetic Programming and Evolvable Machines (published by Springer) and a member of the editorial board of Evolutionary Computation (published by MIT Press). He is also a member of the SIGEVO executive committee and he was named a Fellow of the International Society for Genetic and Evolutionary Computation. Tutorial Description (1) The language in which evolving programs are expressed can have significant impacts on the problem-solving capabilities of a genetic programming system. These impacts stem both from the absolute computational power of the languages that are used, as elucidated by formal language theory, and from the ease with which various computational structures can be produced by random code generation and by the action of genetic operators. Highly expressive languages can facilitate the evolution of programs for any computable function using, when appropriate, multiple data types, evolved subroutines, evolved control structures, evolved data structures, and evolved modular program and data architectures. In some cases expressive languages can even support the evolution of programs that express methods for their own reproduction and variation (and hence for the evolution of their offspring). Tutorial Description (2) This tutorial will begin with a comparative survey of approaches to the evolution of programs in expressive programming languages ranging from machine code to graphical and grammatical representations. Within this context it will then provide a detailed introduction to the Push programming language, which was designed specifically for expressiveness and specifically for use in genetic programming systems. Push programs are syntactically unconstrained but can nonetheless make use of multiple data types and express arbitrary control structures, supporting the evolution of complex, modular programs in a particularly simple and flexible way. The Push language will be described and ten years of Push-based research, including the production of human-competitive results, will be briefly surveyed. The tutorial will conclude with a discussion of recent enhancements to Push that are intended to support the evolution of complex and robust software systems.

Proceedings of the 2005 conference on Genetic and evolutionary computation - GECCO '05, 2005

The Push programming language was developed for use in genetic and evolutionary computation systems, as the representation within which evolving programs are expressed. It has been used in the production of several significant results, including results that were awarded a gold medal in the Human Competitive Results competition at GECCO-2004. One of Push's attractive features in this context is its transparent support for the expression and evolution of modular architectures and complex control structures, achieved through explicit code self-manipulation. The latest version of Push, Push3, enhances this feature by permitting explicit manipulation of an execution stack that contains the expressions that are queued for execution in the interpreter. This paper provides a brief introduction to Push and to execution stack manipulation in Push3. It then presents a series of examples in which Push3 was used with a simple genetic programming system (PushGP) to evolve programs with non-trivial control structures.

Lecture Notes in Computer Science, 1994

This paper studies Genetic Programming (GP) and its relation to the Genetic Algorithm (GA). GP uses a GA approach to breed successive populations of programs, represented in the chromosomes as parse trees, until a program that solves the problem emerges. However, parse trees are not naturally homologous, consequently changes had to be introduced into GP. To better understand these changes it would be instructive if a canonical GA could also be used to perform program induction. To this end an appropriate GA representation scheme is developed (called EP-I for Evolutionary Programming with Introns). EP-I has been tested on three problems and performed identically to GP, thus demonstrating that the changes introduced by GP do not have any properties beyond those of a canonical GA for program induction. EP-I is also able to simulate GP exactly thus gaining further insights into the nature of GP as a GA.

1993

A for-loop is somewhat similar to an inductive argument. Just as the truth of a proposition P(n + 1) depends on the truth of P(n), the correctness of iteration n+1 of a for-loop depends on iteration n having been completed correctly. This paper presents the induce-construct, a new programming construct based on the form of inductive arguments. It is more expressive than the for-loop yet less expressive than the while-loop. Like the for-loop, it is always terminating. Unlike the for-loop, it allows the convenient and concise expression of many algorithms. The for-loop traverses a set of consecutive natural numbers, the induce-construct generalizes to other data types. The induce-construct is presented in two forms, one for imperative languages and one for functional languages. The expressive power of languages in which this is the only recursion construct is greater than primitive recursion, namely it is the multiply recursive functions in the rst order case and the set of functions expressible in G odel's system T in the general case. 0 Data Types We consider languages in which some of the data types are de ned by recursion as in Hoare's`Recursive Data Types' 8] or the language ML. The example in this paper use the following (polymorphic) types. tree 2() = empty j node(; tree 2(); tree 2()) list() = nil j :list() tree n() = empty j node(; list(tree n())) natural = 0 j natural 0 This article was processed using the L a T E X macro package with LLNCS style View publication stats View publication stats

EpochX is a Genetic Programming (GP) framework written in Java. It allows the creation of tree-based and grammar-based GP systems. It has been created to reflect typical ways in which Java programmers work, for example, borrowing from the Java event model and taking inspiration from the Java collections framework. This paper presents EpochX in general, and gives particular attention to the event model and the statistics analysis framework.

1997

Many functions have to be written over and over again for di erent datatypes, either because datatypes change during the development of programs, or because functions with similar functionality are needed on di erent datatypes. Examples of such functions are pretty printers, debuggers, equality functions, uni ers, pattern matchers, rewriting functions, etc. Such functions are called polytypic functions. A polytypic function is a function that is de ned by induction on the structure of user-de ned datatypes. This paper extends a functional language (a subset of Haskell) with a construct for writing polytypic functions. The extended language type checks de nitions of polytypic functions, and infers the types of all other expressions using an extension of Jones' theories of quali ed types and higher-order polymorphism. The semantics of the programs in the extended language is obtained by adding type arguments to functions in a dictionary passing style. Programs in the extended language are translated to Haskell.

Genetic programming is a technique to automatically discover computer programs using principles of Darwinian evolution. This chapter introduces the basics of genetic programming. To make the material more suitable for beginners, these are illustrated with an extensive example. In addition, the chapter touches upon some of the more advanced variants of genetic programming as well as its theoretical foundations. Numerous pointers to further reading, software tools and Web sites are also provided.

2012

Abstract Several techniques have been developed for allowing genetic programming systems to produce programs that make use of subroutines, macros, and other modular program structures. A recently proposed technique, based on the" tagging" and tag-based retrieval of blocks of code, has been shown to have novel and desirable features, but this was demonstrated only within the context of the PushGP genetic programming system.

2003