Votre formateur à domicile. C'est vraiment l'impression que j'ai eue en regardant cette formation. Elle est détaillée, passe bien en revue les nouveautés de Photoshop CS5 : une mise à niveau vers cette nouvelle version, à peu près comme une formation en vrai. L'avantage ? Vous avez directement la liste des parties disponibles, vous pouvez sans problème aller directement à la partie qui vous intéresse. Elles ne sont pas prévues pour être visualisées les unes à la suite des autres : si vous n'utilisez jamais Camera Raw, il vous est inutile de regarder cette partie. Cependant, je ne vous le conseille pas : vous découvrirez ici des fonctionnalités très facilement accessibles (toujours disponibles sous Photoshop mais dans une interface plus lourde). Cela pose quand même un problème : quand on regarde toute la formation d'un bout à l'autre, on a l'impression que le formateur répète, voire bégaye.

La formation est divisée en trois chapitres, chaque chapitre étant subdivisé en une multitude de parties, généralement assez courtes (entre deux et trois minutes), parfois plus longues (jusqu'à une dizaine de minutes) soit plus globales, où l'on vous montre les principales nouveautés dans telle partie, soit plus précises, elles entrent alors dans le détail des nouveautés, tout ce qu'il est possible de dire sur une nouveauté l'est. Tout est bien expliqué, bien détaillé, rien à redire, la compréhension vient toute seule, tout est fait pour qu'elle ne tarde pas.

S'il y a des lacunes techniques dans la présentation (le volume sonore des vidéos n'est pas toujours égalisé) à certains niveaux, d'autres points les compensent : notamment la possibilité de mettre des signets pour revenir à un endroit que l'on n'a pas bien compris, plus intéressant pour son utilisation personnelle, que l'on aimerait montrer à un quidam, etc.

La formation n'est pas prévue pour débuter avec Photoshop, loin de là : elle s'adresse à ceux qui connaissent déjà Photoshop dans une version antérieure et ont envie d'exploiter au mieux cette nouveauté, voir ce qui est maintenant disponible et si elle mérite un achat ou tout simplement à ceux qui veulent devenir de plus en plus efficaces avec la nouvelle mouture du célèbre logiciel. Il n'est pas non plus nécessaire d'avoir une expérience millénaire dans le logiciel : simplement savoir l'utiliser correctement est suffisant.

On pourrait alors croire que des fonctionnalités plus avancées sont évincées de la formation : tel n'a pas été le but. Ici, toutes les nouveautés qui peuvent faire gagner du temps sont présentées, même si l'utilisateur moyen de Photoshop n'en connaît pas toutes les subtilités (j'ai particulièrement été étonné de voir que l'option d'expression régulière dans le renommage de Bridge a été citée, de même que grep, alors qu'en général elles sont réservées à une certaine élite qui les manie tant bien que mal).

Au final, il s'agit là d'une formation très intéressante, vous ne pourrez qu'y apprendre à mieux utiliser la dernière version en date de Photoshop. Grâce à elle, vous utiliserez le logiciel encore plus efficacement, sans passer du temps inutilement à essayer par des moyens détournés ce qui est possible directement. Au final, vous maîtriserez mieux l'outil mais surtout plus vite.

Vous avez vu cette formation ? Qu'en pensez-vous ? Commentez

Vous rêviez de prendre des cours sur Photoshop ? Les horaires ne vous convenaient pas ? video2brain vous a trouvé LA solution : les formations vidéo. À un tel point que certains profs utilisent leurs vidéos pour donner cours.

Au niveau du contenu, il respecte bien le titre : tout ce dont vous avez besoin pour commencer à travailler efficacement et sérieusement avec Photoshop est abordé, quelle que soit votre utilisation au final. Cependant, le formateur venant du monde de la photographie, il oriente sa formation en ce sens - tout en restant tout aussi bien adaptée à toutes les utilisations du logiciel. Vous apprendrez ainsi à vous servir de l'interface, à la personnaliser, à l'adapter à vos besoins - on parle bien ici de l'interface de Photoshop CS5, ce n'est pas une ancienne formation pour une version très antérieure du logiciel qui a été recyclée, c'est entièrement adapté aux dernières améliorations apportées par Adobe.

N'oublions pas un point important : les exercices. Évidemment, vous n'avez pas l'énoncé puis un quart d'heure pour résoudre le problème posé ; rien ne vous empêche de regarder le début de ces vidéos, voir ce à quoi le formateur veut parvenir et le faire par vous-mêmes. Vous en apprendrez ainsi beaucoup. Néanmoins, ces exercices sont prévus pour être regardés, visionnés, décortiqués puis refaits sur d'autres images. Ils ne sont pas vides de contenu didactique, ils font autant partie de la formation que les vidéos plus « théoriques ». Certains aiment, d'autres détestent.

Une question que beaucoup se poseront : cette formation est-elle bien prévue pour des débutants ? La réponse est oui. Enfin, si un débutant sait comment installer et lancer un logiciel, se servir d'une souris et d'un clavier, possède un minimum d'esprit artistique, alors il n'aura pas de problème pour suivre la formation. Il ne finira pas par maîtriser Photoshop, ce n'est pas l'objectif. Il parviendra à se servir efficacement des bases de Photoshop. Même des parties plus avancées, comme les courbes. Elles sont extrêmement dures à maîtriser et pourtant extrêmement pratiques. C'est pour ça que pas moins de deux vidéos y sont consacrées. Dix minutes pour comprendre cette fonctionnalité de Photoshop, ce n'est pas trop peu.

Vous connaissez déjà Photoshop ? Cette formation risque quand même de vous être utile. Vous ne connaissez peut-être pas toutes les bases de Photoshop, surtout si vous avez appris en autodidacte. Si vous êtes professionnel et utilisez déjà Photoshop au quotidien, passez votre chemin, vous n'apprendrez rien de neuf (peut-être serez-vous remis sur le droit chemin de l'utilisation de la version CS5).
Vous ne connaissez rien à Photoshop ni à la retouche en général ? Vous êtes très exactement au bon endroit ! Tout vous sera expliqué, trop peut-être.
Vous venez d'un autre logiciel ? Vous connaissez donc déjà les bases, vous sauterez l'introduction et quelques chapitres de base, les interfaces de ces logiciels n'étant pas sans aucune ressemblance. Tout le reste vous sera utile, la puissance des outils de Photoshop étant souvent sans égale.

Vous avez vu cette formation ? Qu'en pensez-vous ? Commentez

Première impression en ouvrant ce livre : il va vraiment au fond des choses. L'auteure n'hésite pas à ponctuer son texte d'expressions comme « vous en apprendrez plus que vous ne l'auriez jamais voulu » - vraiment, c'est très exactement ce qu'elle fait ! Ainsi, le lecteur se trouve plongé dans les arcanes du logiciel, dans les palettes d'outils plus que pléthoriques - tous y passent, certains sont développés sur une section plus large que d'autres, étant par nature plus indispensables (comme les brosses), tandis que d'autres n'ont droit qu'à un encart, tel l'outil d'accentuation (un filtre d'accentuation associé aux masques donnant un résultat bien meilleur).

Avant d'aborder des notions plus pointues, quelques concepts sont prérequis ; quand certains vous laissent aller sur le Web faire une recherche sur le sujet, ce Missing Manual veut tout couvrir : vous apprendrez en profondeur toutes les bases nécessaires à la compréhension du fonctionnement de certains outils, filtres ou techniques. Cela n'étant évidemment pas sans but : sans ces connaissances, seul le flair pourrait guider l'utilisateur jusqu'au résultat désiré ; avec ce livre, vous ne serez plus livré aux aléas du « pifomètre », vous saurez quel outil utiliser à quel moment et pourquoi - très exactement l'objectif avoué du livre.

Le style, assez simple et sobre, ne vire pas dans le moindre excès, permettant à tout lecteur un peu aguerri de l'anglais de s'y plonger tête baissée : n'allez pas acheter un autre livre sous le prétexte qu'il est en français. Il y a très peu de chances qu'il soit meilleur que celui-ci, qu'il soit autant à la portée de tous que celui-ci.

Cependant, il ne faut pas croire que, ici, tout est rose. Il y a quand même quelques points plus noirs. Notamment, les trois appendices sont relégués en ligne. Peut-être pour sauver l'environnement, abaisser un peu le prix du livre... mais nettement moins lisible. Si tels étaient les objectifs, il aurait mieux valu tout laisser en ligne. Ensuite, l'absence de CD : quelques fichiers que l'auteure traite et maltraite dans l'ouvrage sont disponibles en ligne, pas de CD accompagnant. La dernière page statue qu'il s'agit là de cinq dollars économisés. Dernièrement, les renvois : chaque page recèle un bon nombre de renvois à d'autres sections du livre, pour plus de détails sur un sujet, pour renvoyer à ce qui a déjà été dit ; louable objectif s'il en est. Cependant, la fréquence de ces rappels n'est pas sans gêner la lecture ; un petit tour dans l'index, fort bien construit, ne nécessiterait pas beaucoup plus de temps et faciliterait la lecture. Sans oublier le lot de frustrations : page 133, voir une référence jusqu'à la page 388, qui ne viendra que bien plus tard dans une lecture séquentielle du livre. Cela n'est pas sans souligner une autre caractéristique de l'ouvrage : il est conçu à la fois pour être une référence rapide lors du travail quotidien et pour être un livre d'apprentissage de Photoshop, c'est en cela qu'il s'adresse autant aux débutants qu'aux utilisateurs plus avertis.

Remarquons aussi qu'il est organisé de telle sorte que tout utilisateur puisse l'utiliser : les photographes, notamment, auront une liste de chapitres qui leur seront plus utiles que les autres, tandis que les webdesigners auront des parties qui leur sont plus dédiées qu'aux autres usagers de Photoshop. Le tout enrobant quelques pépites de tutoriels étape par étape sur l'utilisation d'un outil, sur un effet, etc.
Pour les experts, des sections Power User Clinic sont incluses ; d'autres boîtes sur des sujets parents, voisins ou un peu plus éloignés mais toujours pertinents sont aussi là pour vous guider, vous expliquer certains choix, certaines autres possibilités.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

Certains disent de ce livre qu'il va leur donner les bases de Python 3 : sur la quatrième de couverture, c'est écrit noir sur blanc, le lecteur est censé avoir une expérience en programmation. Les premiers chapitres ne changent pas le ton, la syntaxe ne sera pas expliquée. En fait, il n'est pas nécessaire de déjà maîtriser la syntaxe de Python pour comprendre pleinement ce livre. Une expérience de programmation suffit ; les exemples sont donnés dans le bon ordre, c'est-à-dire par niveau croissant de difficulté ; les meilleures pratiques n'ont pas droit à tous les détails quand elles se limitent à la syntaxe (alors que l'auteur, même s'il a dit qu'il ne le ferait pas, donne le squelette de ce qui est nécessaire à leur compréhension). Il n'est absolument pas nécessaire d'avoir un tel bagage en Python ; cela ne peut qu'aider, bien évidemment, le lecteur pourra alors se plonger plus directement dans l'étude des exemples.

Tout au long du livre, l'auteur a parsemé des exemples - réalistes, complets, jusque quelques milliers de lignes pour PyMailGUI -, pas seulement quelques lignes éclaircissant un concept. On trouve des exemples pour faire comprendre tout ce qui est à comprendre du concept étudié, avec sur le côté d'autres exemples, plus longs, commentés en suffisance, entourés de quelques paragraphes d'explication, etc. On peut dire que l'auteur construit ses exemples étape par étape, il est impossible de s'y perdre. Même sur l'épineux sujet des threads, bête noire de tout développeur, il explique en détail ce qui doit l'être, les subtilités techniques n'ont plus de secret. Le tout étant utilisé dans des applications réelles. On trouve même des chapitres dédiés à l'étude d'un exemple, utilisant bien évidemment le code déjà écrit - la réutilisation du code est très importante.

Presque tout sujet principal sur Python est couvert : la programmation système (Python tend à remplacer les scripts Bash et Perl) ; les GUI (Python se montre aussi puissant que le C++ à ce niveau) ; Internet (Python est en plein essor avec des frameworks Web comme Django ou Zope, même si aucun des deux n'est couvert, aucun ne supporte Python 3 actuellement). Le principal problème se situe dans tout ce qui ne peut pas trouver sa place dans ce livre : ZODB, Zope, Django, MySQL, etc. ne sont pas encore portés sur Python 3 ; le livre ne couvrant que cette version de Python, ces sujets doivent être écartés de cette quatrième édition. Notons quand même que ZODB est montré avec Python 2 pour exposer l'utilisation des bases de données orientées objet.

Même si le livre semble impressionnant de par sa taille (1600 pages), il est presque impossible de couvrir autant de sujets en aussi peu de pages. Même si certains sujets auraient pu être couverts, le livre est plus que complet. Certains chapitres aident à comprendre les bases de choses qui ne sont pas couvertes volontairement (les scripts CGI sont expliqués, alors que plus personne ne songerait à les utiliser pour des projets Web modernes, même si les frameworks actuels sont basés sur ces principes).

Avez-vous lu ce livre ? Qu'en pensez-vous ? 1 commentaire

Some thought this book was to give them the basics about Python 3.x; turn the book, it is written: the readers are supposed to have a "previous programming experience." The first chapters are no different, the syntax will not be explained. Actually, you do not need to know Python's syntax to fully understand the book. Programming experience is enough, examples are given in the right order, the best practices are explained not in full details when related to the core language (however, even if he said he will not, the author spends some lines outlining what is really needed). No, it is not required to have completely read a introductive text about Python; of course, it helps, the reader can get more quickly into the full depth of the examples.

Throughout the book you can find examples - realistic, complete (up to thousands of lines for PyMailGUI) -, not a few lines explaining only the concept; you will find there examples for you to understand everything about the studied concept, along with more detailed examples, with comments, concept explanation paragraphs, and the like. One can say he builds his examples step by step, no one can get lost - even when he starts with threads, a subject many developers just do not like, he manages to make everyone completely aware of all those technical subtleties about beginning with threads. Everything here is also shown in use in real world applications.
Examples also mean that the whole book is not all about theory, there are some examples chapters, chapters totally dedicated to a single example, using many snippets written before (code reutilisation is important).

Almost every main subject in Python is covered: system programming, as Python is a replacement for Perl, Bash scripts, etc.; GUIs, as Python can do as much as C++ can in the GUIs' world; Internet, as Python is growing fast with frameworks like Django or Zope (even though any of these is covered: none currently supports Python 3). The main problem is that important things cannot find a place in that book: ZODB, Zope, Django, MySQL, etc. are not yet ported to Python 3; the book only covers Python 3 and thus cannot say much about these. Note that ZODB is shown, in its Python 2 flavour, to show the basics about OODB; wilingly, no Web framework is getting more than a paragraph or two, these technologies are said to change often.

Though this is an impressive book (about 1,600 pages), it is almost impossible to cover so many subjects in so few pages. Even if it lacks a few topics, this book is more than far complete. Some chapters help you understand the basics of things that cannot be covered (CGI scripting is shown, it is not used anymore for new Web projects, but current Web frameworks are based on these principles).

Pour un panorama complet du monde de l'orienté objet, ce livre est certainement à conseiller. L'auteur, par ailleurs professeur à l'ULB (université libre de Bruxelles) démontre son talent pédagogique, dès le début. De nombreuses allusions font d'ailleurs remarquer que ce livre est principalement prévu pour un public étudiant se familiarisant avec la programmation orientée objet, sans rien en connaître, mais ayant déjà connaissance d'un langage de programmation procédural (ou au moins les principes).

Dès le premier exemple, on se plonge dans un environnement Java, sans que cela n'ait été introduit, sans donner vraiment d'explication sur la syntaxe - cela n'est pas vraiment nécessaire, le code est suffisamment documenté pour que la compréhension ne tarde pas. Ensuite sont présentés les différents langages, en s'axant sur leurs particularités syntaxiques, sur les points qui choquent en comparaison au Java. Il n'y a que le minimum qui est présenté, il ne faut pas prendre ce livre pour ce qu'il n'est pas : il introduit à la programmation orientée objet, il n'a pas pour vocation d'apprendre un langage.

C'est d'ailleurs sur ces langages que se portent mes seuls griefs à l'encontre de ce livre : les langages sont parfois fortement détournés pour suivre le discours de l'auteur. On montrera, par exemple, du code Python très peu pythonique, sans utilisation de décorateurs comme @staticmethod ou la définition d'autres constructeurs quand des arguments mots-clés peuvent être utilisés. Du côté C++, on voit, dans les premiers exemples, des directives #include pointées sur... des fichiers .cpp ! Il faut attendre le quinzième chapitre sur les interfaces pour voir l'existence de fichiers .h, ce qui permet de s'assurer de très mauvaises pratiques dans du code C++... Cela passe aussi pour une faiblesse du langage, qu'un utilisateur du C++ pourra faire passer pour une méconnaissance du langage. Passons le fait que le C++/CLI devient du Visual C++ .Net, nom qui n'est attesté sur le Web presque exclusivement comme les nouvelles versions de l'EDI de Microsoft pour le C++, partie de l'environnement plus complet Visual Studio, ainsi que le fait qu'il semble jusqu'au chapitre sur l'héritage que la seule raison de traiter le C++ est de pouvoir en dire tout le mal qu'on peut. Sans oublier que la STL est entièrement nonobstée et que l'on juge les complexités du C++ comme des écarts par rapport aux autres langages, alors qu'il en est l'aîné. On remarque aussi que le PHP est exclusivement utilisé en contexte Web, comme s'il était incapable de faire autre chose (sans oublier que le décorum HTML tout autour ne facilite pas la compréhension de l'exemple, en ajoutant un bon nombre de lignes parfaitement inutiles).
En conclusion de ce paragraphe, on dira que ce livre n'est absolument pas là pour apprendre un langage ou l'autre, ce n'est pas son but, il veut simplement apprendre les bases de la programmation orientée objet, en déclinant les concepts aux différents langages, en montrant leurs différences. Tous les concepts sont illustrés dans tous les langages, permettant ainsi de visualiser in situ les différences de pensée entre les concepteurs. Ces exemples, d'ailleurs, évoluent au fur et à mesure de la progression de la compréhension du lecteur : les premiers exemples sont fort didactiques, on finit dans les derniers chapitres à simuler les réactions chimiques ayant lieu dans un réacteur, on passe d'exemples simplistes à des exemples réalistes.

À un niveau plus général, on remarquera quelques fautes d'orthographe restées malgré les relectures, les schémas de mauvaise facture (réalisés probablement à l'aide d'un logiciel peu évolué tel que Paint), qui font vraiment tache à côté des schémas UML, ainsi que des captures d'écran sur des systèmes d'exploitation relativement préhistoriques (aux alentours de Windows Millenium).

Ce ne sont pas ces quelques défauts qui vont entacher le principal du livre. On appréciera notamment le large chapitre dédié à UML2, ainsi que les schémas UML utilisés bien avant leur formalisation pour aider à comprendre les principes. Des exercices terminent la grande majorité des chapitres, permettant au lecteur de vérifier qu'il a bien assimilé les concepts ; on regrettera de ne voir les solutions que sur le site de l'éditeur, pas dans une annexe au livre.

Il faut aussi remarquer que l'utilisation plus pratique de l'orienté objet est aussi couverte : ainsi, on parlera des méthodes pour la communication entre un client et un serveur à l'aide de RMI, de Corba et d'autres. Sera aussi discutée la sérialisation dans les divers langages, sans toutefois rentrer dans les détails, car ils deviennent plus spécifiques aux langages. On regrettera de ne pas voir ici la sérialisation selon boost pour le C++ ou la fonction serialize() de PHP : ces deux langages ne sont pas arriérés, ils permettent aussi la sérialisation, alors qu'aucune mention n'en est faite.

Des sujets plus pointus comme le multithreading sont aussi abordés : point noir de ce chapitre, C++ et PHP sont oubliés. Signaler qu'aucune méthode vraiment propre n'existe en PHP n'est pas un luxe, préciser l'existence d'une pléthore de possibilités en C++ est un minimum pour tout qui parle de multithreading et de C++ (il n'aurait pas été utile de développer le sujet, mais au moins d'indiquer dans quelle direction chercher si le besoin s'en fait sentir). Les autres langages jouissent d'une description des méthodes disponibles en standard pour obtenir une application multithreadée, en tenant compte de la problématique des accès concurrents.

En bref ? Un ouvrage plus qu'excellent, didactique, qui passe par tous les jalons, toutes les étapes, sans en oublier une, pour la programmation orientée objet. Que le lecteur soit débutant ou plus avancé, il trouvera dans ce livre de quoi apprendre ou se remettre à niveau. Par contre, prendre ce livre pour apprendre un langage n'est pas forcément la meilleure idée, ce n'est pas son objectif, les explications ne vont d'ailleurs pas en ce sens. Le style assez humoristique de l'auteur en fait un livre très facile à lire.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

Mathematica est un outil très puissant, l'auteur le montre à chaque nouvelle recette. Cependant, il faut arriver à l'utiliser, cela n'étant pas facilement possible sans aide externe. Ici, le lecteur est pris par la main, depuis une connaissance très basique requise pour commencer la lecture (avoir joué quelque peu avec Mathematica est bien suffisant), jusqu'à pouvoir résoudre de vrais problèmes à l'aide du logiciel, sans s'enfermer dans un domaine particulier : ce livre s'adresse à tous les publics d'utilisateurs de Mathematica, de l'étudiant au musicien, sans oublier scientifiques, ingénieurs, photographes, développeurs, financiers…

Le livre se base entièrement sur le principe de la résolution de problèmes, des « recettes ». Il n'y a pas de collection de code utile, plus de petits programmes réalisant une tâche spécifique (la dérivation symbolique d'une fonction ou un trémolo).

On ne perd pas de temps sur les bases de Mathematica, un chapitre les expédie rapidement, étant donné qu'il n'est pas nécessaire d'en connaître beaucoup plus. Suit un chapitre sur la programmation fonctionnelle, le paradigme de conception privilégié dans Mathematica. C'est l'un des chapitres les plus durs de tout l'ouvrage, surtout pour ceux qui ne sont pas habitués à une vision fonctionnelle de la programmation ; en tant que tel, il est absolument nécessaire d'avoir compris les principes de ce chapitre, l'auteur n'étant pas avare en exemples : son but est clairement que tout lecteur puisse en comprendre les subtilités. Pour ceux qui connaissent déjà l'un ou l'autre langage fonctionnel, l'auteur réalise quelques parallèles, afin de leur fournir une entrée en matière plus rapide. Les exemples sont généralement dans la catégorie des « one-liners », des programmes rédigés en une seule ligne, bien connus des développeurs Perl, tout en restant lisibles - du moins, pour qui sait les lire, ils sont très explicites. On pourra regretter que plusieurs solutions ne sont pas systématiquement proposées, quand cela peut être utile (autre algorithme, versions intermédiaires menant à la finale, autre paradigme, etc.).

A contrario, un utilisateur beaucoup plus expérimenté avec Mathematica pourra directement consulter les sections qui l'intéressent, l'ouvrage n'étant pas conçu pour n'être lu que d'une couverture à l'autre. En cas de dépendance d'une recette sur un autre chapitre, le lecteur est renvoyé vers la recette correspondante.

On peut diviser ce livre en trois parties : la première, l'introduction à Mathematica, ce qu'il faut savoir pour l'utiliser correctement (programmation fonctionnelle, par motifs ou règles, les structures de données, la gestion du texte et les graphiques - les sept premiers chapitres) ; ensuite, l'utilisation de ces concepts dans des cas plus réalistes (traitement de l'image, du son, fonctionnalités algébriques et analytiques, statistiques, sciences, ingénierie, finance, interactivité) ; finalement, des concepts beaucoup plus avancés pour retirer le maximum de Mathematica (programmation parallèle, interfaçage avec d'autres langages, astuces de débogage et diverses - les quatre derniers chapitres).

Même un utilisateur plus expérimenté peut avoir intérêt à lire la première partie, car il pourra y apprendre à se servir d'outils qu'il n'avait potentiellement jamais imaginés, mais surtout y apprendre à réaliser de meilleurs programmes, pas simplement fonctionnels.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

Petit livre s'il en est. Ses ambitions sont à la hauteur de son épaisseur : avec lui, on peut facilement se mettre dans le bain de CUDA, écrire ses premiers kernels, utiliser l'outil de manière relativement efficace. Par contre, il ne détaille pas l'architecture sous-jacente des processeurs graphiques, il ne perd pas son temps à expliquer le vocabulaire et les détails de la programmation parallèle tant que ce n'est pas nécessaire.

Les auteurs se sont basés sur une méthode d'apprentissage par l'exemple : chaque chapitre est organisé autour de plusieurs exemples, décortiqués autant que nécessaire pour que le lecteur s'y plonge sans trop de difficulté. L'objectif n'est pas de former des gens capables de comprendre jusque dans les moindres détails CUDA et l'optimisation profonde des algorithmes employés, mais plus de les amener à utiliser CUDA, en profitant de grands gains de performances par rapport à la version CPU, le tout dans un ton joyeux, sans se prendre la tête, avec une complexité croissante, sans sauter une marche. On remarquera notamment l'utilisation d'une bibliothèque de fonctions dans les exemples, afin de s'abstraire de ce qui ne concerne pas l'objectif premier du livre. Les auteurs semblent avoir remarqué ce qui pose souvent problème aux débutants avec CUDA et en profitent pour insister sur ces quelques points-clés.

Chaque chapitre est constitué de trois phases : l'introduction, où l'on introduit le sujet qui sera étudié dans le chapitre, avec la liste des objectifs ; le développement en lui-même ; la conclusion, où l'on résume les points essentiels du chapitre pour répondre aux objectifs fixés.

Il ne faut pas considérer ce livre comme une approche exhaustive de CUDA - tel n'en est pas le but -, il donne cependant les pistes nécessaires pour continuer son apprentissage de la technologie, comme le confirme le chapitre 12, où quelques pistes sont évoquées pour aller plus loin (livres de référence à consulter, bibliothèques utiles, etc.).

Par rapport à l'original, on remarquera l'ajout d'une annexe concernant CUDA 4.0, listant simplement les nouveautés de cette version, on aurait apprécié un peu plus de détails (des exemples, du code, notamment). On y apprend aussi que de nouvelles fonctionnalités du C++ sont supportées, alors que rien n'est précédemment dit sur ce langage. On n'apprendra rien sur l'architecture des GPU, pas plus sur la nouvelle architecture Fermi et les grandes nouveautés qu'elle apporte (elle n'est même pas citée), cela n'étant absolument pas l'objectif du livre.

Les prérequis ne sont pas exorbitants : la connaissance de la programmation en C est bien suffisante, inutile de connaître la programmation graphique. Dans cet ordre d'idées, chaque exemple est précédé d'une introduction plus théorique, qui explique ce qui va être réalisé par la suite, au cas où le lecteur ne le saurait pas. Ainsi, on explique brièvement le principe des réductions, des histogrammes, du lancer de rayons, etc.

Avez-vous lu ce livre ? Qu'en pensez-vous ? 1 commentaire

Petit livre s'il en est, tout comme l'indique son nom (le « minimanuel »). Pourtant, tout est couvert : grâce à ce livre, pas besoin d'une expérience dans un langage pour faire ses premiers pas en C++. Une manière d'aborder le C++ très spéciale : on ne considère pas le C comme un prérequis, le C++ est enseigné comme premier langage, partant des bases de la syntaxe jusqu'à la programmation orientée objet, à laquelle pas moins d'une cinquantaine de pages sont dédiées (soit approximativement un quart de l'ouvrage).

Cependant, le tableau n'est pas que clair : on peut remarquer quelques fautes d'orthographe évidentes du début à la fin, ainsi que la présentation de Dev-C++, un EDI dont le support est arrêté depuis... 2005. On remarquera que ce livre a été édité en 2010 et qu'un particulier continue de manière non officielle la maintenance de l'EDI, sans que ce soit précisé.

Aucun point n'est jamais abordé en détail : le polymorphisme, par exemple, est expédié en trois pages seulement. C'est amplement suffisant pour la portée voulue de l'ouvrage (un minimanuel de C++), l'essentiel y est dit, on ne se pose pas de question supplémentaire la partie lue.

Chaque chapitre est divisé en plusieurs parties : le plan et les objectifs, le développement, un récapitulatif (l'essence des éléments principaux du chapitre) puis des exercices avec leur solution. Le développement est parsemé d'exemples, plus que bien commentés ; après chaque portion de code, le résultat que donne son exécution.

Il ne faut pas prendre ce livre pour ce qu'il n'est pas non plus : son but n'est pas d'introduire de l'algorithmique, il n'y en a d'ailleurs aucune trace. Il donne le condensé de la syntaxe du C++, pas une miette de plus - le format ne le permettant pas non plus. En tant que tel, il pourra servir de référence à celui qui ne pratique pas de longue date le C++ ; l'utilisateur plus avancé ne bénéficiera dans ce cas que des annexes, fort complètes, des mots-clés (tous avec un mot d'explication, même s'ils n'ont pas été abordés dans le texte) et des fonctions de la bibliothèque standard (avec l'en-tête de définition).

Sans oublier le point fort du livre : je l'ai lu d'une seule traite, en à peine quelques heures. Il est prévu pour être compréhensible par le commun des mortels.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

Constatation : le Web sémantique semble réservé à une élite de théoriciens. Or, pour qu'il continue à se développer, il faut donner des outils à d'autres personnes, des praticiens. C'est l'objectif de ce livre : le Web sémantique d'un point de vue pratique. On peut dire qu'il y est parvenu. Les exemples ne sont pas simplement des exemples théoriques : ce sont de vrais exemples, présentant de vraies situations.

On vise ici une compréhension du Web sémantique, de ses concepts du point de vue du praticien, de celui qui va utiliser le Web sémantique pour l'apporter au plus grand nombre. Il doit donc bien comprendre chacun des concepts, pas seulement les manières de les exprimer.

Par contre, en ligne de mire, on ne trouve pas une compréhension en profondeur et exhaustive des concepts liés : il s'agit avant tout d'une introduction au sujet. Après avoir lu ce livre, on peut s'aventurer plus loin dans son étude du domaine.

On notera la présence de chapitres In the Wild, présentant l'utilisation pratique d'un langage, un cas d'utilisation réel (pas simplement réaliste), ainsi qu'un Good and Bad Modeling Practices, présentant les avantages et inconvénients de certaines pratiques en matière de modélisation d'ontologies.

Avez-vous lu ce livre ? Qu'en pensez-vous ? 2 commentaires

Un des meilleurs livres sur la programmation déjà parus (comme l'indiquent, par ailleurs, les très nombreuses critiques incluses en début d'ouvrage sur les précédentes éditions) : les sujets abordés sont larges et couvrent plus que ce qu'il faut connaître pour se lancer dans une vraie application Java, les explications n'étant pas en reste (plutôt trop longues que trop courtes, mais toujours agrémentées d'exemples, autant que possible). Du début à la fin, on a l'impression d'être mené par un maître du langage : la prose se révèle précise, les détails très poussés, à un point que l'auteur montre sans cesse qu'il maîtrise le langage et ses spécificités sur le bout des doigts, sans que cela ne gêne la lecture. Par moments, on arrête l'apprentissage du langage pour une petite balade philosophique, en discutant les choix posés par les concepteurs du langage, en expliquant, quand ils se sont trompés, ce qui ne convenait pas. Par moment, les explications vont trop loin et risquent réellement de perdre les plus débutants (écrire un livre pour les débutants est l'une des tâches les plus ardues, l'auteur y arrive la majorité du temps).

S'il faut trouver des points négatifs, on pourrait citer certains exemples dignes de romans-fleuves : des pages de code, bien commenté, compréhensible, mais certainement trop verbeux, voire effrayant pour un débutant. L'introduction mène directement jusque dans certains recoins du langage, une partie que les débutants ne pourront pas comprendre en entier, à moins d'avoir une certaine expérience dans un ou plusieurs autres langages ; de même, l'entièreté d'un concept n'est pas couverte dans le chapitre dédié, car certaines notions nécessaires n'ont pas encore été abordées, cela peut donner une impression de fouillis.

Ce livre a aussi une assez forte orientation « migration depuis C++ », ce qui risque de gêner les lecteurs ne connaissant pas le C++. Cependant, les autres bénéficieront d'un apprentissage qui oppose les deux langages : ce que fait l'un par rapport à l'autre, ce qui les distingue, les avantages et inconvénients de chacun.

Les exercices ne seront pas au goût de tout le monde : certaines fois, il suffit de montrer la véracité d'une explication, ce qui risque de paraître fort inutile aux yeux de certains (tandis que d'autres apprécieront). À côté, des exercices bien plus exigeants, pour lesquels quelques minutes de réflexion ne suffiront probablement pas ; certains sont même proposés comme projets de quadrimestre pour certains cours universitaires.

Maintenant, ce livre est-il à recommander comme tout premier livre Java ? Pour un débutant accroché, oui : certains chapitres sont relativement compliqués à comprendre, il s'agit de ne pas abandonner à la première difficulté. Pour un vrai débutant, sans aucune notion de programmation préalable, il vaut mieux profiter du Thinking in C en long et en large avant d'attaquer cette brique. Une fois lu entièrement, on peut être sûr d'avoir une bonne compréhension du langage, ce qui ne peut qu'être bénéfique aux plus débutants, même si beaucoup vont se demander à quoi cela sert et vont aller voir un ouvrage moins détaillé, plus pragmatique, qui part moins dans de longues discussions sur un sujet pas forcément utile au développement pur et dur.

Avez-vous lu ce livre ? Qu'en pensez-vous ? 5 commentaires

Un ensemble d'items, de gemmes pourrait-on dire, contenant des conseils de programmation en Java, tant pour le novice que pour le développeur plus expérimenté, du point de vue d'un concepteur d'API Java, tous utiles, un jour ou l'autre, vu la diversité des sujets évoqués.

Dans l'avant-propos, on remarque une citation intéressante :

This book address your third need: customary and effective usage. [...] Here he offers good advice, systematically organized, on how to structure your code so that it works well, so that other people can understand it, so that future modifications and improvements are less likely to cause headache.

Ce livre répond à votre troisième besoin : l'habitude et l'usage pratique. [...] Ici, il offre de bons conseils, systématiquement organisés, sur la manière de structurer le code pour qu'il fonctionne bien, que d'autres puissent le comprendre, que de futures modifications et améliorations ne causent pas trop de maux de tête.

C'est exactement ce qui est fait : alors que bien des livres décrivent en longueur la syntaxe du langage ou les outils disponibles, très peu se penchent sur la manière de bien les utiliser. On comprend alors les avantages mais aussi les faiblesses du langage, ce que l'on peut faire et ce qu'il est préférable d'éviter, même avec les meilleures intentions, pour que tous en bénéficient (tant les futurs mainteneurs que les utilisateurs des API).

Un point cependant que l'on pourrait reprocher : une grande partie est orientée du point de vue d'un concepteur d'API, c'est-à-dire pas vraiment le but de la majorité des développements. Ces bonnes pratiques, néanmoins, utilisées dans toute application, ne peuvent qu'améliorer le code et tout ce qui s'en suit, sans beaucoup extrapoler.

On peut donc, sans grand danger, le recommander à tout qui a déjà débuté dans le langage (il n'est pas du tout prévu pour apprendre la syntaxe, il la considère acquise en grande partie) : le seul effet sera de produire du code de meilleure qualité !

Les items ne sont pas prévus pour être lus l'un après l'autre obligatoirement, il y a souvent une série de références d'items qui approfondissent certains points, ce qui fait qu'ils sont généralement assez spécialisés - bien que, parfois, une seule page leur est dédiée, ce qui est un peu court. On peut donc utiliser ce livre comme référence constante lors d'un développement, pour avoir une approche souvent considérée comme la meilleure : tous en bénéficieront, à tout moment de l'utilisation du langage. Cependant, se limiter à le lire ne sera probablement pas suffisant : tester soi-même ce qui est proposé et les alternatives, voir pourquoi, « en vrai », la solution proposée est meilleure en général, déceler les cas où cela n'est pas tellement d'application, discuter de cela avec des experts du langage.

Cette deuxième édition a été complètement revue pour Java SE 5 et 6 et dispense donc les dernières nouveautés de ces deux versions, principalement la 5, étant donné que la mise à jour a commencé avant la sortie de Java 6.

Avez-vous lu ce livre ? Qu'en pensez-vous ? 1 commentaire

Sans grande prétention, cet ouvrage propose d'apprendre les notions fondamentales de JavaScript. On remarquera l'effort pédagogique fourni par l'auteur, qui explique la programmation à des profils plutôt orientés infographie que développeurs. Il y arrive d'une belle manière, allant étape par étape, sans en brûler une seule, pour construire des notions de base en programmation avec JavaScript. L'auteur présuppose une connaissance de HTML.

On n'y retrouvera à ce titre que l'essentiel : après lecture, on pourra ajouter un peu d'interactivité aux pages, mais sans avoir des connaissances très approfondies de JavaScript. Notamment, le modèle DOM y est à peine survolé. Il ne faut pas espérer être à même d'écrire du code JavaScript poussé, ni même d'entreprendre l'AJAX sans formation plus avancée, mais ce n'est clairement pas l'objectif poursuivi. Le développeur ayant déjà une expérience de programmation n'aura sans doute pas grand-chose à apprendre de ce livre, si ce n'est les quelques différences de JavaScript dues à son utilisation côté client.

Malgré quelques fautes d'orthographe, l'auteur s'ingénie à montrer, dans un style clair, l'utilité de JavaScript dans des sites, pas seulement pour s'amuser à réaliser quelques effets, plutôt pour donner une valeur ajoutée, à travers de nombreux exemples illustrés par des captures d'écran du résultat dans le navigateur.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

Un livre tel qu'on aimerait en avoir plus souvent dans les mains : le côté pédagogue de l'auteur n'est en rien gâché par la qualité de l'écrit. Bien qu'il semble a priori plus orienté vers la pratique, ce livre présente également les aspects théoriques nécessaires à la bonne compréhension du contenu (ni éléments de la théorie de la complexité, ni fondements et concepts mathématiques des structures de données ne sont oubliés). Les structures de données les plus utiles sont présentées, leurs méthodes d'accès sont toujours accompagnées de leur complexité en temps (et en espace si cela revêt une certaine importance), pour arriver à comparer plusieurs manières d'implémenter les graphes en fonction des opérations qui devront être effectuées. Les algorithmes généralement appliqués sur ces structures ne sont en rien oubliés, ils sont d'ailleurs doublement présentés : tant un aspect pratique (l'implémentation en C++) que théorique (l'explication de l'algorithme, son pseudocode). Le contenu est orienté du côté du développeur qui doit utiliser ces structures, plutôt que du théoricien qui doit en développer de nouvelles (on ne s'appesantira pas sur le pourquoi du comment, plutôt les avantages et inconvénients, sur les cas d'utilisation, etc.).

Cependant, tout ne concerne pas les structures de données : l'auteur part du principe que le lecteur sait développer dans un certain langage et réexplique donc les fondements de la syntaxe du C++ sans s'appesantir, mais approfondit la programmation orientée objet (il en donne les bases nécessaires pour un aperçu global du sujet, mais sans aller dans toutes les finesses que l'on attendrait d'un livre spécifiquement consacré à la programmation orientée objet). Ceci empêche notamment d'utiliser la STL dès les premiers morceaux de code (les tableaux sont préférés pour les premiers chapitres), bien que, une fois les bases acquises, elle est utilisée de manière systématique.

Du style, on retiendra une certaine dose d'humour, mais aussi de fréquentes références culturelles (pas forcément de culture informatique) tout au long de l'ouvrage (ce dès la préface, d'ailleurs nommée « prolégomènes »). On remarquera aussi une certaine dose de notes de bas de page, des incitations à consulter d'autres ouvrages ou articles pour de plus amples informations sur un sujet, tant pour les principes des structures que pour les nombreux exemples d'utilisation.

Avez-vous lu ce livre ? Qu'en pensez-vous ? 11 commentaires

Domaine émergent malgré son âge (les premiers développements du Web sémantique datent de la fin des années 1990), on en décrie parfois le manque de pédagogie des ressources disponibles. De fait, les concepts sont nombreux et abstraits, mais ce livre les résume en permettant de comprendre les tenants et aboutissants de ces technologies que l'on peut facilement croire comme détachées du Web - pourtant, les auteurs arrivent à en montrer la continuité par rapport à l'existant, à les raccrocher à la réalité (oui, les concepts sont utiles, des applications sont montrées).

Ce livre est destiné à divers publics : tant le décideur que l'étudiant, tous y trouveront leur compte, mais ne le liront pas de la même manière. Il est d'ailleurs prévu de la sorte : il n'est pas nécessaire de le lire de manière linéaire pour en apprécier le contenu. Pour avoir une vue d'ensemble du domaine, les chapitres 1 et 5 à 7 résument l'essentiel sans entrer dans les détails techniques ; celui qui cherche à se former plus spécifiquement sur la pile de standards se focalisera sur les chapitres 2 à 4, qui traitent des standards par ordre de dépendance (d'abord le framework RDF, puis les formalismes des vocabulaires pour finir sur les règles d'inférence).

Ainsi, le livre est bien structuré, pour faciliter une lecture rapide, une utilisation en tant que livre de référence, pour éviter de passer son temps sur des détails qui paraissent peu intéressants aux yeux du lecteur. Chaque chapitre débute par un encadré précisant les objectifs à atteindre et se finit par un autre encadré fournissant un résumé des notions abordées.

Ce n'est pas pour autant qu'on peut parler de livre de vulgarisation : la technique est très présente, les détails plus d'ordre théorique ne sont pas omis, des raccourcis trop rapides ne sont pas pris. Cependant, il reste accessible à tout public intéressé par les révolutions en cours dans le domaine du Web.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

Joomla! est un système de gestion du contenu (CMS, en anglais) très répandu (aux alentours de deux pour cent du Web l'utilise) et très orienté vers les utilisateurs. De ce fait, la documentation autour du développement d'extensions (au sens large) est assez limitée : un de ses défauts est d'être peu orientée développeur, au sens au peu de choses sont expliquées (une série de pièces s'assemblent au fil du tutoriel, sans qu'une ligne directrice soit présente, sans qu'on sache ce que l'on fait).

Dans ce contexte, un tel livre est une aubaine : l'auteur y explique ce qu'il fait, pourquoi il le fait, comment il choisit ses noms de classe et de fichier. Pour chaque type d'extension, il y décrit la manière de procéder, les classes spécifiques à utiliser, les concepts mis en œuvre. Il ne néglige pas de mentionner le fonctionnement interne du CMS derrière cette API, de telle sorte que l'on puisse bien comprendre ce qui se trame en coulisse.

Le livre s'ouvre sur le cheminement d'une requête dans le CMS, de l'appel du fichier index.php aux événements qui apparaissent, en déroulant méthodiquement et sans presser le pas ce fichier, levant le masque sur chaque partie intéressante de son organisation. Ce premier chapitre offre une vue d'ensemble sur les entrailles du logiciel.

Cependant, le livre n'est clairement pas destiné aux débutants : de bonnes connaissances en PHP objet sont absolument requises pour comprendre une grande majorité du livre, il est nécessaire d'avoir déjà joué avec Joomla!, savoir l'utiliser, l'installer. L'auteur passe toutes les prémisses utiles à l'utilisateur de base et se destine directement au développement pour le CMS.

Également, la pédagogie n'est pas le point fort du livre, elle n'est pas voulue du début à la fin : il s'agit d'une documentation technique francophone sur les mécanismes en jeu, sur les API proposées. Pas d'exemple développé de long en large dans le livre, mais bien un fil rouge (le développement d'un dictionnaire, avec composant, module et extension), dont les sources sont proposées à côté du livre. Seuls les morceaux importants sont repris et développés dans le livre, l'auteur se base beaucoup sur la pratique et la lecture de code ; elle est cependant grandement facilitée par les explications plus ex cathedra.

On en retiendra qu'il s'agit d'une excellente documentation technique, loin d'être désuète malgré l'âge de l'ouvrage et l'évolution rapide du CMS ; cependant, le livre n'est pas à conseiller au débutant en programmation (Web, PHP et en général).

Avez-vous lu ce livre ? Qu'en pensez-vous ? 1 commentaire

Les réseaux informatiques sont un vaste sujet : on peut regrouper sous ce titre tant le manuel d'utilisation d'un routeur que les concepts généraux implémentés dans ce routeur. Ce livre se concentre sur la deuxième partie : il donne une vision d'abord théorique sur les concepts, les protocoles, les algorithmes généralement mis en œuvre dans le domaine des réseaux. Ainsi, son public premier sera les étudiants en informatique, mais aussi toute personne désireuse de connaissances en réseaux ; son exhaustivité le rendra également utile en tant qu'ouvrage de référence.

L'approche globale est plus académique, théorique que praticienne : les auteurs se focalisent sur les principes, les concepts avant de partir dans leur utilisation. Les raisons théoriques pour lesquelles les solutions adoptées fonctionnent ne sont pas oubliées.

L'ouvrage n'est pas seulement complet, il est vraiment exhaustif : toutes les couches du modèle étudié (proche du modèle OSI) sont vues en détail, avec force exemples réels. L'inconvénient de cette approche est qu'il n'est pas possible d'en saisir tous les détails en première lecture à moins d'avoir une grande expérience dans le domaine. On peut vraiment parler de la « bible » des réseaux - à ce titre, la taille de l'ouvrage (on devrait plutôt parler de brique) ne devrait pas effrayer, c'est le gage de la complétude dans l'exposé, de la minimisation des non-dits.

Les bases sont couvertes, au même titre que les technologies plus récentes : IPv6, Wi-Fi, VoIP, RFID et bien d'autres sont abordées.

Un point plus noir : les théories sur lesquelles se construisent les réseaux sont supposées connues. Ainsi, une approche des mathématiques, de la programmation (en C, bien que les exemples devraient rester compréhensibles pour des personnes sans connaissance du C), de l'électromagnétisme est requise pour saisir l'utilité de certains développements.

La traduction est de bonne facture, les anglicismes y sont réduits autant que possible dans leur nombre, ce qui rend le texte d'autant plus accessible que l'auteur fait preuve de pédagogie, en introduisant au fur et à mesure des solutions de plus en plus complexes, réelles et actuelles, passant des solutions plus historiques aux principes utilisés actuellement.

Avez-vous lu ce livre ? Qu'en pensez-vous ? 2 commentaires

Parmi les premiers ouvrages en français sur le sujet du NoSQL, ce livre présente la particularité intéressante d'avoir été rédigé par un spécialiste des bases de données relationnelles. Cette compétence est largement mise à profit tout au long du livre, où l'approche NoSQL (unifiée en ce qu'elle abandonne le relationnel) est sans cesse comparée à l'approche relationnelle, déjà fort ancienne au vu de l'histoire de l'informatique. Il ne faut cependant pas croire que l'objectif est de prouver une quelconque supériorité des systèmes largement déployés : l'auteur n'hésite pas à signaler les points où l'une ou l'autre approche est plus adapté, en indiquant qu'il n'est pas rare de devoir faire cohabiter une solution relationnelle en plus d'un accès NoSQL.

Le contenu s'organise selon trois parties fort distinctes.

• La première introduit les notions de base du NoSQL, en partant de l'origine des systèmes de gestion de bases de données (avant l'omniprésence du relationnel) et amène les éléments qui ont propulsé le mouvement NoSQL, les difficultés éprouvées par le relationnel pur (notamment en cas de montée en charge pour des volumes typiques du big data) mais aussi les problèmes qu'il résout. Dès le début, les points plus techniques ne sont pas mis de côté, avec une discussion des interfaces de programmation offertes par les systèmes NoSQL, leurs avantages et inconvénients, sans oublier l'architecture grandement distribuée pour la plupart des représentants de la mouvance NoSQL (ainsi qu'une série de tests pratiques sur MongoDB ou Redis) ou le modèle de données implémenté (schéma, paires clé-valeur, documents, colonnes, etc.).
• La deuxième partie se concentre sur les logiciels regroupés sous le pavillon NoSQL plus en détail : leur installation sur une distribution Linux (Ubuntu), leur programmation (la grande majorité des codes d'exemple est écrite en Python), ainsi que quelques éléments sur les spécificités de chacun. Les plus connus MongoDB ou CouchDB ne sont pas les seuls traités, puisque le moteur de recherche ElasticSearch ou la base de données orientée graphes Neo4j sont aussi introduits, bien qu'en moindres détails.
• L'ouvrage s'achève sur une approche plus pragmatique de la nébuleuse NoSQL. Quand faut-il aller vers du NoSQL ? Comment le marier avec du relationnel ? Quelle base de données choisir ? Comment modéliser ses données ? Comment évaluer le matériel requis pour les besoins estimés ? Comment importer des données ? Il ne s'agit pas simplement de poser les bonnes questions, mais aussi de donner les éléments de réponse qui aideront à effectuer le bon choix, avec un exemple sous forme d'étude du cas de SkyRock, qui mèle allègrement relationnel et NoSQL (y compris les bases MySQL sans relationnel, sans jointures).

Une fois posées, ces presque trois centaines de pages donnent l'impression d'avoir survolé une grande partie de la sphère NoSQL, mais aussi d'en savoir plus sur ses motivations : ces outils ont été créés d'abord pour répondre à un besoin précis, pas pour être génériques. En plus de s'épancher longuement sur les particularités de chaque moteur, il a l'avantage de donner les premiers éléments pour s'en servir, tant du côté client (exemples de programmes) que serveur (administration de base, déploiement de groupes de machines), de telle sorte qu'il est aisé de commencer à tester les moteurs, voir comment ils réagissent dans une situation donnée et effectuer son choix en toute connaissance de cause.

L'avant-propos de ce livre le résume fort bien en peu de mots :

Joomla!, le guide officiel prend une approche différente de celles des autres "modes d'emploi". Il se focalise non pas sur l'utilisation de Joomla, mais sur la construction de sites web réels avec Joomla.

Couvrant tant Joomla 2.5 que 3 (ce qui lui assure d'être à jour jusqu'en 2015), il replace le CMS Joomla! dans une approche holistique de construction d'un site : il ne s'agit pas seulement d'installer une application sur un serveur puis de la configurer, il faut également penser le site, réfléchir aux implications. Ainsi, le deuxième chapitre s'oriente autour des questions essentielles lors la construction d'un site : déterminer son objectif, enregistrer un nom de domaine, choisir un hébergeur ; il présente également des notions de droit d'auteur et de marketing.

Cette caractéristique est approfondie dans les études de cas des derniers chapitres : avant d'entrer dans les détails des extensions utiles dans un cas particulier et des personnalisations à apporter au logiciel, les auteures prennent le temps de planifier le site, d'évaluer les besoins auxquels il répond.

Le cheminement du lecteur commence par une présentation du projet Joomla!, de son histoire dès la scission d'avec Mambo, avec une présentation des outils indispensables à tout utilisateur de Joomla! (les communautés d'entraide, le recueil d'extensions) et de la communauté derrière le projet. Bien évidemment, pour un projet open source, les auteures n'hésitent pas à signaler que toute contribution est intéressante.

La partie réellement technique n'arrive qu'après une quarantaine de pages avec l'installation d'un premier site, sans prérequis : l'utilisateur n'est pas considéré maître de son logiciel FTP et administrateur système, mais bien simple utilisateur d'un service d'hébergement. Les explications sont fondées sur cPanel.

Les chapitres suivants construisent sur ce site vierge en présentant, de manière thématique, les fonctionnalités utiles pour les utilisateurs, en commençant par celles utiles avant de créer la première page de contenu (la configuration et les menus), puis en présentant les extensions et les possibilités de développement de thèmes simples.

Avant de partir sur les études de cas, les auteures expliquent ce qu'il faut faire une fois le site lancé pour le maintenir en vie : s'assurer qu'il est bien référencé, fidéliser les visiteurs, mettre Joomla! à jour.

Ainsi, il est prévu pour parer les lecteurs de toutes les compétences nécessaires pour réaliser un site Web réussi. À lui seul, il donne toutes les clés nécessaires. Notamment, une annexe présente une série de problèmes classiques et la manière de les résoudre ; une autre présente une série de ressources utiles pour approfondir ses connaissances. Par contre, il ne faut pas chercher en lui une présentation avancée des concepts derrière l'implémentation de Joomla! ou pour le personnaliser jusqu'aux tréfonds, ce n'est pas son objectif : il reste relativement orienté vers les utilisateurs débutants, tout au long de l'ouvrage (un glossaire présentant les termes techniques pas forcément connus mais souvent rencontrés dans l'univers Joomla! est disponible à la fin de l'ouvrage).

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

Bien peu d'ouvrages se concentrent sur la manière de bien programmer. À l'instar de Effective Java (Joshua Bloch), ce livre a pour objectif de présenter les principes à respecter pour obtenir un code maintenable, évolutif. Il n'est pas spécifique au C++ dans ses deux premières parties : les principes généraux qui y sont énoncés sont valables pour une série de langages (de manière générale quand il s'agit d'écrire du code lisible ou d'éviter les effets de bord, plus spécifiquement pour l'orienté objet avec les grands principes que sont la substitution ou l'ouvert/fermé).

L'un de ses points forts est que l'auteur fait preuve de pragmatisme : ces préceptes sont prévus pour faciliter la maintenance du code lors de son évolution, mais leur respect peut mener à un code plus compliqué à écrire, à plus de réflexion avant de se lancer au clavier. Si ces évolutions sont très peu probables, inutile d'ajouter une couche de complexité au projet pour en faciliter l'ajout ultérieur (« la solution la plus simple est toujours la meilleure »).

Les premières parties du livre sont alors mises en application dans un jeu d'échecs en console. Bien que l'exemple soit relativement simple, bien coder l'application (pour en faciliter les évolutions, tant dans la jouabilité que dans l'interface) requiert de se poser, de réfléchir avant d'agir. Il s'agit d'ailleurs d'un des points sur lesquels l'auteur insiste : pour produire du code, une application de qualité, il n'est pas suffisant de s'installer derrière un clavier et de taper à un rythme effréné.

L'application des principes se fait exclusivement en C++, avec une certaine utilisation de C++11 là où le standard apporte au code une lisibilité supplémentaire ou de meilleurs messages d'erreur. L'ouvrage suppose cependant une connaissance de C++03, le standard précédent du langage : les nouveautés sont expliquées afin que le lecteur comprenne l'avantage d'utiliser les nouvelles constructions. Par contre, il ne s'agit pas d'un ouvrage traitant en long et en large du nouveau standard.

Certains patrons de conception sont aussi présentés, au niveau de l'étude de cas, afin de résoudre des problématiques propres au développement logiciel. Bien que le paradigme orienté objet soit omniprésent, l'œuvre n'est pas intégriste : d'autres paradigmes implémentés par C++, notamment la programmation générique, sont employés afin de limiter la quantité de code à écrire.

L'organisation est plus proche d'une série de fiches thématiques que d'une narration continue : la partie plus « théorique » de l'ouvrage n'est pas tant prévue pour une lecture linéaire qu'un piochage des éléments intéressants à un instant donné.

Ce livre vivant peut donc être recommandé chaudement à tous les développeurs. Les débutants y trouveront diverses manières d'améliorer leur code, mais ils n'en bénéficieront vraiment qu'avec de l'expérience de la programmation, notamment en C++ (l'annexe présente d'ailleurs un aperçu général de la chaîne de compilation en C++, souvent mystifiante pour ce public cible). Les plus chevronnés pourront découvrir de nouvelles pratiques pour améliorer leur manière de développer.

Avez-vous lu ce livre ? Qu'en pensez-vous ? 10 commentaires

Fortran n'est assurément pas le langage à la mode dans la communauté informatique au sens large : l'Histoire le retient comme l'un des tout premiers langages de programmation (il remonte aux années 1950), mais il reste couramment utilisé aujourd'hui — même si son emploi actuel ne ressemble en rien à ses débuts sur cartes perforées. Ce livre se place résolument au début de la renaissance de Fortran : il s'axe exclusivement autour de la version 90 et l'antique FORTRAN 77 est à peine cité dans le texte principal. En effet, le passage de l'une à l'autre marque une vraie rupture pour les développeurs. La rétrocompatibilité est cependant entièrement conservée, c'est pourquoi les constructions désuètes héritées de FORTRAN 77 sont expliquées dans une annexe — principalement pour faciliter la lecture et la compréhension du code de cette époque.

L'ouvrage, fort académique, a l'avantage d'être pédagogique et d'introduire progressivement les différentes notions, en partant de connaissances assez limitées de la programmation impérative. Il donne également un aperçu très large des possibilités de Fortran, y compris des fonctionnalités les plus récentes telles que la programmation orientée objet. Certains autres aspects, comme les cotableaux, sont à peine survolés — le livre ayant une longueur limitée. Un point gênant pour les plus débutants est l'impasse totale sur les aspects pratiques : l'auteur ne cite ni compilateur ni environnement de développement pour démarrer avec Fortran, pas même en annexe ; certes, ces informations peuvent rapidement devenir dépassées, mais elles aident à entrer dans la pratique du langage.

Toutefois, la lecture laisse une désagréable impression de manque de mise à jour. Outre la mise en page vieillotte, certains exemples font encore référence à des montants en francs et à des taux de TVA de 18,6 % (héritage français du début des années 1990). Les références aux versions plus récentes de Fortran donnent parfois l'impression d'avoir été ajoutées à la va-vite. De même, l'ouvrage cite régulièrement les avantages de Fortran par rapport aux autres langages pour une utilisation scientifique, mais les exemples sont rarement tirés de ce domaine ; les points mis en avant ont surtout trait à la syntaxe de manipulation des tableaux, qui ne sont absolument pas comparés aux langages de référence actuels, à l'instar de MATLAB (qui n'est même pas cité).

Le style de rédaction pourra rebuter plus d'un lecteur. Il est très académique, parfois plus proche du livre de référence que du cours (dix annexes), avec une bonne quantité de notes de bas de page et de remarques renvoyant vers la suite de l'ouvrage. L'auteur se perd régulièrement dans des détails de bas niveau, moins importants à l'heure actuelle, comme l'arithmétique des compléments à deux, les nombres en virgule flottante en base seize et autres détails des architectures IBM relativement anciennes.

Globalement, l'ouvrage apporte des bases de programmation en Fortran moderne largement suffisantes pour bien écrire de grandes quantités de code. Les exercices permettent de bien assimiler la matière. Cependant, pour débuter avec le langage, il reste souvent trop abstrait : la partie théorique, parfois assez consistante, vient toujours avant les exercices ; le lien avec la pratique de développement reste relativement ténu.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

Scott Meyers est un gourou du C++, maintenant parti à la retraite. Sa dernière contribution à l'environnement C++ se veut magistrale, en détaillant les points les moins bien compris et utilisés des dernières itérations de la norme, c'est-à-dire C++11 et C++14, avec un code dans un style résolument moderne. L'auteur exploite dans cet ouvrage sa participation active dans la préparation des nouvelles versions du langage, en expliquant les raisons de l'ajout de l'une ou l'autre fonctionnalité. Il n'est pas avare en clarifications dans l'implémentation des compilateurs les plus courants. Globalement, ce livre fournit une vue approfondie des points les plus délicats des nouveautés syntaxiques.

Clairement, le livre ne s'adresse pas aux débutants : pour en profiter, il est nécessaire d'avoir déjà une certaine exposition aux nouveautés de C++11 et de C++14, avec une bonne expérience de C++ ; ce texte n'est pas un guide complet sur le C++ moderne et les derniers ajouts au langage. Sans ces connaissances préalables, l'ouvrage se montrera très ardu à aborder : l'auteur descend dans les détails les plus sombres de la norme, expose au grand jour toute une série de cas limites, le tout dans un style assez dense (à peine plus de trois cents pages pour autant de contenu, c'est un exploit, surtout que l'écriture reste lisible).

De par cette conception, le livre ravira cependant un public très large. Ceux qui n'ont pas encore une grande compréhension des avancées du C++ moderne auront une explication rationnelle des nouveaux concepts, les plus avancés se réjouiront du style d'écriture orienté vers un usage à long terme : il ne contient pas vraiment de solution directe à des problèmes rencontrés, mais entretient une culture C++ moderne. La performance du code généré est un point sur lequel l'auteur insiste, parfois lourdement.

Chaque « conseil » s'achève toujours sur un bref résumé des points essentiels à retenir. Cependant, la terminologie de « conseil » est très mal adaptée : il s'agit plutôt de séquences sur un sujet donné, préférant l'explorer à fond, en présentant les diverses alternatives et les avantages et défauts des unes et des autres. D'ailleurs, les points spécifiques à C++11 ou C++14 sont indiqués, en précisant ce qui est valable dans une version et pas l'autre, mais aussi tout ce qui s'applique depuis C++98.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

La science des données est un mot clé à la mode actuellement, puisque les entreprises cherchent à tirer le meilleur profit des informations enregistrées. L'un de ses principaux outils est l'apprentissage automatique, domaine actuellement aussi en explosion : il attire l'attention et les auteurs. Certains ouvrages ont une vocation purement pratique, en ignorant complètement les détails des algorithmes, ce qui empêche de comprendre ce qui se passe en cas de résultats insatisfaisants. Ce livre ne se place pas dans cette optique : il descend au cœur des méthodes d'apprentissage, avec les détails mathématiques afférents, de telle sorte que ces outils ne soient pas des boîtes noires. En cela, il s'oriente très clairement vers un public de chercheurs dans le domaine, d'utilisateurs conscients de leurs outils.

C'est aussi, probablement, son point faible : les détails mathématiques occultent le reste du contenu. Le formalisme y est poussé très loin, notamment pour s'accrocher autour de l'axe du principe de minimisation du risque empirique : cette organisation confère au document une remarquable cohérence, mais ignore les questions de mise en œuvre. Le titre indique pourtant un voyage de la théorie à la pratique : cette dernière est résumée à l'implémentation (en C, parfois K&R !) des algorithmes. Les traces d'utilisation réelle des algorithmes sont ténues… et nulle trace de motivation par des applications réelles du contenu. En réalité, en opposition avec son titre, le livre se destine, à peu près exclusivement, aux chercheurs, avec une abondance de preuves mathématiques, mais aussi de références vers la littérature.

On peut pointer quelques manques dans l'ouvrage, comme les arbres de décision et leurs multiples variantes comme les forêts aléatoires, mais aussi la régression, qui n'est pas traitée explicitement. Ils ne sont cependant pas gênants, bon nombre d'algorithmes sont déjà au programme (perceptrons, SVM, AdaBoost, par exemple). Par contre, la question de l'évaluation de la qualité d'un modèle généré n'est pas véritablement à l'ordre du jour, sauf dans le chapitre sur l'apprentissage de fonctions d'ordonnancement.

La mise en page est soignée et aide généralement la lecture. Certaines parties du texte sont encadrées, notamment des sections qui mettent en évidence des notions centrales ou qui récapitulent le chapitre. Cependant, les mêmes artéfacts esthétiques sont employés pour des preuves : sont-elles alors mises en avant par rapport au reste du texte ? Ce n'est pas clair.

Globalement, l'ouvrage est complet et axé sur la théorie, difficile d'accès pour des personnes n'ayant pas eu une formation universitaire poussée en mathématiques. Celui qui souhaite se mettre à l'apprentissage automatique dans la pratique en retirera néanmoins quelques avantages, principalement pour la désacralisation des méthodes employées.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

L'exploitation des données, dans toute la généricité des termes employés, est un terme qui revient très régulièrement dans toutes les libraires, avec quantité d'ouvrages sur le sujet. Cependant, fort peu nombreux sont ceux qui traitent du cas très particulier où les données sont textuelles : c'est exactement ce trou que veut combler ce livre. Son titre indique qu'il portera principalement sur la manière de rechercher de l'information utile dans une masse de documents, tel un moteur de recherche. C'est d'ailleurs à ce thème que sont dédiés les premiers chapitres. Les deux auteurs s'ouvrent à des sujets connexes qui traitent de l'exploitation d'une quantité de textes, comme leur classification ou l'extraction de thèmes latents. On peut regretter que certains mots aient été ajoutés à la couverture sans qu'ils soient réellement traités dans le livre : « data mining », « big data »…

Ces trois cents pages explorent le domaine avec une approche mathématique : les auteurs ne vous présentent pas d'outil-boîte noire à utiliser pour obtenir un résultat sans en comprendre le fonctionnement — ni les hypothèses à poser pour donner des résultats en des temps raisonnables. Les auteurs y passent d'ailleurs un certain temps. Au contraire, l'aspect pratique est relativement délaissé dans l'ouvrage, se concentrant sur les concepts principalement utilisés dans le domaine. Ainsi, contrairement à ce que la quatrième de couverture promet, il ne s'adresse pas tellement à un public de professionnels, mais plutôt d'étudiants et de chercheurs, dont l'objectif est d'atteindre un bon niveau de compréhension du domaine. En cela, le grand nombre de références vers des publications scientifiques de pointe pour approfondir les sujets abordés est une bonne chose. L'ouvrage pourra rester des années dans une bibliothèque sans prendre une ride.

Cependant, après avoir fini la lecture, difficile de mettre en pratique le contenu de l'ouvrage : c'est une chose que l'on peut regretter dans ce livre. Peu d'outils pratiques sont cités : quelques-uns sont égrainés à travers le texte (auquel cas peu de choix est proposé au lecteur), le dernier chapitre se consacre exclusivement à une liste raisonnée de logiciels. Par contre, leur mise en pratique est relativement occultée — à moins que l'on veuille écrire soi-même le code de chacun des algorithmes proposés (ils sont tous détaillés, pas simplement esquissés).

Le sujet est traité de manière relativement exhaustive et progressive, sans précipitation malvenue vers l'un ou l'autre sujet hyper pointu. Quand plusieurs formules sont régulièrement utilisées en pratique, les variantes sont détaillées et justifiées, pour indiquer dans quel cas l'une ou l'autre aura plus de sens. Néanmoins, le style est relativement sec, les auteurs entrent rapidement dans le vif du sujet, sans forcément chercher à justifier le pourquoi du comment. Certaines parties sont structurées au point de mettre d'abord les détails mathématiques, puis quelques utilisations potentielles par après — ce qui aura du mal à accrocher un lecteur qui ne voit pas la vie au travers d'équations. À ce niveau, quelques applications numériques ne feraient pas de mal dans le texte (elles sont rares), car elles aident à bien comprendre la mise en pratique de formules : le lien entre des séries de mots et des suites de chiffres n'est jamais aisé.

Au niveau de la structure globale de l'ouvrage, on peut principalement regretter que l'introduction de l'apprentissage automatique soit si tardive. Certes, cela aide à limiter les prérequis. Cependant, ce choix oblige les auteurs à de vagues formulations indiquant qu'il est possible d'utiliser ce genre d'algorithmes à certains endroits : le niveau de détail est insuffisant pour bien comprendre les tenants et les aboutissants de cette utilisation.

En mode mineur, on peut reprocher à certaines figures d'être relativement peu claires à comprendre. Une bonne partie du contenu du livre se trouve dans les exercices, qui donnent l'impression de ramasser toutes les parties théoriques moins importantes (les auteurs y présentent notamment l'algorithme AdaBoost, plutôt que de l'inclure dans la section sur les algorithmes d'apprentissage). Le chapitre sur les réseaux neuronaux profonds laisse sur sa faim : il présente les concepts essentiels aux réseaux neuronaux tels qu'ils étaient utilisés dans les années 1980 et 1990 (avant leur qualificatif de profond), mais la pratique dans le cadre de la recherche d'information est éclipsée en trois pages.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

La « science des données » se veut à la mode, ce qui incite à la publication de nombreux livres sur ce sujet. Les axes d'approche sont multiples et variés : du côté purement académique (les algorithmes d'apprentissage, étudiés dans l'abstrait) à l'extrême pragmatique (utiliser ces algorithmes comme des boîtes noires). Cet ouvrage se place entre ces deux extrêmes, ce qui le rend, de prime abord, intéressant pour un public large. La présence du terme (voire jargonnerie) « big data » donne l'impression qu'il sera sujet de grands volumes de données, mais l'auteur n'en traite que très rapidement, se focalisant sur les aspects de traitement des données, de leur visualisation et de l'application des algorithmes principaux d'apprentissage automatique.

D'une manière générale, ce livre déçoit par son manque de structure. Les sections se succèdent sans nécessairement avoir de lien entre elles, en présentant parfois approximativement des techniques issues des statistiques et de l'apprentissage automatique sans vraiment de recul. Par exemple, on aura droit à une présentation des data frames de R, très rapidement suivie de la notion d'arbre de décision — sans que les deux aient l'air liés d'une quelconque manière — ou encore à RCommander juste après une introduction à la notion de variable aléatoire. Cette construction déstructurée pourrait être avantageuse pour un public plutôt débutant, sans bagage substantiel en mathématiques ou en programmation, qui aura ainsi la possibilité de tester directement la syntaxe de R entre le chargement d'un jeu de données et son exploitation par apprentissage automatique, sans s'alourdir de considérations autres que pratiques. Néanmoins, une structure assumée aiderait certains à comprendre… et surtout à utiliser l'ouvrage comme référence.

Cet ouvrage contient une introduction à la programmation en R de manière intuitive, renforcée par quantité d'exemples : elle devrait donner les bases à ceux qui n'ont que très peu touché à la programmation, des bases suffisantes pour écrire leur propre code proprement — même en utilisant l'approche orientée objet. Cependant, par la suite, l'auteur ne convainc pas réellement que R est l'outil le plus approprié pour ce cas d'utilisation, notamment à cause du nombre d'avertissements égrainés tout au long de l'ouvrage, autant d'indicateurs que le langage est piégeur. Un bon nombre d'outils est présenté, mais très rarement approfondi : par exemple, dplyr est très rapidement présenté, mais tout aussi vite oublié, sans montrer réellement ses apports par rapport aux fonctionnalités de base de R.

Le premier chapitre du livre est néanmoins très intéressant, notamment pour son bestiaire de la science des données : tous les concepts de base y sont représentés, dont une série graphiquement. Les explications sont succinctes, parfois approximatives, mais facilitent la compréhension du domaine dans son ensemble, chaque élément menant au suivant.
L'autre chapitre qui fait sortir ce livre de la moyenne concerne le suivi d'un projet de développement dans le domaine de la science des données. Il devrait aider le lecteur à s'organiser en situation réelle, notamment en pointant les différences par rapport aux cycles de développement logiciel.

Tout au long de l'ouvrage, l'auteur ne suit qu'une seule approche : comprendre le jeu de données (à l'aide de graphiques, principalement) aide à le modéliser, c'est-à-dire à choisir et appliquer un algorithme d'apprentissage automatique. L'approche inverse, qui consiste à exploiter le résultat d'algorithmes d'apprentissage pour analyser les données, n'est reléguée qu'à quelques notes éparses (à peine parle-t-on de l'importance des variables déterminée par une forêt aléatoire). On a là l'impression que l'auteur a une bonne expérience du domaine, avec un biais très fort envers les solutions très pragmatiques, mais nettement moins envers la recherche, toujours florissante dans le domaine — un comble, quand l'un des objectifs annoncés du livre est de mener à un niveau de compréhension suffisant du domaine pour aborder la littérature scientifique de pointe. Les notions théoriques ne sont toutefois pas oubliées, avec des présentations assez détaillées en ce qui concerne les probabilités et variables aléatoires (jusqu'à préciser la définition d'une tribu !) ou encore l'algèbre linéaire — sans que ces rappels soient réellement mis en rapport avec le reste de l'ouvrage.

Certains sujets sont abordés de manière extrêmement superficielle (comme le traitement d'images ou encore la logique floue), les rendant strictement inutiles. D'autres le sont nettement plus, mais sans que ce soit justifié (le niveau de détail des variables aléatoires ou encore l'optimisation par essaims) : ces outils ne sont pas mis en lien avec le reste des thèmes abordés.

En résumé, ce livre pourrait être utile pour des débutants dans le domaine, qui n'ont pas une grande expérience dans le domaine ou un bagage mathématique poussé. Ces gens pourront profiter du livre, en omettant les parties trop mathématiques abstraites. Cela ne signifie pas que, pour ce public, tous les objectifs annoncés sont atteints. Difficile d'être pleinement opérationnel après uniquement la lecture de ce livre, de « s'autoformer », même en approfondissant chacun des exemples. Par contre, le niveau d'exposition devrait être suffisant pour dialoguer en profondeur avec des personnes dont la science des données est le domaine de prédilection.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

Cet ouvrage concerne deux mots qui reviennent régulièrement à l'actualité : le « big data » et le « machine learning ». Il dresse effectivement un tour d'horizon assez large de cet univers : toutes les étapes d'un projet d'exploitation de données sont traitées, depuis les questions auxquelles on peut s'attendre à trouver une réponse au traitement des données, depuis le déploiement d'une grappe de calcul jusqu'aux algorithmes qui y tourneront, sans oublier la visualisation.

Le principal avantage du livre est qu'il présente, dans un format compact, l'ensemble des notions de base utiles à toute personne devant intervenir dans un projet d'exploitation de données. Son public est donc assez large, le contenu ne nécessite bien souvent pas une longue expérience en informatique pour s'y retrouver : les auteurs assument entièrement ce choix. Les explications sont généralement claires, ce qui cadre bien avec l'objectif ; les nombreuses illustrations aident également. Malgré les quatre auteurs, l'ensemble est extrêmement fluide.

Le livre n'hésite pas à tordre le cou à certaines idées reçues. Non, la science de données n'est pas neuve : ce qui l'est, c'est la capacité (technique) de gérer de grands volumes d'informations. Non, de grandes quantités de données ne résoudront pas tout problème dans une entreprise.

Les aspects réellement techniques ne sont pas oubliés. Le livre s'appesantit sur l'architecture MapReduce avec l'outil Hadoop pour déployer les calculs à large échelle, mais n'oublie pas de présenter YARN ou Drill. Conformément à l'esprit des auteurs, l'installation des outils est mise sur le côté, puisqu'ils préfèrent parler de distributions qui facilitent en bonne partie le travail et sont très bien adaptées à ceux qui débutent dans le domaine.

On peut cependant noter l'un ou l'autre point faible. Le côté apprentissage automatique est extrêmement limité, malgré sa présence dans le titre. La section sur l'apprentissage profond dénote fortement avec le reste du chapitre, étant extrêmement mathématique (au contraire du reste de l'ouvrage !). Une seule étude de cas est présentée, ce qui est dommage, notamment au niveau de la partie sur les outils.

Pour résumer, ce livre est à mettre entre toutes les mains des personnes qui aimeraient découvrir le domaine de l'exploitation des données à grande échelle. Elles auront un aperçu complet et bon nombre de pointeurs pour continuer leur apprentissage.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

Hadoop est probablement l'une des technologies phares actuelles dès que l'on s'approche du traitement de données à grande échelle. Cependant, l'écosystème ne cesse de grandir, avec de plus en plus de composants à connaître pour bien exploiter sa grappe de serveurs Hadoop. Ce livre fournit une introduction exhaustive à cet environnement, il vous familiarise rapidement avec l'ensemble des composants qui constituent Hadoop aujourd'hui.

L'un des grands avantages de cet ouvrage est qu'il recontextualise en permanence les éléments les uns par rapport aux autres : il devient aisé de se retrouver dans la jungle Hadoop. De même, chaque brique est présentée avec les objectifs et les contraintes qui l'ont vue naître, ce qui permet d'apprécier les choix techniques qui ont été posés. Le côté véritablement technique est largement présent : dès le premier chapitre, le lecteur est plongé dans des détails de l'organisation de Hadoop. L'un des maîtres-mots était de chercher à comprendre avant d'utiliser. Pari tenu !

À la fin de la lecture de l'ouvrage, vous êtes censés atteindre un niveau « professionnel » avec Hadoop. Les exemples vous montreront au moins comment utiliser chaque partie de Hadoop, d'une manière relativement basique, mais néanmoins suffisante pour bon nombre d'utilisations. L'aspect administration des machines n'est pas abordé, il ne fait pas partie du périmètre visé par l'auteur.

On peut regretter que le niveau attendu du lecteur ne soit pas clair : l'ouvrage rappelle (assez brièvement) ce qu'est une classe, une fonction, etc., alors que le public cible semble plutôt fin connaisseur de ces notions. Un point bien plus gênant est le nombre d'erreurs techniques, qui diminuent la crédibilité du texte. Par exemple, selon l'auteur, le format PDF est propriétaire (alors qu'il correspond à la norme ISO 32000-1 depuis 2008), W3Schools est un site officiel du W3C, Google utilise l'algorithme PageRank pour l'indexation (en réalité, uniquement pour mesurer la popularité de pages). De même, certains exemples ne sont pas toujours très bien choisis. Par exemple, présenter le NoSQL avec une application extrêmement bien traitée par des systèmes relationnels à très grande échelle (listes du personnel, des commandes) n'est pas le plus judicieux.

En résumé, ce livre aide à se forger une vue d'ensemble de Hadoop pour envisager de l'utiliser efficacement. Il ne fera pas du lecteur un maître, mais lui donnera les éléments nécessaires pour commencer son utilisation sereinement.

Avez-vous lu ce livre ? Qu'en pensez-vous ? 2 commentaires

On trouve sur le marché quantité de livres sur l'apprentissage automatique, mais rares sont ceux qui valent vraiment la peine. Cet ouvrage trouve le juste équilibre entre une composante théorique (savoir comment fonctionnent les algorithmes, sans formalisme excessif) et pratique (utiliser des méthodes d'apprentissage en réalité, sans code inutile). Le sujet du passage à l'échelle (avec une plateforme comme Hadoop) n'est pas abordé, mais cela ne nuit pas au lecteur, qui pourra se référer à l'abondante littérature sur le sujet, tout comme les sujets les plus avancés : l'auteur se focalise sur les algorithmes les plus utiles, plutôt que sur les dernières avancées de la recherche. Le style est très loin d'être académique, même si l'ouvrage pointe régulièrement vers des articles de la littérature scientifique pour approfondir certains points.

Un des points forts est sans nul doute la pédagogie dont fait preuve l'auteur. Il n'abuse pas de jargon (la traduction en français est d'ailleurs de très bonne facture, sans quantité phénoménale d'anglicismes), pour des explications claires et progressives. Les exemples sont aussi bien choisis et donnent envie d'en faire plus. La présentation de scikit-learn n'est pas exhaustive, l'auteur préférant passer du temps sur les éléments les plus importants pour structurer correctement son code.

En résumé, on peut vraiment recommander ce livre pour toutes les personnes qui débutent dans le domaine de l'apprentissage automatique, mais aussi à toutes celles qui ont une certaine expérience et aimeraient la formaliser quelque peu. Le niveau attendu n'est pas très élevé, il suffit de connaissances assez basiques en mathématiques (à condition d'avoir une formation en informatique), comme les fonctions, les dérivées et les matrices. Par contre, il ne conviendra pas vraiment à celles et ceux qui cherchent une ressource plus avancée (même s'ils apprendront l'une ou l'autre chose utile au passage). Le seul aspect vraiment négatif est la séparation en deux ouvrages, celui-ci faisant complètement l'impasse sur les réseaux neuronaux, même si certaines remarques dans le fil du texte y font référence.

Avez-vous lu ce livre ? Qu'en pensez-vous ? 1 commentaire

L'apprentissage profond est la dernière technique à la mode pour l'apprentissage automatique, avec un évident manque de maturité. Il n'empêche que le domaine a donné d'excellents résultats dans un certain nombre d'applications, pour des jeux (comme AlphaGo) et la reconnaissance d'images, notamment. C'est pourquoi des livres comme celui-ci ont un marché à saisir. Comme dans le premier tome, Aurélien Géron ne se focalise pas sur les applications directement pratiques, mais passe aussi du temps sur les principes sous-jacents, de telle sorte que le lecteur a toutes les clés en main pour comprendre ce qu'il fait. Par rapport au premier ouvrage, celui-ci se montre néanmoins beaucoup plus pratique (les exemples de code sont plus nombreux) et passe nécessairement sur le sujet du calcul à plus grande échelle (sur plusieurs machines et cartes graphiques) — sans quoi on serait bien en peine d'exploiter complètement les techniques décrites.

Les points forts de cette œuvre se rapprochent de la première partie, notamment une bonne dose de pédagogie et une langue compréhensible par la majorité (à condition d'avoir les bonnes bases mathématiques) — l'emploi de termes anglophones est cependant plus présent que dans le premier tome. La variété de sujets abordés est intéressante, car elle s'étend sur tous les domaines actuels où l'apprentissage profond se développe (convolution, récursion, apprentissage par renforcement, principalement). Ce dernier exemple est particulièrement important, car rares sont les ressources qui parlent d'apprentissage par renforcement, surtout à un tel niveau de détail (en omettant toutefois les parties mathématiques assez complexes qui viennent rapidement dans le domaine — un grand plus de cet ouvrage qui facilite fortement la compréhension !). On peut regretter que Keras ou une autre interface de plus haut niveau ne soit pas traitée, pour faciliter l'expérimentation rapide.

Cet ouvrage se destine donc à toutes les personnes débutant dans l'apprentissage profond (ou qui connaissent l'utilisation plus classique des réseaux neuronaux, mais souhaitent se mettre au goût du jour). Il servira surtout à ceux qui veulent une référence écrite à garder sous la main ou qui n'aiment pas apprendre par le biais de vidéos en ligne (à ce niveau, quand il faut clairement faire un tri dans les vidéos disponibles, ce livre n'est pas démuni d'avantages).

Avez-vous lu ce livre ? Qu'en pensez-vous ? 1 commentaire

À l'achat, ce livre se dénote par son poids, son nombre de pages. Que peut-il donc contenir de plus que la concurrence ? Le lecteur intéressé regardera ensuite la table des matières et verra que les sujets abordés sont plus étendus : les auteurs ne se focalisent pas sur l'apprentissage automatique, mais visent plus large, toutes les techniques qui permettent à un ordinateur d'extraire des connaissances depuis un jeu de données. C'est là le grand avantage de cet ouvrage, il cherche à donner une vue d'ensemble aussi diversifiée que possible sur un domaine d'étude loin d'être jeune. À la lecture, ce pressentiment se confirme : c'est complet, si ce n'est exhaustif ; c'est une référence (et le texte est prévu comme tel : aucun ordre n'est imposé sur la lecture des chapitres).

La rédaction diffère également de la concurrence, le point de vue adopté étant plus basé sur la théorie que la pratique. Les titres des chapitres ne révèlent pleinement leur cohérence qu'à la lecture. C'est là un parti pris : plus de théorie que de pratique. Cette structuration mène également à des points plus étonnants, comme le fait que la question de l'évaluation d'un apprentissage est traitée d'abord pour l'apprentissage non supervisé, puis (bien) après pour l'apprentissage supervisé plus classique. Également, le texte fourmille de références vers des articles plus académiques encore (les pages 851 à 889 sont réservées à la bibliographie), pour creuser plus avant si le cœur vous en dit.

Un point négatif (par rapport au public visé : « décideurs et […] ingénieurs […, ainsi] qu'aux étudiants de niveau Master 1 et 2 et en école d'ingénieurs ») est justement le côté théorique de toutes choses, le formalisme mathématique poussé à un très bon niveau. Les auteurs se veulent formels, et ce, dès l'introduction. Cela rend malheureusement l'ouvrage assez peu accessible, voire complètement imperméable pour les allergiques des mathématiques. Pourtant, lors de la majorité des chapitres, on se rend compte de l'effort fourni pour éviter l'abus d'anglicismes. Le sous-titre présente le mot clé « deep learning », mais celui-ci n'occupe pas une place aussi prépondérante que cela laisserait penser (deux chapitres sur vingt-trois).

On sent assez fortement qu'il y a trois auteurs, l'ouvrage manquant parfois de cohérence. Il est régulier de voir des références au passé à des notions qui ne sont pourtant détaillées que dans plusieurs chapitres (de manière similaire, les couvertures de Markov sont présentées au moins trois fois). Les rappels sont fréquents, mais il est plus gênant que, lorsque tous les chapitres pointent vers une notion à un endroit précis, cette définition soit elle aussi un rappel. Finalement, certaines informations sont clairement périmées : une note de bas de page indique que « très peu de travaux traitent de ce problème à ce jour (octobre 2009) », soit un peu avant la sortie de l'édition… précédente (en 2010). Trois sources de données sont citées (Microsoft Azure Marketplace, Datamarket, Data Publica), seule la dernière existe encore — quid dans quelques années ?

Par conséquent, l'ouvrage semble plutôt prédestiné à ceux qui veulent une compréhension profonde de la théorie derrière l'apprentissage, de ses liens avec les algorithmes. Il pèche sur les questions plus pratiques. Il n'y a donc pas beaucoup de souci à se faire pour la péremption des informations, qui resteront valables des années, si ce n'est dizaines d'années pour la plupart. Le public visé est plutôt mathématicien ou chercheur dans le domaine : il faut avoir déjà des connaissances préalables en apprentissage pour tirer un maximum du livre.

Avez-vous lu ce livre ? Qu'en pensez-vous ? 1 commentaire

Ce petit livre se dénote de la concurrence par son focus sur les bases de la science des données : pas uniquement les algorithmes d'apprentissage ou d'extraction de connaissances. En effet, il traite aussi de la représentation des données, chose importante en début de projet . Globalement, les chapitres sont organisés comme le serait un projet en science des données. Le lecteur commence son parcours avec les données, puis passe aux techniques d'implémentation (c'est-à-dire le calcul distribué, l'optimisation, les méthodes numériques), finalement aux algorithmes proprement dits.

Tous ces sujets sont abordés de manière assez brève (le livre ne fait même pas trois cents pages) et concise, en insistant juste sur les éléments principaux. Le texte est rédigé de manière assez sèche, sans fioritures ; ce choix le rend d'ailleurs facile à lire. Les explications présentent un certain côté pédagogique qui plaira à bon nombre d'étudiants. Néanmoins, ce dépouillement impose des connaissances préexistantes dans le domaine, bien que pas forcément très poussées : la très brève introduction mène directement au vif du sujet, une progression assez étonnante.

Il s'agit de l'un des rares ouvrages à traiter tant des algorithmes que des techniques d'implémentation, ce qui en fait un point positif : ce lien aide le lecteur à rassembler Hadoop & co. avec les algorithmes d'apprentissage. On peut cependant regretter le fait que les exemples ne soient pas toujours les mieux choisis : notamment, le chapitre sur le calcul de haute performance présente diverses notions sous l'angle habituel de la résolution d'équations aux dérivées partielles — un sujet assez éloigné de la science des données.

La plupart des méthodes d'apprentissage sont ici survolées : les méthodes probabilistes (dont les modèles graphiques), les réseaux neuronaux, les ensembles, les plus proches voisins. Étonnamment, pourtant, les arbres de décision ne sont jamais présentés, ainsi que leurs dérivés directs (comme les forêts aléatoires), malgré leur grande utilité pratique. Tout le côté pratique est toutefois mis de côté : les neuf auteurs se focalisent sur les aspects théoriques du domaine, les principes derrière les méthodes, dans l'idée qu'il « suffit » alors de regarder la documentation d'une bibliothèque d'apprentissage.

Le chapitre sur la visualisation étonne quelque peu, mais apporte des compléments d'information très utiles. Il distille l'expérience acquise, notamment en cartographie, sur la meilleure manière de faire passer un message à travers des graphiques. Il n'importe là pas d'utiliser correctement les bibliothèques, mais d'agencer leurs fonctionnalités pour que les graphiques atteignent leur objectif.

En résumé, il s'agit là d'un très bon support de cours ou d'un petit ouvrage de référence dans le domaine de la science des données. Il ratisse assez large, en donnant des pointeurs vers la recherche actuelle dans le domaine, en omettant la pratique. (À noter que les solutions des exercices ne sont pas fournies.)

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

Les réseaux informatiques sont un vaste sujet, en permanente explosion, d'une diversité sans limites. Difficile de s'y retrouver sans un guide de qualité, c'est cela que ce livre vient fournir. Contrairement à la majorité des classiques du sujet, l'auteur a investi une quantité d'efforts pour présenter les dernières nouveautés du domaine, pour bien montrer que les réseaux informatiques ne sont pas fixés, mais au contraire doivent continuer à évoluer.

Ainsi, la 5G et les réseaux logiciels (SDN) sont abordés avec un certain niveau de détail. Ces ajouts ne se font pas au détriment du volume du livre, puisque les sujets moins d'actualité sont présentés dans des annexes disponibles en ligne (par exemple, ATM ou X.25). On pourrait alors croire que seuls les réseaux du futur sont présentés, mais ce n'est pas le cas : les protocoles actuels sont bien présents.

Le vrai point fort du livre est néanmoins ailleurs. Les sujets sont abordés sous un angle pédagogique, afin que le lecteur s'y retrouve vraiment. Il ne s'agit pas d'une longue description de protocoles, mais plus d'une mise en perspective des techniques utilisées ou prometteuses pour l'avenir. La pédagogie ne s'oppose pas à la profondeur du contenu : par exemple, pour les réseaux IP, les techniques de gestion de la qualité de service (modèles IntServ et DiffServ, notamment) ne sont pas omises.

Par contre, l'ouvrage se focalise sur les couches basses des réseaux, à proximité des télécommunications, des manières précises d'émettre un bit sur une paire de cuivre. Ainsi, TCP et UDP sont présentés, les réseaux xDSL et fibre sont approfondis, mais HTTP et DNS sont à peine survolés. Aussi, la structuration n'est pas toujours la plus aisée à comprendre, certaines technologies (comme WiFi) étant expliquées dans plusieurs parties : avoir quelques connaissances préalables en réseaux informatiques ne pourra qu'aider à compléter les explications supplémentaires, distantes de quelques chapitres. Le chapitre sur la sécurité laisse aussi un peu sur sa faim : malgré des explications très pédagogiques et une section très intéressante sur les attaques possibles sur les SDN, on retrouve des mentions de disquettes et de MD5 (à proximité du mot clé « sécurisé »).

On peut donc conseiller ce livre les yeux fermés aux personnes qui souhaitent comprendre en profondeur les mécanismes à l'œuvre dans les réseaux informatiques, ainsi qu'aux étudiants dans leurs premiers cours de réseaux.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

La conception logicielle n'est probablement pas le sujet en informatique qui a le plus la réputation d'être sexy, ni même intéressant. Le sujet est souvent enseigné de manière dogmatique, sans mise en pratique ou en perspective. Ce livre devrait réconcilier les plus déçus avec le sujet, grâce à son approche très pragmatique : concevoir un jeu assez simple, mais à l'aide de patrons de conception bien choisis. Ainsi, tous les exemples de l'ouvrage, à de rares exceptions près, tournent autour du jeu vidéo. Cette cohérence rend le tout motivant.

L'avantage principal de l'angle d'attaque utilisé est qu'il est foncièrement pratique, chaque patron de conception étant très brièvement présenté de manière abstraite. La plupart des explications concernent son utilisation réelle dans du code, ses interactions avec d'autres patrons. L'auteur part souvent d'un code simplement fonctionnel, sans conception poussée, avant d'introduire les quelques patrons appropriés. Le lecteur peut ainsi voir clairement l'effet structurant de chaque patron de conception, les situations dans lesquelles il peut être utile, mais aussi les avantages qu'il propose.

Pour arriver à ses fins, l'auteur suppose un certain niveau de programmation orientée objet impérative en Java, puis explique le reste. Il passe un certain temps à présenter AWT et LWJGL (OpenGL) pour l'interface graphique, par exemple. Il ne s'agit pas d'un survol accéléré ni d'une descente profonde, mais bien d'un niveau suffisant pour l'application visée (un simple Pacman, certes) et d'autres encore. Aussi, l'auteur présente des techniques de parallélisme (de manière assez générale, le sujet étant vital dans le développement de jeux), de communication en réseau (avec un focus sur les problématiques propres aux jeux, comme NAT et UDP) et d'intelligence artificielle, ainsi que les patrons de conception associés, sans présupposer de connaissances poussées dans ces domaines. Un regret, toutefois, est l'absence des systèmes à entités, un mécanisme de structuration très fort (notamment à l'œuvre dans Unity 3D), mais probablement un peu trop spécifique aux jeux.

En peu de mots, l'on peut dire que ce livre ne peut qu'être recommandé à ceux qui souhaitent débuter dans la conception logicielle, après avoir remarqué les limites des approches naïves. L'ouvrage sera plus difficilement utilisé comme une référence, même si chacun des vingt-trois patrons est présenté de manière abstraite à l'aide de diagrammes UML.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

Le titre semble prometteur : des algorithmes et des techniques de réseau dans l'application des jeux vidéos. Cet objectif est atteint, puisque l'ouvrage présente son contenu avec un lien permanent pour les jeux vidéos. Cette attache vidéoludique ne se présente pas que dans la table des matières, mais aussi dans le texte, chaque section présentant des contraintes spécifiques au jeu vidéo. Les chapitres se divisent en trois parties : la génération de bruit, les techniques d'intelligence artificielle (ces deux-là étant regroupées sous le vocable « algorithmes ») et le réseau. Cette dernière laisse cependant un arrière-goût de trop peu.

L'approche se veut indépendante de tout langage ou moteur de jeu, les auteurs n'écrivent que du pseudo-code. Cette manière de faire rappelle des racines académiques (tout comme le style de rédaction, relativement sec) et permet de présenter les algorithmes dans toute leur généralité, sans bruit en provenance d'une API ou l'autre. Cependant, certains pourront regretter la méthode, puisqu'il faut alors plus de temps pour appliquer un algorithme à son cas particulier — ce qui n'est sans doute pas un mal, chacun devant être plus ou moins spécialisé au type de jeu développé. À ce niveau, la partie réseau reste bien plus dans l'abstrait et s'éloigne des considérations pratiques d'implémentation.

Néanmoins, l'ouvrage n'est sûrement pas le plus abordable, au vu du contenu hautement technique qu'il présente, avec des développements plus académiques que pratiques. Par exemple, les premiers chapitres sur la génération de nombres aléatoires et de bruit nécessitent des prérequis en mathématiques non négligeables ; il n'empêche que cette partie est extrêmement instructive.

Les auteurs présentent un certain nombre de références vers la littérature, notamment scientifique, liées aux problématiques évoquées tout au long du livre. Ces liens permettent souvent d'approfondir le contenu ; cependant, on pourra regretter que toutes ces références ne soient plus accessibles (notamment, sur les techniques d'équilibrage utilisées dans Age of Empires II, sorti en 1999). Malgré tout, bon nombre de ces références ont été mises à jour par rapport à la première édition.

En bref, cet ouvrage peut être recommandé aux personnes qui souhaitent se lancer dans le développement de jeux vidéo, après quelques premiers développements. Il leur permettra de s'améliorer significativement dans une série de domaines spécifiques aux jeux vidéo et ignorés dans la plupart des cours d'algorithmique (par exemple, pour le déplacement d'unités sur un terrain).

Avez-vous lu ce livre ? Qu'en pensez-vous ? 1 commentaire

Vaste sujet qu'est la conception d'algorithmes. Peu de gens maîtrisent réellement ce domaine de l'informatique, le prenant pour mystérieux ou obscur. Cet ouvrage offre un tour d'horizon exhaustif des techniques de conception et abreuve le lecteur d'exemples en tout genre, justement pour donner l'habitude de la pensée algorithmique. Les auteurs suivent un schéma commun pour chaque technique présentée : une introduction, un premier exemple détaillé en profondeur, un résumé de la technique (les points essentiels à mettre en œuvre et les conditions d'application) sous la forme d'un patron de conception d'algorithme, puis une série d'exercices (parfois plus de cent pages pour une méthode, corrections comprises !). Cette manière de procéder explicite comment arriver, par un raisonnement rationnel plutôt qu'intuitif, à une solution efficace (sans oublier d'indiquer où la créativité a droit de cité). Les auteurs mettent en avant la rigueur avec laquelle ils ont rédigé le texte — il faut avouer que ce n'étaient pas des paroles en l'air.

L'ouvrage est principalement constitué d'exercices. Leurs énoncés sont souvent détaillés, de telle sorte qu'on comprenne bien là où les auteurs veulent mener sans devoir regarder la solution. Une manière très efficace d'utiliser le livre est ainsi de réaliser les exercices comme ils sont proposés, en ne vérifiant les solutions qu'à la fin de chaque question. Le lecteur qui préférera rester passif devra au contraire se munir de deux signets (l'un pour les énoncés, l'autre pour les solutions). Les exercices proposés sont relativement variés : on n'a pas droit à une pléthore de graphes et quelques autres pour faire bonne figure, mais un mélange plus varié, avec par exemple des jeux.

Pourtant, l'ouvrage n'est pas le plus abordable. Ce n'est pas tellement dû à ses prérequis — les auteurs s'attendent entre autres à un bon bagage en structures de données et en mathématiques —, mais plutôt au niveau de formalisme mathématique utilisé. Ils démontrent, par exemple, que les schémas de preuves habituels sont corrects ; autant dire que chaque algorithme est donné avec son invariant de boucle. Les preuves données dans les corrections sont détaillées, chaque étape du raisonnement étant minutieusement abordée (les auteurs ne sont pas des adeptes du « laissé au lecteur »). Ceci restreint le public ciblé, qui doit avoir une certaine ouverture d'esprit à la beauté mathématique ; inutile cependant d'avoir un parcours mathématique pur pour tirer bénéfice du livre.

Avez-vous lu ce livre ? Qu'en pensez-vous ? 1 commentaire

L'apprentissage automatique est un domaine aux multiples facettes. Ce livre dépoussière l'une d'entre elles qui n'est que trop peu explorée dans la littérature : l'étude des flux de données, où les algorithmes doivent effectuer des prédictions, mais surtout s'adapter en temps réel à des données disponibles au compte-gouttes (même si ce dernier peut avoir un très bon débit !). Les auteurs font la part belle aux spécificités de ce paradigme : les calculs doivent être effectués très rapidement, on n'a presque pas de temps disponible par échantillon, ni de mémoire d'ailleurs.

Structurellement, on retrouve trois parties bien distinctes :

• une introduction très générale au domaine, qui montre néanmoins l'essentiel de MOA, un logiciel dédié aux tâches d'apprentissage dans les flux ;
• une présentation plus détaillée des algorithmes applicables à des flux, que ce soit pour les résumer, pour en dériver des modèles de prédiction ou pour explorer les données. Cette partie devrait plaire aux étudiants, professionnels et chercheurs qui souhaitent se lancer dans le domaine, notamment avec ses nombreuses références (pour les détails de certains algorithmes moins intéressants ou trop avancés : on sent un vrai lien entre le livre et la recherche actuelle dans le domaine). Les algorithmes sont détaillés avec un certain niveau de formalisme mathématique, pour bien comprendre ce qu'ils font (et pourquoi ils garantissent une certaine approximation de la réalité) ;
• finalement, un guide d'utilisation assez succinct de MOA, avec un bon nombre de captures d'écran du logiciel (imprimées en couleurs !), qui détaille les différents onglets de l'interface graphique (à l'aide de listes très descriptives, mais liées aux autres chapitres de l'ouvrage) et passe rapidement sur les interfaces en ligne de commande et de programmation (ces deux derniers chapitres sont brefs et doivent être complémentés par celui sur l'interface graphique, qui contient les éléments essentiels).

On peut néanmoins reprocher quelques références vers la suite du livre (la section 4.6.2 considère parfois le contenu de la 4.9.2 intégré, par exemple), mais aussi l'omniprésence de MOA : on a l'impression que les auteurs se sont focalisés sur les algorithmes disponibles dans cette boîte à outils, plutôt que de présenter les algorithmes les plus intéressants en général. Cette remarque est toutefois assez mineure, au vu de l'exhaustivité de MOA.

À noter : le livre est aussi disponible gratuitement au format HTML, les auteurs répondant aux commentaires qui leur sont laissés.

Avez-vous lu ce livre ? Qu'en pensez-vous ? 1 commentaire

L'apprentissage automatique est un champ extrêmement développé, mais uniquement pour la découverte de corrélations entre variables. Il est parfois facile de déduire un lien entre des symptômes et une pathologie, mais les algorithmes d'apprentissage ne peuvent pas déterminer qui implique qui : est-ce à cause des symptômes que la maladie est présente ou est-ce l'inverse ? L'apprentissage causal cherche à répondre à ce genre de question, le livre ne porte que sur ce sujet.

Les trois auteurs présentent l'essentiel de ce domaine trop peu connu de la science des données, d'une manière progressive : les premiers raisonnements se font « avec les mains », la formalisation suit (à deux variables aléatoires pour commencer, puis dans le cas général). Notamment, les analyses contrefactuelles sont abordées en détail. Ils n'hésitent pas à parsemer leur texte de bouts de code pour faciliter la compréhension des concepts et la mise en pratique des algorithmes. À ce sujet, ils considèrent que le lecteur connaît les bases de R et de quelques bibliothèques pour comprendre ces morceaux de code, aucune explication syntaxique n'étant donnée. Autant que possible, le sujet est mis en relation avec l'apprentissage automatique plus classique.

Le style de rédaction est toutefois sec et académique. Ceci implique notamment l'abondance de références vers la littérature (les trois auteurs ne sont pas en reste dans la liste des citations…) pour approfondir les sujets : la présentation d'un algorithme se limite bien souvent aux idées principales sous-jacentes, le reste étant disponible dans la littérature. Globalement, l'ouvrage n'est pas toujours aussi facile à suivre que l'on espérerait : il est plutôt destiné à des gens qui connaissent déjà les bases de l'inférence de causalité, mais cherchent à approfondir le sujet ou à découvrir d'autres axes de recherche dans le domaine.

À noter : le livre est aussi disponible gratuitement au format PDF.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

Dans le développement d'un jeu vidéo, les amateurs ont tendance à négliger un point en particulier : le scénario, surtout s'il est voulu interactif. Ce livre propose une base assez solide pour concevoir un tel scénario qui tient la route. Comme indiqué dans le sous-titre, le livre ne se focalise pas sur le jeu vidéo, loin de là : les auteurs traitent aussi bien les jeux audio (à la radio), audiovisuels (comme des films), de rôle (ceux que l'on joue sur table). Par contre, ils survolent les jeux sérieux (dont l'objectif n'est pas le divertissement, mais plutôt la pédagogie) et délaissent les jeux d'évasion (grandeur nature), pourtant cités sur la couverture, ce qui est dommage.

Tout au long de l'ouvrage, on retrouve une série de conseils pour bien s'organiser en travaillant sur un scénario, y compris pour la collaboration en équipe sur un projet réel. On sent vraiment que les auteurs ont une expérience de projets aboutis. Des illustrations en nombre aident à comprendre le propos. Dès que cela est nécessaire, les chapitres sont segmentés selon le medium visé. Le trio derrière la rédaction a aussi inclus des témoignages d'autres professionnels du secteur, pour apporter des astuces plus pragmatiques.

Outre le fond, la présentation est agréable : le livre est illustré en couleur, le texte est parsemé d'humour. La séquence entre les différents chapitres est indiquée à la manière d'un livre dont vous êtes le héros, pour éviter de sortir du cadre du scénario interactif.

On pourra cependant regretter le manque de profondeur et d'analyse, qui nuira aux lecteurs les moins expérimentés. Par exemple, tout au long de l'ouvrage, les auteurs parlent de genres et de clichés, mais sans jamais détailler un seul cliché, ni donner d'exemple pour retravailler une scène (tout au plus une phrase pour donner une idée). Ces précisions supplémentaires aideraient cependant à bien intégrer toutes les subtilités et, plus important encore, à mettre en pratique.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

La visualisation de données est un besoin de plus en plus pressant, notamment dans un contexte de mégadonnées : c'est bien de disposer de données, c'est mieux d'arriver à les exploiter correctement. La visualisation est un outil très utile pour cela, mais seulement quand elle est appliquée à bon escient. C'est ce que ce livre propose : des techniques de visualisation, un lien avec les statistiques, des principes de conception d'une bonne visualisation, mais aussi toute une série d'exemples. L'auteur a comme but d'enseigner la manière de réaliser des graphiques qui ont un impact.

L'auteur est un statisticien et cela se ressent dans la manière d'aborder les sujets : pas question d'afficher des barres d'erreur sans expliciter ce qu'elles représentent (écart type, erreur standard, intervalle de confiance ?), par exemple. Ce n'est pas une raison pour abrutir le lecteur de mathématiques, puisque l'ouvrage ne comporte aucune formule, vraiment aucune. Quelques outils statistiques sont présentés, mais assez brièvement, uniquement en expliquant les principes généraux (des références sont là pour compléter). Ce choix est parfois limitant : pour le bootstrap, notamment, l'auteur répète maintes fois l'utilité de la technique, mais ne l'explique pas vraiment.

Les mises en situation constituent l'épine dorsale du livre, en ce sens que chaque chapitre dispose d'une ou plusieurs visualisations réalistes, parfois comparées : quels sont les avantages de telle manière de représenter les données, quelles sont les interprétations plus faciles à réaliser sur tel graphique, quelle visualisation ne peut pas fonctionner (sans oublier le pourquoi, qu'il soit plutôt statistique ou visuel). Cette manière de procéder rend l'ouvrage très lisible et attirant.

Pour la mise en pratique, l'auteur met à disposition sur son site le code source de chaque graphique qu'il a réalisé pour le livre (surtout en R) — même si le livre en lui-même ne présente pas une seule ligne de code, ce n'est pas un tutoriel R ou Stata.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

Malgré ses aspects très mathématiques, la théorie de l'information se révèle très utile pour l'ingénieur, tant en informatique qu'en électronique, tant elle a su se faire une place : elle couvre la compression des données, la transmission avec détection et correction des erreurs, mais aussi le chiffrement des communications. Ce livre est assez particulier dans la littérature, car il couvre ces trois aspects (le chiffrement est souvent ignoré en théorie de l'information). Il a aussi l'avantage de n'aborder les éléments mathématiques qu'au compte-gouttes, selon les besoins du sujet développé — les auteurs ont évité de présenter trop d'éléments de manière abstraite, ils ont préféré recontextualiser.

Cette troisième édition aborde bon nombre de sujets au goût du jour, comme l'algorithme de hachage SHA-3 (Keccak) ou la cryptographie homomorphe. On peut cependant regretter que la cryptographie post-quantique ne soit pas plus évoquée, puisqu'elle n'est présente que dans un seul exercice (un cryptosystème résistant aux ordinateurs quantiques) : aucune mention des possibilités d'échange de clés à l'aide de photons intriqués, pourtant bientôt utilisés de manière commerciale.

Pour les étudiants, le livre dispose d'une grande série d'exercices, tous corrigés en annexe (bien que de manière assez succincte — suffisant pour vérifier que l'on a le bon résultat, pas tellement pour se débloquer), avec des niveaux de complexité assez variables (mais sans que ce niveau soit indiqué). Dans certains cas, on aurait plutôt préféré voir le sujet de l'exercice traité au fil du texte, avec plus de détails.

L'ouvrage est très complet dans sa présentation : sont présents tous les éléments nécessaires pour l'implémentation complète d'un système de compression, de chiffrement ou de codage sont disponibles, y compris les algorithmes de plus bas niveau (comme le produit efficace de deux polynômes). Les auteurs donnent aussi les recommandations actuelles pour rendre une implémentation cryptographiques sûre. La complétude continue dans les détails mathématiques, puisque toutes les définitions, tous les théorèmes utiles sont donnés (avec une présentation austère, toutefois), souvent avec leur preuve.

Avez-vous lu ce livre ? Qu'en pensez-vous ? 1 commentaire

Le titre de cet ouvrage promet une belle partie appliquée, c'est effectivement ce que l'on ressent à sa lecture : on ne compte plus les lignes de code pour bien montrer ce que l'auteur fait, notamment dans ses graphiques (le code les générant étant présent dans le livre in extenso). Tout le code est d'ailleurs écrit avec Python 3, en utilisant les dernières versions des bibliothèques, afin de rester utilisable aussi longtemps que possible. Ce côté appliqué est présent tout au long du livre, l'auteur cherche toujours à présenter une utilité aux algorithmes qu'il aborde, il ne se contente pas d'un inventaire à la Prévert, le lien avec les applications réalistes est toujours présent.

L'ouvrage est construit progressivement, avec des techniques de plus en plus avancées, en présentant d'abord brièvement les concepts théoriques (sans mathématiques, car tel n'est pas le but du livre), les algorithmes, puis en plongeant dans la pratique. Les approches sont bien souvent comparées sur un même exemple, afin d'en voir les avantages et inconvénients. Cependant, l'apprentissage non supervisé n'est vu que sous un seul angle : l'exploitation de données sans étiquettes dans l'objectif d'effectuer des prédictions, c'est-à-dire comme une approche entièrement supervisée. Ce faisant, tous les aspects d'analyse de données sont négligés : il aurait été agréable, par exemple, de voir une application de partitionnement de données pour comprendre ce qu'elles contiennent (comme déterminer, sans a priori, les différentes manières de participer à un jeu). Au contraire, dans les exemples de partitionnement, on sait d'avance le nombre de classes que l'on cherche.

Au niveau de la présentation, une grande quantité de code et parfois d'images est redondante. Dans les premiers exemples, qui montrent plusieurs algorithmes d'apprentissage supervisé, la validation croisée est présentée à chaque fois, au lieu de se focaliser sur les différences entre les algorithmes. Chaque chapitre commence par une bonne page d'importation de modules Python (y compris des modules qui ne sont pas utilisés dans ce chapitre !). Certaines parties présentent une grande quantité d'images disposées de telle sorte qu'elles prennent un maximum de place (six images de taille raisonnable présentées sur trois pages, alors qu'en les réduisant un peu on aurait pu tout faire tenir sur une seule face…). Par ailleurs, toutes les images sont en noir et blanc, mais ont été conçues en couleurs : il est souvent difficile de s'y retrouver, car l'information de couleur est très exploitée (notamment pour présenter plusieurs courbes : elles ont sûrement des couleurs très différentes, mais les niveaux de gris se ressemblent trop pour que l'on arrive à faire la distinction entre les courbes).

Le côté technique m'a vraiment déçu. Les algorithmes sont présentés très rapidement, leurs paramètres sont quelque peu vus comme des boîtes noires ou simplement ignorés : comment peut-on en comprendre l'impact sur la solution ? Le chapitre sur la détection d'anomalies n'est vu que comme une application de la réduction de dimensionnalité, on ne trouve aucune discussion des algorithmes spécifiquement prévus pour cette tâche (forêts d'isolation, SVM à une classe, etc.), ce qui est assez réducteur. On ne trouve aucune mention des plongements (comme word2vec pour la représentation de mots) dans la section sur les autoencodeurs, alors que c'en est une application très importante.

Le public ciblé semble n'avoir qu'une assez faible expérience en apprentissage automatique. Le livre sera surtout utile à ceux qui veulent une introduction rapide et pas trop poussée au domaine de l'apprentissage non supervisé, un survol du domaine en abordant toutes ses facettes principales. Ceux qui se demandent à quoi l'apprentissage non supervisé peut bien être utile seront servis, mais n'en verront pas toutes les possibilités.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

La nouvelle frontière de l'exploitation de gros jeux de données est le flux, quand de grandes quantités de données arrivent en temps réel et doivent être traitées à la même vitesse. Apache Flink est un outil moderne pour traiter ces problématiques et ce livre, écrit par deux développeurs majeurs du projet, se focalise sur la meilleure manière de développer de telles applications. Il est d'ailleurs très complet et part vraiment des bases (plus théoriques) du traitement de données en flux — certains regretteront que le code fasse son apparition aux alentours de la page 80.

Le contenu se structure de façon très progressive : les auteurs parlent d'abord des principes généraux, puis développent petit à petit et finissent dans des détails sur le fonctionnement interne de Flink (en veillant toutefois à ce que le contenu reste utile pour plusieurs versions). Ainsi, quand l'explication d'un système particulier requiert des détails d'autres sous-systèmes (comme le mécanisme de sauvegarde), ceux-ci sont d'abord esquissés, puis détaillés dans une section ou un chapitre futur : on ne se sent pas dépassé par le contenu, grâce à cette approche progressive.

À ce sujet, le livre couvre Flink 1.7, la version 1.8 étant sortie le même mois que le livre — les nouveautés de Flink 1.8 ne sont pas abordées, ni même citées, comme les évolutions du schéma d'état ou le traitement de données par lots. Chaque système est illustré par l'un ou l'autre exemple, très courts au début du livre, puis bien plus longs ; pour bien en profiter, des connaissances basiques en Scala seront nécessaires (le langage n'est pas du tout présenté). On pourra cependant regretter l'absence d'exemples complets, qui combinent toute une série de fonctionnalités, comme un cas d'utilisation.

Globalement, cet ouvrage pourra viser tant un public de débutants (rien n'est omis dans les bases) que de développeurs plus chevronnés dans le traitement de données en flux (les systèmes et choix de conception de Flink sont abordés en profondeur). Il ne se limite pas aux fonctionnalités et opérateurs de base, mais présente bien toutes les possibilités que l'on a d'adapter le fonctionnement de Flink à ses besoins.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

Julia est un langage de programmation assez récent, mais qui perce notamment dans les domaines où la performance est critique ou quand les besoins en syntaxe spécifique au domaine (DSL) sont élevés. Ce livre présente le langage en faisant abstraction des domaines où il est le plus apprécié, en suivant une approche très progressive adaptée à l'apprentissage de la programmation. L'auteur ne présente donc aucun élément spécifique aux applications du langage, ni même de paquet supplémentaire : il fait plutôt un tri dans les constructions pour proposer les plus courantes, en évitant la redondance — ce qui n'est pas plus mal pour aborder la programmation ! Deux chapitres présentent toutefois brièvement les constructions et outils qui n'ont pas été abordés plus tôt dans l'ouvrage, au cas où le lecteur aurait du code à lire.

De même, chaque chapitre contient une série d'exercices pour mettre en pratique le contenu étudié (malheureusement, la correction n'est disponible qu'en ligne). La pratique est vraiment mise en avant, mais les aspects plus théoriques ne sont pas pour autant négligés quand ils sont nécessaires. Ces passages sont d'ailleurs très clairs. Chaque chapitre se termine par un glossaire des nouveaux termes utilisés dans l'ouvrage, ainsi que, bien souvent, avec une section sur le débogage et les techniques adaptées aux constructions du langage présentées dans ce chapitre. Le dernier chapitre vient ajouter une couche de débogage supplémentaire, pour aider ceux qui n'ont pas de grande expérience en programmation à toujours arriver à leurs fins. Aussi, trois chapitres sont dédiés à des études de cas, qui ne servent qu'à la mise en pratique des nouveaux savoirs, la mise en perspective de différentes manières d'aborder une même problématique.

Le livre est rédigé de manière attrayante et vivante, il ne s'agit pas d'un austère cours de programmation où l'on n'apprend finalement pas grand-chose. Bien au contraire ! Les fonctions disponibles de base en Julia mais réimplémentées pour l'exemple sont toujours suivies de la meilleure manière de procéder (c'est-à-dire d'utiliser l'implémentation de base), ce que tous les ouvrages pour débutants ne font pas forcément. Le chapitre sur la gestion des chaînes de caractères pourrait poser quelques soucis de compréhension pour ceux qui ne sont pas habitués à l'informatique, mais c'est pour la bonne cause, puisque seul Unicode est enseigné, avec ses caractères représentés sur plusieurs octets : de manière globale, l'ouvrage tend à ne présenter que de bonnes pratiques avec le langage.

Globalement, ce livre servira de socle pour tout qui souhaite se lancer en programmation avec le langage Julia. Par contre, eux qui sont déjà adeptes de l'un ou l'autre langage de programmation n'apprécieront probablement pas son rythme lent. On peut regretter que certains points ne soient pas abordés, comme la macro @enum, le paquet Revise.jl ou les opérations vectorielles, s'il faut vraiment chercher une critique à apporter.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

La programmation de cartes graphiques pour du calcul généraliste est un art exigeant : écrire du code correct n'est pas suffisant, il faut aussi qu'il soit rapide, sinon il n'est pas très utile de passer sur un processeur graphique. Pour y arriver, la meilleure alliée est probablement l'expérience et l'auteur semble en avoir une certaine quantité.

Ce livre prend le lecteur par la main en ce qui concerne l'écriture de code (très) performant, tant sur CPU que GPU. Il commence par expliquer toutes les notions utiles pour un CPU, avant de généraliser aux GPU (et de préciser les distinctions), pour travailler à une échelle plus habituelle pour un programmeur (quelques fils d'exécution, pas plusieurs millions). Le lecteur est abreuvé de détails de bas niveau sur le fonctionnement d'un processeur et de la mémoire, afin d'en profiter un maximum : autant que possible, l'auteur limite ses explications à des invariants dans la conception de ces processeurs, de telle sorte que le livre reste utile pendant plusieurs générations de matériel.

Le livre se focalise sur extrêmement peu d'exemples différents, toujours pris dans le traitement d'images (retournement d'une image et détection d'arêtes). Ces exemples ont des caractéristiques suffisamment variées pour les besoins du livre (utilisation intense de la mémoire ou des capacités de calcul) et permettent d'aller droit au but dans les améliorations de performance. D'ailleurs, les analyses de performance ne se limitent pas à constater des différences, mais bien à les expliquer en détail en fonction du matériel utilisé.

La partie la plus décevante du livre est sans conteste la troisième, qui sort de CUDA. On a droit à des introductions extrêmement courtes et partielles à des sujets bien plus variés. Par exemple, pour les bibliothèques livrées avec CUDA, on a plus une liste de possibilités qu'une vraie explication de leur utilisation. Le très bref chapitre sur les réseaux neuronaux explique très rapidement le principe, l'existence de la bibliothèque cuDNN, ses fonctions principales (mais juste les noms, pas leur utilisation !) avant de conseiller l'utilisation de Keras : au vu du titre du livre, on s'attendait à plus de détails.

Le ton est vivant, pas lénifiant, comme l'on a parfois dans les ouvrages introductifs du genre : l'auteur a une certaine expérience pédagogique et la met à profit (même si les personnes allergiques aux noix de coco feraient mieux de passer leur chemin — les concepts principaux sont expliqués à l'aide d'analogies avec la récolte de noix de coco). Une conséquence est que le livre n'est pas compact, les explications ne laissant pas beaucoup de place à l'interprétation. Le public visé n'a pas de grandes connaissances en programmation de haute performance, il s'agit plutôt de scientifiques non informaticiens ou d'étudiants dans ces domaines — par exemple, les premiers chapitres ne supposent aucune connaissance de la ligne de commandes.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

L'infographie 3D est un domaine paradoxal : autant les applications montrent vite un côté fun et entraînant, autant l'apprentissage peut se montrer rébarbatif. Ce livre met véritablement l'accent sur la pratique, c'est-à-dire que les concepts sont dès que possible mis en pratique à l'aide d'« expériences », des morceaux de code à lancer pour mieux comprendre. L'aspect pratique est tellement développé qu'il est handicapant de ne pas avoir d'ordinateur à proximité pour tester ces exemples !

Le côté théorique n'est pas mis de côté, il est fort présent, au point que l'auteur se sent parfois obligé d'indiquer que certaines sections peuvent être sautées en première lecture. Le niveau de détail est toutefois adapté pour des autodidactes, avec des prérequis raisonnables (sauf pour la partie sur la géométrie projective, bien plus difficile d'accès) : trigonométrie, analyse mathématique, algèbre linéaire, à un niveau relativement basique. Les sections vraiment mathématiques sont présentées d'abord de manière assez abstraite, mais en contexte  l'objectif n'est pas d'enseigner des mathématiques, mais des outils mathématiques utiles dans un contexte infographique. L'auteur fait autant de liens que possible avec la pratique d'OpenGL.

L'approche pédagogique risque de surprendre, puisque les quinze premiers chapitres se focalisent sur OpenGL « à l'ancienne », avec toutes ses fonctions fixes. De la sorte, l'auteur suit une approche progressive, laissant OpenGL gérer un grand nombre de difficultés pour se focaliser sur les principes de base (VAO et VBO ne simplifient pas le code) : par conséquent, les nuanceurs n'arrivent que très tard, Vulkan n'est que cité. On peut aussi regretter que la pratique des nuanceurs ne soit pas plus développée, l'auteur ne montrant qu'une série d'effets que l'on peut implémenter grâce à eux. Ce livre ne vise pas à enseigner l'utilisation d'OpenGL, mais bien les principes de l'infographie 3D : la syntaxe OpenGL n'est pas aussi importante que la bonne compréhension des principes sous-jacents.

L'ouvrage ne contient pas énormément de code, surtout les parties nécessaires à la compréhension. Pour voir le code au complet, le lecteur est redirigé vers le contenu supplémentaire du livre. À titre personnel, j'aurais néanmoins préféré voir plus d'extraits de code dans le texte. Il paraît que tout le code est écrit en C++, mais il s'agit plus d'un C89 avec des classes (notamment avec les définitions de variables en début de bloc) : utiliser la classe string plutôt qu'un tableau char* aurait simplifié certains passages.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

L'algorithmique est un sujet indispensable pour toute formation de développeur informatique et c'est (malheureusement ou non) souvent un sujet testé lors des interviews de code des grandes entreprises. Cependant, la matière est souvent enseignée de manière très rigide et rarement accessible au plus grand nombre, y compris en début de cursus (l'algorithmique est parfois considérée comme un sujet éliminatoire par les enseignants).

Ce livre propose un autre angle de vue sur le sujet : le texte est clair, pas encombré de termes techniques inutiles. Le contenu est abordé de manière progressive et intégrée (les notations asymptotiques ne sont pas détaillées de manière abstraite, mais dans le concret d'un algorithme). L'auteur a fait le choix de présenter relativement peu d'algorithmes (aucun algorithme de tri ne nécessite de structure de données comme le monceau), ce qui lui permet d'entrer dans les détails. Chacun est d'ailleurs placé dans un vrai contexte avec des problèmes réels où cet algorithme peut être utilisé. Chaque chapitre est terminé par un petit encadré résumant les notions les plus importantes abordées dans ce chapitre.

L'un des choix posés lors de la rédaction a été une complète indépendance vis-à-vis du langage de programmation. D'un côté, cela rend le livre plus abstrait et légèrement moins accessible. De l'autre, cela permet d'éviter les complexités liées à la syntaxe d'un langage de programmation (le lecteur est d'ailleurs supposé déjà savoir programmer dans un langage, c'est presque le seul prérequis — avec un petit peu de mathématiques). Les intrications mathématiques sont limitées au maximum, afin d'élargir le public visé. Certains sujets nécessitent plus d'écritures mathématiques, mais ils sont clairement indiqués comme tels et ne sont pas nécessaires à la bonne compréhension globale de l'ouvrage.

Ce livre fait partie d'une série de quatre et il est extrait de cours en ligne donnés par l'auteur. Ce premier tome parle d'algorithmique en général, sans entrer dans les détails de structures de données : il se limite à quelques algorithmes de tri (le tri rapide ayant droit à son propre chapitre bien détaillé). L'auteur a d'ailleurs réutilisé certaines des ressources de ces cours pour compléter le livre. On y retrouve donc l'un ou l'autre quiz (avec des solutions très détaillées) et des problèmes (la plupart ayant une solution explicitée dans le livre), mais aussi des tests plus compliqués en ligne ainsi que des vidéos.

En résumé, je trouve que ce livre est une très bonne introduction au sujet de l'algorithmique. Il conviendra très bien aux plus débutants et à ceux que le domaine rebute. Par contre, il faudra le compléter par d'autres livres pour approfondir.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

L'algorithmique est un sujet indispensable pour toute formation de développeur informatique, notamment sa partie sur les structures de données. Ce deuxième tome se focalise sur cette notion (ainsi que sur les graphes) et montre à quel point un bon choix de structure de données permet de réduire la complexité d'un algorithme. Il suit de manière très naturelle le premier (bases de l'algorithmique), sans toutefois en nécessiter la lecture : si vous avez de vieilles bases en algorithmique, vous pourrez probablement passer directement à ce deuxième volume pour vous remettre à jour (au cas où vos souvenirs seraient trop émoussés, une annexe résume — forcément brièvement — les éléments essentiels). Les plus débutants devraient cependant plutôt débuter par le premier livre, avec des explications des concepts de complexité bien plus poussées. Cette division en deux volumes fait d'ailleurs que certains éléments sont répétés par rapport au premier tome (comme la justification du pseudocode ou la définition du tri, ainsi que certains traits d'humour).

Comme dans le premier tome, l'auteur prend le parti d'un texte clair, épuré, accessible au plus grand nombre (on peut apprécier la quantité d'illustrations pour les algorithmes de traversée de graphes, pas toujours les plus intuitifs quand on débute dans le domaine). À nouveau, il se focalise sur les éléments les plus importants du sujet. Notamment, seul l'algorithme de Dijkstra pour les plus courts chemins est détaillé dans le livre (pas de Bellman-Ford ou d'A*). Un autre exemple, peut-être plus litigieux, est celui des structures de données de base, puisque l'auteur considère que le lecteur est parfaitement au courant des propriétés et de la manipulation des tableaux, des listes liées, des files et des piles.

Plus que le premier tome, ce deuxième volume se rapproche des applications pratiques. Les algorithmes présentés semblent moins utiles, mais seulement à première vue. L'auteur met toujours les algorithmes en contexte, justifie leur besoin réel. Ainsi, les algorithmes travaillant sur des graphes sont présentés en même temps que leurs applications dans les réseaux ou la planification. Ce côté appliqué se montre aussi dans la structure des chapitres sur les structures de données : le praticien doit surtout connaître les opérations principales des structures de données, leur complexité, mais pas forcément leur implémentation. L'auteur sépare ainsi la spécification de la structure de données des techniques d'implémentation.

L'organisation des chapitres peut sembler un peu contre-intuitive, avec d'abord les graphes et puis les structures de données. Elle a le grand avantage de justifier le besoin en structures de données par la pratique, par la recherche d'algorithmes efficaces pour des besoins concrets (pas vraiment académiques). On peut regretter que ce tome soit autant lié à la série pour certains aspects : l'algorithme de Dijkstra n'est pas l'algorithme le plus générique pour les plus courts chemins, mais il est le seul présenté ici. Il faudra attendre le troisième tome pour découvrir l'algorithme de Bellman-Ford, dans le cadre de la programmation dynamique (peu après avoir lié celui de Dijkstra aux algorithmes gloutons).

Ce livre fait partie d'une série de quatre et il est extrait de cours en ligne donnés par l'auteur. L'auteur en a réutilisé certaines ressources pour le compléter. On y retrouve donc l'un ou l'autre quiz (avec des solutions très détaillées) et des problèmes (la plupart ayant une solution explicitée dans le livre), mais aussi des tests plus compliqués en ligne ainsi que des vidéos.

Avez-vous lu ce livre ? Qu'en pensez-vous ? 5 commentaires

L'algorithmique est un sujet indispensable pour toute formation de développeur informatique. Ce troisième tome s'intéresse à la manière de concevoir de nouveaux algorithmes selon deux paradigmes : les algorithmes gloutons et la programmation dynamique. Ce livre se place dans la lignée des deux premiers de la série, avec un approfondissement des sujets : par exemple, le deuxième tome abordait les graphes, le troisième présente l'algorithme de Bellman-Ford pour le calcul de plus courts chemins. La lecture des deux premiers ouvrages n'est pas absolument nécessaire, si toutefois vous en avez acquis les bases (aucune annexe ne résume les éléments essentiels) ; certaines connaissances en algorithmique sont requises pour profiter de ce livre.

L'auteur continue avec son parti pris d'un texte clair, épuré, accessible au plus grand nombre. Malgré le niveau technique plus avancé que dans les deux premiers tomes, les explications restent claires et faciles à suivre. Cette troisième partie de la série contient presque exclusivement des exemples des deux techniques de conception d'algorithmes, notamment avec les algorithmes les plus connus et utiles (on a déjà cité Bellman-Ford, il ne faut pas oublier les codes de Huffman, les algorithmes de Prim, de Kruskal, de Floyd-Warshall pour les graphes). Elle s'oriente encore plus vers des applications, mais aussi de la recherche (avec quelques références vers des articles parfois très récents — 2018).

Ce livre fait partie d'une série de quatre et il est extrait de cours en ligne donnés par l'auteur. Tim Roughgarden en a réutilisé certaines ressources pour le compléter. On y retrouve donc l'un ou l'autre quiz (avec des solutions très détaillées) et des problèmes (la plupart ayant une solution explicitée dans le livre), mais aussi des tests plus compliqués en ligne ainsi que des vidéos.

Avez-vous lu ce livre ? Qu'en pensez-vous ? 1 commentaire

La recherche d'algorithmes aussi efficaces que possible pour les problèmes les plus difficiles (c'est-à-dire dans la classe de complexité NP-hard) a lancé la communauté scientifique dans une série de pistes. L'une des approches les plus récentes est la définition de noyaux, des transformations des données d'entrée qui permettent de les réécrire en en diminuant la taille. Ce livre parle exclusivement de ces techniques de définition de noyaux, son sujet est donc l'informatique théorique, plus particulièrement la complexité paramétrique. Malgré le niveau élevé du contenu abordé, les prérequis sont assez limités : une bonne formation en informatique de niveau universitaire suffit, avec une certaine expérience des machines de Turing et de la théorie des graphes.

Pour un sujet aussi complexe et avancé, les auteurs font preuve d'une bonne pédagogie, ils avancent sans hâte, partant de définitions plutôt intuitives pour aller jusqu'à une formalisation complète des concepts utilisés. Cependant, l'approche reste académique, les exemples ne sont pas légion : bon nombre de transformations auraient pu bénéficier d'être explicitées sur des graphes, pour éviter d'être expliquées uniquement de manière abstraite. La plupart des résultats avancés sont prouvés, sans omettre d'étape importante dans le raisonnement, ce qui en facilitera la compréhension par des gens qui ne sont pas du milieu.

Une bonne partie de l'ouvrage présente des outils pour dériver des noyaux utiles, avec plusieurs exemples à chaque fois de problèmes qui peuvent en bénéficier. La manière dont ces exemples sont rédigés peut rebuter, vu qu'une bonne partie du texte constitue un inventaire à la Prévert de théorèmes et algorithmes. On peut regretter que tous ces résultats ne soient pas régulièrement mis en perspective pour montrer l'intérêt d'utiliser des noyaux en pratique.

L'ouvrage peut donc être facilement conseillé à des chercheurs du domaine de la complexité algorithmique ou à des gens que ce domaine intéresse fortement. Ils trouveront du contenu raisonnablement facile d'accès et exhaustif.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

Les fibres optiques occupent une place prépondérante dans les réseaux informatiques modernes, y compris dans la vie de tous les jours avec le déploiement de la FTTH dans de nombreux pays. Cependant, le sujet reste parfois mystérieux : comment des impulsions lumineuses peuvent-elles transférer autant de données en aussi peu de temps ? Ce livre décortique tous les éléments nécessaires à la bonne compréhension des fibres optiques, de manière ascendante ; en partant des bases physiques (les grands principes généraux), des composants optoélectroniques et en allant jusqu'aux protocoles déployés. De ce fait, l'ouvrage est assez complet, il dépasse très largement la simple évocation de principes généraux.

Il offre cependant une vue système sur le domaine, sans entrer dans les détails physiques ; pour les protocoles, il se focalise sur les différences par rapport aux technologies plus traditionnelles, par exemple. Le public visé doit donc posséder des connaissances dans le domaine des réseaux (comme les techniques de multiplexage), mais pas forcément en optique ou en électronique. L'ouvrage est rédigé à destination tant de techniciens qui doivent déployer un réseau qu'aux décideurs techniques.

Dans le domaine des réseaux (et en particulier des fibres optiques), on se retrouve très vite à devoir gérer un grand nombre de sigles : l'auteur fournit, en annexe, une liste de ces sigles et leur définition. Par ailleurs, bon nombre de chapitres sont rédigés de manière encyclopédique, un très grand nombre de types de fibres étant expliqué, les protocoles principaux et leur évolution aussi. L'auteur en fournit une vision historique, en détaillant les différences entre les révisions des normes.

La rédaction est soignée, notamment au niveau du choix du vocabulaire technique, afin d'éviter les anglicismes et les raccourcis qui nuisent à la compréhension. On peut regretter que certaines photos incluses soient de mauvaise qualité (par exemple, quelques illustrations du chapitre sur l'aboutement sont floues). Les dégradations possibles sur les fibres optiques sont étudiées, mais d'un point de vue plutôt physique (agression chimique, efforts mécaniques, etc.) en vue de leur détection et de leur réparation : leur impact sur les communications n'est pas vraiment abordé.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

L'administration de réseaux informatiques en entreprise (par opposition aux réseaux domestiques) est un domaine vaste, où l'on peut se perdre longtemps en protocoles et analyses théoriques sans toucher à la pratique. Le but de l'auteur est tout autre : certes, une base théorique est nécessaire, mais la pratique l'est encore plus. Il a mis en application ce principe pour la rédaction de ce livre, avec un certain brio. Ainsi, la partie théorique n'est pas négligée, mais ne prend pas toute la place : l'ouvrage ne fait pas de la théorie juste pour le plaisir, mais bien parce qu'elle est utile (pour effectuer certains déploiements, pour comprendre des problèmes, etc.).

On sent là que l'auteur a bien plongé les mains dans le cambouis et nous fait un retour d'expérience, sans toutefois se focaliser sur un constructeur en particulier : les fondements, les protocoles sont plus importants que des outils spécifiques ou propriétaires. Le glossaire se révèle être un outil bien pratique, en rassemblant tous les sigles et termes spécifiques avec leur définition en un endroit.

Tout au long de la lecture, on verra des explications assez poussées, abordant aussi l'aspect historique (tout le monde n'a pas la chance d'avoir le dernier matériel). La sécurité est un élément omniprésent et sert à justifier bon nombre d'éléments ajoutés dans un réseau. L'auteur intègre aussi régulièrement de petites références vers les sections à venir, pour indiquer d'autres manières de mettre en œuvre un même concept, comme la virtualisation dans les réseaux (SDN).

Cependant, certains principes des réseaux sont expliqués de manière très succincte : le texte est suffisant pour celui qui a déjà de bonnes bases en réseaux, mais ne l'est probablement pas pour celui qui se replonge dans le domaine après un petit temps d'absence. Par exemple, les VLAN sont expliqués de manière rapide et assez abstraite : on n'a au début aucune idée de leur utilité, il faut bien avancer dans la section pour ce faire.

Au fil du texte, on voit des lignes de commande de configuration de commutateur ou de routeur, mais elles ne sont généralement pas très expliquées. D'ailleurs, les premières ne sont même pas introduites, ce qui fait qu'on se retrouve avec une série de lignes absconses sans savoir ce que l'on peut en faire. On a aussi assez rapidement des références à Wireshark, logiciel de capture et d'analyse de trafic, notamment des filtres pour voir le fonctionnement d'un protocole, mais le logiciel est à peine cité, alors qu'il s'agit d'un outil très intéressant. Aussi, la configuration des pare-feux est abordée très rapidement, sans vraiment proposer de canevas à suivre pour l'élaboration des règles. Finalement, la version papier est imprimée en noir et blanc, alors qu'un certain nombre d'illustrations sont prévues en couleurs.

En conclusion, cet ouvrage est de bonne facture, avec de bonnes explications sur les aspects pratiques des déploiements de grands réseaux. Il pèche par certains aspects, rendant la compréhension plus difficile pour ceux qui ont les moins bonnes bases en réseaux. On peut le conseiller à toute personne souhaitant se lancer dans un déploiement (ou y contribuer) et ayant déjà des notions en réseaux (même si elles sont juste théoriques).

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

Avec la mode du big data, quelques mots clés reviennent régulièrement, à l'instar de Spark. Ceux qui les profèrent ne savent pas toujours ce qui se cache derrière : peu importe le niveau de technicité de ces trublions, ce livre leur donnera les bases de Spark. C'est là l'un de ses atouts : l'ouvrage est d'abord écrit pour ceux qui veulent vraiment se mettre à utiliser Spark (déployer une grappe de serveurs, écrire une application), mais s'adresse également à ceux qui devront superviser des projets Spark « sans mettre les mains au clavier ». De fait, les prérequis sont assez légers : un peu de programmation (pas forcément orientée objet), des notions de Java (puisque Spark est implémenté sur la plateforme Java), un peu de SQL (langage par excellence pour le traitement de données). On pourrait regretter le caractère concis de certains passages, qui pourraient abaisser le niveau des prérequis.

L'auteur ne cherche pas à décrire de manière exhaustive les possibilités offertes par le système, mais plutôt à inculquer une méthodologie pour faciliter la mise en œuvre d'un projet Spark. Par exemple, l'introduction à l'apprentissage automatique ne parle pas du tout des algorithmes disponibles : bon nombre d'ouvrages les expliquent déjà en long et en large. Par contre, très peu parlent de la manière d'introduire de l'apprentissage dans la pratique industrielle : par exemple, comment présenter les résultats d'une manière intelligible pour un public de décideurs qui n'a presque aucune connaissance en statistiques ? Il n'empêche que certains paramètres sont plus détaillés, car ils présentent un intérêt non négligeable pour améliorer la performance d'une application, par exemple.

Spark est expliqué comme une évolution logique des plateformes de traitement des mégadonnées : l'outil n'est pas apparu par magie au milieu du désert, mais dans un contexte très spécifique avec une série d'acteurs qui cherchent à effectuer des traitements similaires à très grande échelle. Ce n'est pas pour ça que les fonctionnalités de Spark sont présentées de manière chronologique : l'auteur préfère d'abord parler des tables de données (DataFrame), bien avant des RDD. De fait, avec Spark 2, ils sont devenus un sujet plutôt avancé. Néanmoins, on peut regretter que Spark 3 ne soit abordé que dans la conclusion et la quatrième de couverture.

L'un des points importants de ce livre est toutefois la présence de deux études de cas, l'une orientée Spark Core, l'autre Spark ML. Cette dernière correspond au chapitre 9, c'est-à-dire à presque un tiers du volume de l'ouvrage ! Elles partent de données brutes sur une entreprise de location de vélos et ne s'arrêtent qu'avec des résultats propres à présenter à des décideurs : ces études de cas sont réalistes, bien que simplifiées.

La mise en page est claire, notamment avec les objectifs de chaque chapitre explicités au début de chacun d'eux. Chaque section est richement illustrée, avec des figures claires, ce qui aide à la compréhension.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

Les algorithmes de flot sont très utilisés en recherche opérationnelle. Souvent, le domaine est perçu comme statique, alors que les développements théoriques et pratiques continuent sans cesse. Cet ouvrage assez succinct présente néanmoins le sujet de recherche dans ses aspects fondamentaux. L'auteur a fait le choix de ne traiter que les algorithmes polynomiaux (exacts ou approchés), afin de garder un livre assez bref. Par ailleurs, un autre choix posé est celui des preuves incluses : elles peuvent toutes être expliquées en moins d'une heure de cours (l'auteur en ayant fait l'expérience). On peut aussi remarquer le soin apporté pour indiquer les structures de données les plus efficaces pour implémenter les algorithmes donnés.

Le premier chapitre démarre sur les chapeaux de roues, avec directement des algorithmes de calcul de plus court chemin dans un graphe, afin d'expliciter des notions qui reviendront régulièrement dans la suite, comme l'étiquetage des nœuds ou la détection de cycle. Par conséquent, le livre est réservé à un public déjà averti des algorithmes sur des graphes… et ouvert aux mathématiques. De fait, l'ouvrage comporte un nombre très élevé de preuves (déjà une vingtaine dans le premier chapitre, une cinquantaine dans le second !), qui en constituent le cœur. Il n'empêche que l'auteur a toujours à cœur de d'abord passer par des raisonnements intuitifs avant de formaliser. Aussi, le contenu reste, en bonne partie, très abstrait : il s'agit de raisonner sur des graphes génériques, pas sur des applications particulières, a priori en totale déconnexion avec la pratique du domaine (sauf en début et fin de livre).

On peut regretter que certains sujets ne soient pas abordés, comme les plus courts chemins avec des contraintes de ressources ces derniers sont extrêmement utiles pour la résolution de problèmes réels de logistique ou de réseau (avec des techniques de génération de colonnes), mais restent à peine abordés. L'utilité de la dualité n'est pas vraiment explicitée, alors qu'elle revient très régulièrement (bon nombre d'algorithmes travaillent sur le dual du problème présenté). De même, les méthodes de point intérieur sont très souvent citées, parfois très légèrement abordées dans les notes de fin de chapitre, mais jamais vraiment décrites dans l'ouvrage, alors que bon nombre de résultats récents les utilisent abondamment.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

Les séries temporelles se présentent dans de plus en plus de situations, alors que, il y a peu, elles étaient étudiées presque uniquement dans un contexte financier. Ce livre cherche à présenter le champ des utilisations possibles de l'analyse des séries chronologiques dans divers domaines ; cependant, son auteure cherche l'exhaustivité dans les méthodes pour approcher les séries temporelles plutôt que dans leur application. Elle nous livre ici une véritable revue en règle des techniques d'analyse et de prédiction de séries chronologiques, tant les plus classiques et statistiques (ARIMA et famille) que les plus récentes (de l'apprentissage automatique jusqu'à l'apprentissage profond). De fait, les méthodes les plus simples sont parfois les plus appropriées.

Alors que la plupart des ouvrages sur le sujet requièrent de bonnes connaissances en statistiques de la part du lecteur, ce n'est pas le cas de celui-ci. Pour une plus grande ouverture, l'auteure ne suppose que des bases en programmation et en statistiques, mais c'est à peu près tout : tous les concepts nécessaires sont brièvement réexpliqués, au besoin. De fait, le parti pris est véritablement pratique. Ainsi, ceux qui souhaitent approfondir la théorie derrière certaines méthodes ne trouveront pas leur bonheur ici, les explications purement mathématiques étant réduites à leur plus simple expression ; par contre, on a droit à des explications sur les faiblesses potentielles des mécanismes d'acquisition de données et sur le nettoyage des données qui suit forcément leur récupération. Ce n'est pas pour autant un livre de recettes : l'auteure cherche toujours à détailler le pourquoi, bien plus que le comment (qui est l'apanage des documentations techniques). Il n'y a d'ailleurs que rarement un intérêt à coder soi-même des algorithmes classiques, ce point est clairement expliqué par l'auteure.

On peut néanmoins se demander pourquoi les codes sont disponibles alternativement en R et en Python : dans certaines situations, l'un des deux langages a un écosystème légèrement plus développé dans un domaine particulier, mais les justifications manquent le reste du temps. Les passages de l'un à l'autre langage sont rarement détaillés, alors qu'on aimerait parfois savoir s'il est vraiment important de s'investir dans un autre langage pour l'analyse de données. En particulier, l'auteure montre un certain nombre de visualisations, mais ne le fait qu'en R, jamais en Python…

Le livre est chargé en références, souvent vers des sites comme StackOverflow : les explications n'y sont souvent pas très détaillées (pas comme dans un article scientifique), mais raisonnablement faciles à comprendre. On pourrait juste regretter que les liens pointent plutôt vers des questions que vers des réponses. De même, les logiciels existants sont bien référencés. L'ouvrage apporte, par rapport à d'autres sources, des listes de logiciels et bibliothèques pas forcément parmi les plus connus, mais surtout parmi les plus utiles — en pratique.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

L'apprentissage automatique a divers domaines d'application, l'un des plus étonnants est sans doute la génération de contenu : images, textes, sons, etc. Depuis quelques années, on voit de plus en plus de démonstrations bluffantes de transfert de style d'un peintre sur des photographies modernes, de rédaction automatisée de texte, etc. Ce livre se focalise sur les principes sous-jacents à ces techniques et sur leur mise en œuvre à l'aide de réseaux neuronaux.

L'auteur sépare assez clairement les chapitres en deux parties. La première aborde essentiellement la théorie, avec les architectures principales de réseaux neuronaux appliquées aux problèmes de génération de contenu. On y découvre quelques applications basiques, mais les plus intéressantes doivent attendre la seconde moitié. Là, les schémas de base sont déclinés pour atteindre les meilleurs résultats actuels sur des tâches de génération de contenu. Il n'y a pas d'objectif d'exhaustivité l'auteur a fait un choix raisonné de techniques variées, pour montrer un maximum d'outils généralisables à d'autres tâches. Il n'hésite par ailleurs pas à donner des références dans la littérature scientifique, abondante dans le domaine, pour approfondir le sujet.

Aucun chapitre ne reste abstrait, puisque chaque technique est implémentée en Python. Il ne manque aucun détail, tout est explicite et expliqué, l'auteur y prête une attention particulière : on y retrouve les architectures de réseaux neuronaux, mais aussi les algorithmes à employer pour arriver à produire le résultat attendu. Les architectures génériques ne sont présentées qu'une seule fois, après quoi leur utilisation est cachée derrière des classes de l'auteur. Par ailleurs, tout le code est disponible sur GitHub, pour faciliter sa réutilisation.

Les applications sont variées et ne sont pas limitées à une forme artificielle d'art. En effet, l'auteur détaille aussi la génération de réponses à des questions ou encore l'inclusion d'éléments génératifs dans des techniques d'apprentissage par renforcement. Les principes sont similaires, mais on n'attend pas à les voir employés dans ce contexte.

On peut aussi apprécier l'impression en couleurs du livre, qui permet aussi la coloration syntaxique du code. Ce petit plus est bien agréable. De plus, le style de l'auteur est attrayant, très peu académique : l'ouvrage se lit très facilement.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

La science des données est un domaine tellement à la mode qu'elle attire des gens de tout horizon… et des livres de qualité variable, tentant de répondre à la demande. La plupart des ouvrages creusent profondément la théorie et les mathématiques derrière chaque algorithme (pour l'utilisation des techniques, les auteurs renvoient à la documentation, s'ils prennent cette peine) ou brossent un tableau tellement rapide qu'on ne comprend pas ce qui se passe vraiment (par contre, l'API d'une bibliothèque très spécifique est expliquée en long et en large). Ce livre cherche une troisième voie, entre une compréhension des algorithmes et une approche pragmatique : la compréhension d'un algorithme vient en l'implémentant, pour bien en saisir les tenants et les aboutissants. Cette maxime est poussée jusque dans ses retranchements, l'un des derniers chapitres présentant brièvement l'utilisation de bases de données SQL… avec une implémentation très basique d'un tel système.

Pour s'ouvrir à un public aussi large que possible, les prérequis sont très limités : des compétences en programmation (un chapitre entier est dédié au langage Python, utilisé dans tout le livre) et une aversion limitée envers les mathématiques (tous les concepts nécessaires étant rapidement expliqués, en prenant surtout un point de vue algorithmique). De là, l'auteur présente tout un cycle de projet de science des données, depuis l'acquisition et le nettoyage des données jusqu'au déploiement d'un modèle d'apprentissage, avec des incursions du côté du partitionnement des données ou de l'analyse de graphes.

Même si les algorithmes sont implémentés de zéro, l'auteur n'oublie pas le lien avec la pratique : presque personne n'implémente lui-même des algorithmes classiques. Ainsi, on a droit à des liens vers scikit-learn ou d'autres bibliothèques Python, selon les cas. Les fonctions développées ont une interface assez proche de celles proposées par ces bibliothèques, mais la ressemblance est la plus frappante pour les réseaux neuronaux (l'interface étant très proche de la classe Sequential de Keras). La grande différence avec les bibliothèques courantes réside dans les structures de données : pour avoir un code aussi explicite et clair que possible, l'auteur utilise des structures de données très précises telles que des listes de tuples nommés ou des dictionnaires, là où en pratique il faut utiliser des matrices pour des raisons de performance.

Si l'essentiel du livre s'intéresse au côté algorithmique de la science des données, l'auteur met l'accent sur les statistiques et fait autant que possible des liens avec des approches plus formelles pour les raisonnements : une intuition sur les données que l'on peut acquérir à l'aide d'un algorithme n'a peut-être aucun sens statistique, auquel cas cette intuition ne vaut pas grand-chose. De même, l'interprétabilité des modèles est mise en avant.

Le code proposé est toujours propre et exploite les dernières possibilités de Python. Le style d'écriture est très informel, ce qui colle parfaitement bien au public visé. On peut cependant regretter le traitement de la visualisation, un sujet très important en science des données, mais assez rapidement brossé.

En peu de mots : le pari de l'auteur est bien tenu !

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

À l'époque où les données sont reines, l'art des visualisations devient de plus en plus important, tant pour comprendre ces données que pour communiquer des faits significatifs. Ce livre se focalise sur ce deuxième axe, c'est-à-dire sur la création de graphiques efficaces et plaisants à l'œil. L'auteur donne aussi des conseils pour bien intégrer ces graphiques dans une narration contextualisée des données, notamment grâce à sa méthodologie INSIGHT (qui n'est en rien spécifique au logiciel Tableau). Le mot d'ordre principal est qu'un graphique se pense : on ne peut pas réaliser de bonnes visualisations en fonçant tête baissée.

Le livre commence par une présentation générale de l'outil Tableau (déjà quelque peu dépassée, l'édition Personal n'existant plus), des types principaux de graphiques disponibles et de la bonne manière de les utiliser (surtout pour les plus exotiques). L'ouvrage est composé de cent chapitres très courts et indépendants, chacun tient dans la durée d'une pause café. Il peut se lire de manière linéaire ou comme une référence : chaque chapitre est écrit comme un petit tutoriel précis, focalisé sur une fonctionnalité du logiciel. L'auteur offre régulièrement un retour personnel d'expérience ou inspiré de la manière dont d'autres ont conçu des visualisations efficaces. L'objectif est de montrer une bonne manière d'utiliser le logiciel, mais sûrement pas la seule. Vu que bon nombre d'utilisateurs viennent de l'environnement Excel, les différences avec Tableau sont régulièrement mises en avant, pour faciliter la prise en main.

Cependant, on peut regretter que le niveau monte très vite dans les premiers chapitres. Il vaut mieux avoir une petite expérience de Tableau pour profiter un maximum de l'ouvrage, sans quoi le vocabulaire spécifique (utilisé dès le début) pourrait être rebutant.

Les figures imprimées en couleur sont les bienvenues dans un livre sur la visualisation, bien qu'elles ne soient pas strictement nécessaires. On ne peut pas se plaindre de la quantité d'illustrations, même si certaines sont trop petites pour être lisibles sur papier.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

Comment fonctionnent les systèmes de gestion de base de données actuels ? Bon nombre de gens les utilisent sans vraiment vouloir entrer dans les détails, mais ceux qui veulent lever le voile n'ont pas vraiment une pléthore de ressources pour le faire. C'est un manque que l'auteur vient ici combler, avec une présentation générale de toutes les techniques utilisées actuellement pour implémenter de tels systèmes, qu'ils soient relationnels ou pas. Deux grands sujets sont explorés : le stockage de données sur disque et les systèmes distribués, chacun occupant approximativement la moitié de l'ouvrage.

L'auteur considère simultanément deux points de vue, celui de l'utilisateur (comment le système fonctionne-t-il ?) et celui du développeur (comment concevoir un nouveau système de base de données ?). Il explicite ainsi les choix à faire lors du développement et donne les avantages et inconvénients des décisions posées par des systèmes existants.

Les bases de données ont une structure particulière pour obtenir une très bonne performance, puisque la conception d'un tel système requiert de penser à un très haut niveau d'abstraction (le type de requête habituel), mais aussi à un très bas niveau (le fonctionnement des disques durs et des SSD pour optimiser la représentation physique des données). L'auteur passe avec aisance d'un niveau d'abstraction à l'autre et explicite les liens nécessaires.

Bien évidemment, tous les concepts utilisés dans l'implémentation des bases de données actuelles ne sont pas passés en détail, notamment la gestion des requêtes et leur optimisation (un sujet déjà traité dans la littérature sur les compilateurs, par exemple). L'auteur a préféré étudier en profondeur les sujets pour lesquels il n'existe pas encore d'ouvrage de référence.

Les chapitres sont organisés de telle sorte qu'on puisse les utiliser comme une référence, mais aussi découvrir ces sujets progressivement. Pour approfondir, l'auteur n'hésite pas à fournir une abondante bibliographie (y compris du code source de certains logiciels de base de données).

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

Julia est l'un des derniers langages à la mode, mais dans une niche relative : celle des gens qui font des mathématiques, au sens très large (cela incluant notamment de la recherche opérationnelle, de l'analyse numérique ou encore de l'apprentissage automatique). Cet ouvrage propose une introduction au langage d'un point de vue très mathématique, justement, en penchant plutôt vers le côté abstrait. Comme son titre l'indique, il faut des bases en programmation impérative pour profiter de son contenu, il n'est pas approprié pour un public de mathématiciens qui cherchent à se mettre à la programmation.

Le livre nous donne un point de vue d'utilisateur non-programmeur de ce langage, celui de quelqu'un qui a utilisé le C++ par le passé pour des raisons de performance. Ce n'est pas pour autant que cet ouvrage d'une centaine de pages explore les manières d'améliorer la performance de son code, il se focalise sur des utilisations.

Le public ciblé est très clairement mathématicien, de par les exemples choisis ou les « défis mathématiques » proposés à quelques reprises. Le livre présente une manière de bien démarrer avec Julia et son environnement pour bon nombre d'applications scientifiques.

On peut noter l'impression soignée que donne l'ouvrage, en couleur et sur un papier très agréable au toucher. La mise en page est étonnamment aérée, ce qui le rend plaisant à la lecture.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

Le flux de données valorisables n'est pas près de se tarir, il a plutôt tendance à se diversifier, par exemple du côté des données à traiter en flux tendu. Pour les gérer, il faut utiliser des outils adaptés, notamment pour garantir un traitement rapide, sans quoi les données n'ont plus tellement d'intérêt. Ce livre porte uniquement sur ces problématiques : bien que le sujet semble restreint de prime abord, sa richesse se dévoile petit à petit. Il montre pourquoi autant d'outils différents existent et, surtout, pourquoi tous ont leur utilité. En bref, l'auteur aide à s'y retrouver dans la jungle des technologies Hadoop, en explicitant les liens entre les briques logicielles.

L'ouvrage est conçu comme une série de tutoriels plus ou moins spécifiques, en suivant une approche pas à pas. Les prérequis sont assez légers (des connaissances de base en programmation et en traitement des données), il n'est par exemple pas nécessaire de déjà savoir utiliser Hadoop ou Spark avant de se lancer dans la lecture. Les présentations des briques logicielles cherchent à montrer en quoi un logiciel peut résoudre un certain nombre de défis techniques, mais aussi en quoi il ne sert à rien pour d'autres. Ces chapitres possèdent aussi une partie bien plus technique, en expliquant comment utiliser l'outil, avec du vrai code (et pas seulement en Java !). Par contre, ce livre évite soigneusement les problématiques d'administration de grappes de serveurs. Il vise uniquement un public de développeurs et de décideurs.

Chaque chapitre se termine par un résumé des points principaux et une liste concise des points clés abordés. Aussi, pour ceux qui cherchent à s'évaluer, des guides d'étude sont proposés, avec une approche bien plus scolaire (des questions à choix multiples et des questions ouvertes, avec des solutions types en fin d'ouvrage). Du contenu plus avancé est aussi proposé en formations vidéo.

Le texte est régulièrement agrémenté d'illustrations pour expliquer le propos, qui aident parfois plus à comprendre que le texte chaloupé. Le tableau est vraiment terni par la qualité de la rédaction, avec une moyenne de deux à trois fautes d'orthographe par page et un style parfois lourd, ce qui rend la lecture difficile. Vu qu'il s'agit d'une nouvelle maison d'édition, on peut espérer que les phases de relecture s'amélioreront avec les prochaines parutions.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

La théorie des graphes est un outil extrêmement important en informatique et en mathématiques, mais elle ressemble assez peu aux autres parties des mathématiques généralement étudiées dans les concepts et techniques mis en œuvre. C'est pourquoi le sujet fait régulièrement l'objet de livres introductifs. Cependant, cet ouvrage risque de ne pas réconcilier grand monde avec ce domaine des mathématiques discrètes.

À la lecture, on profite d'un style de rédaction très sec, avec des successions de définitions, de théorèmes et lemmes, de preuves, d'algorithmes, mais peu d'exemples ou d'intuition. Les éléments sont donnés les uns à la suite des autres sans expliciter les liens qui existent entre eux ou les applications potentielles. Les symboles sont très souvent définis uniquement de manière mathématique, sans interprétation plus facile à comprendre. Les sujets sont abordés sans grande cohérence (le premier chapitre passe rapidement de définitions de base aux notions de nombre chromatique ou d'isomorphisme…). Les illustrations sont réalisées avec un certain amateurisme, avec des flèches dessinées à la main ou des symboles importants manquants.

L'auteur apporte néanmoins un éclairage sur la théorie des ordres du point de vue des graphes, chose que l'on ne voit pas régulièrement. Par contre, on se demande ce que vient faire la programmation linéaire ici, vu qu'elle est abordée de manière décorrélée par rapport aux graphes : on ne voit même pas de formulation linéaire de problèmes dans des graphes, ne fût-ce qu'un flot maximal, alors que les applications des graphes en programmation linéaire ne manquent pas. Le chapitre sur la complexité algorithmique tombe aussi comme un cheveu dans la soupe, sans véritable lien avec le reste de l'ouvrage ; c'est vraiment dommage, au vu des développements algorithmiques dans les graphes.

Les exercices sont nombreux et la très grande majorité est corrigée en détail, c'est sûrement le point fort de l'ouvrage. Ils recouvrent bien la matière traitée. On peut regretter qu'ils ne fassent pas plus le lien avec les applications concrètes de la théorie des graphes ou de la programmation linéaire.

On a ici affaire à un support de cours, sûrement utile lorsque l'enseignant le suit de près. Par contre, j'aurais du mal à conseiller ce livre dans d'autres cas de figure.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

En recherche opérationnelle, on dispose souvent d'une quantité phénoménale d'approches pour un même problème. Cependant, la programmation par contraintes ressort trop rarement, notamment parce qu'elle n'est pas bien connue. Ce livre propose d'approfondir les notions de modélisation en programmation par contraintes afin de tirer un maximum des solveurs, mais aussi d'enrober ces modèles dans des techniques plus générales pour résoudre les problèmes les plus complexes (avec, généralement, une perte de garanties sur l'optimalité des solutions).

Le niveau supposé du lecteur est assez avancé, le premier chapitre se contente de rappeler les principes de base d'un solveur de programmation par contraintes et les contraintes de base, c'est-à-dire les éléments absolument requis pour lire la suite de l'ouvrage. Pour en profiter un maximum, il faudra au lecteur de l'expérience en programmation par contraintes (cet ouvrage est conçu comme une suite à De la programmation linéaire à la programmation par contraintes, des mêmes auteurs, qui cherche à apporter cette expérience).

Le contenu est divisé en quatre études de cas, quatre problèmes complexes où des techniques de programmation par contraintes peuvent apporter des réponses intéressantes dans la pratique (qu'il s'agisse de recherche ou de développements industriels). L'approche des auteurs est très pragmatique, ils ont choisi des problèmes qui restent difficiles à l'heure actuelle et qui sont utiles dans l'industrie. Ils ne passent pas leur temps à admirer des constructions mathématiques, ils se permettent même de sortir du cadre des méthodes exactes pour proposer des heuristiques de recherche locale et des métaheuristiques construites sur des modèles de programmation par contraintes.

L'essentiel des études de cas consiste à comparer différentes manières d'aborder un problème, c'est-à-dire différentes manières de le formuler dans le paradigme de la programmation par contraintes. Ils montrent ainsi l'intérêt d'une bonne formulation dans la pratique numérique de l'optimisation à l'aide de la programmation par contraintes. Ils se focalisent sur le solveur Choco, mais les principes utilisés sont valides pour la plupart des solveurs.

Cet ouvrage propose donc une manière intéressante d'approfondir ses connaissances dans le domaine, à l'aide d'exemples intéressants et loin d'être simplistes.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

La visualisation est souvent le parent pauvre de l'enseignement scientifique : les étudiants sont censés savoir quand une visualisation est bonne, les formations se limitent à leur montrer comment réaliser l'une ou l'autre figure avec un logiciel donné. Par la suite, devenus professionnels, ces mêmes étudiants n'auront bien souvent pas les moyens de corriger le tir si nécessaire, à moins de s'y investir fortement. Ce livre cherche à fournir tous les éléments pour réaliser des visualisations efficaces qui transmettent le message prévu. Ce faisant, il ne montre que très peu de mathématiques et aucun bout de code, il n'utilise pas trop de jargon, pour s'ouvrir à un large public.

L'ouvrage est divisé en deux parties principales. La première se focalise sur les types de graphiques que l'on peut créer, les situations dans lesquelles ils s'avèrent intéressants. La deuxième partie est plus précise : elle traite le choix des couleurs et la préparation d'un graphique adapté aux daltoniens, par exemple.

Chaque chapitre est fortement illustré avec de bons et moins bons exemples de graphiques. Surtout, à chaque fois, l'auteur indique clairement ce qu'il en pense (clairement mauvais, simplement laid), mais aussi ses raisons (utilisation hasardeuse des couleurs et tailles, adéquation au type de données à représenter, etc.) ; ensuite, il donne des indications pour améliorer ces graphiques. Ces exemples ne sont pas abstraits, ils pourraient très bien provenir de la pratique quotidienne. Sur ces points, le livre se distingue de certains de ses concurrents, moins appliqués.

L'auteur suppose un certain niveau de connaissance d'un logiciel pour créer des graphiques (ne fût-ce qu'un tableur comme Excel, même s'il le décourage), car il ne parle jamais d'un seul logiciel en particulier. C'est à l'utilisateur de transposer les conseils donnés dans sa pratique de tous les jours. Le vocabulaire utilisé fait souvent penser à Leland Wilkinson (Grammar of Graphics, dont les principes sont repris par des bibliothèques comme ggplot ou plotnine). Le code utilisé pour générer toutes les visualisations est disponible en ligne (avec ggplot2 en R).

En termes de qualité esthétique, le livre est imprimé sur un papier de bonne qualité et en couleur, ce qui le rend très agréable à tenir en main.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

SQL est un langage souvent peu ou mal enseigné. Il se base sur des principes différents des langages de programmation habituels, ce qui explique sa mauvaise compréhension par bon nombre de personnes. Ce livre part de zéro en ce qui concerne SQL : le lecteur est supposé savoir programmer, c'est-à-dire avoir une habitude de raisonner face à un ordinateur. Ensuite, l'auteur commence à montrer des requêtes SQL, d'abord très simples, puis de plus en plus complexes. À la fin, le lecteur devrait être à même d'effectuer des requêtes analytiques complexes en SQL, sans devoir récupérer des données et les traiter dans un autre langage.

L'ouvrage traite principalement des techniques pour récupérer ses données au bon format depuis une base de données relationnelle. La création des tables et des vues est rapidement abordée. Les formes normales sont aussi au programme, sans approfondissement. Les contraintes relationnelles sont également expliquées.

Au vu des nombreuses différences syntaxiques entre les variantes de SQL implémentées par les différents éditeurs de systèmes relationnels, l'auteur a fait le choix de montrer presque toutes ses requêtes sous MySQL, en expliquant les désaccords avec Microsoft SQL Server et Oracle Database. Certains sujets où les divergences entre les logiciels sont très marquées sont simplement cités, comme les procédures stockées ou les langages PL/SQL et Transact-SQL.

De manière générale, le livre est bien écrit, concis mais pas trop, les explications claires, avec une bonne dose de pragmatisme. L'auteur ne considère pas de connaissances préalables en SQL ou en bases de données, notamment en accompagnant toujours le lecteur face à une erreur que lui renverrait le serveur. Les sujets ne sont pas abordés de manière séquentielle, mais bien par degré de complexité : l'auteur ne commence pas par présenter les subtilités de INSERT avant de passer à l'étude complète de SELECT, mais plutôt par des requêtes simples avant de passer aux jointures.

Je trouve que ce livre sera très adapté à des personnes débutant avec SQL, mais aussi à celles qui souhaitent approfondir le sujet des requêtes analytiques.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

L'intelligence artificielle est la tarte à la crème du jour, avec moult livres (entre autres supports) qui traitent du sujet, de manière plus ou moins appropriée. Ce livre prend un point de vue assez différent de la majorité : il ne se focalise pas sur les algorithmes possibles ou sur des bibliothèques qui les implémentent, mais bien sur les applications de ces techniques (académiques, pour l'écrasante majorité). Quand beaucoup de ressources sur le sujet se focalisent sur la manière d'arriver à un objectif donné, l'auteur présente des résultats auxquels on peut arriver, en pratique.

La variété de domaines abordés impressionne, on a vraiment une vue d'ensemble de toute une série de techniques d'intelligence artificielle. Ce panorama n'est pas complet, bien sûr (on ne voit presque pas d'utilisation des arbres de décision, par exemple), mais il inclut des outils peu connus, comme ARD pour l'interprétabilité de réseaux neuronaux ; les statistiques bayésiennes sont bien représentées, y compris dans les réseaux neuronaux. Beaucoup de sens de l'expression « intelligence artificielle » sont décrits, y compris la logique floue et les techniques évolutionnaires. Toutefois, le chapitre sur les réseaux neuronaux est quelque peu décevant, il semble s'être arrêté avant les développements de ces dix dernières années (uniquement de petits réseaux). L'auteur inclut toujours les RBF, une technique tombée en désuétude (même si elle reste utile).

L'une des principales contributions de ce livre est, sans conteste, la quantité de références incluses, tant pour les algorithmes que leurs applications (qui représentent l'essentiel des références). Certaines références ne sont pas forcément très adaptées au contexte (articles de recherche opérationnelle pour de l'apprentissage, notamment) ; l'auteur de l'ouvrage se retrouve surreprésenté dans les citations.

L'ouvrage débute sur les chapeaux de roues : très clairement, le lecteur est censé avoir déjà une certaine expérience dans le domaine, sans quoi il sera directement perdu. On attend notamment de lui certaines connaissances en statistiques, en processus stochastiques et en traitement des données.

Les explications d'algorithmes sont toujours concises, aucune technique n'a droit à plus d'une dizaine de pages. Ce niveau de concision est parfois problématique pour des sujets plus techniques, comme l'inférence de causalité. Les applications sont elles aussi résumées, mais de manière moins sommaire : ces parties peuvent donner des idées pour nourrir sa pratique quotidienne de science des données.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

La science des données s'axe souvent sur la compréhension de données, mais ignore trop souvent la prise de décision : comment mettre en pratique les résultats d'un modèle d'apprentissage ? Comme le premier volume, les auteurs proposent une série d'études de cas rassemblés par technique, en exploitant les techniques du premier volume. On voit ainsi une série d'exemple où ces techniques sont appliquées et les résultats auxquels on peut arriver.

Cet ouvrage traite d'un grand nombre d'algorithmes d'optimisation : les algorithmes classiques d'optimisation continue, mais aussi toute la panoplie actuelle des métaheuristiques. En particulier, aucune méthode exacte n'est présentée pour les problèmes non convexes (alors qu'elles existent depuis belle lurette et sont efficaces pour un très grand nombre de cas pratiques). Ces techniques sont expliquées de manière très concise, mais claire.

Tout comme le premier volume, l'une des principales contributions de ce livre est, sans conteste, la quantité de références incluses, tant pour les algorithmes que leurs applications (qui représentent l'essentiel des références). Toutefois, les auteurs sont très convaincus par les métaheuristiques, au point d'en énoncé des contre-vérités : aucun de ces algorithmes ne peut trouver, à coup sûr, de solution globalement optimale.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

Parmi les stratégies d'apprentissage en intelligence artificielle, les méthodes d'ensemble sont souvent plébiscitées. De fait, elles ont un pouvoir prédictif très fort, sans autant présenter une performance très faible lors de l'entraînement. Ce livre présente l'état actuel des connaissances dans ce domaine, sans nécessiter de grands prérequis : quelques notions d'apprentissage automatique, notamment avec des arbres de décision, et un peu de probabilités, c'est tout ce qu'il faut pour la lecture (même si un niveau plus avancé permettra d'en tirer plus d'enseignements).

L'auteur utilise un niveau de formalisation assez élevé, ce qui risque de rebuter les personnes allergiques aux mathématiques. Toutes les notations sont bien expliquées, le pseudocode est clair. Le long de l'ouvrage, on passe d'éléments très pratiques (mise en œuvre d'un algorithme donné en R) à d'autres, plus théoriques (comme les raisons pour lesquelles les méthodes d'ensemble devraient bien fonctionner, notamment à travers les liens avec la théorie de l'apprentissage). Le livre, assez complet, contient également une bibliographie scientifique fournie, qui oscille entre articles précurseurs incontournables et études numériques.

Le livre est bien ancré dans le présent, il présente assez longuement les méthodes les plus utilisées actuellement (comme GBM et son implémentation à base d'histogrammes). À l'occasion, l'auteur propose aussi l'une ou l'autre méthodologie pas encore présente dans la littérature. Outre les arbres (utilisés dans presque toutes les méthodes d'ensemble), l'ouvrage présente également des techniques à base de réseaux neuronaux. Le chapitre sur l'évaluation est très générique, il ne présente que peu d'éléments spécifiques aux méthodes d'ensemble. Sa section sur l'interprétation est décevante, elle n'introduit même pas la notion d'importance ou de modèle local (comme LIME).

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

Les mathématiques appliquées sont partout, y compris quand il s'agit de concevoir des scénarios d'évacuation de bâtiment ou de simuler le comportement de piétons dans un jeu vidéo. Ce livre aborde ces questions sous un angle microscopique, comme son nom l'indique : comment se déplace chaque personne dans une foule ? Ce livre répond à cette question en expliquant les principes de modélisation de ces situations, selon l'état actuel des connaissances scientifiques (les techniques proposées sont néanmoins implémentées dans un paquet Python, pour une mise en pratique rapide). Les auteurs développent, tout le long de l'ouvrage, le cas d'étude d'une évacuation de bâtiment, mais indiquent aussi les changements à effectuer pour simuler, par exemple, des flots de voitures.

Comme le titre l'indique assez clairement, le contenu est matheux : pour chaque modèle, les auteurs proposent une mise en équation (en vue d'effectuer des simulations numériques), mais analysent aussi ses propriétés mathématiques (existence et unicité de la solution, par exemple). Ces propriétés sont régulièrement remises en contexte (impact lors d'une simulation d'une non-unicité de solution, par exemple). Ils discutent aussi des phénomènes qui peuvent être mis en évidence par ces modèles, comme le fait que ralentir une foule peut augmenter le nombre de personnes que l'on fait passer par une sortie de secours par seconde (l'effet slower is faster). Les modèles abstraits utilisent un certain nombre de paramètres, mais des valeurs habituelles pour la simulation de piétons sont données. Un chapitre fait le lien entre les expériences du domaine (où l'on demande à une foule de se déplacer), les observations faites sur des situations réelles et les modèles mathématiques : il s'agit réellement de mathématiques appliquées, en lien direct avec la pratique.

Le niveau mathématique requis pour les lecteurs est assez élevé : sans connaissance de base en analyse réelle et en équations différentielles, par exemple, on ne profitera pas beaucoup du contenu. Les analyses des méthodes font souvent appel à des notions de stabilité (fonction de Liapounov) ou à la méthode des perturbations infinitésimales, des sujets qui ne sont presque pas abordés dans l'annexe ou explicités comme prérequis.

On peut toutefois reprocher des notations pas toujours limpides (comme un même symbole qui désigne un scalaire ou un vecteur, selon la section, voire des quantités sans aucun rapport : distance entre deux personnes ou distance par rapport à une situation d'équilibre). Le code fourni avec le livre n'a été développé que dans le contexte de cet ouvrage, il ne s'agit pas d'une bibliothèque utilisée au jour le jour par des chercheurs ou praticiens du domaine.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

L'algorithmique est un vaste domaine, auquel les étudiants sont vite confrontés dans leur cursus informatique, sans les lâcher jusqu'à la fin des cours sur la complexité. Cette quatrième et dernière partie d'Algorithms Illuminated plonge dans les méandres des algorithmes pour les problèmes les plus complexes (du moins, selon la théorie de la complexité). L'auteur continue son approche pragmatique, claire et progressive, malgré la technicité du sujet. Bien qu'étant un livre introductif, l'auteur se permet de présenter des évolutions récentes dans la théorie de la complexité.

En tant que livre d'algorithmique, la présentation de la théorie de la complexité n'est pas habituelle. L'auteur préfère une vue proche de la pratique algorithmique : l'objectif est que le lecteur sache reconnaître un problème difficile pour éviter de partir à la recherche d'un algorithme polynomial qui n'existe probablement pas. De là, l'ouvrage présente des techniques de résolution de ces problèmes (des techniques classiques — algorithme glouton, programmation dynamique — et plus spécifiques — solveurs de satisfiabilité et en nombres entiers). Les algorithmes ne sont pas les plus classiques, mais l'objectif est toujours d'entraîner à la recherche d'algorithmes intelligents.

Les problèmes difficiles présentés dans ce quatrième tome ne sont pas abstraits, ils sont régulièrement présents dans la pratique. Ainsi, chacun est toujours mis en contexte. Le dernier chapitre est une étude de cas, pour montrer comment un problème réel (des mises aux enchères de canaux de fréquences pour les télécommunications sans fil aux États-Unis) doit être abordé avec finesse. Cette partie fait appel à tous les outils développés dans les quatre tomes de la série.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

Le langage de programmation Julia promet de révolutionner l'informatique scientifique au sens large, en offrant à la fois performance et simplicité d'utilisation. Cependant, pour y arriver, les concepteurs du langage ont dû recourir à des abstractions peu courantes, comme le polymorphisme à l'exécution, mais aussi éviter d'implémenter d'autres, comme l'héritage de la programmation orientée objet. Pour en tirer le meilleur parti, il faut donc penser différemment ses programmes : tel est l'objectif de cet ouvrage.

L'auteur considère que le lecteur part déjà d'un certain niveau de programmation en Julia, notamment qu'il a déjà écrit quelques programmes simples et connaît une bonne partie de la syntaxe du langage. Ensuite, il montre une série de patrons applicables dans un grand nombre de cas, en s'appuyant sur des exemples extraits de la bibliothèque standard du langage ou de paquets issus de la communauté ; les autres exemples sont souvent repris du monde de la finance. La majorité des patrons montrés est véritablement spécifique à Julia, même si un chapitre montre l'implémentation des patrons de conception habituels en programmation orientée objet.

L'objectif principal de l'auteur est de donner toutes les clés pour écrire un code Julia idiomatique, en suivant les conventions développées par les programmeurs du langage. Ces techniques pour écrire du code idiomatique sont prévues pour que le résultat soit un programme performant et réutilisable. Il s'agit véritablement de professionnaliser son développement en Julia.

Chaque chapitre se termine par une série de questions pour vérifier sa compréhension, avec une correction en fin d'ouvrage. Tout le code est disponible en ligne.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

Dans le développement d'applications interactives, notamment des jeux, les animations sont souvent un élément difficile à implémenter correctement, surtout en 3D. Ce livre part de connaissances très basiques du rendu avec OpenGL (l'auteur utilise la version 3.3, mais toutes les techniques restent compatibles jusqu'à la version 4.6) et détaille la manière d'implémenter ces animations dans des applications réelles.

Chaque chapitre est divisé en deux parties : la première détaille les principes (fonctionnement d'un produit scalaire, d'une interpolation, etc.), la seconde les implémente en C++. Ce découpage participe à la clarté de l'ouvrage, vu que l'on sait à l'avance très exactement ce que l'on s'apprête à implémenter. Aucune bibliothèque externe n'est utilisée, afin de bien montrer une manière d'implémenter chaque principe (ce qui limite la portabilité du code : la gestion des fenêtres fonctionne exclusivement sous Windows, par exemple). Les chapitres sont vus comme autant d'outils qui finissent par s'assembler pour afficher des animations. Le code C++ n'est pas très moderne, l'objectif étant surtout de démystifier des concepts plutôt que de montrer une implémentation utilisable telle quelle dans un moteur de jeu vidéo ; par ailleurs, tout le code est expliqué, l'auteur ne se limite pas à quelques généralités sur des blocs de centaines de lignes de code.

Les prérequis sont simplifiés à l'extrême, l'auteur ne présuppose pas de connaissances en algèbre linéaire (vecteurs, matrices) ou sur les quaternions pour implémenter les rotations. Les parties mathématiques représentent une petite moitié de l'ouvrage et sont expliquées de manière simple et intuitive, mais avec des raccourcis qui feront hérisser les cheveux des puristes. Les explications sont parfois tellement simplifiées qu'elles en deviennent mathématiquement fausses (le produit d'une matrice et d'un quaternion est appelé « concatenation », les opérations commutatives deviennent « cumulatives », etc.).

Tout le code est disponible en ligne.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

L'informatique théorique rebute régulièrement les étudiants, de par son côté abstrait, contrairement à l'informatique en général. Pourtant, ses apports ne peuvent être négligés, comme les expressions régulières, véritable couteau suisse du traitement de chaînes de caractères. Ce livre aborde la notion de langage régulier et sa version algorithmique, les automates finis, en faisant le lien avec les grammaires régulières et, évidemment, les expressions régulières. Les auteurs ne se limitent pas aux applications classiques, l'annexe se charge d'utilisations comme la vérification de protocoles à l'aide des mêmes outils. Le cœur de l'ouvrage est sans conteste la quantité impressionnante d'exercices corrigés.

Les chapitres sont divisés en cinq parties. Les auteurs débutent toujours un nouveau sujet par l'explication, en termes relativement intuitifs, des idées principales, avant de détailler de manière plus formelle les résultats importants. Ensuite viennent les exercices, puis des indices pour aider à la résolution, finalement les solutions proprement dites. Ce découpage permet d'avoir un coup de pouce dans la résolution d'un exercice sans toutefois avoir la solution complète du premier coup. Le texte principal fournit très peu de démonstrations, elles sont en bonne partie laissées en exercice.

Les prérequis sont très limités, mais un bon bagage de mathématiques sera essentiel pour suivre le contenu : le niveau de formalisme est très élevé, le profane trouvera les explications peu digestes. Par exemple, les auteurs rappellent les principales techniques de preuve, définissent les notions de morphisme de groupe (en omettant, notamment, de définir les groupes). La rédaction est sèche, académique, de telle sorte qu'un tel livre s'utilisera probablement plus comme ouvrage de référence pour un cours qu'afin de découvrir le domaine des automates finis.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

La ligne de commande de Linux, comme pour les autres systèmes d'exploitation, est quelque peu intimidante, même si elle a acquis un caractère plus mythologique avec Linux. Cet ouvrage propose de guider les plus débutants dans l'utilisation de cet outil extrêmement pratique pour de nombreuses tâches. Il pourra également servir de référence, mais ne sera vraisemblablement pas adapté aux plus aguerris.

L'auteur adopte une approche résolument pragmatique, il s'appesantit aussi peu que possible sur les aspects théoriques — même si l'explication des permissions fait partie des plus claires ! Les chapitres correspondent à des types de tâches que l'on peut souhaiter effectuer en ligne de commande, les sections indiquent clairement la forme générale de la commande qui y est expliquée. Les débutants ont souvent du mal à combiner des commandes pour arriver à leurs fins, c'est pourquoi les combinaisons les plus courantes sont utilisées dans les exemples.

Toutes les commandes utiles sont présentées pour l'utilisateur moyen. L'administrateur aura sûrement besoin de plus d'informations, mais l'ouvrage lui permettra d'acquérir les bases. On peut regretter que l'auteur ne passe pas plus de temps sur les éditeurs de texte en ligne de commande, bien que des éléments de vi soient présents.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez

Autant il est facile de déterminer si du code est propre, autant il est difficile d'écrire du code propre. Ce livre n'aborde que ce sujet : l'art de remanier du code fonctionnel en code propre. Pour ce faire, l'auteur et ses six collaborateurs passent en revue une grande quantité d'aspects par lesquels un code peut pécher par manque de propreté, regroupé en sujets génériques.

Ces présentations sont résolument pratiques, la majorité des concepts étant directement appliqués sur des morceaux de code (souvent issus de projets réels, parfois même libres). On compte d'ailleurs aussi trois chapitres entièrement consacrés à des études de cas, classées par difficulté croissante : l'auteur part d'un code améliorable (voire carrément sale) pour l'améliorer, en détaillant chaque étape. Le dernier chapitre résume ces points saillants sous la forme d'heuristiques, pour objectiver la détection de problèmes dans le code.

Néanmoins, l'ouvrage est spécifique à Java : tous les exemples sont écrits dans ce langage. Bon nombre de conseils s'appliquent sans problème à d'autres langages, mais certains chapitres sont spécifiques à la plateforme Java. De plus, on sent que l'original a été écrit en 2009, quand il n'y avait encore que Java 6. On aurait aimé l'opinion de l'auteur sur les nouvelles fonctionnalités apportées depuis lors.

Avez-vous lu ce livre ? Qu'en pensez-vous ? Commentez