- Added solutions by Colin Crain.

15 files changed, 1436 insertions, 954 deletions

diff --git a/challenge-063/colin-crain/perl/ch-1.pl b/challenge-063/colin-crain/perl/ch-1.pl
new file mode 100644
index 0000000000..460e99a7fb
--- /dev/null
+++ b/challenge-063/colin-crain/perl/ch-1.pl
@@ -0,0 +1,88 @@
+#! /opt/local/bin/perl
+#
+#       drop_the_mic.pl
+#
+#         TASK #1 › Last Word
+#         Submitted by: Mohammad S Anwar
+#         Lovingly Crafted by: Ryan Thompson
+#
+#             Define sub last_word($string, $regexp) that returns the
+#             last word matching $regexp found in the given string, or
+#             undef if the string does not contain a word matching
+#             $regexp.
+#
+#             For this challenge, a “word” is defined as any character
+#             sequence consisting of non-whitespace characters (\S)
+#             only. That means punctuation and other symbols are part of
+#             the word.
+#
+#             The $regexp is a regular expression. Take care that the
+#             regexp can only match individual words! See the Examples
+#             for one way this can break if you are not careful.
+#
+#             Examples
+#
+#             last_word('  hello world',                qr/[ea]l/);      # 'hello'
+#             last_word("Don't match too much, Chet!",  qr/ch.t/i);      # 'Chet!'
+#             last_word("spaces in regexp won't match", qr/in re/);      #  undef
+#             last_word( join(' ', 1..1e6),             qr/^(3.*?){3}/); # '399933'
+#
+#         METHOD
+#
+#             It seems the main idea behind this challenge is in the
+#             mechanics of passing a regular expression into a subroutine,
+#             and in handling a variety of edge-cases that can arise whilst
+#             still conforming to the required behavior.
+#
+#             In general, looking for the last occurrence of a thing
+#             requires a sense of state to be updated, but finding one
+#             solution and moving on is much simpler. So with that in mind,
+#             we will tokenize our string and look for a match starting from
+#             the end rather than the beginning. Returning after our first
+#             match will find that last match in the original string. Easy
+#             peasy.
+#
+#             Another detail is that the challenge explicitly asks for a
+#             subroutine, so that is what we will create, along with a
+#             wrapper to call it.
+#
+#
+#
+#       2020 colin crain
+## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
+
+
+
+use warnings;
+use strict;
+use feature ":5.26";
+
+## ## ## ## ## MAIN:
+
+my @pairs = (   ['  hello world',                qr/[ea]l/],
+                ["Don't match too much, Chet!",  qr/ch.t/i],
+                ["spaces in regexp won't match", qr/in re/],
+                [ join(' ', 1..1e6),             qr/^(3.*?){3}/]  );
+
+for my $parameters ( @pairs ) {
+    my $word = last_word($parameters->@*);
+    if (defined $word) {
+        say $word
+    }
+    else {
+        say "\t«no match found»";
+    }
+}
+
+## ## ## ## ## SUBS:
+
+sub last_word {
+    my ($string, $regex) = @_;
+    my @words = split /\s/, $string;
+    my $word;
+    while (@words > 0) {
+        $word = pop @words;
+        return $word if ($word =~ m/$regex/);
+    }
+    return undef;
+}
diff --git a/challenge-063/colin-crain/perl/ch-2.pl b/challenge-063/colin-crain/perl/ch-2.pl
new file mode 100644
index 0000000000..b759e1dd1d
--- /dev/null
+++ b/challenge-063/colin-crain/perl/ch-2.pl
@@ -0,0 +1,160 @@
+#! /opt/local/bin/perl
+#
+#       chopped_and_screwed.pl
+#
+#         TASK #2 › Rotate String
+#         Submitted by: Mohammad S Anwar
+#         Lovingly Crafted by: Ryan Thompson
+#
+#             Given a word made up of an arbitrary number of x and y
+#             characters, that word can be rotated as follows: For the
+#             ith rotation (starting at i = 1), i % length(word)
+#             characters are moved from the front of the string to the
+#             end. Thus, for the string xyxx, the initial (i = 1) % 4 =
+#             1 character (x) is moved to the end, forming yxxx. On the
+#             second rotation, (i = 2) % 4 = 2 characters (yx) are moved
+#             to the end, forming xxyx, and so on. See below for a
+#             complete example.
+#
+#             Your task is to write a function that takes a string of xs
+#             and ys and returns the maximum non-zero number of
+#             rotations required to obtain the original string. You may
+#             show the individual rotations if you wish, but that is not
+#             required.
+#
+#             Example Input: $word = 'xyxx';
+#
+#             Rotation 1: you get yxxx by moving x to the end.
+#             Rotation 2: you get xxyx by moving yx to the end.
+#             Rotation 3: you get xxxy by moving xxy to the end.
+#             Rotation 4: you get xxxy by moving nothing as 4 % length(xyxx) == 0.
+#             Rotation 5: you get xxyx by moving x to the end.
+#             Rotation 6: you get yxxx by moving xx to the end.
+#             Rotation 7: you get xyxx by moving yxxx to the end which is same as the given word.
+#             Output: 7
+#
+#         ANALYSIS AND METHOD
+#
+#             One obvious way to proceed is to build a loop, do the
+#             transform, and jump out if the transformed string is the
+#             same as the initial. This is all well and good, but does
+#             follow through to the next question, which is whether it
+#             will always eventually find a solution, or whether we
+#             might perchance get stuck in an infinite stable
+#             oscillation of some sort.
+#
+#             This got me thinking more about what we’re actually doing
+#             here. And the big reveal is that looked at the right way,
+#             the sequence of characters never changes. When we move the
+#             first character of the string to the end, the last
+#             character is now followed by the first. No matter how many
+#             characters are moved over at a time, this relationship
+#             will always remain true, and each character within the
+#             string will at all times be followed (and proceeded by)
+#             the same characters as in the original untransformed
+#             string. All we have done is create a new rule, that the
+#             end of the string is immediately followed by the
+#             beginning. In topology this is known as a loop, a function
+#             over an interval where the state at the end of the
+#             interval is exactly the same as the beginning. Think of a
+#             donut, being a circle rotated in space to form a torus. We
+#             have made something quite like that, but with a string.
+#
+#             We have no natural data type for a loop of string, but
+#             using modular arithmetic we can pretend we do, leaving the
+#             string alone and just changing the index of the start
+#             point, or, in topology what is known as the base point. As
+#             long as when moving forward we treat the current position
+#             as mod the length of the string, we will remain on the
+#             loop. This is akin to pointing to a point on a circle and
+#             declaring that the circle starts here: no matter where you
+#             start, one can always trace a complete circle from that
+#             point. As a matter of fact, once we have the logic to move
+#             the starting point in our loop according to the rules of
+#             the given progression, we can then determine that we have
+#             worked our way through a complete cycle by observing when
+#             our start point returns to 0. At this level of
+#             abstraction, we have completely abandoned our actual text;
+#             we don’t even need the string anymore to do our math, and
+#             can just count the iterations. Neat!
+#
+#             It is worth noting before we get too excited that what
+#             we’ve solved here this isn’t exactly our problem. It does
+#             however give a lot of insight into what we were tasked
+#             with. In our thought experiment, it doesn’t matter what
+#             the characters of the string are, because given enough
+#             rotations the start point will work its way back to 0. But
+#             for our challenge we do care: in a random assemblage of xs
+#             and ys, an objectively differently ordered but identical
+#             pattern might arise by happenstance, so we will need to
+#             construct and examine the intermediate steps to check for
+#             this. But before that, to follow through in our analysis,
+#             what we can do is construct a little program:
+#
+#                 for my $len (1..500) {
+#                     my $idx = 0;
+#                     my $i;
+#
+#                     while (++$i) {
+#                         $idx = ($idx + ($i % $len)) % $len;
+#                         last if $idx == 0;
+#                     }
+#                     say "$len     $i";  ## string length and number of rotations to cycle
+#                 }
+#
+#             which, for any arbitrary length of string, will provide an
+#             upper bound of the maximum number of steps required to
+#             come full circle.
+#
+#             Just for kicks, we do the transformation here using
+#             substr, lifting out the desired prefix and modifying the
+#             original string at the same time, which we then graft on
+#             to the end of the remaining tail. It’s a succinct solution
+#             I dare say, doing a lot with very few words. Another way
+#             to do this would be to use a substitution match:
+#
+#                 $shifted =~ s/^(.{$moves})(.*)/$2$1/;
+#
+#             Versus the simplicity of the substitution version I can’t
+#             decide which I like best.
+#
+#       2020 colin crain
+## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
+
+
+
+use warnings;
+use strict;
+use feature ":5.26";
+
+## ## ## ## ## MAIN:
+
+my $string = make_xys();
+my $rotations = churn($string);
+say "\nrotations required: $rotations";
+
+## ## ## ## ## SUBS:
+
+sub churn {
+    my $base = shift;
+    my $shifted = $base;
+    my $i;
+
+    say "starting string:      ", $base, "\n";
+    while (++$i) {
+        my $moves = $i % length($base);
+        $shifted .= substr( $shifted, 0, $moves, '');
+        printf "move %-2d  shifting %2d chars:     %s\n", $i, $moves, $shifted;
+        return $i if $shifted eq $base;
+    }
+}
+
+sub make_xys {
+    my $len = shift // int( rand(12) ) + 4;
+    my @xy = ('x','y');
+    my $out;
+    for ( 1..$len) {
+        $out .= $xy[int(rand 2)] ;
+    }
+    return $out;
+}
diff --git a/challenge-063/colin-crain/raku/ch-1.p6 b/challenge-063/colin-crain/raku/ch-1.p6
new file mode 100644
index 0000000000..5a91070786
--- /dev/null
+++ b/challenge-063/colin-crain/raku/ch-1.p6
@@ -0,0 +1,86 @@
+#!/usr/bin/env perl6
+#
+#         63_1_drop_the_mic.raku
+#
+#         TASK #1 › Last Word
+#         Submitted by: Mohammad S Anwar
+#         Lovingly Crafted by: Ryan Thompson
+#
+#             Define sub last_word($string, $regexp) that returns the
+#             last word matching $regexp found in the given string, or
+#             undef if the string does not contain a word matching
+#             $regexp.
+#
+#             For this challenge, a “word” is defined as any character
+#             sequence consisting of non-whitespace characters (\S)
+#             only. That means punctuation and other symbols are part of
+#             the word.
+#
+#             The $regexp is a regular expression. Take care that the
+#             regexp can only match individual words! See the Examples
+#             for one way this can break if you are not careful.
+#
+#             Examples
+#
+#             last_word('  hello world',                qr/[ea]l/);      # 'hello'
+#             last_word("Don't match too much, Chet!",  qr/ch.t/i);      # 'Chet!'
+#             last_word("spaces in regexp won't match", qr/in re/);      #  undef
+#             last_word( join(' ', 1..1e6),             qr/^(3.*?){3}/); # '399933'
+#
+#         METHOD
+#
+#             It seems the main idea behind this challenge is in the
+#             mechanics of passing a regular expression into a subroutine,
+#             and in handling a variety of edge-cases that can arise whilst
+#             still conforming to the required behavior.
+#
+#             In general, looking for the last occurrence of a thing
+#             requires a sense of state to be updated, but finding one
+#             solution and moving on is much simpler. So with that in mind,
+#             we will tokenize our string and look for a match starting from
+#             the end rather than the beginning. Returning after our first
+#             match will find that last match in the original string. Easy
+#             peasy.
+#
+#             Another detail is that the challenge explicitly asks for a
+#             subroutine, so that is what we will create, along with a
+#             wrapper to call it.
+#
+#             For the challenge description, we are given Perl 5
+#             regexes, and the request to return undef. In Raku, we will
+#             need to update this a little, as PCRE requires a little
+#             expansion to allow for new abilities. The examples have
+#             been altered accordingly. Also, undef has been replaced by
+#             Nil, another trivial change in keeping with the spirit of
+#             the specification. After that, accomplishing the task is
+#             short and clear:
+#
+#             Note the subroutine asked for does return Nil here, and
+#             the script when given Nil to report chooses to say «no
+#             match found» instead to avoid confusion with a match.
+#             Seems as good a way to handle this as any.
+#
+#           2020 colin crain
+#
+# # # # # # # # # # #
+
+sub MAIN() {
+    my @pairs =
+            ['  hello world', rx/<[ea]>l/],
+            ["Don't match too much, Chet!", rx:i/ch.t/],
+            ["spaces in regexp won't match", rx:s/in re/],
+            [(1 .. 1e6).join( ' ' ), rx/^(3.*?) ** 3/];
+    for @pairs -> ($string, $regex) {
+        (last_word( $string, $regex ) || '«no match found»').say
+    }
+}
+
+## ## ## ## ## SUBS:
+
+sub last_word ($string, $regex) {
+    my @words = $string.split( /\s/, :skip-empty );
+    for @words.reverse {
+        return $_ if $_.match: /$regex/
+    }
+    return Nil;
+}
diff --git a/challenge-063/colin-crain/raku/ch-2.p6 b/challenge-063/colin-crain/raku/ch-2.p6
new file mode 100644
index 0000000000..30218fe0c9
--- /dev/null
+++ b/challenge-063/colin-crain/raku/ch-2.p6
@@ -0,0 +1,140 @@
+#!/usr/bin/env perl6
+#
+#       chopped_and_screwed.pl
+#
+#         TASK #2 › Rotate String
+#         Submitted by: Mohammad S Anwar
+#         Lovingly Crafted by: Ryan Thompson
+#
+#             Given a word made up of an arbitrary number of x and y
+#             characters, that word can be rotated as follows: For the
+#             ith rotation (starting at i = 1), i % length(word)
+#             characters are moved from the front of the string to the
+#             end. Thus, for the string xyxx, the initial (i = 1) % 4 =
+#             1 character (x) is moved to the end, forming yxxx. On the
+#             second rotation, (i = 2) % 4 = 2 characters (yx) are moved
+#             to the end, forming xxyx, and so on. See below for a
+#             complete example.
+#
+#             Your task is to write a function that takes a string of xs
+#             and ys and returns the maximum non-zero number of
+#             rotations required to obtain the original string. You may
+#             show the individual rotations if you wish, but that is not
+#             required.
+#
+#             Example Input: $word = 'xyxx';
+#
+#             Rotation 1: you get yxxx by moving x to the end.
+#             Rotation 2: you get xxyx by moving yx to the end.
+#             Rotation 3: you get xxxy by moving xxy to the end.
+#             Rotation 4: you get xxxy by moving nothing as 4 % length(xyxx) == 0.
+#             Rotation 5: you get xxyx by moving x to the end.
+#             Rotation 6: you get yxxx by moving xx to the end.
+#             Rotation 7: you get xyxx by moving yxxx to the end which is same as the given word.
+#             Output: 7
+#
+#         ANALYSIS AND METHOD
+#
+#             One obvious way to proceed is to build a loop, do the
+#             transform, and jump out if the transformed string is the
+#             same as the initial. This is all well and good, but does
+#             follow through to the next question, which is whether it
+#             will always eventually find a solution, or whether we
+#             might perchance get stuck in an infinite stable
+#             oscillation of some sort.
+#
+#             This got me thinking more about what we’re actually doing
+#             here. And the big reveal is that looked at the right way,
+#             the sequence of characters never changes. When we move the
+#             first character of the string to the end, the last
+#             character is now followed by the first. No matter how many
+#             characters are moved over at a time, this relationship
+#             will always remain true, and each character within the
+#             string will at all times be followed (and proceeded by)
+#             the same characters as in the original untransformed
+#             string. All we have done is created a new rule, that the
+#             end of the string is immediately followed by the
+#             beginning. In topology this is known as a loop, a function
+#             over an interval where the state at the end of the
+#             interval is exactly the same as the beginning. Think of a
+#             donut, being a circle rotated in space to form a torus. We
+#             have made something quite like that, but with a string.
+#
+#             We have no natural data type for a loop of string, but
+#             using modular arithmetic we can pretend we do, leaving the
+#             string alone and just changing the index of the start
+#             point, or, in topology what is known as the base point. As
+#             long as when moving forward we treat the current position
+#             as mod the length of the string, we will remain on the
+#             loop. This is akin to pointing to a point on a circle and
+#             declaring that the circle starts here: no matter where you
+#             start, one can always trace a complete circle from that
+#             point. As a matter of fact, once we have the logic to move
+#             the starting point in our loop according to the rules of
+#             the given progression, we can then determine that we have
+#             worked our way through a complete cycle by observing when
+#             our start point returns to 0. At this level of
+#             abstraction, we have completely abandoned our actual text;
+#             we don’t even need the string anymore to do our math, and
+#             can just count the iterations. Neat!
+#
+#             It is worth noting before we get too excited that what
+#             we’ve solved here this isn’t exactly our problem. It does
+#             however give a lot of insight into what we were tasked
+#             with. In our thought experiment, it doesn’t matter what
+#             the characters of the string are, because given enough
+#             rotations the start point will work its way back to 0. But
+#             for our challenge we do care: in a random assemblage of xs
+#             and ys, an objectively differently ordered but identical
+#             pattern might arise by happenstance, so we will need to
+#             construct and examine the intermediate steps to check for
+#             this. But before that, to follow through in our analysis,
+#             what we can do is construct a little program:
+#
+#                 for my $len (1..500) {
+#                     my $idx = 0;
+#                     my $i;
+#
+#                     while (++$i) {
+#                         $idx = ($idx + ($i % $len)) % $len;
+#                         last if $idx == 0;
+#                     }
+#                     say "$len     $i";  ## string length and number of rotations to cycle
+#                 }
+#
+#             which, for any arbitrary length of string, will provide an
+#             upper bound of the maximum number of steps required to
+#             come full circle.
+#
+#             Notable in the Raku solution is how elegant it is to
+#             create a string of random xs and ys between 4 and 12
+#             characters long. These constraints are rather arbitrary,
+#             but demonstrate the function well. To move the string
+#             parts we use a substitution routine.
+#
+# # # # # # # # # 2020 colin crain
+
+
+sub MAIN (Bool :$v = False) {
+    say "\nrotations required: ", churn( xys, $v );
+}
+
+sub xys {
+    # creates a string of xs and ys of random length 4..12
+    return [~] <x y>.roll( (4 .. 12).pick );
+}
+
+sub churn ($base, $v) {
+    my $shifted = $base;
+    my $i = 1;
+
+    say "starting string:      ", $base, "\n" if $v;
+    while (1) {
+        my $moves = $i % $base.chars;
+        $shifted ~~ s/(\S ** { $moves })(.*)/$1$0/;
+
+        printf "move %-2d  shifting %2d chars:     %s\n", $i, $moves, $shifted if $v;
+        return $i if $shifted eq $base;
+        $i++;
+    }
+}
diff --git a/stats/pwc-current.json b/stats/pwc-current.json
index aaf36b65a8..042e331cdf 100644
--- a/stats/pwc-current.json
+++ b/stats/pwc-current.json
@@ -1,157 +1,17 @@
 {
-   "subtitle" : {
-      "text" : "[Champions: 22] Last updated at 2020-06-06 19:35:16 GMT"
-   },
    "plotOptions" : {
       "series" : {
-         "borderWidth" : 0,
          "dataLabels" : {
-            "enabled" : 1,
-            "format" : "{point.y}"
-         }
-      }
-   },
-   "legend" : {
-      "enabled" : 0
-   },
-   "title" : {
-      "text" : "Perl Weekly Challenge - 063"
-   },
-   "yAxis" : {
-      "title" : {
-         "text" : "Total Solutions"
+            "format" : "{point.y}",
+            "enabled" : 1
+         },
+         "borderWidth" : 0
       }
    },
-   "tooltip" : {
-      "followPointer" : 1,
-      "pointFormat" : "<span style='color:{point.color}'>{point.name}</span>: <b>{point.y:f}</b><br/>",
-      "headerFormat" : "<span style='font-size:11px'>{series.name}</span><br/>"
-   },
-   "xAxis" : {
-      "type" : "category"
-   },
-   "series" : [
-      {
-         "data" : [
-            {
-               "name" : "Arne Sommer",
-               "drilldown" : "Arne Sommer",
-               "y" : 5
-            },
-            {
-               "y" : 3,
-               "name" : "Bartosz Jarzyna",
-               "drilldown" : "Bartosz Jarzyna"
-            },
-            {
-               "drilldown" : "Cheok-Yin Fung",
-               "name" : "Cheok-Yin Fung",
-               "y" : 3
-            },
-            {
-               "y" : 1,
-               "name" : "Colin Crain",
-               "drilldown" : "Colin Crain"
-            },
-            {
-               "y" : 2,
-               "drilldown" : "Dave Jacoby",
-               "name" : "Dave Jacoby"
-            },
-            {
-               "y" : 5,
-               "drilldown" : "Javier Luque",
-               "name" : "Javier Luque"
-            },
-            {
-               "y" : 2,
-               "drilldown" : "Jorg Sommrey",
-               "name" : "Jorg Sommrey"
-            },
-            {
-               "drilldown" : "Laurent Rosenfeld",
-               "name" : "Laurent Rosenfeld",
-               "y" : 5
-            },
-            {
-               "name" : "Luca Ferrari",
-               "drilldown" : "Luca Ferrari",
-               "y" : 4
-            },
-            {
-               "name" : "Mark Anderson",
-               "drilldown" : "Mark Anderson",
-               "y" : 2
-            },
-            {
-               "name" : "Markus Holzer",
-               "drilldown" : "Markus Holzer",
-               "y" : 2
-            },
-            {
-               "y" : 5,
-               "drilldown" : "Mohammad S Anwar",
-               "name" : "Mohammad S Anwar"
-            },
-            {
-               "y" : 2,
-               "name" : "Niels van Dijke",
-               "drilldown" : "Niels van Dijke"
-            },
-            {
-               "drilldown" : "Noud Aldenhoven",
-               "name" : "Noud Aldenhoven",
-               "y" : 2
-            },
-            {
-               "drilldown" : "Pete Houston",
-               "name" : "Pete Houston",
-               "y" : 1
-            },
-            {
-               "name" : "Roger Bell_West",
-               "drilldown" : "Roger Bell_West",
-               "y" : 5
-            },
-            {
-               "drilldown" : "Saif Ahmed",
-               "name" : "Saif Ahmed",
-               "y" : 2
-            },
-            {
-               "drilldown" : "Sangeet Kar",
-               "name" : "Sangeet Kar",
-               "y" : 4
-            },
-            {
-               "y" : 3,
-               "drilldown" : "Shahed Nooshmand",
-               "name" : "Shahed Nooshmand"
-            },
-            {
-               "y" : 2,
-               "drilldown" : "Simon Proctor",
-               "name" : "Simon Proctor"
-            },
-            {
-               "drilldown" : "Ulrich Rieke",
-               "name" : "Ulrich Rieke",
-               "y" : 4
-            },
-            {
-               "y" : 2,
-               "name" : "Wanderdoc",
-               "drilldown" : "Wanderdoc"
-            }
-         ],
-         "colorByPoint" : 1,
-         "name" : "Perl Weekly Challenge - 063"
-      }
-   ],
    "drilldown" : {
       "series" : [
          {
-            "name" : "Arne Sommer",
+            "id" : "Arne Sommer",
             "data" : [
                [
                   "Perl",
@@ -166,10 +26,10 @@
                   1
                ]
             ],
-            "id" : "Arne Sommer"
+            "name" : "Arne Sommer"
          },
          {
-            "name" : "Bartosz Jarzyna",
+            "id" : "Bartosz Jarzyna",
             "data" : [
                [
                   "Perl",
@@ -180,10 +40,9 @@
                   1
                ]
             ],
-            "id" : "Bartosz Jarzyna"
+            "name" : "Bartosz Jarzyna"
          },
          {
-            "id" : "Cheok-Yin Fung",
             "data" : [
                [
                   "Perl",
@@ -194,6 +53,7 @@
                   1
                ]
             ],
+            "id" : "Cheok-Yin Fung",
             "name" : "Cheok-Yin Fung"
          },
          {
@@ -201,23 +61,31 @@
             "id" : "Colin Crain",
             "data" : [
                [
+                  "Perl",
+                  2
+               ],
+               [
+                  "Raku",
+                  2
+               ],
+               [
                   "Blog",
                   1
                ]
             ]
          },
          {
-            "name" : "Dave Jacoby",
+            "id" : "Dave Jacoby",
             "data" : [
                [
                   "Perl",
                   2
                ]
             ],
-            "id" : "Dave Jacoby"
+            "name" : "Dave Jacoby"
          },
          {
-            "name" : "Javier Luque",
+            "id" : "Javier Luque",
             "data" : [
                [
                   "Perl",
@@ -232,7 +100,7 @@
                   1
                ]
             ],
-            "id" : "Javier Luque"
+            "name" : "Javier Luque"
          },
          {
             "name" : "Jorg Sommrey",
@@ -245,7 +113,7 @@
             "id" : "Jorg Sommrey"
          },
          {
-            "name" : "Laurent Rosenfeld",
+            "id" : "Laurent Rosenfeld",
             "data" : [
                [
                   "Perl",
@@ -260,7 +128,7 @@
                   1
                ]
             ],
-            "id" : "Laurent Rosenfeld"
+            "name" : "Laurent Rosenfeld"
          },
          {
             "name" : "Luca Ferrari",
@@ -287,18 +155,17 @@
             ]
          },
          {
-            "id" : "Markus Holzer",
+            "name" : "Markus Holzer",
             "data" : [
                [
                   "Raku",
                   2
                ]
             ],
-            "name" : "Markus Holzer"
+            "id" : "Markus Holzer"
          },
          {
             "name" : "Mohammad S Anwar",
-            "id" : "Mohammad S Anwar",
             "data" : [
                [
                   "Perl",
@@ -312,17 +179,18 @@
                   "Blog",
                   1
                ]
-            ]
+            ],
+            "id" : "Mohammad S Anwar"
          },
          {
-            "name" : "Niels van Dijke",
-            "id" : "Niels van Dijke",
             "data" : [
                [
                   "Perl",
                   2
                ]
-            ]
+            ],
+            "id" : "Niels van Dijke",
+            "name" : "Niels van Dijke"
          },
          {
             "data" : [
@@ -335,16 +203,17 @@
             "name" : "Noud Aldenhoven"
          },
          {
-            "id" : "Pete Houston",
             "data" : [
                [
                   "Perl",
                   1
                ]
             ],
+            "id" : "Pete Houston",
             "name" : "Pete Houston"
          },
          {
+            "name" : "Roger Bell_West",
             "data" : [
                [
                   "Perl",
@@ -359,21 +228,19 @@
                   1
                ]
             ],
-            "id" : "Roger Bell_West",
-            "name" : "Roger Bell_West"
+            "id" : "Roger Bell_West"
          },
          {
-            "name" : "Saif Ahmed",
+            "id" : "Saif Ahmed",
             "data" : [
                [
                   "Perl",
                   2
                ]
             ],
-            "id" : "Saif Ahmed"
+            "name" : "Saif Ahmed"
          },
          {
-            "name" : "Sangeet Kar",
             "id" : "Sangeet Kar",
             "data" : [
                [
@@ -384,11 +251,10 @@
                   "Raku",
                   2
                ]
-            ]
+            ],
+            "name" : "Sangeet Kar"
          },
          {
-            "name" : "Shahed Nooshmand",
-            "id" : "Shahed Nooshmand",
             "data" : [
                [
                   "Raku",
@@ -398,20 +264,22 @@
                   "Blog",
                   1
                ]
-            ]
+            ],
+            "id" : "Shahed Nooshmand",
+            "name" : "Shahed Nooshmand"
          },
          {
-            "name" : "Simon Proctor",
             "data" : [
                [
                   "Raku",
                   2
                ]
             ],
-            "id" : "Simon Proctor"
+            "id" : "Simon Proctor",
+            "name" : "Simon Proctor"
          },
          {
-            "id" : "Ulrich Rieke",
+            "name" : "Ulrich Rieke",
             "data" : [
                [
                   "Perl",
@@ -422,7 +290,7 @@
                   2
                ]
             ],
-            "name" : "Ulrich Rieke"
+            "id" : "Ulrich Rieke"
          },
          {
             "data" : [