* New tree configuration of the project:

.../ ... + -- EO | | | | +-- src ----- + -- EDO | | | | +-- test + -- MO | | | | +-- tutorial + -- MOEO | | | | +-- doc + -- SMP | | | | ... + -- EOMPI | | + -- EOSERIAL Question for current maintainers: ./README: new release? Also: * Moving out eompi & eoserial modules (issue #2). * Correction of the errors when executing "make doc" command. * Adding a solution for the conflicting headers problem (see the two CMake Cache Values: PROJECT_TAG & PROJECT_HRS_INSTALL_SUBPATH) (issue #1) * Header inclusions: ** src: changing absolute paths into relative paths ('#include <...>' -> '#include "..."') ** test, tutorial: changing relative paths into absolute paths ('#include "..."' -> '#include <...>') * Moving out some scripts from EDO -> to the root * Add a new script for compilation and installation (see build_gcc_linux_install) * Compilation with uBLAS library or EDO module: now ok * Minor modifications on README & INSTALL files * Comment eompi failed tests with no end *** TODO: CPack (debian (DEB) & RedHat (RPM) packages) (issues #6 & #7) ***
2014-08-04 13:40:28 +02:00 · 2014-08-04 13:40:28 +02:00 · 490e837f7a
commit 490e837f7a
parent 515bd5943d
2359 changed files with 7688 additions and 16329 deletions
--- a/tutorial/eo/Parallelization/INSTALL
+++ b/tutorial/eo/Parallelization/INSTALL
@ -0,0 +1,63 @@
+How to install EoMPI
+====================
+
+Install OpenMpi
+---------------
+
+1) Download OpenMPI on their website or with the following command:
+
+    wget http://www.open-mpi.org/software/ompi/v1.6/downloads/openmpi-1.6.tar.bz2
+
+2) Untar the downloaded archive in a directory and change working directory to there:
+
+    tar -xvjf openmpi*.tar.bz2
+    cd openmpi-X.Y
+
+3) Use configuration script to indicate in which directory OpenMPI should be installed, and other options:
+
+Simplest configuration:
+    ./configure --prefix=/home/`whoami`/openmpi/
+
+Only static libraries:
+    ./configure --enable-static --disable-shared
+
+Only static libraries, with prefix, disable build for Fortran77 and Fortran90, add support for SGE:
+    ./configure --enable-static --disable-shared --prefix=/home/`whoami`/openmpi/ --disable-mpi-f77 --disable-mpi-f90 --with-sge
+
+Other options are available in the README file.
+
+4) Make it and install:
+
+In sequential:
+    make all install
+
+Or in parallel:
+    make -j 2 all
+    make install
+
+5) Try to compile and run the sample program:
+
+    ~/openmpi/bin/mpicxx -o sample mpi.c
+    ~/openmpi/bin/mpirun -np 3 ./sample
+
+Configure EO to use MPI
+-----------------------
+
+You only need to configure eo-conf.cmake so as to use MPI :
+
+1) Put the WITH_MPI boolean to true:
+
+    SET(WITH_MPI TRUE CACHE BOOL "Use mpi ?" FORCE)
+
+2) Indicate in which directories you have installed openmpi:
+
+    SET(MPI_DIR "/where/did/you/install/openmpi" CACHE PATH "OpenMPI directory" FORCE)
+
+3) Recompile eo:
+
+    ./distclean
+    ./build_gcc_linux_release.sh
+
+4) If you meet any issue, don't hesitate to contact the EO mailing list:
+
+    eodev-main@lists.sourceforge.net
--- a/tutorial/eo/Parallelization/css/deck.core.css
+++ b/tutorial/eo/Parallelization/css/deck.core.css
@ -0,0 +1,405 @@
+html {
+  height: 100%;
+}
+
+body.deck-container {
+  overflow-y: auto;
+  position: static;
+}
+
+.deck-container {
+  position: relative;
+  min-height: 100%;
+  margin: 0 auto;
+  padding: 0 48px;
+  font-size: 16px;
+  line-height: 1.25;
+  overflow: hidden;
+  /* Resets and base styles from HTML5 Boilerplate */
+  /* End HTML5 Boilerplate adaptations */
+}
+.js .deck-container {
+  visibility: hidden;
+}
+.ready .deck-container {
+  visibility: visible;
+}
+.touch .deck-container {
+  -webkit-text-size-adjust: none;
+  -moz-text-size-adjust: none;
+}
+.deck-container div, .deck-container span, .deck-container object, .deck-container iframe,
+.deck-container h1, .deck-container h2, .deck-container h3, .deck-container h4, .deck-container h5, .deck-container h6, .deck-container p, .deck-container blockquote, .deck-container pre,
+.deck-container abbr, .deck-container address, .deck-container cite, .deck-container code, .deck-container del, .deck-container dfn, .deck-container em, .deck-container img, .deck-container ins, .deck-container kbd, .deck-container q, .deck-container samp,
+.deck-container small, .deck-container strong, .deck-container sub, .deck-container sup, .deck-container var, .deck-container b, .deck-container i, .deck-container dl, .deck-container dt, .deck-container dd, .deck-container ol, .deck-container ul, .deck-container li,
+.deck-container fieldset, .deck-container form, .deck-container label, .deck-container legend,
+.deck-container table, .deck-container caption, .deck-container tbody, .deck-container tfoot, .deck-container thead, .deck-container tr, .deck-container th, .deck-container td,
+.deck-container article, .deck-container aside, .deck-container canvas, .deck-container details, .deck-container figcaption, .deck-container figure,
+.deck-container footer, .deck-container header, .deck-container hgroup, .deck-container menu, .deck-container nav, .deck-container section, .deck-container summary,
+.deck-container time, .deck-container mark, .deck-container audio, .deck-container video {
+  margin: 0;
+  padding: 0;
+  border: 0;
+  font-size: 100%;
+  font: inherit;
+  vertical-align: baseline;
+}
+.deck-container article, .deck-container aside, .deck-container details, .deck-container figcaption, .deck-container figure,
+.deck-container footer, .deck-container header, .deck-container hgroup, .deck-container menu, .deck-container nav, .deck-container section {
+  display: block;
+}
+.deck-container blockquote, .deck-container q {
+  quotes: none;
+}
+.deck-container blockquote:before, .deck-container blockquote:after, .deck-container q:before, .deck-container q:after {
+  content: "";
+  content: none;
+}
+.deck-container ins {
+  background-color: #ff9;
+  color: #000;
+  text-decoration: none;
+}
+.deck-container mark {
+  background-color: #ff9;
+  color: #000;
+  font-style: italic;
+  font-weight: bold;
+}
+.deck-container del {
+  text-decoration: line-through;
+}
+.deck-container abbr[title], .deck-container dfn[title] {
+  border-bottom: 1px dotted;
+  cursor: help;
+}
+.deck-container table {
+  border-collapse: collapse;
+  border-spacing: 0;
+}
+.deck-container hr {
+  display: block;
+  height: 1px;
+  border: 0;
+  border-top: 1px solid #ccc;
+  margin: 1em 0;
+  padding: 0;
+}
+.deck-container input, .deck-container select {
+  vertical-align: middle;
+}
+.deck-container select, .deck-container input, .deck-container textarea, .deck-container button {
+  font: 99% sans-serif;
+}
+.deck-container pre, .deck-container code, .deck-container kbd, .deck-container samp {
+  font-family: monospace, sans-serif;
+}
+.deck-container a {
+  -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
+}
+.deck-container a:hover, .deck-container a:active {
+  outline: none;
+}
+.deck-container ul, .deck-container ol {
+  margin-left: 2em;
+  vertical-align: top;
+}
+.deck-container ol {
+  list-style-type: decimal;
+}
+.deck-container nav ul, .deck-container nav li {
+  margin: 0;
+  list-style: none;
+  list-style-image: none;
+}
+.deck-container small {
+  font-size: 85%;
+}
+.deck-container strong, .deck-container th {
+  font-weight: bold;
+}
+.deck-container td {
+  vertical-align: top;
+}
+.deck-container sub, .deck-container sup {
+  font-size: 75%;
+  line-height: 0;
+  position: relative;
+}
+.deck-container sup {
+  top: -0.5em;
+}
+.deck-container sub {
+  bottom: -0.25em;
+}
+.deck-container textarea {
+  overflow: auto;
+}
+.ie6 .deck-container legend, .ie7 .deck-container legend {
+  margin-left: -7px;
+}
+.deck-container input[type="radio"] {
+  vertical-align: text-bottom;
+}
+.deck-container input[type="checkbox"] {
+  vertical-align: bottom;
+}
+.ie7 .deck-container input[type="checkbox"] {
+  vertical-align: baseline;
+}
+.ie6 .deck-container input {
+  vertical-align: text-bottom;
+}
+.deck-container label, .deck-container input[type="button"], .deck-container input[type="submit"], .deck-container input[type="image"], .deck-container button {
+  cursor: pointer;
+}
+.deck-container button, .deck-container input, .deck-container select, .deck-container textarea {
+  margin: 0;
+}
+.deck-container input:invalid, .deck-container textarea:invalid {
+  border-radius: 1px;
+  -moz-box-shadow: 0px 0px 5px red;
+  -webkit-box-shadow: 0px 0px 5px red;
+  box-shadow: 0px 0px 5px red;
+}
+.deck-container input:invalid .no-boxshadow, .deck-container textarea:invalid .no-boxshadow {
+  background-color: #f0dddd;
+}
+.deck-container button {
+  width: auto;
+  overflow: visible;
+}
+.ie7 .deck-container img {
+  -ms-interpolation-mode: bicubic;
+}
+.deck-container, .deck-container select, .deck-container input, .deck-container textarea {
+  color: #444;
+}
+.deck-container a {
+  color: #607890;
+}
+.deck-container a:hover, .deck-container a:focus {
+  color: #036;
+}
+.deck-container a:link {
+  -webkit-tap-highlight-color: #fff;
+}
+.deck-container.deck-loading {
+  display: none;
+}
+
+.slide {
+  width: auto;
+  min-height: 100%;
+  position: relative;
+}
+.slide h1 {
+  font-size: 4.5em;
+}
+.slide h1, .slide .vcenter {
+  font-weight: bold;
+  text-align: center;
+  padding-top: 1em;
+  max-height: 100%;
+}
+.csstransforms .slide h1, .csstransforms .slide .vcenter {
+  padding: 0 48px;
+  position: absolute;
+  left: 0;
+  right: 0;
+  top: 50%;
+  -webkit-transform: translate(0, -50%);
+  -moz-transform: translate(0, -50%);
+  -ms-transform: translate(0, -50%);
+  -o-transform: translate(0, -50%);
+  transform: translate(0, -50%);
+}
+.slide .vcenter h1 {
+  position: relative;
+  top: auto;
+  padding: 0;
+  -webkit-transform: none;
+  -moz-transform: none;
+  -ms-transform: none;
+  -o-transform: none;
+  transform: none;
+}
+.slide h2 {
+  font-size: 2.25em;
+  font-weight: bold;
+  padding-top: .5em;
+  margin: 0 0 .66666em 0;
+  border-bottom: 3px solid #888;
+}
+.slide h3 {
+  font-size: 1.4375em;
+  font-weight: bold;
+  margin-bottom: .30435em;
+}
+.slide h4 {
+  font-size: 1.25em;
+  font-weight: bold;
+  margin-bottom: .25em;
+}
+.slide h5 {
+  font-size: 1.125em;
+  font-weight: bold;
+  margin-bottom: .2222em;
+}
+.slide h6 {
+  font-size: 1em;
+  font-weight: bold;
+}
+.slide img, .slide iframe, .slide video {
+  display: block;
+  max-width: 100%;
+}
+.slide video, .slide iframe, .slide img {
+  display: block;
+  margin: 0 auto;
+}
+.slide p, .slide blockquote, .slide iframe, .slide img, .slide ul, .slide ol, .slide pre, .slide video {
+  margin-bottom: 1em;
+}
+.slide pre {
+  white-space: pre;
+  white-space: pre-wrap;
+  word-wrap: break-word;
+  padding: 1em;
+  border: 1px solid #888;
+}
+.slide em {
+  font-style: italic;
+}
+.slide li {
+  padding: .25em 0;
+  vertical-align: middle;
+}
+
+.deck-before, .deck-previous, .deck-next, .deck-after {
+  position: absolute;
+  left: -999em;
+  top: -999em;
+}
+
+.deck-current {
+  z-index: 2;
+}
+
+.slide .slide {
+  visibility: hidden;
+  position: static;
+  min-height: 0;
+}
+
+.deck-child-current {
+  position: static;
+  z-index: 2;
+}
+.deck-child-current .slide {
+  visibility: hidden;
+}
+.deck-child-current .deck-previous, .deck-child-current .deck-before, .deck-child-current .deck-current {
+  visibility: visible;
+}
+
+@media screen and (max-device-width: 480px) {
+  /* html { -webkit-text-size-adjust:none; -ms-text-size-adjust:none; } */
+}
+@media print {
+  * {
+    background: transparent !important;
+    color: black !important;
+    text-shadow: none !important;
+    filter: none !important;
+    -ms-filter: none !important;
+    -webkit-box-reflect: none !important;
+    -moz-box-reflect: none !important;
+    -webkit-box-shadow: none !important;
+    -moz-box-shadow: none !important;
+    box-shadow: none !important;
+  }
+  * :before, * :after {
+    display: none !important;
+  }
+
+  a, a:visited {
+    color: #444 !important;
+    text-decoration: underline;
+  }
+
+  a[href]:after {
+    content: " (" attr(href) ")";
+  }
+
+  abbr[title]:after {
+    content: " (" attr(title) ")";
+  }
+
+  .ir a:after, a[href^="javascript:"]:after, a[href^="#"]:after {
+    content: "";
+  }
+
+  pre, blockquote {
+    border: 1px solid #999;
+    page-break-inside: avoid;
+  }
+
+  thead {
+    display: table-header-group;
+  }
+
+  tr, img {
+    page-break-inside: avoid;
+  }
+
+  @page {
+    margin: 0.5cm;
+}
+
+  p, h2, h3 {
+    orphans: 3;
+    widows: 3;
+  }
+
+  h2, h3 {
+    page-break-after: avoid;
+  }
+
+  .slide {
+    position: static !important;
+    visibility: visible !important;
+    display: block !important;
+    -webkit-transform: none !important;
+    -moz-transform: none !important;
+    -o-transform: none !important;
+    -ms-transform: none !important;
+    transform: none !important;
+    opacity: 1 !important;
+  }
+
+  h1, .vcenter {
+    -webkit-transform: none !important;
+    -moz-transform: none !important;
+    -o-transform: none !important;
+    -ms-transform: none !important;
+    transform: none !important;
+    padding: 0 !important;
+    position: static !important;
+  }
+
+  .deck-container > .slide {
+    page-break-after: always;
+  }
+
+  .deck-container {
+    width: 100% !important;
+    height: auto !important;
+    padding: 0 !important;
+    display: block !important;
+  }
+
+  script {
+    display: none;
+  }
+}
--- a/tutorial/eo/Parallelization/css/deck.goto.css
+++ b/tutorial/eo/Parallelization/css/deck.goto.css
@ -0,0 +1,41 @@
+.deck-container .goto-form {
+  position: absolute;
+  z-index: 3;
+  bottom: 10px;
+  left: 50%;
+  height: 1.75em;
+  margin: 0 0 0 -9.125em;
+  line-height: 1.75em;
+  padding: 0.625em;
+  display: none;
+  background: #ccc;
+  overflow: hidden;
+}
+.borderradius .deck-container .goto-form {
+  -webkit-border-radius: 10px;
+  -moz-border-radius: 10px;
+  border-radius: 10px;
+}
+.deck-container .goto-form label {
+  font-weight: bold;
+}
+.deck-container .goto-form label, .deck-container .goto-form input {
+  display: inline-block;
+  font-family: inherit;
+}
+
+.deck-goto .goto-form {
+  display: block;
+}
+
+#goto-slide {
+  width: 8.375em;
+  margin: 0 0.625em;
+  height: 1.4375em;
+}
+
+@media print {
+  .goto-form, #goto-slide {
+    display: none !important;
+  }
+}
--- a/tutorial/eo/Parallelization/css/deck.hash.css
+++ b/tutorial/eo/Parallelization/css/deck.hash.css
@ -0,0 +1,13 @@
+.deck-container .deck-permalink {
+  display: none;
+  position: absolute;
+  z-index: 4;
+  bottom: 30px;
+  right: 0;
+  width: 48px;
+  text-align: center;
+}
+
+.no-history .deck-container:hover .deck-permalink {
+  display: block;
+}
--- a/tutorial/eo/Parallelization/css/deck.menu.css
+++ b/tutorial/eo/Parallelization/css/deck.menu.css
@ -0,0 +1,47 @@
+.deck-menu .slide {
+  background: #eee;
+  position: relative;
+  left: 0;
+  top: 0;
+  visibility: visible;
+  cursor: pointer;
+}
+.no-csstransforms .deck-menu > .slide {
+  float: left;
+  width: 22%;
+  height: 22%;
+  min-height: 0;
+  margin: 1%;
+  font-size: 0.22em;
+  overflow: hidden;
+  padding: 0 0.5%;
+}
+.csstransforms .deck-menu > .slide {
+  -webkit-transform: scale(0.22) !important;
+  -moz-transform: scale(0.22) !important;
+  -o-transform: scale(0.22) !important;
+  -ms-transform: scale(0.22) !important;
+  transform: scale(0.22) !important;
+  -webkit-transform-origin: 0 0;
+  -moz-transform-origin: 0 0;
+  -o-transform-origin: 0 0;
+  -ms-transform-origin: 0 0;
+  transform-origin: 0 0;
+  -webkit-box-sizing: border-box;
+  -moz-box-sizing: border-box;
+  box-sizing: border-box;
+  width: 100%;
+  height: 100%;
+  overflow: hidden;
+  padding: 0 48px;
+  margin: 12px;
+}
+.deck-menu iframe, .deck-menu img, .deck-menu video {
+  max-width: 100%;
+}
+.deck-menu .deck-current, .no-touch .deck-menu .slide:hover {
+  background: #ddf;
+}
+.deck-menu.deck-container:hover .deck-prev-link, .deck-menu.deck-container:hover .deck-next-link {
+  display: none;
+}
--- a/tutorial/eo/Parallelization/css/deck.navigation.css
+++ b/tutorial/eo/Parallelization/css/deck.navigation.css
@ -0,0 +1,43 @@
+.deck-container .deck-prev-link, .deck-container .deck-next-link {
+  display: none;
+  position: absolute;
+  z-index: 3;
+  top: 50%;
+  width: 32px;
+  height: 32px;
+  margin-top: -16px;
+  font-size: 20px;
+  font-weight: bold;
+  line-height: 32px;
+  vertical-align: middle;
+  text-align: center;
+  text-decoration: none;
+  color: #fff;
+  background: #888;
+}
+.borderradius .deck-container .deck-prev-link, .borderradius .deck-container .deck-next-link {
+  -webkit-border-radius: 16px;
+  -moz-border-radius: 16px;
+  border-radius: 16px;
+}
+.deck-container .deck-prev-link:hover, .deck-container .deck-prev-link:focus, .deck-container .deck-prev-link:active, .deck-container .deck-prev-link:visited, .deck-container .deck-next-link:hover, .deck-container .deck-next-link:focus, .deck-container .deck-next-link:active, .deck-container .deck-next-link:visited {
+  color: #fff;
+}
+.deck-container .deck-prev-link {
+  left: 8px;
+}
+.deck-container .deck-next-link {
+  right: 8px;
+}
+.deck-container:hover .deck-prev-link, .deck-container:hover .deck-next-link {
+  display: block;
+}
+.deck-container:hover .deck-prev-link.deck-nav-disabled, .touch .deck-container:hover .deck-prev-link, .deck-container:hover .deck-next-link.deck-nav-disabled, .touch .deck-container:hover .deck-next-link {
+  display: none;
+}
+
+@media print {
+  .deck-prev-link, .deck-next-link {
+    display: none !important;
+  }
+}
--- a/tutorial/eo/Parallelization/css/deck.scale.css
+++ b/tutorial/eo/Parallelization/css/deck.scale.css
@ -0,0 +1,28 @@
+/* Remove this line if you are embedding deck.js in a page and
+using the scale extension. */
+.csstransforms {
+  overflow: hidden;
+}
+
+.csstransforms .deck-container.deck-scale:not(.deck-menu) > .slide {
+  -webkit-box-sizing: padding-box;
+  -moz-box-sizing: padding-box;
+  box-sizing: padding-box;
+  width: 100%;
+  padding-bottom: 20px;
+}
+.csstransforms .deck-container.deck-scale:not(.deck-menu) > .slide > .deck-slide-scaler {
+  -webkit-transform-origin: 50% 0;
+  -moz-transform-origin: 50% 0;
+  -o-transform-origin: 50% 0;
+  -ms-transform-origin: 50% 0;
+  transform-origin: 50% 0;
+}
+
+.csstransforms .deck-container.deck-menu .deck-slide-scaler {
+  -webkit-transform: none !important;
+  -moz-transform: none !important;
+  -o-transform: none !important;
+  -ms-transform: none !important;
+  transform: none !important;
+}
--- a/tutorial/eo/Parallelization/css/deck.status.css
+++ b/tutorial/eo/Parallelization/css/deck.status.css
@ -0,0 +1,18 @@
+.deck-container .deck-status {
+  position: absolute;
+  bottom: 10px;
+  right: 5px;
+  color: #888;
+  z-index: 3;
+  margin: 0;
+}
+
+body.deck-container .deck-status {
+  position: fixed;
+}
+
+@media print {
+  .deck-status {
+    display: none;
+  }
+}
--- a/tutorial/eo/Parallelization/css/eompi.css
+++ b/tutorial/eo/Parallelization/css/eompi.css
@ -0,0 +1,9 @@
+.changed
+{
+    color: green;
+}
+
+.specific
+{
+    color: red;
+}
--- a/tutorial/eo/Parallelization/css/horizontal-slide.css
+++ b/tutorial/eo/Parallelization/css/horizontal-slide.css
@ -0,0 +1,76 @@
+.csstransitions.csstransforms {
+  overflow-x: hidden;
+}
+.csstransitions.csstransforms .deck-container > .slide {
+  -webkit-transition: -webkit-transform 500ms ease-in-out;
+  -moz-transition: -moz-transform 500ms ease-in-out;
+  -ms-transition: -ms-transform 500ms ease-in-out;
+  -o-transition: -o-transform 500ms ease-in-out;
+  transition: transform 500ms ease-in-out;
+}
+.csstransitions.csstransforms .deck-container:not(.deck-menu) > .slide {
+  position: absolute;
+  top: 0;
+  left: 0;
+  -webkit-box-sizing: border-box;
+  -moz-box-sizing: border-box;
+  box-sizing: border-box;
+  width: 100%;
+  padding: 0 48px;
+}
+.csstransitions.csstransforms .deck-container:not(.deck-menu) > .slide .slide {
+  position: relative;
+  left: 0;
+  top: 0;
+  -webkit-transition: -webkit-transform 500ms ease-in-out, opacity 500ms ease-in-out;
+  -moz-transition: -moz-transform 500ms ease-in-out, opacity 500ms ease-in-out;
+  -ms-transition: -ms-transform 500ms ease-in-out, opacity 500ms ease-in-out;
+  -o-transition: -o-transform 500ms ease-in-out, opacity 500ms ease-in-out;
+  transition: -webkit-transform 500ms ease-in-out, opacity 500ms ease-in-out;
+}
+.csstransitions.csstransforms .deck-container:not(.deck-menu) > .slide .deck-next, .csstransitions.csstransforms .deck-container:not(.deck-menu) > .slide .deck-after {
+  visibility: visible;
+  -webkit-transform: translate3d(200%, 0, 0);
+  -moz-transform: translate(200%, 0);
+  -ms-transform: translate(200%, 0);
+  -o-transform: translate(200%, 0);
+  transform: translate3d(200%, 0, 0);
+}
+.csstransitions.csstransforms .deck-container:not(.deck-menu) > .deck-previous {
+  -webkit-transform: translate3d(-200%, 0, 0);
+  -moz-transform: translate(-200%, 0);
+  -ms-transform: translate(-200%, 0);
+  -o-transform: translate(-200%, 0);
+  transform: translate3d(-200%, 0, 0);
+}
+.csstransitions.csstransforms .deck-container:not(.deck-menu) > .deck-before {
+  -webkit-transform: translate3d(-400%, 0, 0);
+  -moz-transform: translate(-400%, 0);
+  -ms-transform: translate(-400%, 0);
+  -o-transform: translate(-400%, 0);
+  transform: translate3d(-400%, 0, 0);
+}
+.csstransitions.csstransforms .deck-container:not(.deck-menu) > .deck-next {
+  -webkit-transform: translate3d(200%, 0, 0);
+  -moz-transform: translate(200%, 0);
+  -ms-transform: translate(200%, 0);
+  -o-transform: translate(200%, 0);
+  transform: translate3d(200%, 0, 0);
+}
+.csstransitions.csstransforms .deck-container:not(.deck-menu) > .deck-after {
+  -webkit-transform: translate3d(400%, 0, 0);
+  -moz-transform: translate(400%, 0);
+  -ms-transform: translate(400%, 0);
+  -o-transform: translate(400%, 0);
+  transform: translate3d(400%, 0, 0);
+}
+.csstransitions.csstransforms .deck-container:not(.deck-menu) > .deck-before .slide, .csstransitions.csstransforms .deck-container:not(.deck-menu) > .deck-previous .slide {
+  visibility: visible;
+}
+.csstransitions.csstransforms .deck-container:not(.deck-menu) > .deck-child-current {
+  -webkit-transform: none;
+  -moz-transform: none;
+  -ms-transform: none;
+  -o-transform: none;
+  transform: none;
+}
--- a/tutorial/eo/Parallelization/css/shjs.css
+++ b/tutorial/eo/Parallelization/css/shjs.css
@ -0,0 +1,67 @@
+pre.sh_sourceCode {
+  background-color: white;
+  color: black;
+  font-style: normal;
+  font-weight: normal;
+}
+
+pre.sh_sourceCode .sh_keyword { color: blue; font-weight: bold; }           /* language keywords */
+pre.sh_sourceCode .sh_type { color: darkgreen; }                            /* basic types */
+pre.sh_sourceCode .sh_usertype { color: teal; }                             /* user defined types */
+pre.sh_sourceCode .sh_string { color: red; font-family: monospace; }        /* strings and chars */
+pre.sh_sourceCode .sh_regexp { color: orange; font-family: monospace; }     /* regular expressions */
+pre.sh_sourceCode .sh_specialchar { color: pink; font-family: monospace; }  /* e.g., \n, \t, \\ */
+pre.sh_sourceCode .sh_comment { color: brown; font-style: italic; }         /* comments */
+pre.sh_sourceCode .sh_number { color: purple; }                             /* literal numbers */
+pre.sh_sourceCode .sh_preproc { color: darkblue; font-weight: bold; }       /* e.g., #include, import */
+pre.sh_sourceCode .sh_symbol { color: darkred; }                            /* e.g., <, >, + */
+pre.sh_sourceCode .sh_function { color: black; font-weight: bold; }         /* function calls and declarations */
+pre.sh_sourceCode .sh_cbracket { color: red; }                              /* block brackets (e.g., {, }) */
+pre.sh_sourceCode .sh_todo { font-weight: bold; background-color: cyan; }   /* TODO and FIXME */
+
+/* Predefined variables and functions (for instance glsl) */
+pre.sh_sourceCode .sh_predef_var { color: darkblue; }
+pre.sh_sourceCode .sh_predef_func { color: darkblue; font-weight: bold; }
+
+/* for OOP */
+pre.sh_sourceCode .sh_classname { color: teal; }
+
+/* line numbers (not yet implemented) */
+pre.sh_sourceCode .sh_linenum { color: black; font-family: monospace; }
+
+/* Internet related */
+pre.sh_sourceCode .sh_url { color: blue; text-decoration: underline; font-family: monospace; }
+
+/* for ChangeLog and Log files */
+pre.sh_sourceCode .sh_date { color: blue; font-weight: bold; }
+pre.sh_sourceCode .sh_time, pre.sh_sourceCode .sh_file { color: darkblue; font-weight: bold; }
+pre.sh_sourceCode .sh_ip, pre.sh_sourceCode .sh_name { color: darkgreen; }
+
+/* for Prolog, Perl... */
+pre.sh_sourceCode .sh_variable { color: darkgreen; }
+
+/* for LaTeX */
+pre.sh_sourceCode .sh_italics { color: darkgreen; font-style: italic; }
+pre.sh_sourceCode .sh_bold { color: darkgreen; font-weight: bold; }
+pre.sh_sourceCode .sh_underline { color: darkgreen; text-decoration: underline; }
+pre.sh_sourceCode .sh_fixed { color: green; font-family: monospace; }
+pre.sh_sourceCode .sh_argument { color: darkgreen; }
+pre.sh_sourceCode .sh_optionalargument { color: purple; }
+pre.sh_sourceCode .sh_math { color: orange; }
+pre.sh_sourceCode .sh_bibtex { color: blue; }
+
+/* for diffs */
+pre.sh_sourceCode .sh_oldfile { color: orange; }
+pre.sh_sourceCode .sh_newfile { color: darkgreen; }
+pre.sh_sourceCode .sh_difflines { color: blue; }
+
+/* for css */
+pre.sh_sourceCode .sh_selector { color: purple; }
+pre.sh_sourceCode .sh_property { color: blue; }
+pre.sh_sourceCode .sh_value { color: darkgreen; font-style: italic; }
+
+/* other */
+pre.sh_sourceCode .sh_section { color: black; font-weight: bold; }
+pre.sh_sourceCode .sh_paren { color: red; }
+pre.sh_sourceCode .sh_attribute { color: darkgreen; }
+
--- a/tutorial/eo/Parallelization/css/thales.css
+++ b/tutorial/eo/Parallelization/css/thales.css
@ -0,0 +1,91 @@
+.deck-container em {
+    color:rgb(255,115,0);
+}
+
+.deck-container s {
+    color:rgb(180,180,211);
+}
+
+.deck-container {
+  font-family: "Helvetica Neue", sans-serif;
+  font-size: 1.75em;
+  color:RGB(50,50,101);
+  background:white url("./img/thales.jpg") no-repeat fixed bottom left;
+}
+.deck-container .slide {
+}
+.deck-container .slide h1 {
+  color:rgb(50,50,101);
+}
+.deck-container .slide h2 {
+  color:rgb(255,115,0);
+  border-bottom-color:lightgray;
+}
+.deck-container .slide h3 {
+  color:RGB(57,138,199);
+}
+.deck-container .slide pre {
+  border-color: #ccc;
+}
+.deck-container .slide blockquote {
+  font-size: 2em;
+  font-style: italic;
+  padding: 1em 2em;
+  color: #000;
+  border-left: 5px solid #ccc;
+  font-family:serif;
+}
+.deck-container .slide blockquote p {
+  margin: 0;
+}
+.deck-container .slide blockquote cite {
+  font-size: .5em;
+  font-style: normal;
+  font-weight: bold;
+  color: #888;
+}
+.deck-container .slide ::-moz-selection {
+  background: #c00;
+  color: #fff;
+}
+.deck-container .slide ::selection {
+  background: #c00;
+  color: #fff;
+}
+.deck-container .slide a, .deck-container .slide a:hover, .deck-container .slide a:focus, .deck-container .slide a:active, .deck-container .slide a:visited {
+  color:RGB(152,191,12);
+  text-decoration: none;
+}
+.deck-container .slide a:hover, .deck-container .slide a:focus {
+  text-decoration: underline;
+}
+.deck-container > .slide .deck-before, .deck-container > .slide .deck-previous {
+  opacity: 0.4;
+}
+.deck-container > .slide .deck-before:not(.deck-child-current) .deck-before, .deck-container > .slide .deck-before:not(.deck-child-current) .deck-previous, .deck-container > .slide .deck-previous:not(.deck-child-current) .deck-before, .deck-container > .slide .deck-previous:not(.deck-child-current) .deck-previous {
+  opacity: 1;
+}
+.deck-container > .slide .deck-child-current {
+  opacity: 1;
+}
+.deck-container .deck-prev-link, .deck-container .deck-next-link {
+  background: #ccc;
+  font-family: serif;
+}
+.deck-container .deck-prev-link, .deck-container .deck-prev-link:hover, .deck-container .deck-prev-link:focus, .deck-container .deck-prev-link:active, .deck-container .deck-prev-link:visited, .deck-container .deck-next-link, .deck-container .deck-next-link:hover, .deck-container .deck-next-link:focus, .deck-container .deck-next-link:active, .deck-container .deck-next-link:visited {
+  color: #fff;
+}
+.deck-container .deck-prev-link:hover, .deck-container .deck-prev-link:focus, .deck-container .deck-next-link:hover, .deck-container .deck-next-link:focus {
+  background: #c00;
+  text-decoration: none;
+}
+.deck-container .deck-status {
+  font-size: 0.6666em;
+}
+.deck-container.deck-menu .slide {
+  background: #eee;
+}
+.deck-container.deck-menu .deck-current, .no-touch .deck-container.deck-menu .slide:hover {
+  background: #ddf;
+}
+
--- a/tutorial/eo/Parallelization/eompi.html
+++ b/tutorial/eo/Parallelization/eompi.html
@ -0,0 +1,903 @@
+<!DOCTYPE html>
+<!--[if lt IE 7]> <html class="no-js ie6" lang="en"> <![endif]-->
+<!--[if IE 7]>    <html class="no-js ie7" lang="en"> <![endif]-->
+<!--[if IE 8]>    <html class="no-js ie8" lang="en"> <![endif]-->
+<!--[if gt IE 8]><!-->  <html class="no-js" lang="en"> <!--<![endif]-->
+<head>
+	<meta charset="utf-8">
+	<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
+	
+	<title>EO::MPI parallelization</title>
+	
+	<meta name="description" content="A short presentation on EO::MPI parallelization">
+	<meta name="author" content="Benjamin BOUVIER">
+	<meta name="viewport" content="width=1024, user-scalable=no">
+	
+	<!-- Core and extension CSS files -->
+	<link rel="stylesheet" href="css/deck.core.css">
+	<link rel="stylesheet" href="css/deck.goto.css">
+	<link rel="stylesheet" href="css/deck.menu.css">
+	<link rel="stylesheet" href="css/deck.navigation.css">
+    <link rel="stylesheet" href="css/deck.status.css">
+	<link rel="stylesheet" href="css/deck.hash.css">
+	<link rel="stylesheet" href="css/deck.scale.css">
+	
+	<!-- Style theme. More available in /themes/style/ or create your own. -->
+    <!-- <link rel="stylesheet" href="../themes/style/web-2.0.css"> -->
+	<link rel="stylesheet" href="css/thales.css">
+	<link rel="stylesheet" href="css/eompi.css">
+    
+
+    <!-- highlight js -->
+    <link rel="stylesheet" href="css/shjs.css">
+	
+	<!-- Transition theme. More available in /themes/transition/ or create your own. -->
+	<link rel="stylesheet" href="css/horizontal-slide.css">
+	
+	<script src="js/modernizr.custom.js"></script>
+</head>
+
+<body class="deck-container">
+
+<!-- Begin slides -->
+<section class="slide" id="title-slide">
+    <h1>EO's Parallelization with MPI</h1>
+</section>
+
+<section class="slide">
+    <h2>What is parallelization?</h2>
+    <ul>
+        <li><h3>Divide and Conquer paradigm</h3>
+            <p>A difficult problem can be splitted into simpler sub problems.</p>
+            <p>Therefore the sub problems should be solved faster.</p>
+        </li>
+        <li class="slide"><h3>Parallelize.</h3>
+        <p>Process serveral tasks together (<em>concurrent programming</em>).</p>
+            <p>By different ways :
+                <ul>
+                    <li><em>Shared memory</em> : Multitask, OpenMP, etc.</li>
+                    <li><em>Message Passing Interface</em> : MPI.</li>
+                    <li>Other ways, undetailed here: <em>coroutines</em>, <em>multi-thread / LightWeightProcess</em>,
+                    <em>Field Programmable Gate Array (FPGA)</em>, <em>General Purpose GPU (GPGPU)</em>, etc.</li>
+                </ul>
+            </p>
+        </li>
+    </ul>
+</section>
+
+<section class="slide">
+    <h2>Shared memory (e.g : OpenMP)</h2>
+    <ul>
+        <li class="slide"><strong>Multicore</strong> : more than one core per processor.
+            <ul>
+                <li>Processes several instruction streams together, each one manipulating different datas.</li>
+                <li>Different from <em>superscalar</em> processors, which can process more than one instruction during a
+                single processor cycle.</li>
+                <li>A multicore processor can however be superscalar.</li>
+                <li>For instance : <em>IBM's Cell microprocessor (PlayStation3)</em></li>
+            </ul>
+        </li>
+
+        <li class="slide"><strong>Symmetric multiprocessing</strong> : More than one processor which communicate through
+        a specific bus.
+            <ul>
+                <li><em>Bus contention</em> is the principal limitating factor.</li>
+            </ul>
+        </li>
+
+        <li class="slide">The main drawback is explicitly contained in the name.
+            <ul>
+                <li>Memory is <em>shared</em></li>
+                <li>Bus contention?</li>
+                <li>Low memory?</li>
+                <li>Use of virtual memory (swap) and page faults?</li>
+                <li>=> Can slow the speedup compared with the number of processors.</li>
+            </ul>
+        </li>
+    </ul>
+</section>
+
+<section class="slide">
+    <h2>Message Passing Interface (e.g : OpenMPI)</h2>
+    <p>Memory isn't shared here, manipulated objects are sent on a network: there is communication between the machines
+    (called <em>hosts</em>)</p>
+    <ul>
+        <li><strong>Cluster</strong>
+        <ul class="slide">
+            <li>Several machines network connected (for instance, in an Ethernet network).</li>
+            <li>Can have different specifications, but this can affect load balancing.</li>
+            <li>Most of the <em>supercomputers</em> are clusters.</li>
+            <li>For exemple : Beowulf Cluster, Sun Grid Engine...</li>
+        </ul>
+        </li>
+
+        <li><strong>Massive parallel processing</strong>
+        <ul class="slide">
+            <li>This is not machines but processors which are directly connected by network.</li>
+            <li>Like a cluster, but the networks are specific, so as to wire more processors.</li>
+        </ul>
+        </li>
+
+        <li><strong>Grid (a.k.a Distributed Computing)</strong>
+        <ul class="slide">
+            <li>Networks with potentially high latence and low bandwith, like Internet.</li>
+            <li>Example of programs : BOINC, Seti@home...</li>
+        </ul>
+        </li>
+    </ul>
+</section>
+
+<section class="slide">
+    <h1>Parallelization myths</h1>
+</section>
+
+<section class="slide">
+    <h2>A myth about speed: the car's enigma</h2>
+    <ul>
+        <li class="slide">If a car has to travel 100 Km, but has yet traveled 60 Km in 1 hour (i.e it has an average
+        speed of 60 Km per hour), what is its maximal average speed on the whole traject
+        ?</li>
+
+        <p><img src="http://www.canailleblog.com/photos/blogs/chevaux-trop-rigolo-229540.jpg" /></p>
+        <li class="slide">Some hints:
+            <ul>
+                <li>The driver can use all the hilarious gas (N<sub>2</sub>O, nitrous oxyde, a.k.a <em>nitro</em>) he
+                needs.</li>
+                <li>Let's suppose even that the car can travel at speed of light, or teleport (despite general theory of
+                relativity).</li>
+            </ul>
+        </li>
+
+        <li class="slide">The solution: <strong>100 Km/h</strong></li>
+        <li class="slide">The explanation: let's suppose that the car teleports after the first 60 Km. It would have
+        traveled 60 Km in 1 hour and 40 Km in 0 seconds, which is 100 Km in 1 hour: 100 Km/h.</li>
+    </ul>
+</section>
+
+<section class="slide">
+    <h2>A myth about speed: "Il dit qu'il voit pas le rapport ?"</h2>
+    <p><img src="http://r.linter.fr/questionnaire/document/image/250/7241.jpg" /></p>
+    <ul class="slide">
+        <li>Let P be the parallelizable proportion of the program (~ the remaining distance to travel), which can be
+        processed by N machines.</li>
+        <li>Then 1 - P is the sequential (non parallelizable) proportion of the program (~ the already traveled distance), which
+        can be processed by 1 machine.</li>
+        <li>A sequential version would take 1 - P + P = 1 unit (of time) to terminate.</li>
+        <li>A parallel version would take (1-P) + P / N units to terminate.</li>
+        <li>The <em>speedup</em> (gain of speed) would then be:
+            <img src="http://upload.wikimedia.org/wikipedia/en/math/f/4/0/f40f1968282e110c7e65222d2b5d3115.png"
+            style="height:100px;"/>
+        which tends to 1-P as N tends to infinity.</li>
+        <li>The maximal theoritical speedup (~ maximal average speed) would then be 1 / (1-P)</li>
+        <li><h3>This result is known as Amdahl's law</h3></li>
+    </ul>
+</section>
+
+<section class="slide">
+    <h2>A myth about data : the cat's enigma</h2>
+    <ul>
+        <li class="slide">
+            <p>If 3 cats catch 3 mices in 3 minutes, how many cats are needed to catch 9 mices in 9
+            minutes ?
+            <img src="http://www.creabar.com/photo/Animaux/ggq91fch.jpg" />
+            </p>
+        </li>
+        <li class="slide">The solution: 3 too !</li>
+        <li class="slide">A better question to ask would be: how many mices can catch 9 cats in 3 minutes ?</li>
+    </ul>
+</section>
+
+<section class="slide">
+    <h2>A myth about data</h2>
+    <ul>
+        <li>The idea is no more to make a processing faster (for a constant amount of data) but to process more data (in
+        the same time).</li>
+        <li>In this case, the most hosts we add, the most data we can process at a time.</li>
+        <li>This doesn't contradict Amdahl's Law, which makes the assumption that the amount of data to process stays
+        the same.</li>
+        <li>There is also another way to calculate speedup here:
+            <img src="http://upload.wikimedia.org/wikipedia/en/math/1/9/f/19f6e664e94fbcaa0f5877d74b6bffcd.png"
+            style="height: 50px;" />
+            where P is the number of processes, alpha the non parallelizable part of the program.
+        </li>
+        <li><h3>This result is known as the Gustafson's Law</h3></li>
+    </ul>
+</section>
+
+<section class="slide">
+    <h2>A metric: speedup</h2>
+    <ul>
+        <li><strong>Speedup</strong> refers to how much a parallel algorithm is faster than a corresponding sequential algorithm</li>
+        <li>It's a quantitative mesure, relative to the sequential version :
+            <img src="http://upload.wikimedia.org/wikipedia/en/math/a/8/0/a8080d5bd23d7ba57a9cf4fedcefadad.png"
+            style="height:100px;"/>
+            where T<sub>1</sub> is the time taken by the sequential version and T<sub>p</sub> the time taken by the parallel version with p
+            processes.
+        </li>
+        <li>A speedup equal to one indicates that the version is as performant as the sequential version.</li>
+        <li>Practically, speedup may not be linear in number of processes (Amdahl's Law)</li>
+    </ul>
+</section>
+
+<section class="slide">
+    <h1>Parallelization in EO</h1>
+</section>
+
+<section class="slide">
+    <h2>Objectives</h2>
+    <ul>
+        <li>Remember, tasks have to be independant from one to another.</li>
+        <li>Process data faster: what takes time in EO?
+            <ul class="slide">
+                <li>Evaluation!</li>
+            </ul>
+        </li>
+        <li>Process more data during the same time: where?
+            <ul class="slide">
+                <li>Multi-start!</li>
+            </ul>
+        </li>
+        <li>Other objectives :
+            <ul>
+                <li>Readily serialize EO objects.</li>
+                <li>Be able to easily implement other parallel algorithms.</li>
+            </ul>
+        </li>
+    </ul>
+</section>
+
+<section class="slide">
+    <h2>Evaluation: Long story short</h2>
+    <pre class="sh_cpp"><code>
+    int main( int argc, char **argv )
+    {
+        eo::mpi::Node::init( argc, argv );
+        // PUT EO STUFF HERE
+        // Let's make the assumption that pop is a eoPop&lt;EOT&gt;
+        // and evalFunc is an evaluation functor
+        eo::mpi::DynamicAssignmentAlgorithm assign;
+        eoParallelPopLoopEval&lt;EOT&gt; popEval( assign, eo::mpi::DEFAULT_MASTER, evalFunc );
+        popEval( pop, pop );
+    }
+    </code></pre>
+</section>
+
+<section class="slide">
+    <h2>Serializing EO objects</h2>
+    <ul>
+        <li>Serializing is writing a message from a binary source into a message transmissible data.</li>
+        <li>Several formats can be used
+            <ul class="slide">
+                <li>Binary directly - but all the hosts have to be the same!</li>
+                <li>Text based formats: XML, YAML, JSON,...</li>
+            </ul>
+        </li>
+        <li>So why use text?
+            <ul class="slide">
+                <li>It's human readable, more or less easily parsable.</li>
+                <li>It's independant from the data type representations on the machines (e.g: an int on a 32 bits and on
+                a 64 bits machines are not the same).</li>
+                <li>Main drawbacks: it takes more space and it needs a processing for encoding and decoding.</li>
+            </ul>
+        </li>
+    </ul>
+</section>
+
+<section class="slide">
+    <h2>eoserial : principle</h2>
+    <img src="./img/serialisation.png" style="float:left;margin-right:25px;" />
+    <ul>
+        <li>JSON serialization
+            <ul class="slide">
+                <li>Lighter than XML.</li>
+                <li>Easily parsable, the grammar is trivial.</li>
+                <li>Allows to represent tables, objects and texts: it's sufficient!</li>
+            </ul>
+        </li>
+        <li>What happens in your life when you're serializable?
+        </li>
+        <li>Implement interface eoserial::Persistent and your object can be saved and loaded, in JSON format.</li>
+        <li>No need to serialize the whole object, you choose what you need to save and load.</li>
+        <li>Everything can be serialized!<ul class="slide">
+            <li>Atomic types are directly serialized into eoserial::String (thanks to std::stringstream)</li>
+            <li>Arrays are serializable (into eoserial::Array), if what they contain is too.</li>
+            <li>Object can be serializable (into eoserial::Object), if what they contain is too.</li>
+        </ul></li>
+    </ul>
+</section>
+
+<section class="slide">
+    <h2>eoserial : interface eoserial::Persistent</h2>
+    <pre class="sh_cpp">
+    <code>
+    # include &lt;serial/eoSerial.h&gt;
+
+    class MyObject : public eoserial::Persistent {
+        public:
+
+        // A persistent class needs a default empty ctor.
+        MyObject() {}
+
+        int id;
+
+        // Implementation of eoserial::Persistent::pack
+        // What to save when making a serialized object?
+        eoserial::Object* pack() const
+        {
+            eoserial::Object* obj = new eoserial::Object;
+            // eoserial::make creates a eoserial::String from a basic type
+            eoserial::String* idAsString = eoserial::make( id );
+            // the key "saved_id" will be associated to the JSON object idAsString
+            obj->add( "saved_id", idAsString );
+            // could have be done with
+            // (*obj)["saved_id"] = idAsString;
+            // as obj is a std::map pointer
+            return obj;
+        }
+
+        // Implementation of eoserial::Persistent::unpack
+        // What data to retrieve from a JSON object and where to put it?
+        void unpack(const eoserial::Object* json)
+        {
+            // retrieves the value from key "saved_id" in "*json" object and put it into member "id"
+            eoserial::unpack( *json, "saved_id" , id );
+        }
+    };
+    </code>
+    </pre>
+</section>
+
+<section class="slide">
+    <h2>eoserial : use it</h2>
+    <pre class="sh_cpp">
+    <code>
+# include &lt;eoSerial.h&gt;
+# include &lt;fstream&gt;
+# include &lt;cassert&gt;
+
+    int main(void)
+    {
+        MyObject instance;
+        instance.id = 42;
+
+        // Writes
+        eoserial::Object* obj = instance.pack();
+        std::ofstream ofile("filename");
+        obj->print( ofile );
+        ofile.close();
+        delete obj;
+
+        // Reads
+        std::ifstream ifile("filename");
+        std::stringstream ss;
+        while( ifile )
+        {
+            std::string s;
+            ifile &gt;&gt; s;
+            ss &lt;&lt; s;
+        }
+        eoserial::Object* objCopy = eoserial::Parser::parse( ss.str() );
+        MyObject instanceCopy;
+        instanceCopy.unpack( objCopy );
+
+        assert( instanceCopy.id == instance.id );
+
+        return 0;
+    }
+    </code>
+    </pre>
+</section>
+
+<section class="slide">
+    <h2>eoserial : more complex uses</h2>
+    <pre class="sh_cpp"><code>
+    struct ComplexObject
+    {
+        bool someBooleanValue; // will be serialized into a string
+        MyObject obj; // Objects can contain other objects too
+        std::vector&lt;int&gt;; // and tables too!
+    };
+
+    int main(void)
+    {
+        ComplexObject co;
+        // let's imagine we've set values of co.
+        eoserial::Object* json = new eoserial::Object;
+        // serialize basic type
+        (*json)["some_boolean_value"] = eoserial::make( co.someBooleanValue );
+        // MyObject is Persistent, so eoserial knows how to serialize it
+        json->add( "my_object", &co.obj );
+        // Instead of having a "for" loop, let's automatically serialize the content of the array
+        json->add( "int_array",
+            eoserial::makeArray&lt; std::vector&lt;int&gt;, eoserial::MakeAlgorithm &gt;( co.array ) );
+        // Print everything on the standard output
+        json->print( std::cout );
+        delete json;
+        return 0;
+    }
+    </code></pre>
+</section>
+
+<section class="slide">
+    <h2>MPI</h2>
+    <ul>
+        <li>We know how to serialize our objects. Now, we need to transmit them over the network.</li>
+        <li><strong>Message Passing Interface</strong> (MPI) is a norm.</li>
+        <li>OpenMPI implements it, in C, in the SPMD (Single Program Multiple Data) fashion. It is an active community
+        and the library is very well documented.</li>
+        <li>Boost::mpi gives it a C++ flavour (and tests each status code returned by MPI calls, throwing up exceptions
+        instead).</li>
+        <li>MPI helps by:
+            <ul class="slide">
+                <li>Managing the administration of roles: each MPI process has a <em>rank</em> and knows the whole
+                <em>size</em> of the cluster.</li>
+                <li>Regrouping outputs of different processes into one single output.</li>
+                <li>Managing the routing of messages and connections between the processes.</li>
+                <li>Launch a given number of processes via SSH, or a cluster engine (like SGE).</li>
+            </ul>
+        </li>
+        <li>MPI doesn't deal with:
+            <ul class="slide">
+                <li>Debugging: if one of your program segfaults, buy a parallel debugger or... Good luck!</li>
+                <li>More generally, knowing what happens: even the standard output becomes a shared resource without any
+                protection!</li>
+            </ul>
+        </li>
+    </ul>
+</section>
+
+<section class="slide">
+    <h1>Design of parallel algorithms</h1>
+</section>
+
+<section class="slide">
+    <h2>Some vocabulary</h2>
+    <ul>
+        <li>In the most of cases, we want the results to be retrieved in one place. Besides, communication in MPI is
+        synchronous (it's a design choice making things are simpler).</li>
+        <li>One process will have particular responsabilities, like aggregating results: it's the <strong>master</strong>.</li>
+        <li>Other processes will be used to do the processing (it's the goal, after all?) : they're the
+        <strong>workers</strong>. Or <strong>slaves</strong>, but it may be <em>patronizing</em> and the master is rarely called
+        the <em>patron</em>.</li>
+        <li>As there is one master, the algorithm is said to be <strong>centralized</strong>. Some well-known parallel algorithms
+        use this paradigm: <em>Google's MapReduce</em>, <em>Apache's Hadoop</em>(free implementation of Google's one :-)),...</li>
+        <li>A <strong>job</strong> is the parallel algorithm seen in its globality (i.e., as a function).</li>
+        <li>A job is a set of <strong>tasks</strong>, which are the atomic, decomposed part which can be serialized and
+        processed by a worker, at a time.</li>
+    </ul>
+</section>
+
+<section class="slide">
+    <h2>Evaluation (1/2)</h2>
+    <p>
+        Let's see how we could implement our parallelized evaluation<br/>
+        It's feasible as evaluating an individual is independant from evaluating another one.<br/>
+        <pre><code>
+        // On master side
+        function parallel_evaluate( population p )
+            foreach individual i in p,
+                send i to a worker
+                if there is no available worker,
+                    wait for any response (return)
+                    and retry
+                endif
+            endforeach
+            inform all the available workers that they are done (yes, it's a centralized algorithm)
+            wait for all remaining responses
+        endfunction
+
+        when receiving a response:
+            replace the evaluated individual in the population
+
+        // On worker side
+        function parallel_evaluate( evaluation function f )
+            wait for a individual i
+            apply f on it
+            send i to the master
+        endfunction
+        </code></pre>
+    </p>
+</section>
+
+<section class="slide">
+    <h2>Evaluation (2/2)</h2>
+    <p>But a parallelization algorithm is interesting only if the process time is higher than the
+    communication time. If process time is too short relatively to the communication time, we can do the following:
+        <pre><code>
+        // On master side<span class="changed">
+        function parallel_evaluate( population p, number of elements to send each time packet_size )
+            index = 0
+            while index &lt; size
+                sentSize := how many individuals (&lt;= packet_size) can we send to a worker?
+                find a worker. If there is no one, wait for any response (return) and retry
+                send the sentSize to the worker
+                send the individuals to the worker
+                index += sentSize
+            endwhile</span>
+            inform all the available workers that they're done
+            wait for all remaining responses
+        endfunction
+
+        when receiving a response:
+            replace the evaluated individuals in the population
+
+        // On worker side
+        function parallel_evaluate( evaluation function f )
+        <span class="changed">size := wait for a sentSize as described above
+            individuals := wait for size individuals
+            apply f on each of them
+            send back the individuals</span>
+        endfunction
+        </code></pre>
+</section>
+
+<section class="slide">
+    <h2>Multi start</h2>
+    <p>The idea behing multi-start is to run many times the same algorithm (for instance, eoEasyEA), but with different
+    seeds: the workers launch the algorithm and send their solutions as they come to the master, which saves the
+    ultimate best solution.</p>
+    <pre>
+        // On master side
+        variable best_score (initialized at the worst value ever) // score can be fitness, for instance
+
+        function parallel_multistart( integer runs )
+            seeds = table of generated seeds, or fixed seeds, whose size is at least "runs"
+            for i := 0; i &lt; runs; ++i
+                find a worker. If there is no one, wait for any response (return) and retry
+                send to the worker a different seed
+            endfor
+            inform all the available workers that they're done
+            wait for all remaining responses
+        endfunction
+
+        when receiving a response:
+            received_score := receive score from the worker.
+            If the received_score &gt; best_score
+                send worker a message indicating that master is interested by the solution
+                receive the solution
+                updates the best_score
+            else
+                send worker a message indicating that master isn't interested by the solution
+            endif
+
+        // On worker side
+        function parallel_multistart( algorithm eoAlgo )
+            seed := wait for a seed
+            solution := eoAlgo( seed )
+            send solution score to master
+            master_is_interested := wait for the response
+            if master_is_interested
+                send solution to master
+            endif
+        endfunction
+    </pre>
+</section>
+
+<section class="slide">
+    <h2>Common parts vs specific parts</h2>
+    <ul>
+        <li>These two algorithms have common parts and specific parts.</li>
+        <li>Identifying them allows to design generic parallel algorithms.</li>
+        <li>In the following code sample, specific parts are in red. Everything else is hence generic.</li>
+    </ul>
+
+    <pre><code>
+        // On master side
+        function parallel_evaluate(<span class="specific">population p, number of elements to send each time packet_size </span>)
+            <span class="specific">index = 0</span>
+            while <span class="specific">index &lt; size</span>
+                find a worker. If there is no one, wait for any response (return) and retry
+                <span class="specific">sentSize := how many individuals (&lt;= packet_size) can we send to a worker?
+                send the sentSize to the worker
+                send the individuals to the worker
+                index += sentSize</span>
+            endwhile</span>
+            inform all the available workers that they're done
+            wait for all remaining responses
+        endfunction
+
+        when receiving a response:
+            <span class="specific">replace the evaluated individuals in the population</span>
+
+        // On worker side
+        function parallel_evaluate(<span class="specific"> evaluation function f </span>)
+        <span class="specific">size := wait for a sentSize as described above
+            individuals := wait for size individuals
+            apply f on each of them
+            send back the individuals</span>
+        endfunction
+        </code></pre>
+
+</section>
+
+<section class="slide">
+    <h2>Common parts</h2>
+    <ul>
+        <li>Master runs a loop.</li>
+        <li>Master has to manage workers (find them, wait for them, etc...)</li>
+        <li>Workers need to be informed if they have something to do or not (stop condition in master part)</li>
+        <li>Master needs to wait to get all the responses.</li>
+    </ul>
+</section>
+
+<section class="slide">
+    <h2>Specific parts</h2>
+    <ul>
+        <li>Loop condition in the master's part.</li>
+        <li>What has to be sent to a worker by master?</li>
+        <li>What has to be done by a worker when it receives an order?</li>
+        <li>What has to be done when the master receives a response?</li>
+    </ul>
+</section>
+
+<section class="slide">
+    <h2>Generic parallel algorithm</h2>
+    <p>The calls to specific parts are in red.</p>
+    <pre><code>
+    // Master side
+    function parallel_algorithm()
+        while ! <span class="specific">isFinished()</span>
+            worker := none
+            while worker is none
+                wait for a response and affect worker the origin of the response
+                <span class="specific">handleResponse( worker )</span>
+                worker = retrieve worker
+            endwhile
+            send worker a work order
+            <span class="specific">sendTask( worker )</span>
+        endwhile
+
+        foreach available worker
+            indicate worker it's done (send them a termination order)
+        endforeach
+
+        while all responses haven't be received
+            worker := none
+            wait for a response and affect worker the origin of the response
+            <span class="specific">handleResponse( worker )</span>
+            send worker a termination order
+        endwhile
+    endfunction
+
+    // Worker side
+    function parallel_algorithm()
+        order := receive order
+        while order is not termination order
+            <span class="specific">processTask( )</span>
+            order = receive order
+        endwhile
+    endfunction
+    </code></pre>
+</section>
+
+<section class="slide">
+    <h2>TLDR;</h2>
+    <img src="./img/generic_parallel.png" style="height:800px;"/>
+</section>
+
+<section class="slide">
+    <h2>Functors</h2>
+    <ul>
+        <li>Using functors allows them to wrap <em>and</em> be wrapped (decorator pattern).</li>
+        <li>IsFinished : implements <em>bool operator()()</em>, indicating that the job is over.</li>
+        <li>SendTask : implements <em>void operator()( int worker_rank )</em>, indicating what to send to the
+        worker.</li>
+        <li>ProcessTask : implements <em>void operator()()</em>, indicating what the worker has to do when it receives a
+        task.</li>
+        <li>HandleResponse : implements <em>void operator()( int worker_rank )</em>, indicating what to do when
+        receiving a worker response.</li>
+        <li>Implementing these 4 functors is sufficient for a parallel algorithm!</li>
+        <li>You can also wrap the existing one to add functionalities.</li>
+    </ul>
+</section>
+
+<section class="slide">
+    <h2>Stores</h2>
+    <ul>
+        <li>These 4 functors can use about the same data.</li>
+        <li>This data needs to be shared : all the functors are templated on a JobData structure.</li>
+        <li>A job needs data and functors to be launched.</li>
+        <li>Several jobs can use the same data and functors.</li>
+        <li>=> Data and functors are saved into a store, which can be reused between different jobs.</li>
+    </ul>
+</section>
+
+<section class="slide">
+    <h2>Scheduling tasks between workers</h2>
+    <ul>
+        <li>Until here, we don't know how to schedule tasks between workers.</li>
+        <li>Naive, simple solution: as soon as a worker has finished a task, give it a new task. Workers are put in a
+        queue, this is the <strong>dynamic assignment</strong> (scheduling).</li>
+        <li>If the worker's number of call is well-known, initially give to each worker a fixed amount of tasks. When a
+        worker has finished a task, give it another task only if it the amount of remaining tasks is positive ; else,
+        wait for another worker. Workers are managed with a fixed table, this is the <strong>static
+            assignment</strong>.</li>
+    </ul>
+</section>
+
+<section class="slide">
+    <h2>Let's go back to evaluation in EO</h2>
+    <ul>
+        <li>The idea behind applying a functor to each element of a table is very generic. Google, Python and Javascript
+        call it <strong>map</strong>, we call it <strong>ParallelApply</strong>, according to existing
+        <strong>apply</strong> function, in apply.h.</li>
+        <li>There is also a <em>ParallelApplyJob</em>, a <em>ParallelApplyStore</em> which contains a
+        <em>ParallelApplyData</em>, a <em>IsFinishedParallelApply</em>, etc...</li>
+        <li>This is what is used when calling parallel evaluation.</li>
+    </ul>
+</section>
+
+<section class="slide">
+    <h2>Customizing evaluation: reminder</h2>
+    <pre class="sh_cpp"><code>
+    int main( int argc, char **argv )
+    {
+        eo::mpi::Node::init( argc, argv );
+        // PUT EO STUFF HERE
+        // Let's make the assumption that pop is a eoPop&lt;EOT&gt;
+        // and evalFunc is an evaluation functor
+        eo::mpi::DynamicAssignmentAlgorithm assign;
+        eoParallelPopLoopEval&lt;EOT&gt; popEval( assign, eo::mpi::DEFAULT_MASTER, evalFunc );
+        // The store is hidden behind this call, but it can be given at eoParallelPopLoopEval constructor!
+        popEval( pop, pop );
+    }
+    </code></pre>
+</section>
+
+<section class="slide">
+    <h2>Customizing evaluation: the idea</h2>
+    <ul>
+        <li>We would like to retrieve best individuals, as soon as they're processed, and print their fitness in the
+        standard output, for instance.</li>
+        <li>We can wrap one of the 4 functors.</li>
+        <li>Master side or worker side?
+            <ul class="slide">
+                <li>Master side: we want to retrieve the <em>global</em> best individual, not the best individual in
+                population slices.</li>
+                <li>We have 3 choices: IsFinished, HandleResponse, SendTask.</li>
+                <li>So which one?
+                    <ul class="slide">
+                    <li>The functor HandleResponse should be reimplemented: in a sequential version, it would be done just
+                    after the evaluation of an individual. The HandleResponse is the nearest functor called after having
+                    received the result.</li>
+                    </ul>
+                </li>
+            </ul>
+        </li>
+        <li>How to do it?
+            <ol class="slide">
+                <li>Retrieve which slice has been processed by the worker.</li>
+                <li>Call the embedded HandleResponse.</li>
+                <li>Compare the fitnesses of individuals in the slice to the global best individual.</li>
+            </ol>
+        </li>
+    </ul>
+</section>
+
+<section class="slide">
+    <h2>Customizing evaluation: implementation!</h2>
+    <pre class="sh_cpp"><code>
+    // Our objective is to minimize fitness, for instance
+    struct CatBestAnswers : public eo::mpi::HandleResponseParallelApply&lt;EOT&gt;
+    {
+        CatBestAnswers()
+        {
+            best.fitness( 1000000000. );
+        }
+
+        void operator()(int wrkRank)
+        {
+            // Retrieve informations about the slice processed by the worker
+            int index = _data->assignedTasks[wrkRank].index;
+            int size = _data->assignedTasks[wrkRank].size;
+            // call to the wrapped function HERE
+            (*_wrapped)( wrkRank );
+            // Compare fitnesses of evaluated individuals with the best saved
+            for(int i = index; i &lt; index+size; ++i)
+            {
+                if( best.fitness() &lt; _data->table()[ i ].fitness() )
+                {
+                    eo::log &lt;&lt; eo::quiet &lt;&lt; "Better solution found:" &lt;&lt; _data->table()[i].fitness() &lt;&lt; std::endl;
+                    best = _data->table()[ i ];
+                }
+            }
+        }
+
+        protected:
+
+        EOT best;
+    };
+    </code></pre>
+</section>
+
+<section class="slide">
+    <h2>Using customized handler</h2>
+    <pre class="sh_cpp"><code>
+        int main( int argc, char **argv )
+        {
+            eo::mpi::Node::init( argc, argv );
+            // PUT EO STUFF HERE
+            // Let's make the assumption that pop is a eoPop&lt;EOT&gt;
+            // and evalFunc is an evaluation functor
+            eo::mpi::DynamicAssignmentAlgorithm assign;
+            // What was used before
+            // eoParallelPopLoopEval&lt;EOT&gt; popEval( assign, eo::mpi::DEFAULT_MASTER, evalFunc );
+            // What's new
+            eo::mpi::ParallelApplyStore&lt; EOT &gt; store( evalFunc, eo::mpi::DEFAULT_MASTER );
+            CatBestAnswer catBestAnswers;
+            store.wrapHandleResponse( &catBestAnswers );
+
+            eoParallelPopLoopEval&lt; EOT &gt; popEval( assign, eo::mpi::DEFAULT_MASTER, &store );
+            // What doesn't change
+            popEval( pop, pop );
+        }
+    </code></pre>
+</section>
+
+<section class="slide">
+    <h1>Thank you for your attention</h1>
+</section>
+
+<section class="slide">
+    <h2>Remarks</h2>
+    <ul>
+        <li>This presentation is made of HTML5, CSS3, JavaScript, thanks to frameworks
+        <a href="http://imakewebthings.com/deck.js/">Deck.js</a> (slides) and <a href="http://shjs.sourceforge.net/">SHJS</a> (syntax
+        highlighting).
+        <li>If you have any complaint to make, please refer to <a href="mailto:johann@dreo.fr">Johann Dreo</a>.</li>
+        <li>If you have any question or compliment, please refer to <a href="mailto:benjamin.bouvier@gmail.com">me</a>
+        (Benjamin Bouvier).</li>
+    </ul>
+</section>
+
+<!-- deck.navigation snippet -->
+<a href="#" class="deck-prev-link" title="Précédent">&#8592;</a>
+<a href="#" class="deck-next-link" title="Suivant">&#8594;</a>
+
+<!-- deck.status snippet -->
+<p class="deck-status">
+	<span class="deck-status-current"></span>
+	/
+	<span class="deck-status-total"></span>
+</p>
+
+<!-- deck.goto snippet -->
+<form action="." method="get" class="goto-form">
+	<label for="goto-slide">Go to slide:</label>
+	<input type="text" name="slidenum" id="goto-slide" list="goto-datalist">
+	<datalist id="goto-datalist"></datalist>
+	<input type="submit" value="Go">
+</form>
+
+<!-- deck.hash snippet -->
+<a href="." title="Permalink to this slide" class="deck-permalink">#</a>
+
+
+<!-- Grab CDN jQuery, with a protocol relative URL; fall back to local if offline -->
+<!-- <script src="//ajax.aspnetcdn.com/ajax/jQuery/jquery-1.7.min.js"></script> -->
+<script>window.jQuery || document.write('<script src="js/jquery-1.7.min.js"><\/script>')</script>
+
+<!-- Deck Core and extensions -->
+<script src="js/deck.core.js"></script>
+<script src="js/deck.hash.js"></script>
+<script src="js/deck.menu.js"></script>
+<script src="js/deck.goto.js"></script>
+<script src="js/deck.status.js"></script>
+<script src="js/deck.navigation.js"></script>
+<script src="js/deck.scale.js"></script>
+
+<!-- Initialize the deck -->
+<script>
+$(function() {
+	$.deck('.slide');
+});
+</script>
+<!-- Initialize the highlighter -->
+<script src="js/shjs.js"></script>
+<script src="js/shjs-cpp.js"></script>
+<script>
+    sh_highlightDocument();
+</script>
+
+</body>
+</html>
--- a/tutorial/eo/Parallelization/img/generic_parallel.dia
+++ b/tutorial/eo/Parallelization/img/generic_parallel.dia
--- a/tutorial/eo/Parallelization/img/generic_parallel.png
+++ b/tutorial/eo/Parallelization/img/generic_parallel.png
--- a/tutorial/eo/Parallelization/img/serialisation.dia
+++ b/tutorial/eo/Parallelization/img/serialisation.dia
--- a/tutorial/eo/Parallelization/img/serialisation.png
+++ b/tutorial/eo/Parallelization/img/serialisation.png
--- a/tutorial/eo/Parallelization/js/deck.core.js
+++ b/tutorial/eo/Parallelization/js/deck.core.js
@ -0,0 +1,498 @@
+/*!
+Deck JS - deck.core
+Copyright (c) 2011 Caleb Troughton
+Dual licensed under the MIT license and GPL license.
+https://github.com/imakewebthings/deck.js/blob/master/MIT-license.txt
+https://github.com/imakewebthings/deck.js/blob/master/GPL-license.txt
+*/
+
+/*
+The deck.core module provides all the basic functionality for creating and
+moving through a deck.  It does so by applying classes to indicate the state of
+the deck and its slides, allowing CSS to take care of the visual representation
+of each state.  It also provides methods for navigating the deck and inspecting
+its state, as well as basic key bindings for going to the next and previous
+slides.  More functionality is provided by wholly separate extension modules
+that use the API provided by core.
+*/
+(function($, deck, document, undefined) {
+	var slides, // Array of all the uh, slides...
+	current, // Array index of the current slide
+	$container, // Keeping this cached
+	
+	events = {
+		/*
+		This event fires whenever the current slide changes, whether by way of
+		next, prev, or go. The callback function is passed two parameters, from
+		and to, equal to the indices of the old slide and the new slide
+		respectively. If preventDefault is called on the event within this handler
+		the slide change does not occur.
+		
+		$(document).bind('deck.change', function(event, from, to) {
+		   alert('Moving from slide ' + from + ' to ' + to);
+		});
+		*/
+		change: 'deck.change',
+		
+		/*
+		This event fires at the beginning of deck initialization, after the options
+		are set but before the slides array is created.  This event makes a good hook
+		for preprocessing extensions looking to modify the deck.
+		*/
+		beforeInitialize: 'deck.beforeInit',
+		
+		/*
+		This event fires at the end of deck initialization. Extensions should
+		implement any code that relies on user extensible options (key bindings,
+		element selectors, classes) within a handler for this event. Native
+		events associated with Deck JS should be scoped under a .deck event
+		namespace, as with the example below:
+		
+		var $d = $(document);
+		$.deck.defaults.keys.myExtensionKeycode = 70; // 'h'
+		$d.bind('deck.init', function() {
+		   $d.bind('keydown.deck', function(event) {
+		      if (event.which === $.deck.getOptions().keys.myExtensionKeycode) {
+		         // Rock out
+		      }
+		   });
+		});
+		*/
+		initialize: 'deck.init' 
+	},
+	
+	options = {},
+	$d = $(document),
+	
+	/*
+	Internal function. Updates slide and container classes based on which
+	slide is the current slide.
+	*/
+	updateStates = function() {
+		var oc = options.classes,
+		osc = options.selectors.container,
+		old = $container.data('onSlide'),
+		$all = $();
+		
+		// Container state
+		$container.removeClass(oc.onPrefix + old)
+			.addClass(oc.onPrefix + current)
+			.data('onSlide', current);
+		
+		// Remove and re-add child-current classes for nesting
+		$('.' + oc.current).parentsUntil(osc).removeClass(oc.childCurrent);
+		slides[current].parentsUntil(osc).addClass(oc.childCurrent);
+		
+		// Remove previous states
+		$.each(slides, function(i, el) {
+			$all = $all.add(el);
+		});
+		$all.removeClass([
+			oc.before,
+			oc.previous,
+			oc.current,
+			oc.next,
+			oc.after
+		].join(" "));
+		
+		// Add new states back in
+		slides[current].addClass(oc.current);
+		if (current > 0) {
+			slides[current-1].addClass(oc.previous);
+		}
+		if (current + 1 < slides.length) {
+			slides[current+1].addClass(oc.next);
+		}
+		if (current > 1) {
+			$.each(slides.slice(0, current - 1), function(i, el) {
+				el.addClass(oc.before);
+			});
+		}
+		if (current + 2 < slides.length) {
+			$.each(slides.slice(current+2), function(i, el) {
+				el.addClass(oc.after);
+			});
+		}
+	},
+	
+	/* Methods exposed in the jQuery.deck namespace */
+	methods = {
+		
+		/*
+		jQuery.deck(selector, options)
+		
+		selector: string | jQuery | array
+		options: object, optional
+				
+		Initializes the deck, using each element matched by selector as a slide.
+		May also be passed an array of string selectors or jQuery objects, in
+		which case each selector in the array is considered a slide. The second
+		parameter is an optional options object which will extend the default
+		values.
+		
+		$.deck('.slide');
+		
+		or
+		
+		$.deck([
+		   '#first-slide',
+		   '#second-slide',
+		   '#etc'
+		]);
+		*/	
+		init: function(elements, opts) {
+			var startTouch,
+			tolerance,
+			esp = function(e) {
+				e.stopPropagation();
+			};
+			
+			options = $.extend(true, {}, $[deck].defaults, opts);
+			slides = [];
+			current = 0;
+			$container = $(options.selectors.container);
+			tolerance = options.touch.swipeTolerance;
+			
+			// Pre init event for preprocessing hooks
+			$d.trigger(events.beforeInitialize);
+			
+			// Hide the deck while states are being applied to kill transitions
+			$container.addClass(options.classes.loading);
+			
+			// Fill slides array depending on parameter type
+			if ($.isArray(elements)) {
+				$.each(elements, function(i, e) {
+					slides.push($(e));
+				});
+			}
+			else {
+				$(elements).each(function(i, e) {
+					slides.push($(e));
+				});
+			}
+			
+			/* Remove any previous bindings, and rebind key events */
+			$d.unbind('keydown.deck').bind('keydown.deck', function(e) {
+				if (e.which === options.keys.next || $.inArray(e.which, options.keys.next) > -1) {
+					methods.next();
+					e.preventDefault();
+				}
+				else if (e.which === options.keys.previous || $.inArray(e.which, options.keys.previous) > -1) {
+					methods.prev();
+					e.preventDefault();
+				}
+			});
+			
+			/* Bind touch events for swiping between slides on touch devices */
+			$container.unbind('touchstart.deck').bind('touchstart.deck', function(e) {
+				if (!startTouch) {
+					startTouch = $.extend({}, e.originalEvent.targetTouches[0]);
+				}
+			})
+			.unbind('touchmove.deck').bind('touchmove.deck', function(e) {
+				$.each(e.originalEvent.changedTouches, function(i, t) {
+					if (startTouch && t.identifier === startTouch.identifier) {
+						if (t.screenX - startTouch.screenX > tolerance || t.screenY - startTouch.screenY > tolerance) {
+							$[deck]('prev');
+							startTouch = undefined;
+						}
+						else if (t.screenX - startTouch.screenX < -1 * tolerance || t.screenY - startTouch.screenY < -1 * tolerance) {
+							$[deck]('next');
+							startTouch = undefined;
+						}
+						return false;
+					}
+				});
+				e.preventDefault();
+			})
+			.unbind('touchend.deck').bind('touchend.deck', function(t) {
+				$.each(t.originalEvent.changedTouches, function(i, t) {
+					if (startTouch && t.identifier === startTouch.identifier) {
+						startTouch = undefined;
+					}
+				});
+			})
+			.scrollLeft(0).scrollTop(0)
+			/* Stop propagation of key events within editable elements of slides */
+			.undelegate('input, textarea, select, button, meter, progress, [contentEditable]', 'keydown', esp)
+			.delegate('input, textarea, select, button, meter, progress, [contentEditable]', 'keydown', esp);
+			
+			/*
+			Kick iframe videos, which dont like to redraw w/ transforms.
+			Remove this if Webkit ever fixes it.
+			 */
+			$.each(slides, function(i, $el) {
+				$el.unbind('webkitTransitionEnd.deck').bind('webkitTransitionEnd.deck',
+				function(event) {
+					if ($el.hasClass($[deck]('getOptions').classes.current)) {
+						var embeds = $(this).find('iframe').css('opacity', 0);
+						window.setTimeout(function() {
+							embeds.css('opacity', 1);
+						}, 100);
+					}
+				});
+			});
+			
+			if (slides.length) {
+				updateStates();
+			}
+			
+			// Show deck again now that slides are in place
+			$container.removeClass(options.classes.loading);
+			$d.trigger(events.initialize);
+		},
+		
+		/*
+		jQuery.deck('go', index)
+		
+		index: integer | string
+		
+		Moves to the slide at the specified index if index is a number. Index is
+		0-based, so $.deck('go', 0); will move to the first slide. If index is a
+		string this will move to the slide with the specified id. If index is out
+		of bounds or doesn't match a slide id the call is ignored.
+		*/
+		go: function(index) {
+			var e = $.Event(events.change),
+			ndx;
+			
+			/* Number index, easy. */
+			if (typeof index === 'number' && index >= 0 && index < slides.length) {
+				ndx = index;
+			}
+			/* Id string index, search for it and set integer index */
+			else if (typeof index === 'string') {
+				$.each(slides, function(i, $slide) {
+					if ($slide.attr('id') === index) {
+						ndx = i;
+						return false;
+					}
+				});
+			};
+			
+			/* Out of bounds, id doesn't exist, illegal input, eject */
+			if (typeof ndx === 'undefined') return;
+			
+			$d.trigger(e, [current, ndx]);
+			if (e.isDefaultPrevented()) {
+				/* Trigger the event again and undo the damage done by extensions. */
+				$d.trigger(events.change, [ndx, current]);
+			}
+			else {
+				current = ndx;
+				updateStates();
+			}
+		},
+		
+		/*
+		jQuery.deck('next')
+		
+		Moves to the next slide. If the last slide is already active, the call
+		is ignored.
+		*/
+		next: function() {
+			methods.go(current+1);
+		},
+		
+		/*
+		jQuery.deck('prev')
+		
+		Moves to the previous slide. If the first slide is already active, the
+		call is ignored.
+		*/
+		prev: function() {
+			methods.go(current-1);
+		},
+		
+		/*
+		jQuery.deck('getSlide', index)
+		
+		index: integer, optional
+		
+		Returns a jQuery object containing the slide at index. If index is not
+		specified, the current slide is returned.
+		*/
+		getSlide: function(index) {
+			var i = typeof index !== 'undefined' ? index : current;
+			if (typeof i != 'number' || i < 0 || i >= slides.length) return null;
+			return slides[i];
+		},
+		
+		/*
+		jQuery.deck('getSlides')
+		
+		Returns all slides as an array of jQuery objects.
+		*/
+		getSlides: function() {
+			return slides;
+		},
+		
+		/*
+		jQuery.deck('getContainer')
+		
+		Returns a jQuery object containing the deck container as defined by the
+		container option.
+		*/
+		getContainer: function() {
+			return $container;
+		},
+		
+		/*
+		jQuery.deck('getOptions')
+		
+		Returns the options object for the deck, including any overrides that
+		were defined at initialization.
+		*/
+		getOptions: function() {
+			return options;
+		},
+		
+		/*
+		jQuery.deck('extend', name, method)
+		
+		name: string
+		method: function
+		
+		Adds method to the deck namespace with the key of name. This doesn’t
+		give access to any private member data — public methods must still be
+		used within method — but lets extension authors piggyback on the deck
+		namespace rather than pollute jQuery.
+		
+		$.deck('extend', 'alert', function(msg) {
+		   alert(msg);
+		});
+
+		// Alerts 'boom'
+		$.deck('alert', 'boom');
+		*/
+		extend: function(name, method) {
+			methods[name] = method;
+		}
+	};
+	
+	/* jQuery extension */
+	$[deck] = function(method, arg) {
+		if (methods[method]) {
+			return methods[method].apply(this, Array.prototype.slice.call(arguments, 1));
+		}
+		else {
+			return methods.init(method, arg);
+		}
+	};
+	
+	/*
+	The default settings object for a deck. All deck extensions should extend
+	this object to add defaults for any of their options.
+	
+	options.classes.after
+		This class is added to all slides that appear after the 'next' slide.
+	
+	options.classes.before
+		This class is added to all slides that appear before the 'previous'
+		slide.
+		
+	options.classes.childCurrent
+		This class is added to all elements in the DOM tree between the
+		'current' slide and the deck container. For standard slides, this is
+		mostly seen and used for nested slides.
+		
+	options.classes.current
+		This class is added to the current slide.
+		
+	options.classes.loading
+		This class is applied to the deck container during loading phases and is
+		primarily used as a way to short circuit transitions between states
+		where such transitions are distracting or unwanted.  For example, this
+		class is applied during deck initialization and then removed to prevent
+		all the slides from appearing stacked and transitioning into place
+		on load.
+		
+	options.classes.next
+		This class is added to the slide immediately following the 'current'
+		slide.
+		
+	options.classes.onPrefix
+		This prefix, concatenated with the current slide index, is added to the
+		deck container as you change slides.
+		
+	options.classes.previous
+		This class is added to the slide immediately preceding the 'current'
+		slide.
+		
+	options.selectors.container
+		Elements matched by this CSS selector will be considered the deck
+		container. The deck container is used to scope certain states of the
+		deck, as with the onPrefix option, or with extensions such as deck.goto
+		and deck.menu.
+		
+	options.keys.next
+		The numeric keycode used to go to the next slide.
+		
+	options.keys.previous
+		The numeric keycode used to go to the previous slide.
+		
+	options.touch.swipeTolerance
+		The number of pixels the users finger must travel to produce a swipe
+		gesture.
+	*/
+	$[deck].defaults = {
+		classes: {
+			after: 'deck-after',
+			before: 'deck-before',
+			childCurrent: 'deck-child-current',
+			current: 'deck-current',
+			loading: 'deck-loading',
+			next: 'deck-next',
+			onPrefix: 'on-slide-',
+			previous: 'deck-previous'
+		},
+		
+		selectors: {
+			container: '.deck-container'
+		},
+		
+		keys: {
+			// enter, space, page down, right arrow, down arrow,
+			next: [13, 32, 34, 39, 40],
+			// backspace, page up, left arrow, up arrow
+			previous: [8, 33, 37, 38]
+		},
+		
+		touch: {
+			swipeTolerance: 60
+		}
+	};
+	
+	$d.ready(function() {
+		$('html').addClass('ready');
+	});
+	
+	/*
+	FF + Transforms + Flash video don't get along...
+	Firefox will reload and start playing certain videos after a
+	transform.  Blanking the src when a previously shown slide goes out
+	of view prevents this.
+	*/
+	$d.bind('deck.change', function(e, from, to) {
+		var oldFrames = $[deck]('getSlide', from).find('iframe'),
+		newFrames = $[deck]('getSlide', to).find('iframe');
+		
+		oldFrames.each(function() {
+	    	var $this = $(this),
+	    	curSrc = $this.attr('src');
+            
+            if(curSrc) {
+            	$this.data('deck-src', curSrc).attr('src', '');
+            }
+		});
+		
+		newFrames.each(function() {
+			var $this = $(this),
+			originalSrc = $this.data('deck-src');
+			
+			if (originalSrc) {
+				$this.attr('src', originalSrc);
+			}
+		});
+	});
+})(jQuery, 'deck', document);
--- a/tutorial/eo/Parallelization/js/deck.goto.js
+++ b/tutorial/eo/Parallelization/js/deck.goto.js
@ -0,0 +1,170 @@
+/*!
+Deck JS - deck.goto
+Copyright (c) 2011 Caleb Troughton
+Dual licensed under the MIT license and GPL license.
+https://github.com/imakewebthings/deck.js/blob/master/MIT-license.txt
+https://github.com/imakewebthings/deck.js/blob/master/GPL-license.txt
+*/
+
+/*
+This module adds the necessary methods and key bindings to show and hide a form
+for jumping to any slide number/id in the deck (and processes that form
+accordingly). The form-showing state is indicated by the presence of a class on
+the deck container.
+*/
+(function($, deck, undefined) {
+	var $d = $(document);
+	
+	/*
+	Extends defaults/options.
+	
+	options.classes.goto
+		This class is added to the deck container when showing the Go To Slide
+		form.
+		
+	options.selectors.gotoDatalist
+		The element that matches this selector is the datalist element that will
+		be populated with options for each of the slide ids.  In browsers that
+		support the datalist element, this provides a drop list of slide ids to
+		aid the user in selecting a slide.
+		
+	options.selectors.gotoForm
+		The element that matches this selector is the form that is submitted
+		when a user hits enter after typing a slide number/id in the gotoInput
+		element.
+	
+	options.selectors.gotoInput
+		The element that matches this selector is the text input field for
+		entering a slide number/id in the Go To Slide form.
+		
+	options.keys.goto
+		The numeric keycode used to show the Go To Slide form.
+		
+	options.countNested
+		If false, only top level slides will be counted when entering a
+		slide number.
+	*/
+	$.extend(true, $[deck].defaults, {
+		classes: {
+			goto: 'deck-goto'
+		},
+		
+		selectors: {
+			gotoDatalist: '#goto-datalist',
+			gotoForm: '.goto-form',
+			gotoInput: '#goto-slide'
+		},
+		
+		keys: {
+			goto: 71 // g
+		},
+		
+		countNested: true
+	});
+
+	/*
+	jQuery.deck('showGoTo')
+	
+	Shows the Go To Slide form by adding the class specified by the goto class
+	option to the deck container.
+	*/
+	$[deck]('extend', 'showGoTo', function() {
+		$[deck]('getContainer').addClass($[deck]('getOptions').classes.goto);
+		$($[deck]('getOptions').selectors.gotoInput).focus();
+	});
+
+	/*
+	jQuery.deck('hideGoTo')
+	
+	Hides the Go To Slide form by removing the class specified by the goto class
+	option from the deck container.
+	*/
+	$[deck]('extend', 'hideGoTo', function() {
+		$($[deck]('getOptions').selectors.gotoInput).blur();
+		$[deck]('getContainer').removeClass($[deck]('getOptions').classes.goto);
+	});
+
+	/*
+	jQuery.deck('toggleGoTo')
+	
+	Toggles between showing and hiding the Go To Slide form.
+	*/
+	$[deck]('extend', 'toggleGoTo', function() {
+		$[deck]($[deck]('getContainer').hasClass($[deck]('getOptions').classes.goto) ? 'hideGoTo' : 'showGoTo');
+	});
+	
+	$d.bind('deck.init', function() {
+		var opts = $[deck]('getOptions'),
+		$datalist = $(opts.selectors.gotoDatalist),
+		slideTest = $.map([
+			opts.classes.before,
+			opts.classes.previous,
+			opts.classes.current,
+			opts.classes.next,
+			opts.classes.after
+		], function(el, i) {
+			return '.' + el;
+		}).join(', '),
+		rootCounter = 1;
+		
+		// Bind key events
+		$d.unbind('keydown.deckgoto').bind('keydown.deckgoto', function(e) {
+			var key = $[deck]('getOptions').keys.goto;
+			
+			if (e.which === key || $.inArray(e.which, key) > -1) {
+				e.preventDefault();
+				$[deck]('toggleGoTo');
+			}
+		});
+		
+		/* Populate datalist and work out countNested*/
+		$.each($[deck]('getSlides'), function(i, $slide) {
+			var id = $slide.attr('id'),
+			$parentSlides = $slide.parentsUntil(opts.selectors.container, slideTest);
+			
+			if (id) {
+				$datalist.append('<option value="' + id + '">');
+			}
+			
+			if ($parentSlides.length) {
+				$slide.removeData('rootIndex');
+			}
+			else if (!opts.countNested) {
+				$slide.data('rootIndex', rootCounter);
+				++rootCounter;
+			}
+		});
+		
+		// Process form submittal, go to the slide entered
+		$(opts.selectors.gotoForm)
+		.unbind('submit.deckgoto')
+		.bind('submit.deckgoto', function(e) {
+			var $field = $($[deck]('getOptions').selectors.gotoInput),
+			ndx = parseInt($field.val(), 10);
+			
+			if (!$[deck]('getOptions').countNested) {
+			  if (ndx >= rootCounter) return false;
+				$.each($[deck]('getSlides'), function(i, $slide) {
+					if ($slide.data('rootIndex') === ndx) {
+						ndx = i + 1;
+						return false;
+					}
+				});
+			}
+			
+			$[deck]('go', isNaN(ndx) ? $field.val() : ndx - 1);
+			$[deck]('hideGoTo');
+			$field.val('');
+			
+			e.preventDefault();
+		});
+		
+		// Dont let keys in the input trigger deck actions
+		$(opts.selectors.gotoInput)
+		.unbind('keydown.deckgoto')
+		.bind('keydown.deckgoto', function(e) {
+			e.stopPropagation();
+		});
+	});
+})(jQuery, 'deck');
+
--- a/tutorial/eo/Parallelization/js/deck.hash.js
+++ b/tutorial/eo/Parallelization/js/deck.hash.js
@ -0,0 +1,141 @@
+/*!
+Deck JS - deck.hash
+Copyright (c) 2011 Caleb Troughton
+Dual licensed under the MIT license and GPL license.
+https://github.com/imakewebthings/deck.js/blob/master/MIT-license.txt
+https://github.com/imakewebthings/deck.js/blob/master/GPL-license.txt
+*/
+
+/*
+This module adds deep linking to individual slides, enables internal links
+to slides within decks, and updates the address bar with the hash as the user
+moves through the deck. A permalink anchor is also updated. Standard themes
+hide this link in browsers that support the History API, and show it for
+those that do not. Slides that do not have an id are assigned one according to
+the hashPrefix option. In addition to the on-slide container state class
+kept by core, this module adds an on-slide state class that uses the id of each
+slide.
+*/
+(function ($, deck, window, undefined) {
+	var $d = $(document),
+	$window = $(window),
+	
+	/* Collection of internal fragment links in the deck */
+	$internals,
+	
+	/*
+	Internal only function.  Given a string, extracts the id from the hash,
+	matches it to the appropriate slide, and navigates there.
+	*/
+	goByHash = function(str) {
+		var id = str.substr(str.indexOf("#") + 1),
+		slides = $[deck]('getSlides');
+		
+		$.each(slides, function(i, $el) {
+			if ($el.attr('id') === id) {
+				$[deck]('go', i);
+				return false;
+			}
+		});
+		
+		// If we don't set these to 0 the container scrolls due to hashchange
+		$[deck]('getContainer').scrollLeft(0).scrollTop(0);
+	};
+	
+	/*
+	Extends defaults/options.
+	
+	options.selectors.hashLink
+		The element matching this selector has its href attribute updated to
+		the hash of the current slide as the user navigates through the deck.
+		
+	options.hashPrefix
+		Every slide that does not have an id is assigned one at initialization.
+		Assigned ids take the form of hashPrefix + slideIndex, e.g., slide-0,
+		slide-12, etc.
+
+	options.preventFragmentScroll
+		When deep linking to a hash of a nested slide, this scrolls the deck
+		container to the top, undoing the natural browser behavior of scrolling
+		to the document fragment on load.
+	*/
+	$.extend(true, $[deck].defaults, {
+		selectors: {
+			hashLink: '.deck-permalink'
+		},
+		
+		hashPrefix: 'slide-',
+		preventFragmentScroll: true
+	});
+	
+	
+	$d.bind('deck.init', function() {
+	   var opts = $[deck]('getOptions');
+		$internals = $(),
+		slides = $[deck]('getSlides');
+		
+		$.each(slides, function(i, $el) {
+			var hash;
+			
+			/* Hand out ids to the unfortunate slides born without them */
+			if (!$el.attr('id') || $el.data('deckAssignedId') === $el.attr('id')) {
+				$el.attr('id', opts.hashPrefix + i);
+				$el.data('deckAssignedId', opts.hashPrefix + i);
+			}
+			
+			hash ='#' + $el.attr('id');
+			
+			/* Deep link to slides on init */
+			if (hash === window.location.hash) {
+				$[deck]('go', i);
+			}
+			
+			/* Add internal links to this slide */
+			$internals = $internals.add('a[href="' + hash + '"]');
+		});
+		
+		if (!Modernizr.hashchange) {
+			/* Set up internal links using click for the poor browsers
+			without a hashchange event. */
+			$internals.unbind('click.deckhash').bind('click.deckhash', function(e) {
+				goByHash($(this).attr('href'));
+			});
+		}
+		
+		/* Set up first id container state class */
+		if (slides.length) {
+			$[deck]('getContainer').addClass(opts.classes.onPrefix + $[deck]('getSlide').attr('id'));
+		};
+	})
+	/* Update permalink, address bar, and state class on a slide change */
+	.bind('deck.change', function(e, from, to) {
+		var hash = '#' + $[deck]('getSlide', to).attr('id'),
+		opts = $[deck]('getOptions'),
+		osp = opts.classes.onPrefix,
+		$c = $[deck]('getContainer');
+		
+		$c.removeClass(osp + $[deck]('getSlide', from).attr('id'));
+		$c.addClass(osp + $[deck]('getSlide', to).attr('id'));
+		
+		$(opts.selectors.hashLink).attr('href', hash);
+		if (Modernizr.history) {
+			window.history.replaceState({}, "", hash);
+		}
+	});
+	
+	/* Deals with internal links in modern browsers */
+	$window.bind('hashchange.deckhash', function(e) {
+		if (e.originalEvent && e.originalEvent.newURL) {
+			goByHash(e.originalEvent.newURL);
+		}
+		else {
+			goByHash(window.location.hash);
+		}
+	})
+	/* Prevent scrolling on deep links */
+	.bind('load', function() {
+		if ($[deck]('getOptions').preventFragmentScroll) {
+			$[deck]('getContainer').scrollLeft(0).scrollTop(0);
+		}
+	});
+})(jQuery, 'deck', this);
--- a/tutorial/eo/Parallelization/js/deck.menu.js
+++ b/tutorial/eo/Parallelization/js/deck.menu.js
@ -0,0 +1,187 @@
+/*!
+Deck JS - deck.menu
+Copyright (c) 2011 Caleb Troughton
+Dual licensed under the MIT license and GPL license.
+https://github.com/imakewebthings/deck.js/blob/master/MIT-license.txt
+https://github.com/imakewebthings/deck.js/blob/master/GPL-license.txt
+*/
+
+/*
+This module adds the methods and key binding to show and hide a menu of all
+slides in the deck. The deck menu state is indicated by the presence of a class
+on the deck container.
+*/
+(function($, deck, undefined) {
+	var $d = $(document),
+	rootSlides; // Array of top level slides
+	
+	/*
+	Extends defaults/options.
+	
+	options.classes.menu
+		This class is added to the deck container when showing the slide menu.
+	
+	options.keys.menu
+		The numeric keycode used to toggle between showing and hiding the slide
+		menu.
+		
+	options.touch.doubletapWindow
+		Two consecutive touch events within this number of milliseconds will
+		be considered a double tap, and will toggle the menu on touch devices.
+	*/
+	$.extend(true, $[deck].defaults, {
+		classes: {
+			menu: 'deck-menu'
+		},
+		
+		keys: {
+			menu: 77 // m
+		},
+		
+		touch: {
+			doubletapWindow: 400
+		}
+	});
+
+	/*
+	jQuery.deck('showMenu')
+	
+	Shows the slide menu by adding the class specified by the menu class option
+	to the deck container.
+	*/
+	$[deck]('extend', 'showMenu', function() {
+		var $c = $[deck]('getContainer'),
+		opts = $[deck]('getOptions');
+		
+		if ($c.hasClass(opts.classes.menu)) return;
+		
+		// Hide through loading class to short-circuit transitions (perf)
+		$c.addClass([opts.classes.loading, opts.classes.menu].join(' '));
+		
+		/* Forced to do this in JS until CSS learns second-grade math. Save old
+		style value for restoration when menu is hidden. */
+		if (Modernizr.csstransforms) {
+			$.each(rootSlides, function(i, $slide) {
+				$slide.data('oldStyle', $slide.attr('style'));
+				$slide.css({
+					'position': 'absolute',
+					'left': ((i % 4) * 25) + '%',
+					'top': (Math.floor(i / 4) * 25) + '%'
+				});
+			});
+		}
+		
+		// Need to ensure the loading class renders first, then remove
+		window.setTimeout(function() {
+			$c.removeClass(opts.classes.loading)
+				.scrollTop($[deck]('getSlide').offset().top);
+		}, 0);
+	});
+
+	/*
+	jQuery.deck('hideMenu')
+	
+	Hides the slide menu by removing the class specified by the menu class
+	option from the deck container.
+	*/
+	$[deck]('extend', 'hideMenu', function() {
+		var $c = $[deck]('getContainer'),
+		opts = $[deck]('getOptions');
+		
+		if (!$c.hasClass(opts.classes.menu)) return;
+		
+		$c.removeClass(opts.classes.menu);
+		$c.addClass(opts.classes.loading);
+		
+		/* Restore old style value */
+		if (Modernizr.csstransforms) {
+			$.each(rootSlides, function(i, $slide) {
+				var oldStyle = $slide.data('oldStyle');
+
+				$slide.attr('style', oldStyle ? oldStyle : '');
+			});
+		}
+		
+		window.setTimeout(function() {
+			$c.removeClass(opts.classes.loading).scrollTop(0);
+		}, 0);
+	});
+
+	/*
+	jQuery.deck('toggleMenu')
+	
+	Toggles between showing and hiding the slide menu.
+	*/
+	$[deck]('extend', 'toggleMenu', function() {
+		$[deck]('getContainer').hasClass($[deck]('getOptions').classes.menu) ?
+		$[deck]('hideMenu') : $[deck]('showMenu');
+	});
+
+	$d.bind('deck.init', function() {
+		var opts = $[deck]('getOptions'),
+		touchEndTime = 0,
+		currentSlide,
+		slideTest = $.map([
+			opts.classes.before,
+			opts.classes.previous,
+			opts.classes.current,
+			opts.classes.next,
+			opts.classes.after
+		], function(el, i) {
+			return '.' + el;
+		}).join(', ');
+		
+		// Build top level slides array
+		rootSlides = [];
+		$.each($[deck]('getSlides'), function(i, $el) {
+			if (!$el.parentsUntil(opts.selectors.container, slideTest).length) {
+				rootSlides.push($el);
+			}
+		});
+		
+		// Bind key events
+		$d.unbind('keydown.deckmenu').bind('keydown.deckmenu', function(e) {
+			if (e.which === opts.keys.menu || $.inArray(e.which, opts.keys.menu) > -1) {
+				$[deck]('toggleMenu');
+				e.preventDefault();
+			}
+		});
+		
+		// Double tap to toggle slide menu for touch devices
+		$[deck]('getContainer').unbind('touchstart.deckmenu').bind('touchstart.deckmenu', function(e) {
+			currentSlide = $[deck]('getSlide');
+		})
+		.unbind('touchend.deckmenu').bind('touchend.deckmenu', function(e) {
+			var now = Date.now();
+			
+			// Ignore this touch event if it caused a nav change (swipe)
+			if (currentSlide !== $[deck]('getSlide')) return;
+			
+			if (now - touchEndTime < opts.touch.doubletapWindow) {
+				$[deck]('toggleMenu');
+				e.preventDefault();
+			}
+			touchEndTime = now;
+		});
+		
+		// Selecting slides from the menu
+		$.each($[deck]('getSlides'), function(i, $s) {
+			$s.unbind('click.deckmenu').bind('click.deckmenu', function(e) {
+				if (!$[deck]('getContainer').hasClass(opts.classes.menu)) return;
+
+				$[deck]('go', i);
+				$[deck]('hideMenu');
+				e.stopPropagation();
+				e.preventDefault();
+			});
+		});
+	})
+	.bind('deck.change', function(e, from, to) {
+		var container = $[deck]('getContainer');
+		
+		if (container.hasClass($[deck]('getOptions').classes.menu)) {
+			container.scrollTop($[deck]('getSlide', to).offset().top);
+		}
+	});
+})(jQuery, 'deck');
+
--- a/tutorial/eo/Parallelization/js/deck.navigation.js
+++ b/tutorial/eo/Parallelization/js/deck.navigation.js
@ -0,0 +1,91 @@
+/*!
+Deck JS - deck.navigation
+Copyright (c) 2011 Caleb Troughton
+Dual licensed under the MIT license and GPL license.
+https://github.com/imakewebthings/deck.js/blob/master/MIT-license.txt
+https://github.com/imakewebthings/deck.js/blob/master/GPL-license.txt
+*/
+
+/*
+This module adds clickable previous and next links to the deck.
+*/
+(function($, deck, undefined) {
+	var $d = $(document),
+	
+	/* Updates link hrefs, and disabled states if last/first slide */
+	updateButtons = function(e, from, to) {
+		var opts = $[deck]('getOptions'),
+		last = $[deck]('getSlides').length - 1,
+		prevSlide = $[deck]('getSlide', to - 1),
+		nextSlide = $[deck]('getSlide', to + 1),
+		prevId = prevSlide ? prevSlide.attr('id') : undefined;
+		nextId = nextSlide ? nextSlide.attr('id') : undefined;
+		
+		$(opts.selectors.previousLink)
+			.toggleClass(opts.classes.navDisabled, !to)
+			.attr('href', '#' + (prevId ? prevId : ''));
+		$(opts.selectors.nextLink)
+			.toggleClass(opts.classes.navDisabled, to === last)
+			.attr('href', '#' + (nextId ? nextId : ''));
+	};
+	
+	/*
+	Extends defaults/options.
+	
+	options.classes.navDisabled
+		This class is added to a navigation link when that action is disabled.
+		It is added to the previous link when on the first slide, and to the
+		next link when on the last slide.
+		
+	options.selectors.nextLink
+		The elements that match this selector will move the deck to the next
+		slide when clicked.
+		
+	options.selectors.previousLink
+		The elements that match this selector will move to deck to the previous
+		slide when clicked.
+	*/
+	$.extend(true, $[deck].defaults, {
+		classes: {
+			navDisabled: 'deck-nav-disabled'
+		},
+		
+		selectors: {
+			nextLink: '.deck-next-link',
+			previousLink: '.deck-prev-link'
+		}
+	});
+
+	$d.bind('deck.init', function() {
+		var opts = $[deck]('getOptions'),
+		slides = $[deck]('getSlides'),
+		$current = $[deck]('getSlide'),
+		ndx;
+		
+		// Setup prev/next link events
+		$(opts.selectors.previousLink)
+		.unbind('click.decknavigation')
+		.bind('click.decknavigation', function(e) {
+			$[deck]('prev');
+			e.preventDefault();
+		});
+		
+		$(opts.selectors.nextLink)
+		.unbind('click.decknavigation')
+		.bind('click.decknavigation', function(e) {
+			$[deck]('next');
+			e.preventDefault();
+		});
+		
+		// Find where we started in the deck and set initial states
+		$.each(slides, function(i, $slide) {
+			if ($slide === $current) {
+				ndx = i;
+				return false;
+			}
+		});
+		updateButtons(null, ndx, ndx);
+	})
+	.bind('deck.change', updateButtons);
+})(jQuery, 'deck');
+
--- a/tutorial/eo/Parallelization/js/deck.scale.js
+++ b/tutorial/eo/Parallelization/js/deck.scale.js
@ -0,0 +1,170 @@
+/*!
+Deck JS - deck.scale
+Copyright (c) 2011-2012 Caleb Troughton
+Dual licensed under the MIT license and GPL license.
+https://github.com/imakewebthings/deck.js/blob/master/MIT-license.txt
+https://github.com/imakewebthings/deck.js/blob/master/GPL-license.txt
+*/
+
+/*
+This module adds automatic scaling to the deck.  Slides are scaled down
+using CSS transforms to fit within the deck container. If the container is
+big enough to hold the slides without scaling, no scaling occurs. The user
+can disable and enable scaling with a keyboard shortcut.
+
+Note: CSS transforms may make Flash videos render incorrectly.  Presenters
+that need to use video may want to disable scaling to play them.  HTML5 video
+works fine.
+*/
+(function($, deck, window, undefined) {
+	var $d = $(document),
+	$w = $(window),
+	baseHeight, // Value to scale against
+	timer, // Timeout id for debouncing
+	rootSlides,
+
+	/*
+	Internal function to do all the dirty work of scaling the slides.
+	*/
+	scaleDeck = function() {
+		var opts = $[deck]('getOptions'),
+		obh = opts.baseHeight,
+		$container = $[deck]('getContainer'),
+		baseHeight = obh ? obh : $container.height();
+
+		// Scale each slide down if necessary (but don't scale up)
+		$.each(rootSlides, function(i, $slide) {
+			var slideHeight = $slide.innerHeight(),
+			$scaler = $slide.find('.' + opts.classes.scaleSlideWrapper),
+			scale = $container.hasClass(opts.classes.scale) ?
+				baseHeight / slideHeight :
+				1;
+			
+			$.each('Webkit Moz O ms Khtml'.split(' '), function(i, prefix) {
+				if (scale === 1) {
+					$scaler.css(prefix + 'Transform', '');
+				}
+				else {
+					$scaler.css(prefix + 'Transform', 'scale(' + scale + ')');
+				}
+			});
+		});
+	}
+
+	/*
+	Extends defaults/options.
+
+	options.classes.scale
+		This class is added to the deck container when scaling is enabled.
+		It is enabled by default when the module is included.
+	
+	options.classes.scaleSlideWrapper
+		Scaling is done using a wrapper around the contents of each slide. This
+		class is applied to that wrapper.
+
+	options.keys.scale
+		The numeric keycode used to toggle enabling and disabling scaling.
+
+	options.baseHeight
+		When baseHeight is falsy, as it is by default, the deck is scaled in
+		proportion to the height of the deck container. You may instead specify
+		a height as a number of px, and slides will be scaled against this
+		height regardless of the container size.
+
+	options.scaleDebounce
+		Scaling on the browser resize event is debounced. This number is the
+		threshold in milliseconds. You can learn more about debouncing here:
+		http://unscriptable.com/index.php/2009/03/20/debouncing-javascript-methods/
+
+	*/
+	$.extend(true, $[deck].defaults, {
+		classes: {
+			scale: 'deck-scale',
+			scaleSlideWrapper: 'deck-slide-scaler'
+		},
+
+		keys: {
+			scale: 83 // s
+		},
+
+		baseHeight: null,
+		scaleDebounce: 200
+	});
+
+	/*
+	jQuery.deck('disableScale')
+
+	Disables scaling and removes the scale class from the deck container.
+	*/
+	$[deck]('extend', 'disableScale', function() {
+		$[deck]('getContainer').removeClass($[deck]('getOptions').classes.scale);
+		scaleDeck();
+	});
+
+	/*
+	jQuery.deck('enableScale')
+
+	Enables scaling and adds the scale class to the deck container.
+	*/
+	$[deck]('extend', 'enableScale', function() {
+		$[deck]('getContainer').addClass($[deck]('getOptions').classes.scale);
+		scaleDeck();
+	});
+
+	/*
+	jQuery.deck('toggleScale')
+
+	Toggles between enabling and disabling scaling.
+	*/
+	$[deck]('extend', 'toggleScale', function() {
+		var $c = $[deck]('getContainer');
+		$[deck]($c.hasClass($[deck]('getOptions').classes.scale) ?
+			'disableScale' : 'enableScale');
+	});
+
+	$d.bind('deck.init', function() {
+		var opts = $[deck]('getOptions'),
+		slideTest = $.map([
+			opts.classes.before,
+			opts.classes.previous,
+			opts.classes.current,
+			opts.classes.next,
+			opts.classes.after
+		], function(el, i) {
+			return '.' + el;
+		}).join(', ');
+		
+		// Build top level slides array
+		rootSlides = [];
+		$.each($[deck]('getSlides'), function(i, $el) {
+			if (!$el.parentsUntil(opts.selectors.container, slideTest).length) {
+				rootSlides.push($el);
+			}
+		});
+		
+		// Use a wrapper on each slide to handle content scaling
+		$.each(rootSlides, function(i, $slide) {
+			$slide.children().wrapAll('<div class="' + opts.classes.scaleSlideWrapper + '"/>');
+		});
+
+		// Debounce the resize scaling
+		$w.unbind('resize.deckscale').bind('resize.deckscale', function() {
+			window.clearTimeout(timer);
+			timer = window.setTimeout(scaleDeck, opts.scaleDebounce);
+		})
+		// Scale once on load, in case images or something change layout
+		.unbind('load.deckscale').bind('load.deckscale', scaleDeck);
+
+		// Bind key events
+		$d.unbind('keydown.deckscale').bind('keydown.deckscale', function(e) {
+			if (e.which === opts.keys.scale || $.inArray(e.which, opts.keys.scale) > -1) {
+				$[deck]('toggleScale');
+				e.preventDefault();
+			}
+		});
+
+		// Enable scale on init
+		$[deck]('enableScale');
+	});
+})(jQuery, 'deck', this);
+
--- a/tutorial/eo/Parallelization/js/deck.status.js
+++ b/tutorial/eo/Parallelization/js/deck.status.js
@ -0,0 +1,95 @@
+/*!
+Deck JS - deck.status
+Copyright (c) 2011 Caleb Troughton
+Dual licensed under the MIT license and GPL license.
+https://github.com/imakewebthings/deck.js/blob/master/MIT-license.txt
+https://github.com/imakewebthings/deck.js/blob/master/GPL-license.txt
+*/
+
+/*
+This module adds a (current)/(total) style status indicator to the deck.
+*/
+(function($, deck, undefined) {
+	var $d = $(document),
+	
+	updateCurrent = function(e, from, to) {
+		var opts = $[deck]('getOptions');
+		
+		$(opts.selectors.statusCurrent).text(opts.countNested ?
+			to + 1 :
+			$[deck]('getSlide', to).data('rootSlide')
+		);
+	};
+	
+	/*
+	Extends defaults/options.
+	
+	options.selectors.statusCurrent
+		The element matching this selector displays the current slide number.
+		
+	options.selectors.statusTotal
+		The element matching this selector displays the total number of slides.
+		
+	options.countNested
+		If false, only top level slides will be counted in the current and
+		total numbers.
+	*/
+	$.extend(true, $[deck].defaults, {
+		selectors: {
+			statusCurrent: '.deck-status-current',
+			statusTotal: '.deck-status-total'
+		},
+		
+		countNested: true
+	});
+	
+	$d.bind('deck.init', function() {
+		var opts = $[deck]('getOptions'),
+		slides = $[deck]('getSlides'),
+		$current = $[deck]('getSlide'),
+		ndx;
+		
+		// Set total slides once
+		if (opts.countNested) {
+			$(opts.selectors.statusTotal).text(slides.length);
+		}
+		else {
+			/* Determine root slides by checking each slide's ancestor tree for
+			any of the slide classes. */
+			var rootIndex = 1,
+			slideTest = $.map([
+				opts.classes.before,
+				opts.classes.previous,
+				opts.classes.current,
+				opts.classes.next,
+				opts.classes.after
+			], function(el, i) {
+				return '.' + el;
+			}).join(', ');
+			
+			/* Store the 'real' root slide number for use during slide changes. */
+			$.each(slides, function(i, $el) {
+				var $parentSlides = $el.parentsUntil(opts.selectors.container, slideTest);
+
+				$el.data('rootSlide', $parentSlides.length ?
+					$parentSlides.last().data('rootSlide') :
+					rootIndex++
+				);
+			});
+			
+			$(opts.selectors.statusTotal).text(rootIndex - 1);
+		}
+		
+		// Find where we started in the deck and set initial state
+		$.each(slides, function(i, $el) {
+			if ($el === $current) {
+				ndx = i;
+				return false;
+			}
+		});
+		updateCurrent(null, ndx, ndx);
+	})
+	/* Update current slide number with each change event */
+	.bind('deck.change', updateCurrent);
+})(jQuery, 'deck');
+
--- a/tutorial/eo/Parallelization/js/jquery-1.7.min.js
+++ b/tutorial/eo/Parallelization/js/jquery-1.7.min.js
--- a/tutorial/eo/Parallelization/js/modernizr.custom.js
+++ b/tutorial/eo/Parallelization/js/modernizr.custom.js
--- a/tutorial/eo/Parallelization/js/shjs-cpp.js
+++ b/tutorial/eo/Parallelization/js/shjs-cpp.js
@ -0,0 +1 @@
+if(!this.sh_languages){this.sh_languages={}}sh_languages.cpp=[[[/(\b(?:class|struct|typename))([ \t]+)([A-Za-z0-9_]+)/g,["sh_keyword","sh_normal","sh_classname"],-1],[/\b(?:class|const_cast|delete|dynamic_cast|explicit|false|friend|inline|mutable|namespace|new|operator|private|protected|public|reinterpret_cast|static_cast|template|this|throw|true|try|typeid|typename|using|virtual)\b/g,"sh_keyword",-1],[/\/\/\//g,"sh_comment",1],[/\/\//g,"sh_comment",7],[/\/\*\*/g,"sh_comment",8],[/\/\*/g,"sh_comment",9],[/(\bstruct)([ \t]+)([A-Za-z0-9_]+)/g,["sh_keyword","sh_normal","sh_classname"],-1],[/^[ \t]*#(?:[ \t]*include)/g,"sh_preproc",10,1],[/^[ \t]*#(?:[ \t]*[A-Za-z0-9_]*)/g,"sh_preproc",-1],[/\b[+-]?(?:(?:0x[A-Fa-f0-9]+)|(?:(?:[\d]*\.)?[\d]+(?:[eE][+-]?[\d]+)?))u?(?:(?:int(?:8|16|32|64))|L)?\b/g,"sh_number",-1],[/"/g,"sh_string",13],[/'/g,"sh_string",14],[/\b(?:__asm|__cdecl|__declspec|__export|__far16|__fastcall|__fortran|__import|__pascal|__rtti|__stdcall|_asm|_cdecl|__except|_export|_far16|_fastcall|__finally|_fortran|_import|_pascal|_stdcall|__thread|__try|asm|auto|break|case|catch|cdecl|const|continue|default|do|else|enum|extern|for|goto|if|pascal|register|return|sizeof|static|struct|switch|typedef|union|volatile|while)\b/g,"sh_keyword",-1],[/\b(?:bool|char|double|float|int|long|short|signed|unsigned|void|wchar_t)\b/g,"sh_type",-1],[/~|!|%|\^|\*|\(|\)|-|\+|=|\[|\]|\\|:|;|,|\.|\/|\?|&|<|>|\|/g,"sh_symbol",-1],[/\{|\}/g,"sh_cbracket",-1],[/(?:[A-Za-z]|_)[A-Za-z0-9_]*(?=[ \t]*\()/g,"sh_function",-1],[/([A-Za-z](?:[^`~!@#$%&*()_=+{}|;:",<.>\/?'\\[\]\^\-\s]|[_])*)((?:<.*>)?)(\s+(?=[*&]*[A-Za-z][^`~!@#$%&*()_=+{}|;:",<.>\/?'\\[\]\^\-\s]*\s*[`~!@#$%&*()_=+{}|;:",<.>\/?'\\[\]\^\-\[\]]+))/g,["sh_usertype","sh_usertype","sh_normal"],-1]],[[/$/g,null,-2],[/(?:<?)[A-Za-z0-9_\.\/\-_~]+@[A-Za-z0-9_\.\/\-_~]+(?:>?)|(?:<?)[A-Za-z0-9_]+:\/\/[A-Za-z0-9_\.\/\-_~]+(?:>?)/g,"sh_url",-1],[/<\?xml/g,"sh_preproc",2,1],[/<!DOCTYPE/g,"sh_preproc",4,1],[/<!--/g,"sh_comment",5],[/<(?:\/)?[A-Za-z](?:[A-Za-z0-9_:.-]*)(?:\/)?>/g,"sh_keyword",-1],[/<(?:\/)?[A-Za-z](?:[A-Za-z0-9_:.-]*)/g,"sh_keyword",6,1],[/&(?:[A-Za-z0-9]+);/g,"sh_preproc",-1],[/<(?:\/)?[A-Za-z][A-Za-z0-9]*(?:\/)?>/g,"sh_keyword",-1],[/<(?:\/)?[A-Za-z][A-Za-z0-9]*/g,"sh_keyword",6,1],[/@[A-Za-z]+/g,"sh_type",-1],[/(?:TODO|FIXME|BUG)(?:[:]?)/g,"sh_todo",-1]],[[/\?>/g,"sh_preproc",-2],[/([^=" \t>]+)([ \t]*)(=?)/g,["sh_type","sh_normal","sh_symbol"],-1],[/"/g,"sh_string",3]],[[/\\(?:\\|")/g,null,-1],[/"/g,"sh_string",-2]],[[/>/g,"sh_preproc",-2],[/([^=" \t>]+)([ \t]*)(=?)/g,["sh_type","sh_normal","sh_symbol"],-1],[/"/g,"sh_string",3]],[[/-->/g,"sh_comment",-2],[/<!--/g,"sh_comment",5]],[[/(?:\/)?>/g,"sh_keyword",-2],[/([^=" \t>]+)([ \t]*)(=?)/g,["sh_type","sh_normal","sh_symbol"],-1],[/"/g,"sh_string",3]],[[/$/g,null,-2]],[[/\*\//g,"sh_comment",-2],[/(?:<?)[A-Za-z0-9_\.\/\-_~]+@[A-Za-z0-9_\.\/\-_~]+(?:>?)|(?:<?)[A-Za-z0-9_]+:\/\/[A-Za-z0-9_\.\/\-_~]+(?:>?)/g,"sh_url",-1],[/<\?xml/g,"sh_preproc",2,1],[/<!DOCTYPE/g,"sh_preproc",4,1],[/<!--/g,"sh_comment",5],[/<(?:\/)?[A-Za-z](?:[A-Za-z0-9_:.-]*)(?:\/)?>/g,"sh_keyword",-1],[/<(?:\/)?[A-Za-z](?:[A-Za-z0-9_:.-]*)/g,"sh_keyword",6,1],[/&(?:[A-Za-z0-9]+);/g,"sh_preproc",-1],[/<(?:\/)?[A-Za-z][A-Za-z0-9]*(?:\/)?>/g,"sh_keyword",-1],[/<(?:\/)?[A-Za-z][A-Za-z0-9]*/g,"sh_keyword",6,1],[/@[A-Za-z]+/g,"sh_type",-1],[/(?:TODO|FIXME|BUG)(?:[:]?)/g,"sh_todo",-1]],[[/\*\//g,"sh_comment",-2],[/(?:<?)[A-Za-z0-9_\.\/\-_~]+@[A-Za-z0-9_\.\/\-_~]+(?:>?)|(?:<?)[A-Za-z0-9_]+:\/\/[A-Za-z0-9_\.\/\-_~]+(?:>?)/g,"sh_url",-1],[/(?:TODO|FIXME|BUG)(?:[:]?)/g,"sh_todo",-1]],[[/$/g,null,-2],[/</g,"sh_string",11],[/"/g,"sh_string",12],[/\/\/\//g,"sh_comment",1],[/\/\//g,"sh_comment",7],[/\/\*\*/g,"sh_comment",8],[/\/\*/g,"sh_comment",9]],[[/$/g,null,-2],[/>/g,"sh_string",-2]],[[/$/g,null,-2],[/\\(?:\\|")/g,null,-1],[/"/g,"sh_string",-2]],[[/"/g,"sh_string",-2],[/\\./g,"sh_specialchar",-1]],[[/'/g,"sh_string",-2],[/\\./g,"sh_specialchar",-1]]];
--- a/tutorial/eo/Parallelization/js/shjs.js
+++ b/tutorial/eo/Parallelization/js/shjs.js
--- a/tutorial/eo/Parallelization/mpi.c
+++ b/tutorial/eo/Parallelization/mpi.c
@ -0,0 +1,35 @@
+# include <mpi.h>
+# include <stdio.h>
+# include <string.h>
+
+int main(int argc, char **argv)
+{
+    int rank, size;
+    char someString[] = "Can haz cheezburgerz?";
+
+    MPI_Init(&argc, &argv);
+
+    MPI_Comm_rank( MPI_COMM_WORLD, & rank );
+    MPI_Comm_size( MPI_COMM_WORLD, & size );
+
+    if ( rank == 0 )
+    {
+        int n = 42;
+        int i;
+        for( i = 1; i < size; ++i)
+        {
+            MPI_Send( &n, 1, MPI_INT, i, 0, MPI_COMM_WORLD );
+            MPI_Send( &someString, strlen( someString )+1, MPI_CHAR, i, 0, MPI_COMM_WORLD );
+        }
+    } else {
+        char buffer[ 128 ];
+        int received;
+        MPI_Status stat;
+        MPI_Recv( &received, 1, MPI_INT, 0, 0, MPI_COMM_WORLD, &stat );
+        printf( "[Worker] Number : %d\n", received );
+        MPI_Recv( buffer, 128, MPI_CHAR, 0, 0, MPI_COMM_WORLD, &stat );
+        printf( "[Worker] String : %s\n", buffer );
+    }
+
+    MPI_Finalize();
+}
				`@ -0,0 +1 @@`
				if(!this.sh_languages){this.sh_languages={}}sh_languages.cpp=[[[/(\b(?:class\|struct\|typename))([ \t]+)([A-Za-z0-9_]+)/g,["sh_keyword","sh_normal","sh_classname"],-1],[/\b(?:class\|const_cast\|delete\|dynamic_cast\|explicit\|false\|friend\|inline\|mutable\|namespace\|new\|operator\|private\|protected\|public\|reinterpret_cast\|static_cast\|template\|this\|throw\|true\|try\|typeid\|typename\|using\|virtual)\b/g,"sh_keyword",-1],[/\/\/\//g,"sh_comment",1],[/\/\//g,"sh_comment",7],[/\/\\/g,"sh_comment",8],[/\/\/g,"sh_comment",9],[/(\bstruct)([ \t]+)([A-Za-z0-9_]+)/g,["sh_keyword","sh_normal","sh_classname"],-1],[/^[ \t]#(?:[ \t]include)/g,"sh_preproc",10,1],[/^[ \t]#(?:[ \t][A-Za-z0-9_])/g,"sh_preproc",-1],[/\b[+-]?(?:(?:0x[A-Fa-f0-9]+)\|(?:(?:[\d]\.)?[\d]+(?:[eE][+-]?[\d]+)?))u?(?:(?:int(?:8\|16\|32\|64))\|L)?\b/g,"sh_number",-1],[/"/g,"sh_string",13],[/'/g,"sh_string",14],[/\b(?:__asm\|__cdecl\|__declspec\|__export\|__far16\|__fastcall\|__fortran\|__import\|__pascal\|__rtti\|__stdcall\|_asm\|_cdecl\|__except\|_export\|_far16\|_fastcall\|__finally\|_fortran\|_import\|_pascal\|_stdcall\|__thread\|__try\|asm\|auto\|break\|case\|catch\|cdecl\|const\|continue\|default\|do\|else\|enum\|extern\|for\|goto\|if\|pascal\|register\|return\|sizeof\|static\|struct\|switch\|typedef\|union\|volatile\|while)\b/g,"sh_keyword",-1],[/\b(?:bool\|char\|double\|float\|int\|long\|short\|signed\|unsigned\|void\|wchar_t)\b/g,"sh_type",-1],[/~\|!\|%\|\^\|\\|\(\|\)\|-\|\+\|=\|\[\|\]\|\\\|:\|;\|,\|\.\|\/\|\?\|&\|<\|>\|\\|/g,"sh_symbol",-1],[/\{\|\}/g,"sh_cbracket",-1],[/(?:[A-Za-z]\|_)[A-Za-z0-9_](?=[ \t]\()/g,"sh_function",-1],[/([A-Za-z](?:[^`~!@#$%&()_=+{}\|;:",<.>\/?'\\[\]\^\-\s]\|[_]))((?:<.>)?)(\s+(?=[&][A-Za-z][^`~!@#$%&()_=+{}\|;:",<.>\/?'\\[\]\^\-\s]\s[`~!@#$%&()_=+{}\|;:",<.>\/?'\\[\]\^\-\[\]]+))/g,["sh_usertype","sh_usertype","sh_normal"],-1]],[[/$/g,null,-2],[/(?:<?)[A-Za-z0-9_\.\/\-_~]+@[A-Za-z0-9_\.\/\-_~]+(?:>?)\|(?:<?)[A-Za-z0-9_]+:\/\/[A-Za-z0-9_\.\/\-_~]+(?:>?)/g,"sh_url",-1],[/<\?xml/g,"sh_preproc",2,1],[/<!DOCTYPE/g,"sh_preproc",4,1],[/<!--/g,"sh_comment",5],[/<(?:\/)?[A-Za-z](?:[A-Za-z0-9_:.-])(?:\/)?>/g,"sh_keyword",-1],[/<(?:\/)?[A-Za-z](?:[A-Za-z0-9_:.-])/g,"sh_keyword",6,1],[/&(?:[A-Za-z0-9]+);/g,"sh_preproc",-1],[/<(?:\/)?[A-Za-z][A-Za-z0-9](?:\/)?>/g,"sh_keyword",-1],[/<(?:\/)?[A-Za-z][A-Za-z0-9]/g,"sh_keyword",6,1],[/@[A-Za-z]+/g,"sh_type",-1],[/(?:TODO\|FIXME\|BUG)(?:[:]?)/g,"sh_todo",-1]],[[/\?>/g,"sh_preproc",-2],[/([^=" \t>]+)([ \t])(=?)/g,["sh_type","sh_normal","sh_symbol"],-1],[/"/g,"sh_string",3]],[[/\\(?:\\\|")/g,null,-1],[/"/g,"sh_string",-2]],[[/>/g,"sh_preproc",-2],[/([^=" \t>]+)([ \t])(=?)/g,["sh_type","sh_normal","sh_symbol"],-1],[/"/g,"sh_string",3]],[[/-->/g,"sh_comment",-2],[/<!--/g,"sh_comment",5]],[[/(?:\/)?>/g,"sh_keyword",-2],[/([^=" \t>]+)([ \t])(=?)/g,["sh_type","sh_normal","sh_symbol"],-1],[/"/g,"sh_string",3]],[[/$/g,null,-2]],[[/\\//g,"sh_comment",-2],[/(?:<?)[A-Za-z0-9_\.\/\-_~]+@[A-Za-z0-9_\.\/\-_~]+(?:>?)\|(?:<?)[A-Za-z0-9_]+:\/\/[A-Za-z0-9_\.\/\-_~]+(?:>?)/g,"sh_url",-1],[/<\?xml/g,"sh_preproc",2,1],[/<!DOCTYPE/g,"sh_preproc",4,1],[/<!--/g,"sh_comment",5],[/<(?:\/)?[A-Za-z](?:[A-Za-z0-9_:.-])(?:\/)?>/g,"sh_keyword",-1],[/<(?:\/)?[A-Za-z](?:[A-Za-z0-9_:.-])/g,"sh_keyword",6,1],[/&(?:[A-Za-z0-9]+);/g,"sh_preproc",-1],[/<(?:\/)?[A-Za-z][A-Za-z0-9](?:\/)?>/g,"sh_keyword",-1],[/<(?:\/)?[A-Za-z][A-Za-z0-9]/g,"sh_keyword",6,1],[/@[A-Za-z]+/g,"sh_type",-1],[/(?:TODO\|FIXME\|BUG)(?:[:]?)/g,"sh_todo",-1]],[[/\\//g,"sh_comment",-2],[/(?:<?)[A-Za-z0-9_\.\/\-_~]+@[A-Za-z0-9_\.\/\-_~]+(?:>?)\|(?:<?)[A-Za-z0-9_]+:\/\/[A-Za-z0-9_\.\/\-_~]+(?:>?)/g,"sh_url",-1],[/(?:TODO\|FIXME\|BUG)(?:[:]?)/g,"sh_todo",-1]],[[/$/g,null,-2],[/</g,"sh_string",11],[/"/g,"sh_string",12],[/\/\/\//g,"sh_comment",1],[/\/\//g,"sh_comment",7],[/\/\\/g,"sh_comment",8],[/\/\*/g,"sh_comment",9]],[[/$/g,null,-2],[/>/g,"sh_string",-2]],[[/$/g,null,-2],[/\\(?:\\\|")/g,null,-1],[/"/g,"sh_string",-2]],[[/"/g,"sh_string",-2],[/\\./g,"sh_specialchar",-1]],[[/'/g,"sh_string",-2],[/\\./g,"sh_specialchar",-1]]];