Ceci est un livre qui traite de comment faire faire au ordinateurs ce que vous voulez qu'ils fasses. Les ordinateurs sont aujourd'hui aussi commun que les tournevis, mais contiennent bien plus de complexité cachée et sont donc bien plus compliqués à utiliser et comprendre. Pour beaucoup, ils restent des choses extraordinaires et légèrement menacantes.

Nous avons trouvé deux manières efficaces de combler le gouffre entre nous, organismes biologiques mollassons avec un talent pour le social et le raisonnement spatial, et les ordinateurs, manipulateurs insensibles de données dans signification. La première est d'en appeler à notre sens du monde physique et de construire des interfaces qui ressemblent à ce monde et nous permettent de manipuler des formes sur un écran avec nos doigts. Cela marche très bien pour de la casual machine interaction.

Mais nous n'avons pas encore trouvé une bonne manière d'utiliser l'approche “pointer et cliquer” pour communiquer à l'ordinateur des choses que le concepteur de l'interface n'avait pas anticipées. Pour les open-ended interfaces, comme demander à l'ordinateur de faire des tâches arbitraires, nous sommes plus chanceux avec une approche qui fait appel à notre talent du langage : apprendre à la machine un langage.

Le langage humain autorise des mots et des phrases à être combinées dans de nombreuses façons, ce qui nous permet de dire de nombreuses choses. Les langages compréhensibles par l'ordinateur, quoique habituellement moins flexibles grammaticalement, suivent un principe similaire.

Le “Casual computing” s'est bien davantage répandu lors des 20 années passées, et les interfaces basées sur le langage, qui étaient encore par le passé la manière par défaut avec laquelles les gens interagissaient avec les ordinateurs, a été largement remplacée par des interfaces graphiques. Mais elles sont toujours là, si vous savez ou regarder. Un de ces langages, JavaScript, est disponible dans chaque navigateur web et est donc disponible à quasiment tout dispositif.

Ce livre vise à vous rendre familier de ce langage afin de vous permettre de faire que l'ordinateur fasse ce que vous vouliez.

  I do not enlighten those who are not eager to learn, nor arouse those who are not anxious to give an explanation themselves. If I have presented one corner of the square and they cannot come back to me with the other three, I should not go over the points again.
  Confucius

Au-delà de l'explication de JavaScript, j'introduirais aussi des principes basiques de la programmation. Il se trouve que la programmation est une discipline difficile. Les règles fondamentales sont simples et claires. Mais les programmes construits sur ces règles tendent à devenir complexes et à introduire leur propre règle et complexité. En quelque sorte, vous construisez votre propre labyrinthe, et vous risquez de vous y perdre.

Il y aura des moments où lire ce livre paraîtra très frustrant. Si la programmation est quelque chose d'entièrement nouveau pour vous, il y aura beaucoup de nouvelles notions à digérer. Beaucoup de cette nouvelle matière sera alors combinée de m'anières qui requiereront de faire de nouvelles connections.

À vous revient la tâche de faire l'effort nécessaire. Si vous éprouvez des difficultées à suivre ce livre, ne sautez pas rapidement à des conclusions quand à vos propres capacités. Yout va bien, il faut juste perséverer. Faites une pause, relisez un peu, et assurez vous toujours de lire et comprendre les exemples de programmes et les exercices. Apprendre est un travail difficile, mais tout ce que vous apprendrez sera votre et rendra l'apprentissage suivant plus simple.

  The computer programmer is a creator of universes for which he [sic] alone is responsible. Universes of virtually unlimited complexity can be created in the form of computer programs.

  Le programmeur est créateur d'univers pour lesquels il est seul responsable. Des univers sont d'une complexité virtuellement illimité peuvent être créés sous la forme de programmes informatiques.
  
  Joseph Weizenbaum, Computer Power and Human Reason (Puissance de l'ordinateur et raison humaine)

Un programme informatique, c'est de nombreuses choses. C'est un texte tapé par un programmeur, c'est la force directrice qui fait qu'un ordinateur fait ce qu'il fait, ce sont les données dans la mémoire de l'ordinateur, alors même que l'ordinateur contrôle des opérations effectuées sur cette même mémoire. Les analogies qui tentent de comparer les programmes à des objets qui nous sont familiers sont vites prises de court. Une de ces analogies, superficielle, qui fonctionne, est celle de la machine - beaucoup de pièces séparées sont impliquées, et pour faire fonctionner l'ensemble, nous devons considérer la manière dont ces différentes pièces s'interconnectent et contribuent à l'opération dans son ensemble.

Un ordinateur est une machine construite pour héberger une de ces machines immatérielles. Les ordinateurs en soi ne peuvent que stupidement exécuter des choses basiques. La raison qui les rend si utiles est qu'ils le font à une vitesse incroyablement rapide. Un programme peut ingénieusement combiner une énorme nombre de ces actions simples pour faires des choses très compliquées.

Pour certains d'entre nous, écrire des programmes est un jeu fascinant. Un programme est une construction de la pensée. Il ne coûte rien à construire, il ne pèse rien, et il se développe facilement sous nos doigts qui les tapent.

Mais sans attention, la taille et la complexité d'un programme croîra de manière incontrôlable, échappant même à la personne l'ayant créé. Garder les programmes sous contrôle est un des principal problème de la programmation. Lorsqu'un programme fonctionne, c'est très bien. L'art de la programmation est l'art de contrôler la complexité. Un bon programme est subdued—made simple in its complexity

Beaucoup de programmeurs pensent que cette complexité est gérée au mieux en n'utilisant dans leur programme qu'une petite partie de techniques parfaitement maîtrisées. Ils ont composé des règles simples (“best practices”) prescrivant la forme que les programmes devraient avoir, et les plus zélés d'entre eux considèrerons ceux qui sortent de cette petite zone sécurisée comme de mauvais programmeurs.

Quelle hostilitée à la richesse de la programmation — essayer de la réduire à quelque chose d'évident et de prédicatble, placer un tabou sur tous les programmes bizarres et beaux ! La paysage des techniques de programmation est énorme, fascinant dans sa diversité, et toujours largement inexploré. Il est certainement dangereux d'amener le programmeur inexpérimenté vers tout type de confusion, mais cela signifie que vous devriez toujours procéder avec précaution et rester sur vos gardes. Lors de votre apprentissage, il y aura toujours de nouveaux défis et territoires à explorer. Les programmeurs qui refusent de continuer à explorer stagneront, oublieront leur joie, et s'ennuieront même de leur art.

Au tout début, à la naissance de l'informatique, il n'y avait pas de langage de programmation. Les programmes ressemblaient à quelque chose comme ça :

00110001 00000000 00000000
00110001 00000001 00000001
00110011 00000001 00000010
01010001 00001011 00000010
00100010 00000010 00001000
01000011 00000001 00000000
01000001 00000001 00000001
00010000 00000010 00000000
01100010 00000000 00000000

Il s'agit d'un programme pour ajouter les nombres de 1 à 10 ensemble et imprimer le résultat : 1 + 2 + … + 10 = 55. Il peut être exécuter sur une machine simple et hypothétique. Pour programmer les premiers ordinateurs, il était nécessaire de mettre un large ensemble d'interrupteurs sur la bonne position et de faire des trous dans des bandes de carton et de les insérer dans l'ordinateur. Vous pouvez probablement vous imaginer le caractère fastidieux et la propension à l'erreur amenés par cette procédure. Le moindre programme simple nécessitait beaucoup d'intelligence et de discipline. Les programmes plus complexes étaient quasiment inconcevables.

Bien sur, entrer manuellement ces motifs ésotériques de bits (les un et les zéro) devait donner au programmeur l'impression d'être une sorte de puissant sorcier. Et cela devait représenter quelque chose en terme de satisfaction au travail.

Chaque ligne du programme précédent contient une unique instruction. Il pourrait être écrit en français comme suit :

1. Store the number 0 in memory location 0.
2. Store the number 1 in memory location 1.
3. Store the value of memory location 1 in memory location 2.
4. Subtract the number 11 from the value in memory location 2.
5. If the value in memory location 2 is the number 0,
   continue with instruction 9.
6. Add the value of memory location 1 to memory location 0.
7. Add the number 1 to the value of memory location 1.
8. Continue with instruction 3.
9. Output the value of memory location 0.

1. Stocker le nombre 0 en mémoire à l'emplacement 0.
2. Stocker le nombre 1 en mémoire à l'emplacement 1.
3. Stocker la valeur en mémoire à l'emplacement 1 à l'emplacement 2.
4. Soustraire le nombre 11 à la valeur en mémoire à l'emplacement 2.
5. Si la valeur en mémoire à l'emplacement 2 est le nombre 0,
   continuer avec l'instruction 9.
6. Ajouter à la valeur en mémoire à l'emplacement 1 la valeur en mémoire à l'emplacement 0.
7. Ajouter le nombre 1 à la valeur en mémoire à l'emplacement 0.
8. Continuer avec l'instruction 3.
9. Retourner la valeur en mémoire à l'emplacement 0.

Même si cela est déjà plus lisible que la soupe de bits, c'est toujours plutôt déplaisant. Cela pourraît être aider d'utiliser des noms plutôt que des nombres pour les instructions et les emplacements mémoire.

 Set “total” to 0.
 Set “count” to 1.
[loop]
 Set “compare” to “count”.
 Subtract 11 from “compare”.
 If “compare” is zero, continue at [end].
 Add “count” to “total”.
 Add 1 to “count”.
 Continue at [loop].
[end]
 Output “total”.

Pouvez-vous voir comment le programme fonctionne à ce point ? Les deux premières lignes donnent aux deux emplacement mémoire leur valeur de départ : total va être utilisé pour construire le résultat du calcul, et count va garder trace du nombre que nous cherchons. Les lignes utilisant compare sont sans doute les plus bizarres. Le programme veut voir si count est égal à 11 afin de décider s'il peut arrêter de tourner. Comme notre machine hypothétique est plutôt primitive, elle peut seulement tester si un nombre est zéro et faire une décision (sauter à un point x) sur la base de cela. Elle utilise donc la valeur en mémoire nommée compare pour calculer la valeur de count - 11 et incrémenter count de 1 chaque fois que le programme décide que count n'est pas encore 11.

Voici le même programme en JavaScript :

var total = 0, count = 1;
while (count <= 10) {
  total += count;
  count += 1;
}
console.log(total);
// → 55

Cette version nous donne quelques améliorations supplémentaires. Et plus important, il n'y a plus besoin de spécifier la manière dont nous voulons voir notre programme sauter d'une instruction à l'autre. La construction while le prend en charge. Elle continue d'exécuter le bloc le suivant (englobé dans des accolades) tant que la condition qui lui a été donné est remplie. Cette condition est count ⇐ 10, ce qui signifie “ count est inférieur ou égal à 10”. Nous n'avons plus besoin de créer une valeur temporaire et de la comparer à zéro, ce qui était un détail inintéressant. Un part de la puissance des langages de programmation est qu'ils prennent en charge pour nous ce genre de détails inintéressants.

À la fin du programme, après que la construction while soit terminée, l'opération console.log est appliquée au résultat de manière à l'imprimer en sortie.

Pour terminer, voilà quoi ce programmer pourrait ressembler si nous avions les fort pratique opération range et sum disponibles, qui respectivement crééent une collection de nombre à l'intérieur d'une plage (range) et calcule la somme d'une collection de nombres :

console.log(sum(range(1, 10)));
// → 55

La morale de cette histoire est qu'un programme peut être exprimée de manière longue ou courte, illisible ou lisible. La première version du programme est extrêmement obscure, tandis que la dernière est quasiment de l'anglais : log the sum of the range of numbers from 1 to 10.(imprime la suite de nombres de 1 à 10) (Nous verrons dans de prochains chapitres comment construire des opérations comme sum et range).

Un bon langage de programmation aide le programmeur en lui permettant de parler des actions que l'ordinateur doit exécuter à un plus haut niveau (bas niveau = langage machine, haut-niveau : langage de programmation proche du langage humain). Il aide à omettre les détails inintéressants, fourni les blocs de construction (comme while et console.log), permet de définir ses propres blocs de construction (comme sum et range), et rend la composition à l'aide de ces blocs aisée.

JavaScript a été présenté en 1995 comme un moyen d'ajouter des programmes aux pages web dans le navigateur Netscape. La langagea depuis été adopté par tous les autres principaux navigateurs graphiques. Il a permis de rendre possible les applications web modernes — applications avec lesquelles vous pouvez interagir directement, sans avoir à recharger la page pour chaque action. C'est aussi utilisé dans des sites internet plus traditionnels pour fourni de formes variées d'interactivité et d'intelligence.

Il est important de noter que JavaScript n'a quasiment rien à voir avec le langage de programmation nommé Java. Le nom similaire a été inspiré pour des considérations marketing, davantage que pour des raisons intelligentes. Lorsque JavaScript a été présenté, la langage Java était fortement marketé et gagnait en popularité. Quelqu'un a pensé que cela pouvait être une bonne idée du surfer sur ce succès. Nous sommes maintenant bloqués avec ce nom.

Après son adoption hors de Netscape, un document standard fut écrit pour décrire la manière donc le langage JavaScript devait fonctionner pour être sûr que les différents logiciels clamant supporter JavaScript parlaient bien du même langage. Il est appelé le standard ECMAScript, d'après l'organisation internationale ECMA qui fit la standardisation. En pratique, ECMAScript et JavaScript peuvent être utilisés de manière interchangeable — ce sont deux noms pour le même langage.

Il en est qui diront des choses effroyables sur le langage JavaScript. Beaucoup de ces choses sont vraies. La première fois que j'ai eu a écrire quelque chose en JavaScript, j'en suis rapidement venue à le maudire. Il acceptait à peu près tout ce que je tapais, mais l'interprêtait d'une manière totalement différente de ce que j'avais voulu signifier. Cela avait beaucoup à voir avec le fait que je n'avais aucune idée de ce que je faisais bien sûr, mais il y a aussi un réel problème ici : JavaScript est ridiculement tolérant dans ce qu'il accepte. L'idée derrière cela était de rendre la programmation plus aisée pour les débutants. En réalité, cela rend juste la recherche de problèmes dans vos programme s lus difficile puisque le système ne vous indiqueras pas où ils sont.

Cette flexibilité à toutefois ses avantages. Elle laisse la place pour beaucoup de techniques impossibles dans des langages plus rigides, et comme nous allons le voir (par exemple dans le chapitre 10), cela peut être utiliser pour dépasser certaines limitatons de JavaScript. Après avoir correctement appris le langage et travailler avec quelques temps, j'ai finir par apprendre à aimer JavaScript.

Il y a eu différentes versions de JavaScript. La version 3 d'ECMAScript a été largement supportée durant l'ascension de JavaScript vers la domination, en gros entre 2000 et 2010. À ce moment, le travail était en cours vers une ambitieuse version 4, qui planifiait bon nombre d'améliorations radicales et d'extension au langage. Changer un langage vivant, très utilisé de manière aussi radicale se trouva être politiquement difficile, et le travail sur la version 4 fut abandonnée en 2008, amenant à une version 5 bien moins ambitieuse qui sortit en 2009. Nous en sommes maintenant à un point ou tous les navigateurs majeurs supportent la version 5, qui est la version du langage sur laquelle nous allons nous focaliser. La version 6 est en court de finalisation, et certains navigateurs commencent à supporter des fonctionnalités de cette version.

Les navigateurs ne sont pas la seul plateforme sur laquelle JavaScript est utilisée. Des bases de données, comme MongoDB et CouchDB, utilisent JavaScript comme langage de scriptage et de requête. Plusieurs plateformes pour la programmation client et serveur, la plus notable étant le projet Node.js (c'est le sujet du chapitre 20) fournissent un puissant environnement pour programmer en JavaScript hors du navigateur.

Le code est le texte qui constitue les programmes. La plupart des chapitres de ce livre en contiennent pas mal. Dans mon expérience, lire et écrire du code sont des parties indispensables de l'apprentissage de la programmation, essayez donc de na pas simplement y jeter l'oeil. Lisez-les attentivement et comprenez-les. Cela peut être lent et déroutant au début, mais je vous promet que vous en prendrez vite l'habitude. Ce sera la même chose pour les exercices. Ne présupposez pas avoir compris tant que vous n'avez pas écrit une solution fonctionnelle.

Je vous recommande de tester vos solutions avec un vrai interpréteur JavaScript. De cette manière, vous aurez un retour instantané indiquant si ce que vous faites marche, et, j'espère, vous serez tenté d'expérimenter et d'aller au-delà des exercices.

Lorsque vous lisez ce livre dans votre navigateur, nous pouvez éditer (et exécuter) tous les programmes d'exemple en les cliquant.

Si vous souhaitez exécuter les programmes définis dans ce livre hors de l'environnement fourni, quelques attentions sont nécessaires. Beaucoup des exemples se suffisent à eux-même et devraient fonctionner dans n'importe quel environnement JavaScript. Mais le code dans les chapitres plus avancées est principalement écrit pour ces environnements spécifiques (le navigateur ou Node.js) et ne peut être exécuté que dans ceux-ci. Aussi, de nombreux chapitres définissent de plus larges programmes, et les segments de code qui y apparaissent dépendent les uns des autres ou de fichiers externes. La sandbox du site internet fourni des liens vers des fichiers zip contenant tous les scripts et données nécéssaires pour exécuter le code d'un chapitre donné.

Ce livre contient globalement 3 parties. Les 11 premiers chapitres s'intéressent au langage JavaScript lui-même. Les 8 chapitres suivants concernent les navigateurs web et la façon dont JavaScript est utilisé pour les programmer. Finallement, deux chapitres sont dévoués à Node.js, un autre environnement où programmer en JavaScript.

Tout du long de ce livre, vous trouverez cinq chaptitres projet, qui décrivent des exemples de larges programmes afin de vous donner un aperçu de réelle programmation. Par ordre d'apparition, nous verrons comment construire un simulation d'intelligence artificielle, un langage de programmation, un jeu de plate-forme, un programme de dessin, et un site web dynamique.

La partie langage de ce livre commence avec quatre chapitres introduisant la structure de base du langage JavaScript. Ils introduisent les contrôles de structure (des mots tels while que vous avez déjà vu dans cette introduction), les fonctions (écrire votre propre opérations), et les structures de données. Après cela, vous serez capable d'écrire vos propres programmes. Ensuite, les chapitres 5 et 6 introduisent des techniques pour utiliser des fonctions et des objets pour écrire du code plus abstrait (dans le sens ayant un niveau d'abstraction plus haut) et ainsi de garder la complexité sous contrôle.

Après un premier chapitre projet, La première partie de ce livre est suivie de chapitres sur gestion des erreurs et correction de celles-ci, sur les expressions régulière (un outil important pour travailler avec des données texte), et sur la modularité—un autre outil contre la complexité. Le second chapitre projet conclut la première partie de ce livre.

La seconde partie, les chapitres 12 à 19, décrit les outils auquels JavaScript a accès dans un navigateur. Vous apprendrez à afficher des choses à l'écran (Chapitres 13 et 16), à répondre à des inputs utilisateur (chapitres 14 et 18), et communiquer à travers le réseau (chapitre 17). À nouveau, cette partie comporte deux chapitres projets.

Après cela, le chapitre 20 décrit Node.js, et le chapitre 21 décrit la construction d'un simple système web utilisant cet outil. Conventions typographiques

Dans ce livre, le texte écrit en monospace représente les éléments de programmes — ce sont parfois des fragments qui se suffisent à eux-même, ou parfois qui réfèrent à des fragments de programments plus grands. Les programmes (vous en avez déjà vu quelques uns) sont écrit comme suit :

function fac(n) {
  if (n == 0)
    return 1;
  else
    return fac(n - 1) * n;
}

De temps à autre, afin de montrer la sortie imprimée par un programme, la sortie attendu est indiquée après, avec deux slashes et une flêche devant

console.log(fac(8));
// → 40320

Bonne chance !