"In contrast [to Tim Toady] part of the Zen of Python is, "There should be one — and preferably only one — obvious way to do it." (from the article on "There's more than one way to do it", link above).

Worlds colliding...

Contrast and compare that to others notably Java, C++ and Python. Btw the latter I distaste so much - both language, creators and users - I thought it unfair to make any further comment about it.

That may be the case but as far as the evolutionary computing you talked about is concerned, unfortunately there doesn't appear to be anything in CPAN comparable to DEAP.

(Side note: evolutionary computing cannot generally be considered to be an optimizing approach, despite contrary language (including something I'm about to mention) and there is at least one approach in the field where the evolution is in memes rather than genes and so where no one breeds and no one dies, namely particle swarm optimization.)

At the end all these languages are Turing complete and will eventually arrive at the same tape square. What interests me is the spirit and the inspiration. Pretty metaphysical I agree... A comment to your side-note: I am not sure what is more "scary": genes dying out or ideas? Ideas I should think.

I have whipped up some code to get me started with Perl's evolutionary computing toolkit.

#!/usr/bin/env perl

# Brief and dirty attempt to solve a system of simultaneous equations 
+(2)
# using Genetic Algorithms in particular CPAN module
#   Algorithm::Evolutionary
#   Perl module for performing paradigm-free evolutionary algorithms
#   by J. J. Merelo, jmerelo (at) geneura.ugr.es
# (parts of my program were copied from manpage)
#
# The toy problem here is to find INTEGER solutions to the system of e
+quations y-x=2 and y-2x=11
# wrt x and y.
# Our 2 genes are 'x' and 'y'. We encode these as 8-bit integers
# 7+1sign bit. The algorithm will mutate/crossover etc the bit string 
+of each member of
# the population. Then it will evaluate how well the genes of each mem
+ber of the population
# solve the problem at hand. This is called the fitness. The fittest g
+enes survive and the
# rest are discarded, with some probability.
# Author: bliako
# Date: 16/04/2018

use strict;
use warnings;

use Algorithm::Evolutionary::Experiment;
use Algorithm::Evolutionary::Op::Easy;
use Algorithm::Evolutionary::Op::Bitflip;
use Algorithm::Evolutionary::Op::Crossover;

my $num_genes = 2;

my $fitness = sub {
    my $individual = shift;
    my $genes = chromosome2genes($individual->Chrom());
    return calculate_discrepancy($genes);
};

my $m = Algorithm::Evolutionary::Op::Bitflip->new(2); # flip this numb
+er of bits randomly
my $c = Algorithm::Evolutionary::Op::Crossover->new(2); # crossover wi
+th 2 points
# every iteration applies the above operations to the population along
+ with a fitness function
# and selection rate (prob of good genes to survive, lower means more 
+"bad" genes enter the next generation) 
my $ez = new Algorithm::Evolutionary::Op::Easy $fitness, 0.4, [$m,$c];
my $popSize = 500; # population size, each individual in this pop has 
+a chromosome which consists of 2 genes
my $indiType = 'BitString'; # the chromosome is a sequence of bits as 
+a string
my $indiSize = 8*$num_genes; # 8 bits per gene
my $e = new Algorithm::Evolutionary::Experiment $popSize, $indiType, $
+indiSize, $ez;
my $populationRef;
my $previous_fitness = 0;
my ($current_fitness, $best);
while(1){
    $populationRef = $e->go();
    $best = $populationRef->[0];
    print "Best so far: ", $best->asString(), " (", individual2string(
+$best),")\n";
    $current_fitness = $best->Fitness();
    if( $current_fitness == 0 ){ print "bingo!\n"; last }
    #if( ($previous_fitness - $current_fitness) == 0 ){ last }
    $previous_fitness = $current_fitness;
}

print "\nI tried to solve the system of equations: y-x=2 and y-2x=11. 
+The solution should be x=3, y=5\n";
print "Final solution found: ".individual2string($best)."\n";

exit(0);

sub individual2string {
    my $individual = $_[0];
    my $genes = chromosome2genes($individual->Chrom());
    my $fit = calculate_discrepancy($genes);
    return genes2string($genes) . " -> discrepancy=" . $fit
}
# interpret an array of genes wrt our problem, i.e. an x and a y
sub genes2string {
    my $genes = $_[0];
    return "x=".$genes->[0].", y=".$genes->[1];
}
# convert a huge bit string into an array of genes
# the array to place the genes in is given
sub chromosome2genes {
    my $achromosome = $_[0]; # chromosome bit string containing all ge
+nes as 10101

    my @retgenes = (0)x$num_genes;

    # convert a chromosome which consists of genes which consist of bi
+ts(alleles)
    # into a set of numbers to be applied to our problem.
    # each chromosome below consists of 2 genes which consist of 8 bit
+s (1sign+7)
    # these 8bits are interpreted as integers in +-127 range (which is
+ enough for our problem
    # however if solution involved bigger numbers we need to increase 
+range/bits)
    my $i=0;
    while( $achromosome =~ /([01])([01]{7})/g ){
        my $sig = $1 eq '1' ? -1 : 1;
        my $g2 = $2;

        # Here is how a sequence of 8bits is converted to integers. 1s
+t bit is sign.
        # I am sure there is a better way using pack.
        my $g = 0;
        my $j = 1;
        map { $g += $_*$j; $j*=2; } split(//, $g2);
        $g *= $sig;

        $retgenes[$i++] = $g;
        #print "$g2->num=$g\n";
    }
    return \@retgenes
}
sub    calculate_discrepancy {
    my $genes = $_[0];

    # Our problem is to solve the simultaneous equation: y-x=2 and y-2
+x=11
    # where genes[0] -> y, genes[1]->x
    my $e1 = $genes->[0] - $genes->[1] - 2;
    my $e2 = $genes->[0] + 2*$genes->[1] - 11;
    # we calculate discrepancy but we need to return fitness:
    return -($e1*$e1 + $e2*$e2);
}
[download]

Nice example code!