Le Framework .NET

Écrire du code performant, voilà un titre prometteur qu'il faut cependant relativiser. À travers cet ouvrage, Jean-Philippe GOUIGOUX ne nous apprend pas réellement à écrire du code performant, mais plutôt à identifier dans du code les problèmes de performance.
J'ai apprécié ce livre car l'auteur y prend le pli de démystifier le profilage de code en partant du prédicat qu'il n'est pas nécessaire d'être un expert pour s'attaquer à un problème de performance. À travers un exemple concret, il illustre les différents problèmes de performance que l'on peut rencontrer dans une application mais surtout les techniques pour localiser, au moyen d'un profileur, les goulets d'étranglement. Le tout est très efficace et remplit pleinement son objectif.
Un ouvrage à lire sans hésiter si l'on est confronté, ou simplement si on s'intéresse, aux problèmes de performance d'une application, mais surtout si l'on souhaite apprendre la façon des les identifier.

Ce livre traite de profilage d'applications .NET et de bonnes pratiques de programmation.
Nonobstant le titre, vous n'allez pas vraiment apprendre à écrire du code performant. Vous allez plutôt apprendre à détecter du code contre-performant, puis à le corriger.
L'auteur s'attache tout au long des chapitres à nous convaincre que le profilage d'application n'est pas l'affaire des experts et qu'avec des bons outils et un objectif précis, il est possible d'améliorer grandement les performances d'une application.
L'auteur attaque l'ouvrage avec une présentation générale du profilage d'application. Puis, nous enchainons avec une présentation technique de la mémoire et des bonnes pratiques associées à son utilisation ainsi que quelques bonnes recommandations sur l'écriture de code performant. Ce chapitre est très intéressant pour tout développeur ne sachant pas exactement comment fonctionne les allocations et le ramasse-miettes.
Puis à travers une application de test, l'auteur nous montre, profileur à l'appui, les différentes situations chronophages qu'il a pu rencontrer au cours de son expérience. Le but de la suite du livre est de montrer comment le profileur choisi (ANTS profiler) permet d'aider à la détection des goulets d'étranglement de son application. Le code est ensuite réécrit, tout en proposant à chaque fois des conseils sur les meilleures façons de l'optimiser.
Nous ne découvrirons pas ici de recette miracle. L'auteur explique qu'avec des outils et du temps, on peut améliorer les 20% d'erreurs qui correspondent à 80% des ralentissements.
L'ouvrage est très intéressant et plutôt facile à lire. Les illustrations sont nombreuses même si elles ne remplaceront pas la situation réelle que l'auteur encourage à suivre en même temps que la lecture. Il démystifie avec enthousiasme cette partie du développement qui est souvent délaissée jusqu'à ce qu'un vrai problème de performance mobilise les équipes.

Ayant eu la chance de l'avoir avant sa sortie officiel, je dois dire que je ne regrette pas du tout. En effet que vous souhaitez passer la certification ou simplement mieux comprendre WPF, ce livre est un must. Du début à la fin, vous serez guidé dans l'univers de WPF et de tout ce qui fait sa puissance. Vous commencerez doucement par (re)voir les bases de WPF (type de fenêtre, code XAML) pour ensuite glisser naturellement vers la gestion des évènements puis viendra les chapitres sur la gestion du contenu, le databinding, la validation et la conversion de données, les styles et animations, la localisation et les ressources et enfin le déploiement des applications.
De plus au sein des chapitres sont abordés des notions que nous avons peu l'habitude de manipuler : Création et lecture de document XPS, manipulation du FlowDocument, localisation des applications WPF, etc, etc,etc. Bref ce livre est extrêmement complet. A posséder absolument dans sa bibliothèque

Un très bon livre pour débuter sur la plate-forme .NET. Si vous vous posez la question qu'est-ce que .NET, comment ça fonctionne, à quoi ça sert,... Ce livre est pour vous. Que vous soyez dans le support technique, la gestion de projet ou le développement logiciel, il vous offrira bien plus qu'un vernis sur le sujet. Les nombreux exemples simples et pertinents sont écrits en C#, la connaissance de ce langage n'est pas nécessaire mais améliorera sa lecture, personnellement je ne connaissais pas ce langage lorsque j'ai débuté sa lecture mais le langage Delphi qui est assez 'proche'. De plus, les 3/4 de l'ouvrage ne nécessitent pas d'être devant un PC. Appréciable ! J'ai pu lire les précédents livres de l'auteur sur Delphi, la qualité pédagogique de son travail reste constante. Quoi dire de plus ? Associer sa lecture avec celle de l'ouvrage de Jeffrey Richter Programmer Microsoft .NET qui est complémentaire et nullement redondante. Bonne lecture.

Livre intéressant pour les débutants en dot net!

Comme son nom l'indique, ce livre décrit la technologie dotnet et l'utilisation de sa bibliothèque de classe. Il est écrit dans un style remarquablement clair et d'un vocabulaire très accessible. Il entre très rapidement dans le vif du sujet. Ce livre donne une bonne approche du framework .Net et je dois dire qu'il m'a plutôt laissé une bonne impression.

Tous les principaux domaines d'application de dotnet y sont abordé : WinForm, WebForm, application asp.net, contrôles Web, contrôles personnalisés, services Web, sécurité, ADO.Net, multithread, accès distant... Ils sont associés à chaque fois d'exemples plutôt bien choisis, simples, fort bien commentés et limités le plus possible au sujet abordé, ce qui en rend la compréhension encore plus aisée.

Ce livre s'adresse aussi bien aux débutants ayant tout de même une expérience de programmation orienté objet et les rudiments du langage C# (Les exemples étant dans ce langage et la grammaire du langage n'étant pas traité dans ce livre), qu'aux initiés désirant acquérir ou approfondir leurs connaissances dans cette technologie. Par contre, il n'apprendra probablement que peu de chose aux développeurs maîtrisant déjà cette technologie.

Cet ouvrage est à mon avis le complément du livre '.NET' de Dick Lantim. Il aborde en profondeur le CLR notamment les éléments de bases : classes, types de bases, événements, exception, gestion mémoire, etc. On peut être surpris, pour des choses si 'banales', du nombre d'informations que cela représente. Il ne s'agit pas d'un livre de programmation au sens propre du terme mais d'une étude sur le comportement et le fonctionnement interne du CLR. Un ouvrage dense et précis aussi efficace que celui sur Windows 32 bit du même auteur. Je ne peux que vous le conseiller comme brique de base pour votre apprentissage ou pour renforcer votre compréhension sur certains des points abordés. Un ouvrage de référence dans tous les sens du terme !

Comme annoncé dans la préface par les auteurs, ce livre s'adresse aux développeurs, et non aux designers, mais plus particulièrement aux développeurs initiés qui ont déjà une certaine pratique du C# ou de la plateforme .NET en général. Aucun rappel n'est effectué sur les bases du C# et c'est tant mieux, il en reste plus pour le vif du sujet.
Parlons en d'ailleurs, dès le premier chapitre on rentre dedans, avec notre premier Hello en WPF. Le reste de ce chapitre est tout simplement une sorte d'introduction aux futurs chapitres avec des petits exemples (comme pour le Data Binding) ou sous forme d'image (comme pour la 3D).
Les chapitres suivants passent en revue les principales caractéristiques de WPF, avec par un exemple un chapitre sur la liste des contrôles communs (Bouton, TextBox...), un autre sur les différents positionnements des contrôles dans les fenêtres (StackPanel, Grid...), mais aussi par le très intéressant et selon moi, le plus intéressant, Data Binding.
On retrouvera également des chapitres sur les très intéressants, Animations, et 3D Graphics, pour faire des applications WPF jolies.
Le reste des chapitres vous expliquera les rudiments de WPF, comme la navigation (applications XBAPs), la création et l'application de styles sur vos contrôles, les Graphics (images...) ou même mettre du texte en forme, de mille et une façons.
Le tout est toujours agrémenté d'images pour facilité la compréhension, ainsi que de codes sources expliqués pour une meilleure compréhension.
On saluera également la présence d'appendices avec entre autres le très intéressant Silverlight.
En conclusion, ce livre va je pense devenir Le livre de référence sur WPF, tout comme le sont la plupart des livres aux éditions O'Reilly dans leur catégorie.

A première vue, ce livre, écrit pour la version 1.1 du Framework, pourrait sembler dépasse. En fait, il n'en est rien...
Les exemples de pièges du Framework présentés dans ce livre sont toujours d'actualité, et probablement pour un bon moment.
Le livre est composé de 8 chapitres, abordant chacun une famille de « Gotchas » différente (CLR, compilateur, langages et API, Interopérabilité, Garbage collection, Héritage et polymorphisme, Multithreading et COM).
L'auteur s'exprime clairement de façon très didactique, et, même si ces problèmes ne se rencontrent pas tous les jours, c'est définitivement un livre qu'il faut lire une fois, pour s'y référer le jour ou on tombe dans un des 75 petites pièges vicieux du Framework qu'il expose.
C'est un livre qui s'apprécie d'autant plus que l'on connait déjà le Framework, et que je conseille plutôt aux développeurs expérimentés.

Je dois admettre que je suis très impressionné par ce livre. Non pas par la le niveau technique du livre (je n'en attendais pas moins de la part des auteurs ) mais surtout par la pédagogie employée pour expliquer des concepts qui peuvent, parfois, sembler compliquer/déroutant à des développeurs amateurs ou ne connaissant pas le sujet.
Tout ceux qui ont déjà écrit des livres (ou encore des articles) savent qu'il n'est pas simple d'expliquer et de retranscrire des notions complexes.
Les auteurs de ce livre ont parfaitement réussit ce challenge: il est donc à la fois très technique (n'oubliez pas que LINQ n'est pas une mince affaire) mais très bien expliqué, ce qui le rend d'autant plus intéressant !
Bref, pour tous ceux qui veulent en savoir plus sur les entrailles de LINQ, son fonctionnement, etc... ou bien pour tout ceux qui veulent savoir comment l'utiliser (et bien l'utiliser), alors je ne saurais que trop recommander ce livre !

Si vous travaillez avec NHibernate, hésitez entre plusieurs ORM, ou simplement êtes curieux de comment fonctionne NHibernate, ce livre vous est absolument nécessaire.
En effet, un problème récurrent, selon moi, avec NHibernate, est la difficulté de trouver un référentiel clair et complet...ce qui est maintenant le cas avec ce livre.
On passe en revue non seulement la configuration et l'utilisation du framework NHibernate, mais les auteurs abordent aussi les choix de design qui ont été effectués, et proposent une introduction a des concepts d'architecture.
Tout cela, sans dogmatisme, sans imposer leur vision du développement, et en insistant sur le fait que NHibernate peut ne pas être le meilleure solution pour un problème donné.
On va voir d'abord une définition de la persistance Objet/relationnel, et les défis que les ORM cherchent a relever, puis on va voir comment configurer NHibernate, mapper les entités aux objet, les transactions, le cache de NHibernate, tout en suivant la construction d'une application d'enchères.
En conclusion, un excellent livre, seul bémol (expliquant la note de 4/5), le livre cible la version 1.2 de NHibernate, alors que la version 2.0 est sortie le 23 août. Les incompatibilités sont peu nombreuses, mais il est dommage qu'elles ne soient pas mentionnées dans le livre. Malgré ce décalage entre les deux versions, ce livre reste un investissement a mon avis obligatoire pour toute équipe travaillant avec NHibernate, et pour tous les développeurs curieux de comment fonctionne cet ORM.
English version :
If you work with NHibernate, are hesitating between several ORM, or are simply curious about how NHibernate works, this book is absolutely necessary.
Indeed, a recurring problem, I believe, with NHibernate, is the difficulty of finding a clear and comprehensive reference... what is now the case with this book.
It reviews not only the configuration and use of the NHibernate framework, but the authors also address the design choices that were made, and an introduction to concepts of architecture.
All this, without dogmatism, without imposing their vision of development, and emphasizing that NHibernate is not a silver bullet.
We will first see a definition of Object/relational mapping, and issues the ORMs seek to solve, then we will see how to configure NHibernate, to map the subject entities, transactions, the caching options, while following the construction of an auction application.
In conclusion, an excellent book, the only drawback (explaining the rating of 4 / 5), is that the book targets the 1.2 version of NHibernate, while version 2.0 was released on August 23. Incompatibilities are few, but it is a pity they are not mentioned in the book. Despite the discrepancy between the two versions, the book remains an investment in my opinion, mandatory for any team working with NHibernate, and for all developers interested in how an ORM works.

Aujourd'hui, Entity Framework est l'outil phare de Microsoft concernant le mapping objet relationnel. Son petit frère, LinQ to SQL a été abandonné par l'équipe ADO.Net. Cette décision fut prise face aux nombreuses limitations du produit, comme le fait d'être limité à une base de données de type SQL Serveur. Son grand frère, EF, ne souffre d'aucune de ces limitations et même s'il est encore un peu jeune (design POCO non supporté, personnalisation des classes générées parfois hasardeuse), il propose déjà un nombre important de fonctionnalités et d'un design robuste, ce que l'on est en droit d'attendre d'un outil de mapping objet relationnel.
Il y a quelques mois, je me suis beaucoup intéressé à EF et je suis tombé sur le blog de Julia Lerman, qui regorgeait d'articles passionnants sur le sujet. Avec ce livre, l'auteure de "Programming Entity Framework" développe encore plus profondement le sujet et offre au lecteur un large aperçu de l'outil. J'ai été frappé par sa richesse (un nombre de sujets étudiés importants sur 750 pages), sa démarche pédagogique (mélange abile de théories et d'exercices pratiques) et son analyse objective sur la 1ère version de l'outil. Sur un sujet aussi nouveau qu'Entity Framework, l'auteure s'est vraiment surpassée, notons la facilité de lecture malgré qu'il soit en anglais.
Julia Lerman a volontairement divisé le livre en 2 parties, une 1ère partie dite d'introduction composée de 14 chapitres et une seconde traitant de sujets plus avancés.
Dans la 1ère partie, vous trouverez notamment les concepts de base du framework comme la conception et la personnalisation d'un modèle EDM, les requêtes de type CRUD, ainsi que son utilisation dans une application Winforms, WPF, ASP.Net et dans un service WCF. A ce sujet, j'ai trouvé très intéressant d'apprendre les bonnes pratiques de l'auteure sur l'utilisation du framework dans une application .Net. Rassurez vous, il n'est pas nécessaire de lire en entier cette 1ère partie pour utiliser le framework. Dès le 3ème chapitre, vous aurez déjà les mains dans le camboui, et une compréhension de l'outil sommaire mais juste.
La 2ème partie du livre se veut plus avancée. Entre autres, vous y trouverez une étude approfondie des relations entre les entités, de la gestion des transactions, des performances, de l'objet ObjectStateManager, des exceptions ainsi qu'une implémentation des interfaces IPOCO du framework. Autant vous dire, qu'après avoir lu ce livre, vous aurez acquis de solides connaissances sur Entity Framework. L'auteure termine par une étude poussée de son utilsation dans les différents types d'application du framework .Net.
En plus d'être riche, j'ai apprécié l'avis objectif de l'auteure sur l'outil et ses attentes pour la prochaine version qui devrait être livrée avec Visual Studio 2010 et .Net 4. Elle n'hésite pas à faire remarquer le manque de fonctionnalités de l'éditeur EDM, la difficulté à réaliser des tests unitaires ou à implémenter des classes personnalisées.
"Programming Entity Framework" de Julia Lerman est pour moi la référence sur le sujet et toute personne intéressée par l'outil devrait avoir ce livre à portée de main.

Entity Framework est un sujet à la mode, encore plus depuis que l'abandon de Linq To SQL a été annoncé. Contrairement à ce dernier, Entity Framework est bien plus complet, mais aussi plus complexe à utiliser. Il fallait justement une personne comme Julia Lerman pour tenter d'écrire un livre sur le sujet. C'est le second livre que je lis sur le sujet et le premier m'a laissé un arrière-goût de bâclé et fouilli. Si l'architecture d'Entity Data Model était plutôt bien expliquée, l'utilisation du framework était lui, plus difficile. C'est donc avec un a priori que j'ai commencé à lire ce livre-là.

Après avoir lu la longue et ennuyeuse préface de 14 pages, je m'attaque au premier chapitre du bouquin : la présentation d'Entity Framework. Et directement, c'est la bonne surprise! Plutôt que partir sur des schémas théoriques dans tous les sens, le chapitre prend un exemple simple et vous montre l'intérêt qu'il y a à utiliser EF plutôt qu'une autre framework ou tout simplement, du pur ADO.Net.
À partir de ce moment-là, le livre se dévore. C'est clair, c'est léger, c'est plaisant à lire. Les principes complexes sont vulgarisés et l'on comprend (ou l'on a du moins l'impression de comprendre) quasiment tout.

C'est ensuite que ça devient intéressant, car, là où d'autres livres se contentaient des bases et d'un exemple plus complexe, l'auteur continue son approche pédagogique en rajoutant peu à peu des contraintes comme des procédures stockées touchant plusieurs tables d'un coup en Insert, Delete, Update, ou encore l'utilisation au sein d'un environnement SOA ou tout simplement de la performance au sein d'Entity Framework. Là où la plupart des livres techniques ne donnent qu'une approche théorique et où rapidement on se rend compte à la pratique que notre problématique n'a pas de réponse au sein du livre, avec ce livre-ci, et ses 750 pages, on part avec une connaissance plus large et une meilleure préparation à l'utilisation d'Entity Framework au sein d'un projet rempli de contraintes fortes et complexes.

En plus de ce très bon livre que je conseille comme LE livre de référence sur Entity Framework, Julian Lerman maintient un site pour son livre, avec pleins d'astuces et de ressources complémentaires, qu'il est bon d'avoir dans ses favoris : http://www.learnentityframework.com/

Si vous êtes déjà familier avec le dotnet et que vous souhaitez tirer parti de la puissance de WPF, ce livre est fait pour vous.
Tout d'abord, si vous souhaitez tirer parti de WPF cet ouvrage très complet sur le sujet vous permettra de bien comprendre cette technologie et d'en comprendre les subtilités rapidement et d'une manière efficace. Ce livre contient une foule d'information ce qui en fait une véritable référence pour tous les développeurs qui souhaite tirer parti de la puissance de WPF. L'auteur prend aussi la peine de bien expliquer le fonctionnement de chacun des concepts expliqués en portant soin de bien nous exposer toutes les subtilités qui permettront au lecteur de mieux exploiter la technologie dans son processus de développement. Pour ceux qui comptent aussi découvrir le silverlight, le livre compte une partie complète traitant de ce sujet, mais un effort de recherche sera aussi à fournir par le lecteur sur ce point, car l'accent n'a pas été mis sur le silverlight, mais bien dans le WPF.
Par contre, je trouve que l'auteur du livre aurait pu accorder une place plus importante au produit expression de Microsoft dans le livre. Même si ceux si ne sont pas essentiel dans le développement d'une application WPF, il n'en demeure pas moins que de connaitre vaguement cette outil peut parfois être pratique. Il aurait aussi été intéressant d'avoir quelques exercices en fin de chapitre à fin de mettre en ouvre les connaissances acquises tout au long de ce dernier.
Pour conclure, ce livre constitue une excellente référence pour tout programmeur dotnet qui souhaite utiliser la puissance de WPF dans ces projets. Ce livre constitue une bonne entrée en la matière et ce livre pourra par la suite être utilisé comme une référence très complète.

Si, comme pour moi, WPF vous évoque vaguement quelque chose et que vous souhaitez en apprendre plus sans être noyé de détails superflus, alors cet ouvrage est fait pour vous.
Les différents aspects de cette technologie sont détaillés, chapitre après chapitre, à travers de nombreux exemples de code. Une rapide introduction et une initiation au langage XAML permettent de se plonger rapidement dans le bain. Par après, l'auteur a pris le pli d'un fil rouge - la création d'un gestionnaire de contacts - pour présenter les autres points clé de WPF.
L'approche choisie par l'auteur en fait, selon moi, un ouvrage agréable à lire, et qui peut-être abordé à deux niveaux. En lecture "rapide" il permet de se faire une idée assez précise de ce que permet WPF et des lignes directrices de cette nouvelle technologie. En lecture parallèle avec un PC pour mettre les exemples en pratique, il permet à un développeur, ayant cependant déjà une connaissance de base dans le framework .NET, de rapidement saisir et mettre en pratique les concepts clé du développement WPF. Cerise sur le gâteau, l'auteur aborde en dernière section le développement Silverlight à travers le même type d'approche, à savoir le développement d'une petite application.
En conclusion, si vous souhaitez rapidement vous familiariser avec WPF, de façon générale ou en mettant les mains à la pâte, ce livre répondra à vos attentes.

Professional Windows Workflow Foundation est un livre de la collection Wrox. Comme beaucoup d'autres livres de cette collection, j'aime beaucoup la façon dont sont architecturés les contenus.
En général les plans sont plutôt didactiques et cet ouvrage n'échappe pas à la règle. Il nous amène sur les traces du moteur de workflow de Microsoft, disponible depuis le framework.net 3.0.
Bien qu'écrit dans une langue de Shakespeare sortant un peu du vocabulaire classique informatique, il en reste très lisible et très compréhensible. On commence par le traditionnel Hello World qui est bienvenu pour commencer à appréhender cette autre façon de programmer.
L'auteur rentre précisément dans les détails et fait profiter le lecteur de son expérience et de ses astuces dans l'écriture d'applications à base de workflow. On appréciera notamment le chapitre dédié aux spécificités d'interactions de WF avec ASP.NET. L'auteur explore également les workflow événementiels, un point souvent délaissés par les tutoriels présent sur le net.
Un petit point négatif quand même, j'ai trouvé que l'auteur rentrait trop vite dans des considérations techniques qui pourraient noyer le lecteur. Certains chapitres auraient mérité de se situer un peu plus loin dans le livre et auraient également mérité d'être enrichis d'exemples complémentaires.
Ma conclusion : n'hésitez pas à lire ce livre si vous envisagez d'apprendre Windows Workflow Foundation.

IronPython est le premier langage dynamique qui ait été développé pour .Net. A la base, .Net n'était pas prévu pour ce type de langage. On voit au fil du livre qu'il est souvent nécessaire de faire appel à des astuces pour vraiment tirer partie des langages statiques et dynamiques de .Net.

Le livre commence par une introduction générale à Python. Une revue rapide du langage lui-même est suivie par l'utilisation des différents assemblies disponibles dans la plateforme .Net. Cette première partie permet d'être à l'aise avec IronPython.

La partie suivante est dédiée aux possibilités offertes par IronPython, de par le langage et son affiliation à .Net. Les auteurs passent des modules standard Python aux modules .Net (ce qui peut être déboussolant, pourquoi utiliser les uns et pas les autres ?) selon ce qu'on cherche à faire. A cause de .Net, une grande partie est dédiée à XML car c'est une partie permettant de simplifier l'écriture des interfaces graphiques. Plusieurs patterns usuels sont aussi présentés sous l'approche .Net.

La troisième partie part de l'interface de référence WPF, avec plusieurs manières de l'utiliser. Un début de pont depuis C# est aussi proposé. Par la suite, on aborde la partie administration avec WMI. Je dois dire que de mon point de vue, c'est la partie la plus bizarre. WMI a son propre langage qui ne ressemble en rien à Python ou C#. En plus, on ajoute le langage spécifique à PowerShell (qui vient un peu comme un cheveu sur la soupe). Il y a un livre dédié, donc le seul accent est mis sur la communication entre IronPython et PowerShell. Soit donc deux nouveaux langages dans un seul chapitre.

IronPython est un langage .Net, donc il est possible de faire de l'ASP avec. Un chapitre est consacré à cette approche, chapitre bien écrit mais qui nécessite d'avoir en parallèle l'exemple décrit sans quoi on se perd un peu. En continuant le web, on passe aux web services et aux bases de données qui sont regroupées sous un seul chapeau. La base des outils SQL nécessaires est abordée, ainsi que les protocoles de web services basiques. En revanche, il y a quelques erreurs, comme SOAP qui n'est pas qu'utilisé avec des requêtes POST en HTTP, mais bien aussi avec des requêtes GET et sur d'autres transports. Enfin, l'utilisation d'IronPython avec Silverlight est abordé. Les interactions avec d'autres langages ainsi qu'avec la page affichée permettent de développer des applications légères efficaces.

Dans tout le livre, on a vu des bases de communication avec les autres langages .Net. C'est dans la dernière partie qu'on voit les bons moyens d'intégrer des assemblies .Net dans IronPython et inversement. Comme je l'ai dit au départ, l'intégration n'est malheureusement pas tout à fait aisée, et les différentes techniques ajoutent un coût d'écriture certain. Au moins, elles sont exposées dans ce livre, en attendant .Net 4.0.

Pour conclure, ceux qui ont besoin d'un langage dynamique (pour scripter une application, par exemple) peuvent se pencher sur IronPython, le premier langage dynamique proposé par la plateforme .Net, compatible avec le langage Python version 2.5. et donc acheter ce livre pour maîtriser cette implémentation.

IronPython is the first dynamic language developed for the .Net plateform. At first, .Net didn't support this kind of language. This is something that keeps on coming back througout the book: you have to use some additional tricks to unleash the power of .Net dynamic and static languages.

The book starts with a general introduction to IronPython. A quick review of the language itself is followed by the use of the .Net assemblies. At the end of this part, one is comfortable enough to do some small IronPython programs.

The next part is dedicated to what IronPython offers thanks to Python and to its affiliation to .Net. The authors go through standard Python (battery included) and the somewhat associated .Net assemblies (some arguments on using one or the other could have been a big plus to the explanations), depending on what must be done. Because or (or thanks to) .Net, several pages are dedicated to XML, as it is needed to simplify the description of UIs. Also several useful designed patterns are presented with the .Net approach.

The next part starts with WPF, the official graphical interface, with several ways of using it (bridge from C#, XAML, ...). Then WMI (used for system administration) is handled, but from my point of view, it is the weirdest part. WMI has its own language which does not seem like C# or Python. Besides, PowerShell, presented as well as a way of doing system administration, has its own language. There is a book dedicated to PowerShell, so only the communication between IronPython and PowerShell is handled. So two additional languages in this chapter, perhaps too many (they are limited to this chapter).

IronPython is a .Net language, so it is possible to do ASP with it. A chapter deals with this approach, chapter well written but it needs to follow the associated example in your favorite IDE if you want to follow what's happening. Web means also web services and databases, handled in one chapter. The basis of SQL tools addressed, as well as basic webservces (mainly REST). I have to say that there are some mistakes there, as SOAP is not only used with POST HTTP requests but also with GET requests (it can be seen in the official w3c specification) and also with other transport protocols than HTTP. Perhaps these are .Net implementation's limitation, in which case it should have been mentioned. Finally Silverlight integration allows developping light clients that can interact with other langages as well as the web page.

Throughout the book, complete interaction with other .Net languages was not addressed. It is the goal of the last part to show how assemblies can be used in IronPython and how IronPython scripts can be used from .Net static languages. As I've said, the interaction does not go completely smoothly, there are several solutions to accomplish it. At least, the book does not only speak about the upcoming .Net 4.0 that will help this interaction.

As a conclusion, those who need a dynamic language (to script an application) can go for IronPython, th first dynamic language for the .Net framework, compatible with the langage Python 2.5, and in that case, go for this book that will help you for anything.

Récemment, j'ai décidé de me plonger dans Silverlight. Curieux de ce framework, mais n'ayant pas une grosse expérience de WPF, j'ai cherché un livre me permettant, dans un premier temps, d'avoir une approche "débutant" pour les concepts de base, mais qui soit aussi une référence un peu plus exhaustive une fois que cette étape d'apprentissage soit passée.
Le livre Silverlight In Action m'à complétement comblé pour ces deux aspects.
Après deux chapitres portant respectivement sur une introduction et sur le moyen d'intégrer Silverlight dans les pages web, les deux chapitres suivant couvrent en soixante-dix pages les types de layout, et les contrôles du Framework. Ces chapitres ont a mon avis un bon équilibre entre la quantité de code et d'explication, sachant que chaque contrôle est décrit avec un exemple court de code et une capture d'écran du résultat, de façon relativement atomique, chaque snippet/capture se concentrant sur un seul contrôle.
Les deux chapitres suivants introduisent le data binding (semblable, en moins riche, à celui de WPF) ainsi que les différents mécanismes de communication disponibles (services web, WCF, conversion JSON, RSS et sockets, le tour d'horizon est complet). La complexité, en particulier pour le chapitre sur la communication, monte d'un bon cran.
Les trois chapitres suivants ont été les plus durs pour moi, vu qu'ils concernent les contenus multimédias, les graphismes vectoriels et les animations. Bien que ce ne soit pas mon fort, ces chapitres sont assez didactiques et détaillés pour en retirer au moins une compréhension de ces sujets suffisante pour dynamiser un projet Silverlight (ne vous attendez pas a commencer un jeu en 2d après le chapitre sur les animations).
Les derniers chapitres vont aborder les styling des contrôles et des composants (sympathique pour présenter une interface utilisateur originale et cohérente), et quelques sujets couverts plus rapidement, comme l'Isolated Storage, la DLR, et autres informations sur l'hébergement.
L'un dans l'autre, ce livre est excellent pour se mettre à SilverLight, mais aussi pour y revenir régulièrement. Le seul bémol est le manque d'un fil conducteur au livre, permettant, par exemple, de voir la construction d'une application, de façon itérative, en partant du layout jusqu'à l'hébergement. Un autre point noir est le site web "compagnon" du livre, qui est mentionne plusieurs fois dans le livre, et qui consiste en tout et pour tout en une page unique, renvoyant sur les sources et sur la page d'accueil du livre. Décevant pour un livre sur une technologie RIA.
English Version
Recently, I decided to dive into Silverlight. Curious about this framework, but not having a big experience of WPF, I looked for a book to go through the beginner phase and the basic concepts, but is also as a reference once the initial learning stage has passed.
Silverlight In Action hit the spot for both these needs.
After introducting Silverlight, as well as a discussion on how to integrate Silverlight into web pages, the two following chapters cover over seventy pages the different types of layout, and the controls available in the framework. These chapters have, in my opinion, a good balance between the amount of code and explanation, given that each control is described with a short example of code and a screenshot of the result, each snippet / capture being focused on a single control.
The next two chapters introduce data binding (similar, if less rich than in WPF) and the various means of communication available (Web services, WCF, JSON, RSS and sockets, the roundup is complete). Complexity, particularly the chapter on communication, raises a little bit.
The next three chapters were the hardest for me, as they relate to multimedia content, vector graphics and animations. Although this is not my forte, these chapters are quite didactic and detailed enough to get at least an understanding of these topics sufficient to spice up a Silverlight project (do not expect to start a game in 2d after the chapter on animation) .
The final chapters will address the styling of controls and components (to provide a coherent and original user interface ), as well as some topics covered more quickly, such as Isolated Storage, the DLR, and other information on hosting.
All in all, this book is excellent to begin SilverLight, but also to come back regularly. The only bemol is the lack of a common thread to the book, allowing, for example, see the construction of an application, iteratively, starting from the layout to the accommodation. Another black spot is the website "companion" to the book, which is mentioned several times in the book, which consists altogether in a single page with links to the code samples and the book home page.

Un ouvrage richement illustré - sources et impressions d'écran - qui vous permettra de découvrir Silverlight. Ce livre m'a permis d'appréhender Silverlight sans problème et constitue donc, à mon avis, une bonne entrée en matière. Une fois l'étape "découverte" passée, il faudra se tourner vers d'autres ouvrages destinés à un public expérimenté.
Notez que cet ouvrage est destiné aux débutants "Silverlight", mais que le lecteur doit bien connaître le framework .NET (2.0 minimum, idéalement 3.5 pour se concentrer uniquement sur Silverlight) et le développement Web (ASP.NET, DHTML). Les exemples de code sont en C#, mais les utilisateurs d'autres langages .NET s'y retrouveront facilement.

Cet ouvrage constitue une introduction à Silverlight 2 et 3.
Très axée pour les débutants, l'auteur fait un tour très rapide des divers éléments constituants Silverlight, des contrôles au binding en passant par une présentation de Silverlight 3.
Après 450 pages de lecture, on se demande quand le livre va démarrer enfin. Mais en fait non, l'auteur se borne à décrire très sommairement les divers éléments de Silverlight. L'objectif du livre est clair, un compagnon pour la prise en main de Silverlight, pour des personnes n'ayant pas eu l'occasion de suivre des tutoriels ou désireux d'avoir une information centralisée.
On regrettera certains aspects qui je trouve sont expliqués trop brièvement, comme les dependency property ou le modèle MV-VM. On appréciera le tour d'horizon de Silverlight 3 ainsi que la présentation des nouvelles fonctionnalités, comme le mode détaché.
En conclusion, un livre pour les débutants qui saura vous accompagner dans la découverte de Silverlight, à déconseiller à ceux qui ont déjà mis un pied dans Silverlight.

Ce livre a pour objectif de vous apprendre Silverlight dans sa version 2.
Une première partie est consacrée à l'apprentissage du langage XAML qui constitue la base de Silverlight. Les auteurs survolent alors la suite logicielle de Microsoft dédiée notamment à Silverlight avant d'aborder l'accès aux données depuis Silverlight et l'intégration de ce dernier dans un projet ASP.NET. Sont alors abordés les concepts "avancés" de Silverlight, tels que la création d'un UserControl ou encore l'utilisation des Styles et Controles Templates. Un chapitre est alors consacré à l'outil DeepZoom.
La lecture de cet ouvrage permet de rapidement se familiariser avec le fonctionnement de Silverlight. Les différents concepts sont abordés de façon claire et précise. J'ai cependant parfois eu l'impression que les explications proposées manquaient de profondeur et qu'un peu plus de détails aurait été le bienvenu. En fait, les détails sont bels et bien présents, mais dans les nombreux exemples de code qui jalonnent le livre. C'est là qu'il faudra parfois chercher ce qui n'est pas clairement écrit dans le texte. On pourra également regretter l'absence d'un "fil rouge" pour guider le lecteur à travers les différents chapitres.
En conclusion, je dirais que cet ouvrage constitue une excellente méthode pour apprendre Silverlight mais il est, selon moi, destiné à une public "averti". En effet, bien qu'une annexe soit consacrée au langage C#, une bonne expérience en programmation du Framework .NET et du langage C# constituent des prérequis à le lecture efficace de ce livre. Par contre, pour un lecteur expérimenté voulant s'initier rapidement à Silverlight, cet ouvrage devrait répondre à ses attentes.

Version française
On ne présente plus l'intérêt des tests unitaires. En effet, cette technique devient de plus en plus répandue dans le monde informatique, quel que soit le langage, et permet, lorsque ces tests sont bien faits, d'améliorer nettement la qualité du logiciel produit, tout en facilitant la maintenance du produit. Des tests unitaires bien codés permettent de détecter rapidement tout nouveau bug introduit dans le projet, et peuvent donc éviter des régressions dans le code.
La question qui reste souvent en suspens est de savoir comment produire de "bons" tests unitaires. La littérature informatique contient un nombre important de livres parlant de méthodologies (Agile, XP, Scrum), mais il manquait (en tout cas, en .NET), un livre explicitant clairement comment produire des tests unitaires de qualité. C'est l'objectif de The Art Of Unit Testing.
Le livre commence par une introduction aux tests unitaires, à NUnit, et par un ensemble de définitions. On passe ensuite assez vite à un peu de pratique avec un premier test unitaire.
La partie suivante approfondit la notion de mock et de stubs, et aborde en profondeur le Framework Rhino Mocks. Cette partie présente de plus un ensemble de bonnes pratiques liées à l'utilisation de ce Framework, ou de tout autre Framework d'isolation.
Après avoir abordé les éléments constitutifs des tests unitaires, la troisième partie présente un ensemble de bonnes pratiques pour les tests eux-mêmes, pour éviter (entre autres) que le coût de maintenance des tests ne dépasse le gain procuré par leur existence.
Enfin, la dernière partie du livre se place à un niveau au-dessus, et présente les différents points à garder à l'esprit lors de l'introduction des tests unitaires au niveau d'une organisation et plus particulièrement dans un projet déjà existant, ce qui peut représenter une bonne partie des cas lorsque l'on introduit les tests au sein d'une équipe ou d'un ensemble de projets.
Ma plus grande crainte avec ce livre était que, Roy Osherove travaillant pour TypeMock, il parle surtout des outils commerciaux de TypeMock (Isolator, Ivonna et compagnie). En fait, ces outils ne sont que très peu mentionnés dans cet ouvrage, qui se concentre sur les "standards" que sont NUnit et Rhino Mocks.
L'un dans l'autre, ce livre est probablement la meilleure introduction aux tests unitaires que j'ai jamais lue, et devrait, à mon avis, être une lecture obligatoire pour toute équipe décidant de commencer à utiliser les tests unitaires. En tout cas, personnellement, c'est le livre que j'aurais aimé avoir il y a deux ans, quand j'ai commencé à écrire des tests.
Cela dit, ce livre requiert une certaine expérience du développement avec le framework.NET pour l'apprécier correctement, je le conseillerais donc à des personnes ayant au moins 2 ou 3 projets derrière eux.
English version
It is no longer needed to discuss the need for unit tests. Indeed, this technique becomes increasingly widespread in the computer world, whatever the language, and, when those tests are well crafted, they can significantly improve the quality of software, while facilitating the maintenance of the product. Unit tests can detect any new bug introduced in the product, and can therefore avoid regressions in the code.
The question that often remains unresolved is how to produce "good" unit tests. The literature contains a large number of books discussing methods (Agile, XP, Scrum), but there was no (in any case, for. NET) book explaining clearly how to produce some quality unit tests. That is the goal of The Art Of Unit Testing .
The book begins with an introduction to NUnit, and a set of definitions. It then moves quickly enough to a bit of practice with a first unit test.
The next section develops the concept of mock and stubs, and discusses in depth the Rhino Mocks framework. This part furthermore presents a set of good practices related to the use of this Framework, or any other isolation framework.
After discussing the building blocks of unit tests, the third part presents a set of good practice for the tests themselves, to avoid (among other issues) that the maintenance cost of the tests exceeds the advantage gained by their existence.
The last part of the book is looking at a level above, and presents the different points to keep in mind when introducing unit tests in an organization and especially in an existing project, which can represent a large proportion of cases when introducing unit testing in a team or project.
My biggest apprehension with this book was that, with Roy Osherove working for TypeMock, he would speak mostly of the commercial tools develpped by TypeMock (Isolator, Ivonna and co.). In fact, these tools are only marginally mentioned in this book, which focuses on 'standards' such as NUnit and Rhino Mocks.
All in all, this book is probably the best introduction to unit tests I've ever read, and should, in my opinion, be required reading for any team or person decided to start unit tests. In any case, personally, this is the book that I would have loved to have two years ago, when I started writing tests.
That said, this book requires some development experience with the .NET framework to appreciate it properly, therefore I recommend it to people having at least 2 or 3 projects behind them.

Boo est l'un des nombreux langages supportés par la plate-forme .Net. Sa syntaxe inspirée de Python apporte concision et lisibilité au code, mais contrairement à Python, il n'est pas orienté programmation dynamique. Ses aspects lisibles, concis et statiques en font un choix judicieux pour développer des Domain Specific Languages (DSL), ie un langage restreint spécialisé dans un domaine d'application bien précis, et qui permettra d'être très productif pour scripter, exprimer des contraintes, etc.
Dans cet ouvrage, vous trouverez une courte introduction au langage Boo, pour vous mettre le pied à l'étrier. Ensuite, vous approfondirez au fur et à mesure vos connaissances, en abordant successivement toutes les notions importantes pour construire un DSL, pour le faire évoluer, et l'intégrer dans une éventuelle interface pour utilisateur final. Ce livre réussit à être presque exhaustif tout en restant abordable. Toutefois il m'a semblé que la philosophie des DSL n'était pas suffisamment abordée.
L'avez vous lu ? Qu'en pensez-vous ?