Remerciements à Jean Rohmer

• Des esprits atypiques
• Les informaticiens ont réussi à inventer le désordre sans espace
• Un univers intentionnel

Les langages - historique personnel

• Jouer sur Apple II - Lemonade (1979) - j'ai beaucoup joué avec ce jeu
  http://www.virtualapple.org/lemonadestanddisk.html
• Basic - Tennis Championship (1984) - mon premier logiciel commercialisé
  http://www.virtualapple.org/tennischampionshipdisk.html
• Assembleur - 65816 (1987-1988)
  Pour Broderbund sur Apple II GS : Downhill Challenge et ShowOff
• Ada, List, Turbo Pascal - Master Of Science - 1988
• Assembleur - 6502 -> 68000 (1989)
  Pour Broderbund sur Atari STE : adaptation de Prince Of Persia
• C : Unix (1989)
• Cobol : Unix (1989)

Les langages - historique personnel

• X Windows : DEC Ultrix (1990)
• Objective C, Postscript : NeXT (1991-1992)
• MS Basic : RaPID - Access 2.0 (1994) - générateur d'applications de gestion
• C++ : Windows 95, MFC 4.0 et Visual Studio 4 (1997)
  Pour un éditeur multimédia : La bible de Jérusalem
• Premiers concepts de programmation intentionnelle (1998)
• ASP, Javascript, Ajax (1999) - premiers pas, premiers clients
• C# (1999-2000) - premier cours donnés en interne chez Microsoft France
• Création d'Intentware.com (2001)
• .NET, ASP.NET (2002)

Les langages - historique personnel

• Création d'Ijax basé sur Mootools (2006)
  Pour une association : La Bible multilingues en ligne
  Et une bibliothèque numérique
• Python, Trac, Django, Web2Py (2009)
• CoffeeScript, Coffekup, Docco, Ace (2011) - redémarrage du projet Intentware

Actualité des langages

• Index TIOBE
• http://stackoverflow.com/tags
• http://fr.wikipedia.org/wiki/Langage_de_programmation
• Chronologie des langages de programmation

Gestion de projet

• Comparatif des logiciels de gestion de projet
• Trac
  http://trac.edgewall.org
• Redmine
  http://www.redmine.org
• Project.Net
  http://www.project.net

Modélisation

• Yuml
  http://yuml.me/diagram/scruffy/activity/draw
• GAE Sql
  http://gaesql.appspot.com
• Creately
  http://creately.com
• Gliffy
  http://gliffy.com

Bases de données

• Sqlite - lire toute la doc (passionnante)
  http://sqlite.org
• NoSql - à parcourir
  http://nosql-database.org/
• MongoDB - très interessant
  http://www.mongodb.org/
• DabbleDB - voir la démo pour inspiration
  http://dabbledb.com/demo/#play

Frameworks Javascript

• Prototype - le premier
  http://www.prototypejs.org
• Dojo - le plus complet
  http://dojotoolkit.org
• Mootools - le plus élégant
  http://mootools.net
• Jquery - le plus utilisé
  http://jquery.com/

Frameworks Javascript pour mobiles

• Jquery Mobile - évidemment
  http://jquerymobile.com. Voir aussi la démo
• Sencha Touch - très complet
  http://www.sencha.com/products/touch. Voir aussi la démo
• Wink - très intéressant
  http://www.winktoolkit.org. Voir aussi la démo

Développment pour Mobile

• Titanium
  http://www.appcelerator.com/products
• Phonegap
  http://www.phonegap.com

HTML5

• Références
  http://diveintohtml5.org/
• Tutoriels et Démos
  http://www.html5rocks.com/en/
• Testez votre navigateur
  http://html5test.com

Javascript sur le serveur

• Un monde en pleine ébuilition
• Wakanda - un outil très complet
  http://www.wakanda.org/
• Persevere - un projet très riche et technique
  http://www.persvr.org/Page/Persevere
• Node - un serveur réseau basé sur V8 Javascript
  http://nodejs.org. Voir aussi la doc

Editeur de code en ligne

• Ace - le plus utilisé
  http://ace.ajax.org
• Codemirror
  http://codemirror.net

Environnement de développement en ligne

• Coderun - C#, javascript + .NET ; très impressionant
  http://www.coderun.com/
• Cloud9 - javascript + node.js ; très prometteur
  http://c9.io

Nouveaux langages

• Coffeescript - un javascript simplifié et enrichi
  http://jashkenas.github.com/coffee-script/
• CoffeeKup - un langage de template HTML dérivé de Coffeescript
  http://coffeekup.org
• Less - le langage de stylesheet dynamique
  hhttp://lesscss.org

• Variables globales

  function plus_two(n) { two = 2; return n + two; }
  plus_two(3); // 5 - évidemment, 3 + 2 = 5
  two;         // 2 - ben alors JS ?

• Le bloc with

  var foo = 5;
  with (obj)
      foo; // 5, à moins que obj.foo n'existe

• C'est quoi le problème de l'opérateur == ?

  2 === "2"; // faux - évidemment un nombre n'est pas une chaine
  2 == "2";  // vrai - ben alors JS ?

Que s'est-il passé ?

• Contraintes de temps ?
• Interferences avec le business ?
• Usage de substances interdites ?
• Programmation en binôme ?

server.listen(function(request, response) {
    database.open(function(connection) {
        connection.query("SELECT * FROM posts", function(cursor) {
            cursor.fetchAll(function(posts) {
                response.write(posts.forEach(function(post) {
                    return post.title;
                }));
            });
        });
    });
});

// ben alors ?

• CoffeeScript utilise l'indentation.

  foo = (a, b) ->
    c = a + b     # l'indentation délimite un bloc - "{" implicite
    console.log c # même niveau d'indentation, même bloc
  foo 2, 3        # désindente termine le bloc - "}" implicite

• Les blocs sont définis par l'indentation que vous mettez de toute façon :

  if name != "honey badger"
    care()
  else
    eat_cobra()

  Vous voyez les blocs ?

• Une fonction en JavaScript:

  var sum = function(a, b) {
      return a + b;
  }

• En CoffeeScript:

  sum = (a, b) -> a + b

• function(a, b) devient (a, b) ->
• function() devient simplement ->
• return est implicite: une fonction renvoie toujours la valeur de sa dernière expression.

• Les parenthèses sont optionelles:

  sum = (a, b) -> a + b # vous vous en souvenez ? Ca calcule a + b :)
  
  sum(2, 3) # renvoie 5
  sum 2, 3  # renvoie 5

• Appel de fonction sans argument:

  connection.close() # appelle la fonction close
  connection.close   # renvoie la fonction, ne l'appelle pas

• Toutes les déclarations de variables sont locales:

  foo = "bar"
  # est compilé en:
  var foo;
  foo = "bar";

• Plus de problème mystérieux avec == :

  2 == "2"
  # est compilé en:
  2 === "2" # renvoie faux, comme vous vous y attendez
  
  2 is 2 # est équivalent à 2 == "2"

• En JavaScript:

  var tweet = {
      user: {
          name: "bodiltv",
          url: "http://bodil.tv/"
      },
      text: "PONIES RULE SO HARD"
  };

• En CoffeeScript:

  tweet =
    user:
      name: "bodiltv"
      url: "http://bodil.tv/"
    text: "PONIES RULE SO HARD"

• En JavaScript:

  var things_that_rule = [
      "robot unicorns",
      "honey badgers",
      "Lord Inglip"
  ];

• En CoffeeScript:

  things_that_rule = [
      "robot unicorns"
      "honey badgers"
      "Lord Inglip"
  ]

• Affectation de variables à partir d'un tableau :

  sum_and_difference = (a, b) -> [ a + b, a - b]
  [ sum, difference ] = sum_and_difference 5, 2
  sum # renvoie 7
  difference # revoie 3
  

• Le bloc if :

  if elvis.state == "alive"
    console.log "Hail to the King!"
  else
    console.log "You lie!"

• Il y a une forme plus courte :

  if power_level > 9000 then attack() else retreat()

• Ca peut même être utilisé en tant que suffixe:

  reign_in_graceland() if name == "Elvis"

• La bloucle classique :

  while count > 0
    count -= 1

• until est un raccourci pour while not:

  until power_level > 9000
    power_level += 1

• Et vous pouvez les mettre après une instruction, tout comme if:

  power_level++ while power_level <= 9000

• if fonctionne comme un opérateur ternaire:

  foo = false
  result = if foo then "foo is truthy" else "foo is falsy"
  # result est "foo is falsy"

• while renvoie un tableau:

  counter = 0
  list = while counter < 5
    counter++
    "n" + counter
  # list is [ 'n1', 'n2', 'n3', 'n4', 'n5' ]

• Même l'instruction switch revoie quelque chose:

  result = switch request.error_code
    when 200 then "OK"
    when 301 then "don't live here anymore"
    when 404 then "not found"
    when 500 then "i maed u a page... but i eated it"
    else "unknown error call the police " + request.error_code
  

• Comparisons chainées:

  if 20 < temperature < 30
    venture_outside()

• L'opérateur d'existence:

  foo = { bar: "bar" }
  if foo.bar? then console.log foo.bar
  # if (foo.bar != null) { ... }

• Fatigué de concaténer des chaînes de caractères ? On a récuppéré ça de Ruby:

  pokemon = "Snorlax"
  console.log "Wild #{pokemon} appeared!"
  "Wild Snorlax appeared!"

• On peut même mettre du code dedans:

  pokemon = "Snorlax"
  console.log "Wild #{pokemon.toUpperCase()} appeared!"
  "Wild SNORLAX appeared!"

• Vous voulez des chaînes vraiment grandes ? CoffeeScript n'est pas géné par les sauts de lignes :

  blurb = "I don't always drink beer,
           but when I do,
           I prefer Dos Equis."
  console.log blurb
  "I don't always drink beer, but when I do, I prefer Dos Equis."

• Ou bien utilisez heredocs pour conserver le formatage et ne pas s'occuper des guillemets :

  html = """
         <div class="article">
           <h1>Honey Badger</h1>
           <p>Honey Badger don't care.</p>
         </div>
         """

• Opérateurs de découpage :

  numbers = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
  
  numbers[3..6] # [ 3, 4, 5, 6 ]
  numbers[7..]  # [ 7, 8, 9 ]
  numbers[..3]  # [ 0, 1, 2, 3 ]

• Et nous pouvons aussi faire des remplacements :

  numbers = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
  
  numbers[3..6] = [ "foo", "bar" ]
  numbers # [ 0, 1, 2, "foo", "bar", 7, 8, 9 ]
                

• Itérer sur les membre d'une liste :

  numbers = [ 1, 2, 3, "many" ]
  for number in numbers
    console.log "I just counted to #{number}"

• Il y a une forme suffixe, bien sûr :

  numbers = [ 1, 2, 3, "many" ]
  console.log "I just counted to #{number}" for number in numbers

• Et ça renvoie une nouvelle liste:

  numbers = [ 1..5 ]
  result = number + 1 for number in numbers
  result # [ 2, 3, 4, 5, 6 ]

Des syntaxes concises pour les opérations map et filter :

( expression for item in array )
( expression for item in array when condition )

( expression for key, value of object )
( expression for key, value of object when condition )

Avez-vous jamais essayé de faire fonctionner Javascript comme un langage orienté objet ?

Shape = function(x, y) {
    this.x = x;
    this.y = y;
};

Shape.prototype.centre = function() {
    return [ this.x, this.y ];
};

Shape.prototype.area = function() {
    return 0;
};

var point = new Shape(13, 37);

• Dans votre page web :

  <script type="text/javascript" src="coffee-script.js"></script>
  
  <script type="text/coffeescript" src="my.coffee"></script>

• Dans Node:

  $ npm install coffee-script

  var my_cs_module = require("./my_cs_module");

• Compiler puis exécuter partout où Javascript fonctionne :

  $ coffee -c my_script.coffee