Partage
  • Partager sur Facebook
  • Partager sur Twitter

[Big-Tuto] Bonnes pratiques et notions avancées en POO

Débroussaillage et recherche de co-auteurs sérieux

    8 décembre 2010 à 9:51:32

    Bonjour.
    Depuis un bon moment, je suis titillé par l'idée d'écrire des tutoriels sur la POO avancée (notamment en Python, pour lequel j'ai écrit un tuto sur le pattern Decorator sur ce site), mais une remarque récente de M@teo21 m'a donné l'idée de lancer un projet de big-tuto ambitieux, dont j'aimerais abattre la phase de réflexion initiale avec vous, et pour lequel je rechercherais un ou plusieurs co-auteurs sérieux.

    Le tutoriel en question aborderait les bonnes pratiques et les notions avancées de le programmation orientée objet, de manière indépendante du langage (l'idée de base serait de proposer des exemples à la fois en C++, en Java et en Python, étant donné que ces 3 langages sont mis en avant sur le SDZ).
    Voici une première idée de plan global :

    Partie 1 : Rappels et grands principes de la POO



    Cette partie permettrait d'étudier de manière approfondie les notions classiques de la POO : héritage, encapsulation et masquage de l'implémentation (les deux dernières notions étant souvent amalgamées à tort), ainsi que d'introduire les grands principes de la POO : l'utilisation d'interface abstraites, Encapsulation Over Inheritance, Don't Repeat Yourself, Single Responsibility Principle, Liskov Substitution Principle, Dependency Inversion Principle

    Chaque chapitre serait présenté avec une étude de cas, présentant un exemple, étudié itérativement dans lequel on pourrait montrer les erreurs de conception possibles, et l'intérêt et le bienfondé de ces notions (ainsi, éventuellement, que les limites quand cela s'y prête).

    Partie 2 : Design Patterns de base



    Dans cette partie, on utiliserait les notions de la partie précédente pour introduire les premiers design patterns : les plus simples, ceux qui s'expliquent directement comme des applications des grands principes.
    J'ai en tête Strategy et State, Decorator, Factory et Abstract Factory, Observer, (Singleton...), Adapter et Façade, Composite, Command.

    Comme précédemment, l'idée est de présenter ces patterns en posant une étude de cas dans laquelle on se propose de résoudre un problème donné, en prenant le temps de montrer des conceptions bancales avant d'introduire le pattern.

    Partie 3 : Design Patterns avancés



    Cette partie permettrait de présenter certains design patterns composés (je pense à MVC/MVD), ou d'utilisation plus "marginale" (Proxy, Lightweight…)

    Annexes



    En annexe, on pourrait présenter quelques Anti-Patterns, éventuellement quelques notions vraiment propres à certains langages, ainsi qu'une bibliographie (indispensable!)…


    Qu'en pensez-vous ?
    Y a-t'il parmi vous des auteurs motivés pour co-écrire ce tutoriel (je chercherais en priorité des développeurs Java…) ?
    • Partager sur Facebook
    • Partager sur Twitter
    Zeste de Savoir, le site qui en a dans le citron !
      8 décembre 2010 à 10:20:05

      Salut,

      Je trouve que c'est une super idée. Je lirai ça avec plaisir et intérêt.

      Je me pose une question qui va peut-être en faire rire certains mais bon, le ridicule ne tuant pas, je me lance : est-ce que ces grands principes peuvent s'appliquer à PHP 5 ?
      • Partager sur Facebook
      • Partager sur Twitter
        8 décembre 2010 à 10:32:21

        Oui.
        À la base ça s'applique à n'importe quel langage orienté objet : on touche plus à la conception qu'à l'implémentation, d'ailleurs il n'est pas inenvisageable de donner des exemples en PHP5... Niveau langage dynamique j'opte pour Python, personnellement, parce que je connais plutôt bien ce langage, mais ce n'est qu'un choix. ;)
        • Partager sur Facebook
        • Partager sur Twitter
        Zeste de Savoir, le site qui en a dans le citron !
          8 décembre 2010 à 10:46:22

          Ok merci. Ma question n'était donc pas si ridicule, ouf ! :p
          Bon courage pour ce tuto très prometteur ! :)
          • Partager sur Facebook
          • Partager sur Twitter
            8 décembre 2010 à 11:24:22

            Salut NoHar,

            Le sujet m'intéresse au plus haut point. Je voudrais bien t'assister à la rédaction, mais mes connaissances sont un peu limitées (c'est en partie pour ça que je suis très intéressé).

            Ceci dit je pense avoir de bonnes bases en C++ et en POO, donc si tu as besoin d'une personne pour relire, t'assurer que c'est suffisament clair, reperer les fautes d'orthographes ou quoi que que soit, je serait ravi de t'aider. :)

            Bon courage.
            • Partager sur Facebook
            • Partager sur Twitter
              8 décembre 2010 à 22:01:23

              Bonjour :)

              C'est dommage de poster un message juste pour ça, mais il n'y a pas de bouton "+1".
              Je viens donc juste signaler mon immense intérêt pour ton projet.

              La façon dont tu prévois d'expliquer tout ça m'attire vraiment.
              Reste à te trouver des "pros" de la conception OO. :p
              • Partager sur Facebook
              • Partager sur Twitter
                16 décembre 2010 à 15:23:21

                Je trouve que c'est une excellente idée, et je tiens à souligner deux points qui me semblent important concernant ce futur tuto:

                1) Il est INDISPENSABLE que la Partie 2 soit basé sur le même concept que celui que tu as utilisé dans ton tuto sur le Decorator. Je l'ai déjà dit, je le répète, le seul moyen de faire comprendre à quelqu'un ce qu'est un pattern particulier c'est de lui faire comprendre (sur un cas concret) POURQUOI ce pattern est utile, et quel problème est-ce qu'il résout. Et l'idée des "conceptions bancales" est parfaite pour ça

                2) Je pense qu'il serait pas mal d'inclure une présentation rapide de l'UML dans l'introduction ou en annexe. Je sais qu'il y a déjà des chapitres là dessus sur le sdz, mais un rappel succinct des notations permettra à ton tuto d'être self-contained.

                3) Certains bouquins (je pense au GoF) séparent les patterns en différentes catégories.. Le problème c'est que ces catégories sont souvent définies en début d'ouvrage, alors que le lecteur n'est pas encore familier avec ce que sont les DP. Je pense qu'il est important (conceptuellement) d'introduire les différentes catégories de patterns, mais cela doit être fait à la fin de ta deuxième partie (ou au début de ta troisième partie), quand le lecteur a déjà une certaine expérience.

                4) Tu te proposes de faire un tuto général (indépendant du langage choisi) et c'est une excellente idée. Le problème c'est que certains "concept" généraux ne sont pas applicables (ou en tout cas pas applicables directement) à certains langages. Je prendrai comme exemple les "interfaces" qui, si elles font parties intégrantes de Java, ne sont en revanche pas très naturelles en Python. Attention, je ne dis pas qu'il n'est pas possible d'implémenter ce genre de comportement en python, je dis simplement que cela mérite quelques précisions. Je pense que ces "détails" propres à chaque langage mériteraient de faire l'objet d'un chapitre complet, et pas seulement d'une annexe.

                Voilà pour l'instant mon feedback par rapport à ton plan. Je suis actuellement en train d'approfondir mes connaissances en OO Design, et je suis volontaire pour t'aider dans la rédaction de ton tuto (par contre, je code en python et non en Java, donc ça ne t'intéresse peut-être pas..). Bref, si tu veux bien de mon aide -> MP.

                Quoi qu'il en soit, je te souhaite bon courage, car ce tuto sera utile à beaucoup de monde (la littérature actuelle sur le sujet, bien que prolifique, est de qualité assez moyenne..)
                • Partager sur Facebook
                • Partager sur Twitter
                  16 décembre 2010 à 15:41:47

                  Merci pour ce commentaire encourageant !

                  Sur le point 4), j'y ai effectivement pensé, mais c'est peut-être une bonne occasion pour dire qu'en python "tout est plus simple" à faire de manière polymorphe grâce au duck-typing.
                  Ceci dit, on trouve quand même quelques modules standards de Python qui présentent des interfaces abstraites (comme libhtml, libxml, AST — qui implémente aussi un visitor, d'ailleurs :p —), même si effectivement c'est loin d'être le plus élégant que l'on puisse faire.
                  • Partager sur Facebook
                  • Partager sur Twitter
                  Zeste de Savoir, le site qui en a dans le citron !
                    26 juillet 2011 à 17:20:20

                    Le tutoriel est-il toujours en cours ?

                    Pour ton idée d'antipatterns c'est une excellente idée, d'ailleurs reprise dans un ouvrage absolument fantastique sur RoR. Quoique, le bouquin en question montre l'implémentation.

                    L'idée de ton tutoriel est très bien. Cependant, il faudrait sortir un tutoriel par langage pour montrer l'implémentation. En plus de tes explications des grands principes.

                    Ton projet est une tâche plus qu'ambitieuse. Dans la mesure où certains de ses principes sont des structures dans certains langages et quasiment inappplicables dans d'autres (enfin pas pour tout les principes).
                    • Partager sur Facebook
                    • Partager sur Twitter
                      3 novembre 2019 à 13:11:51

                      Bonjour à tous,

                      juste une curiosité, où en est on 9 ans plus tard. Le sujet m'intéresse au plus haut point. Excellente idée en tout cas.

                      • Partager sur Facebook
                      • Partager sur Twitter

                      [Big-Tuto] Bonnes pratiques et notions avancées en POO

                      × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                      • Editeur
                      • Markdown