[FRENCH] Revue du livre “MCSD Certification Toolkit (Exam 70-483): Programming in C#”

Book cover

Introduction

J’ai tout récemment passé et obtenu la certification Microsoft 70-483 “Programming in C#” qui est l’un des points d’entrée des cycles de certification développeur .Net et WinRT.
Pour m’y préparer j’ai notamment lu les 2 livres qui y sont dédiés (en anglais) : MCSD Certification Toolkit (Exam 70-483): Programming in C# et Programming in C#: Exam Ref 70-483 dont je vous conseille vivement la lecture.
Ils ont en effet constitué mon support principal pour la préparation de la certification et ont bien remplis leur office.

Cet article est une revue complète de MCSD Certification Toolkit (Exam 70-483): Programming in C#.
C’est le 1er livre que vous devriez lire, je pense celui qui prépare le mieux à la certification, mais paradoxalement le moins bon techniquement, et vous allez vite comprendre pourquoi.

C’est malheureusement le gros point noir de ce livre : il est parsemé d’erreurs techniques, allant du simple abus de langage que seuls les experts remarqueront et sans conséquence pour les néophytes, aux  mauvaises pratiques, en passant par les affirmations contraires à la réalité, et là c’est plus embêtant. Parfois au sein d’une même section se côtoient le pire et le meilleur.

Ce post ne se veut pas un errata complet puisque je n’ai pas pris note de toutes les erreurs mais des principales le but étant surtout d’en faire la typologie sans être exhaustif.

J’ai choisi de partir du pire, les mauvaises pratiques, pour aller vers le meilleur, les bonnes pratiques, car ce livre reste en grande majorité rempli de très bons éléments techniques.

Des défauts

Des mauvaises pratiques

Dispenser de mauvaises pratiques, surtout quand une bonne partie de l’audience est constituée de développeurs non expérimentés, est sûrement ce qu’il y a de pire pour un livre technique.

Cependant soyons honnête il y en a heureusement très peu dans ce livre et comme il ne se prétend pas être une référence technique ce n’est pas du tout rédhibitoire.

Par exemple les conventions de nommage sont souvent oubliées ainsi on se retrouve avec des méthodes displayName, concatenateName ou encore square, ce qui semblerait indiquer que l’auteur ayant écrit ces codes est un récent transfuge de Java vers .Net. Je ne vais pas jeter la pierre ayant moi même suivi ce chemin et ayant eu un petit temps d’adaptation à ces conventions.

Un peu plus grave est la modification de l’état d’une instance de type valeur ce qui démontre une méconnaissance des subtilités de cette catégorie de type. Mais à la décharge du/des auteurs une minorité de développeurs C#/.Net/WinRT en a conscience.

Toujours à propos des types valeurs il est affirmé qu’il vaut mieux utiliser des tableaux de références plutôt que des tableaux de valeurs car les valeurs sont copiées. C’est tout simplement faux puisque les tableaux eux-mêmes sont manipulés par référence donc dans les deux cas il n’y a pas de copie. Ce n’est donc pas une bonne raison d’utiliser la sémantique de référence pour un type même si par défaut c’est celle-ci qu’il faut choisir.

Au niveau de la conception des classes le livre mélange allègrement données métiers et traitements technico-techniques, comme l’accès à une base de données, au lieu de les découpler.
Le découplage est pourtant le b.a.-ba et n’aurait rien coûté dans ce cas, donc pas de raison de ne pas le démontrer à des débutants.
Mais à la décharge du livre les questions de la certification officielle ne sont pas exemplaires à cet égard.

Enfin lors de la démonstration d’ADO.Net la plupart des exemple n’explicitent pas la portée des connexions et des commandes à l’aide du bloc using, bien que cette bonne pratique soit abordée plus loin dans un encart.

Des erreurs

Un peu moins graves sont les erreurs technico-techniques comme l’affirmation que l’élément courant de la boucle foreach doit avoir le bon type, ce qui est faux, et c’est d’ailleurs “dangereux” et source de nombreux bugs : foreach convertit implicitement si le type n’est pas correct : par exemple de double en int.

Certaines illustrations sont fausses : e.g. pour les méthodes d’extension le livre parle d’étendre la classe Math ce qui est inutile car elle ne peut être instanciée car elle est static, et là c’est vraiment pas de chance pour les auteurs parce que c’est une exception plutôt que la règle, mauvaise pioche comme on dit.

Une classe “partial” est décrite comme générant plusieurs fichiers au sein du même assembly alors qu’ils sont tous agrégés par le compilateur C# en une classe unique intégrée à l’assembly.

On nous apprend également que l’on peut setter une instance de type valeur à null ce qui est complètement faux : null n’a de sens que pour une référence vers une instance de type référence.

Le livre affirme que les instances de type valeur sont systématiquement stockées sur la pile : c’est faux, elles peuvent aussi être inlinées au sein d’instances de type référence sur le tas, mais c’est une croyance malheureusement très répandue dans la communauté donc difficile de les blâmer.

Plus anecdotique on nous dit que le type int peut stocker des valeurs allant jusqu’à 4 294 967 286 alors que ce n’est que la moitié.

Plus embêtant mais très répandu on apprend qu’il y a 2 types de passage de paramètre : par copie pour les types valeur et par référence pour les types référence, ça sonne bien mais c’est faux, tout se fait par copie, y compris donc copie de référence pour les types référence.

Complètement original par contre est le fait que les méthodesabstraites” seraient également désignées sous le terme synonyme de méthodesvirtuelles” alors que ce sont 2 concepts liés mais distincts : une méthode abstraite peut être considérée comme virtuelle, mais pas l’inverse. Donc là un souci de compréhension des concepts de programmation orientée objet ce qui semble aussi confirmer mon hypothèse quant à un fort biais Java : les développeurs Java sont ceux qui écrivent le plus de méthodes virtuelles mais sont ceux qui savent le moins ce qu’elles sont (par rapport aux développeurs C++ et C#). Paradoxal ? Non quand on sait que par défaut toutes les méthodes d’instance en Java sont virtuelles donc jamais un développeur Java n’aura a écrire “virtual“.

Des approximations

Certaines simplifications sont sans dangers pour les débutants car cela peut éviter de leur donner trop d’informations d’un coup ou les faire douter mais idéalement on ne prépare pas une certification seulement pour le macaron mais avant tout pour asseoir une véritable expertise et également apprendre de nouvelles choses, ce qui nécessite un peu de précision.

Voici un exemple d’erreur qui est sans gravité mais démontre une méconnaissance du langage : la dernière partie de la boucle for est décrite comme ne pouvant servir qu’à l’expression d’instruction de comptage (++, *=, -=…) ce qui est faux, elle peut même être absente.
Je vous rassure de nombreux développeurs talentueux peuvent passer toute leur carrière en le croyant sans incidence sur la qualité de leur travail et leur productivité.

Un autre exemple de ce type est la description des boucles while et do-while comme deux entités bien distinctes alors qu’elles ne sont que les deux faces d’une même médaille.

De même en présentant la 1ère fois les méthodes d’extension il est dit que leur objet est l’extension d’une classe sans la recompiler, ce qui n’est qu’un aspect plutôt anecdotique.
Heureusement dans ce cas, la bonne définition est donnée dans une autre section, d’où l’importance de tout lire.

De même il est avancé que l’objet de foreach par rapport à la boucle for est la possibilité d’itérer quand on ne connait pas le nombre d’éléments de la collection, alors que c’est surtout l’absence d’un indexeur qui conditionne son utilisation, et en effet d’autres collections nous indiquent bien leur longueur mais ne fournissent pas d’indexeur donc sont mieux exploitées par un foreach.

D’autres approximations sont dommages pour des développeurs ayant une certaine expérience comme affirmer que c’est Visual Studio qui appelle les constructeurs alors que c’est bien sûr le CLR.
Malheureusement les développeurs non curieux qui n’ont jamais mis le nez hors de Visual Studio ont du mal à comprendre que quand on développe ce type d’applications on a 3 acteurs :
.Net ou WinRT qui est la plateforme sous-jacente et fournit notamment la bibliothèque de types et l’environnement d’exécution
C# qui est un langage possédant un compilateur capable de générer du code s’exécutant sur la plateforme .Net
Visual Studio qui est un outil de productivité (le meilleur à mon avis) qui s’interface avec C# et .Net/WinRT via MSBuild notamment.

Le marqueur “volatile” est sensé indiquer que le code peut être modifié par d’autres composants que notre code, c’est partiellement vrai, mais il est aussi très utile en dehors de ce contexte (cf un autre de mes articles : Synchronization, memory visibility and leaky abstractions).
Là encore les auteurs sont pardonnés parce que c’est une subtilité qu’on ne voit qu’en pratiquant un peu la programmation parallèle et la majorité des développeurs .Net passe à travers et c’est très bien comme ça.

De même les auteurs n’ont pas conscience que & est aussi un opérateur booléen valide mais ne court-circuitant pas contrairement à &&. Et malheureusement une des questions d’un test est consacrée à ce sujet, donc le test est faux, ce qui ironiquement est contraire à la façon dont sont décrits les tests au début du livre comme devant être non ambigus notamment.

Certains sujets semblent non maîtrisés comme les ORMs qui sont décrits comme des outils graphiques alors que ce n’est pas du tout le 1er cas d’utilisation, comme le démondre le virage “Code First” d’Entity Framework. NHibernate est quant à lui désigné comme faisant partie des ORMs dédiés aux autres bases de données et langages alors que son 1er cas d’utilisation est l’interaction avec SQL Server depuis C#.

Des abus de langage

Les abus de langage sont généralement peu graves, sauf là encore pour les débutants qui ont besoin de retenir des définitions rigoureuses, afin d’établir des repères les aidant dans l’apprentissage et la consolidation des connaissances.

Par exemple System.Int32 (alias int en C#) est désigné comme une classe plutôt que simplement un type (pour éviter de parler de type valeur), là encore sûrement une réminiscence de Java et son type Integer qui en effet est un type référence.

Pour les structs C# des champs sont définis mais sont désignés par le terme “propriété” ce qui sera source de confusion pour un lecteur débutant puisque plus loin dans le livre les propriétés sont bien sûr désignées par ce même terme.

Souvent le livre utilise le terme de “fichier de classe” au lieu de “classe” tout court, sûrement une autre réminiscence de Java où en effet un fichier source ne peut contenir qu’une classe publique mais même là ça serait un abus de langage.

Dans le même genre le livre parle d’instance d’interface au lieu de référence d’interface, une interface ne pouvant bien sûr pas être instanciée.

Autre sujet mal maîtrisé, le BackgroundWorker : la méthode Invoke est utilisée dans les gestionnaires des évènements ProgressChanged et WorkerCompleted alors que justement l’objet du BackgroundWorker est de capturer automatiquement le contexte et donc de les invoquer sur le thread UI lui-même.

Des soucis mineurs

Accessoirement et comme on pouvait s’y attendre le livre souffre d’un manque de relecture, il y a en effet beaucoup de fautes d’orthographe et de grammaire mais cela n’affecte pas la compréhension, le contexte permettant toujours de comprendre le propos.

Vers la fin du livre il y a un énorme pâté de code pour démontrer la validation en Windows Forms. D’une part je ne comprends pas l’utilité de dumper un volume aussi gros de code, d’autre part il est un concentré de mauvaise pratiques comme jongler avec des valeurs volantes au lieu de les consolider dans des types dédiés, placer le code de validation au sein même de l’UI alors qu’il aurait sa place dans des composants dédiés ou encore utiliser la couleur de fond d’un contrôle pour vérifier la validité du formulaire, c’est un mode de communication plutôt … amateur!

Là encore le danger est pour les débutants qui risquent de faire le plein de mauvaises pratiques et de les appliquer dans leur environnement professionnel voire les transmettre à leurs collègues.

Des termes techniques sont définis dans le lexique de certains chapitres mais jamais abordés ce qui peut laisser penser que certaines sections ont été “oubliées”.

Des sujets sont répétés : la section sur les délégués, les méthodes anonymes et les lambdas apparaît 2 fois, avec deux textes différents, donc sans doute que 2 auteurs ont travaillé dessus sans se coordonner.

Trop de temps est consacré à des composants obsolètes comme les ArrayList remplacés depuis par des équivalents génériques.

Des qualités

Ne lister que les erreurs serait vraiment injuste car ce livre regorge également de très bons éléments, certaines sections d’une qualité digne des meilleures références techniques.

De bonnes introductions

Tout d’abord le livre offre un panorama des outils utilisés dans le développement avec C# sous .Net ou WinRT, et de nombreuses sections sont des petites introductions qui permettent au lecteur de rapidement comprendre les tenants et aboutissants d’un outil.

L’introduction à la programmation parallèle est très correcte avec notamment un petit topo sur le thread-pool et ses limitations comme l’impossibilité d’effectuer un join, et sur les méthodes asynchrones de C# 5.0.

La partie sur les moniteurs est très bien pour réviser mais juste un peu courte pour un débutant découvrant le sujet qui ne saisira pas certains concepts comme la “ready-queue”.

Le livre possède aussi une bonne introduction à Entity Framework et illustre son utilisation avec le workflowDatabase First“.

LINQ est également bien présenté et aborde les deux syntaxes de construction des requêtes : via le mini-langage intégré à C# ou directement via le chaînage des méthodes fournies par Enumerable.

L’introduction à la sécurité est très complète tout en étant très compacte et aborde des sujets aussi variés que le hachage, le chiffrement symétrique et asymétrique, ou encore les certificats.
C’est parfait pour les développeurs qui comme moi connaissent ces sujet mais ne sont pas complètement au fait de leur implémentation concrète au sein de .Net/WinRT.
Et j’ai d’ailleurs eu une question sur cette section lors du passage de la certification.

De bonnes illustrations

Par exemple l’illustration de l’usage de la boucle do-while avec la lecture d’entrées utilisateur est très pertinente et est un cas d’utilisation réel et récurrent.

De même un exemple non trivial d’utilisation des énumérateurs est fourni ce qui permet de bien comprendre comment les choses fonctionnent sous le capot.

Il y a également de bons exemples sur la programmation orientée objet, notamment sur l’utilisation des classes abstraites et des méthodes virtuelles, ainsi que la notion de contrat et d’interface, e.g. avec les implémentations explicites.

Pour illustrer l’importance de la réflexion le livre utilise la problématique du mapping objet-relationnel ce qui en plus d’être très pertinent est une bonne démonstration technique pour les débutants puisqu’en 20 lignes de code on se retrouve avec un mini ORM, alors qu’au 1er abord on pourrait penser à une implémentation bien plus lourde.

Des sujets bien traités

Certains sujets bénéficient d’un traitement plus en profondeur avec des éléments techniques pointus.

C’est le cas des chaines de caractères, leur immutabilité et la gestion de leur stockage par le CLR (interning) étant bien abordés.

L’introduction au fonctionnement de la garbage-collection est concise et de qualité, et insiste notamment sur le non-déterminisme, en l’illustrant avec l’utilisation de fichiers.
Ce qui amène à la compréhension instinctive de la finalité des finaliseurs/destructeurs et du pattern disposable.
Les explications sont équilibrées : assez de profondeur technique pour bien comprendre le fonctionnement et acquérir des connaissances allant au delà de la certification, sans noyer le débutant sous trop de subtilités, tout en exposant bien les raisons d’être et les cas d’utilisation.
C’est franchement une des meilleures descriptions que j’ai vu de ce sujet.

Un autre exemple où le contenu est plus fournis que nécessaire pour la certification est CodeDOM qui bénéficie d’une démonstration riche et complète utilisant C# et VB.Net, qui va au delà de l’exemple canonique copié et recopié partout consistant en la compilation d’un “Hello world” utilisant C#.

De la contextualisation et des bonnes pratiques

Pour finir il faut savoir que le livre distille pas mal d’informations qui permettent de mettre les concepts en perspectives, ainsi que des bonne pratiques.
Même si ce n’est pas vraiment utile pour la certification qui évalue avant tout votre capacité à utiliser les outils et pas à en parler, cela permettra à tout développeur de mieux comprendre les outils qu’il utilise sans s’être forcément posé trop de questions.

Par exemple la raison d’être des types énumérés est très bien expliquée en insistant sur l’amélioration de la lisibilité et donc de la maintenabilité du code.

De même pour les types et méthodes generics où le livre insiste bien sur tous leurs bienfaits comme la réutilisation du code, la sécurité de typage et les performances.

L’introduction au principe d’encapsulation est très bonne, évoquant notamment la validation comme un cas d’utilisation pertinent et l’application de transformations pour par exemple éviter les injections SQL, moins réaliste je pense mais intéressant quand même.

L’accent est souvent mis sur des bonnes pratiques comme l’utilisation systématique d’accolades même quand il n’y a qu’une seule instruction, pour les blocs if notamment.

Il y a souvent des bon conseils comme l’importance de ne pas véhiculer d’information sensible via les exceptions, et de les rendre sérialisables si elles doivent passer les limites d’un app-domain.

Enfin le livre fait référence à de bonnes ressources complémentaires comme pinvoke.net qui est incontournable quand on fait de l’interop native via P/Invoke (DllImport).

Le bilan

L’intérêt principal de ce livre est qu’il présente une large gamme de sujets, et je pense qu’il est exhaustif par rapport au programme officiel.

Ce livre profitera plus ou moins au lecteur selon son niveau en C#/.Net/WinRT :
– si vous avez un très bon niveau, senior avec 5 ans d’expérience, alors vous serez capable de faire la part des choses entre les bonnes informations et les erreurs, et ce livre sera un de vos meilleurs alliés pour passer la certification,
– si vous avez un niveau junior confirmé avec des bases solides ce livre pourra vous aider à passer au niveau intermédiaire ne serait-ce que par l’énumération de sujets importants et de bons points techniques à travailler,
– par contre si vous êtes débutant, outre le fait qu’il est sans doute un peu tôt pour passer la certification, ce livre est dangereux si vous assimilez les erreurs et mauvaises pratiques naïvement, donc il faut redoubler de prudence et ne pas hésiter à demander à des développeurs expérimentés en cas de doute.

Me concernant, je pourrais diviser à la louche le contenu comme suit :

  • 75% était constitué d’acquis que le livre m’a permis de réviser,
  • 15% concernait des sujets que j’avais oubliés et donc j’étais bien content d’avoir pris le temps de lire le livre en entier parce que “faire l’impasse” sur 15% du programme ça fait beaucoup, ça représente en effet la moitié de la marge de manœuvre accordée pour cet examen (il faut avoir 700/1000),
  • 10% concernait des sujets que je ne connaissais pas, dont j’avais pu entendre parler mais que je n’avais jamais utilisés comme WCF Data Service ou bien la possibilité d’utiliser des options inlinées dans les expressions rationnelles, ou encore des bonnes pratiques que j’avais ratées comme l’utilisation de labels aux directives #endregion

J’ai donc beaucoup appris à la lecture de ce livre, des choses plus ou moins importantes certes, mais toute connaissance est bonne à prendre quand on recherche l’expertise.

Conclusion

Comme vous l’avez constaté “MCSD Certification Toolkit (Exam 70-483): Programming in C#” est un livre très inégal.
Ce que je ne comprends pas c’est pourquoi la version électronique a toujours autant d’erreurs malgré les réactions offusquées, et souvent un peu disproportionnées, des lecteurs déçus.

Donc devriez-vous lire ce livre ?
Si vous passez la certification 70-483 la réponse est un “oui” sans détour parce qu’il résume bien tous les points qu’il vous faudra connaitre pour réussir la certification et il vous aidera à déterminer où vous êtes un peu faible.
C’est aussi un choix par défaut, il n’y a pas vraiment d’alternatives.

Par contre si vous avez besoin d’un livre technique pour monter en compétence alors je le déconseille car vous risqueriez d’apprendre de mauvaises pratiques, et lire un livre en étant suspicieux n’est pas bon pour la mémorisation puisqu’on a tendance à ne plus rien croire.

Surtout ne faites pas comme certains lecteurs qui ont arrêté la lecture après les 1ères pages constatant l’accumulation d’erreurs, et cela pour deux raisons :
– la qualité du livre s’améliore au fil des chapitres et autant j’ai trouvé énormément d’erreurs dans le 1er quart, autant vers la fin c’était beaucoup plus rare, c’est comme si la 1ère partie sur les bases avait été confiée à un développeur débutant, le milieu à un développeur un peu plus expérimenté et la dernière partie à un développeur confirmé.
– même dans les portions truffées d’erreurs il y a des informations importantes voire même des petites pépites.
Donc même si vous êtes considéré comme un expert ce livre vous apportera quelque chose et il serait dommage de faire l’impasse dessus pour passer la certification.

Ce qui est certains c’est que ce livre est le résultat d’un travail énorme qui mérite beaucoup de respect, et il vaut mieux des ressources imparfaites que pas de ressources du tout.

Ma note finale
Noter ce livre est pour moi assez difficile puisque d’un côté je trouve l’accumulation d’erreurs et d’approximations techniques dommageables pour les lecteurs non avertis qui doivent constituer une bonne partie de l’audience, mais d’un autre côté il remplit parfaitement son office de préparation à la certification.

Si c’était un livre se voulant une référence technique je lui aurais mis 5/10.
Pour un lecteur souhaitant simplement d’obtenir la certification alors il vaut 9/10.
Par conséquent je lui donne une note de 8/10, soit 4 étoiles sur 5 sur Amazon, parce que j’ai surpondéré l’aspect passage de la certification qui est le propos officiel de ce livre qui n’a pas l’ambition d’être une référence technique.

4 thoughts on “[FRENCH] Revue du livre “MCSD Certification Toolkit (Exam 70-483): Programming in C#”

  1. Ayant décidé de passer cette certification je cherchais justement un article interressant qui se rapportait au “training” de celle-ci et j’ai découvert le votre un peu “par hasard” :) Merci d’avoir pris du temps pour le rédiger. J’achète donc le livre sans me poser plus de questions.

    • Content que cet article vous soit utile. :)
      Vous pouvez acheter le livre les yeux fermés car il est un très bon support de préparation mais comme indiqué dans l’article il faut rester vigilant lors de la lecture.
      En tout cas n’hésitez pas si vous avez des doutes sur des questions non mentionnées ici.
      Bon courage et bonne chance pour la certification.

Leave a Reply to Joblob Cancel reply

Your email address will not be published. Required fields are marked *

Prove me you\'re human :) *

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>