Conférence sur la programmation orientée aspect et JAC, à Toulouse.

Posté par . Modéré par Fabien Penso.
Tags :
0
28
mai
2003
Java
Le 26 Juin 2003 se tiendra à l'ENSEEIHT de Toulouse une conférence ouverte à tous sur la programmation orientée aspect. Le conférencier est Laurent Martelli, un des managers du projet JAC (Java Aspect Components).

L'avantage de la programmation orientée aspect réside dans une modularisation très efficace, d'où d'énormes possibilités de réutilisation du code (jetez un oeil aux modules fournis par JAC, et vous aurez du mal à trouver ce qu'il vous reste encore à coder :-).

La plupart des serveurs d'application s'orientent vers la technique des aspects (JBoss4 par exemple). Le Club des Utilisateurs de Linux a Toulouse (CULTe), l'Enseeiht et la societe AopSys vous proposent une conference a Toulouse, ouverte a tous, sur le theme:

***
"La separation des problematiques dans le design d'applications, la reutilisation maximale de code: deux atouts de la _programmation orientee Aspect_"
***


suivie d'une presentation des travaux de "AopSys.com" :

***
"Des composants orientes Aspect _open-source_ en Java: JAC"
***


Ce cycle de conferences aura lieu le Jeudi 26 Juin de 14h a 18h, en salle des theses de l'Enseeiht (Rue riquet, à Toulouse).

Le public intéressé comprend:
* des professeurs, ingenieurs de recherche et etudiants a l'Enseeiht et dans les autres poles d'etudes superieures de Toulouse (faculte, INSA...),
* des membres de diverses associations informatiques de la region Midi-Pyrenees (association Linux de Toulouse, ...)
* des chercheurs du CNRS (LAAS)
* des professionnels du tissu industriel de la region toulousaine (societes de service en informatique, developpeurs independants, grands comptes)

ou toute personne désirant approfondir ses connaissances dans ce domaine novateur qu'est la programmation orientée aspect.

Aucune pre-inscription n'est nécessaire pour venir assister aux conférences. Pour toute information, n'hesitez pas a contacter le CULTe (mailto:aop@culte.org) ou le conferencier Laurent Martelli de la societe AopSys (mailto:laurent@aopsys.com).
  • # Re: Conférence sur la programmation orientée aspect et JAC, à Toulouse.

    Posté par . Évalué à 2.

    Quelqu'un a un lien (en français si possible) sur la POA ?? Ca a l'air intéressant mais faudrait un survol pour savoir de quoi il retourne.
    • [^] # Re: Conférence sur la programmation orientée aspect et JAC, à Toulouse.

      Posté par (page perso) . Évalué à 3.

      J'avais lu un livre de fou l'an passé sur la programmation orientée multi-agents. Dans mes recherches post-lecture, j'étais tombé sur des trucs sympatoches sur la POA sur les sites de facultés. Je les avais pas cité dans mon mémoire parce que ça faisait un peu hors sujet, donc je n'ai plus les références. Mais cependant, essaie de regarder du coté des universités de Toulouse. Tu devrais trouver ton bonheur.
    • [^] # Re: Conférence sur la programmation orientée aspect et JAC, à Toulouse.

      Posté par . Évalué à -2.

      J'ai lu plusieures tentatives d'explication, mais je ne sais toujours pas en quoi ça consiste. C'est un peu comme pour XML, tout le monde en parle mais au fond pas grand monde sait ce que c'est et je doute même qu'il existe plus de 10 personnes au monde sachant à quoi sert XML.

      BeOS le faisait il y a 15 ans !

      • [^] # Re: Conférence sur la programmation orientée aspect et JAC, à Toulouse.

        Posté par (page perso) . Évalué à 3.

        En trois mots: séparation des préocuppations. Pour plus de détails, voir le site de JAC.
      • [^] # Re: Conférence sur la programmation orientée aspect et JAC, à Toulouse.

        Posté par . Évalué à 4.

        Magnifique troll : je doute même qu'il existe plus de 10 personnes au monde sachant à quoi sert XML.

        Ou alors je fais parti des 10 personnes.
        • [^] # Re: Conférence sur la programmation orientée aspect et JAC, à Toulouse.

          Posté par . Évalué à 0.

          Merci merci ;)

          D'une façon plus sérieuse, j'aimerai bien savoir ce que XML a de si merveilleux à part d'imposer un meta-format universel (ce qui n'est deja pas si mal) ?

          BeOS le faisait il y a 15 ans !

          • [^] # Re: Conférence sur la programmation orientée aspect et JAC, à Toulouse.

            Posté par . Évalué à 8.

            Ben, proposer un méta-format universel, c'est justement à ça que sert XML (ça ne se réduit pas à < machin > < / machin >, même si c'est la base, il y a tout un tas de trucs qui vont autour, les DTD, Xschema, Xpath, XSLT, XSL-FO, etc, qui servent à décrire, référencer, transformer, ou présenter les données ainsi stockées dans ledit format universel)

            Après, placer le mot « XML » entre « business-oriented global enterprise workflow for high-availability next-generation management platform » pour le arriver à faire vendre encore plus, c'est autre chose.
      • [^] # Re: Conférence sur la programmation orientée aspect et JAC, à Toulouse.

        Posté par (page perso) . Évalué à 7.

        Bon en gros, c'est le paradigme de programmation à la mode en ce moment. Pour replacer le truc, on pourrait dire "procédural -> orienté objet -> orienté aspect" ...

        En quoi ça consiste ? et bien, l'idée est que dans un programme, on structure d'une certaine façon (imagine que par exemple tu as défini un certain nombre de classes d'objets pour ton programme, qui sont donc représentés grosso-modo sous forme d'un ou de plusieurs arbres d'héritage).

        Mais en fait cette structuration "fige" ton programme dans une représentation donnée.
        C'est à dire que tu peux très bien avoir des morceaux de code, qui pourraient être structurés, mais qui ne le peuvent pas car avec la structuration que tu as choisie pour ton programme, ces bouts de codes sont disséminés à divers endroits de tes classes. Du coup, tu ne peux pas structurer ces bouts de code là -- ce qui est un peu dommage, non ?

        Tu as en fait différents "aspects" de ton programme qui sont combinés dans tes classes, et en programmation objet classique, tu n'as pas de moyens pour structurer ces "aspects". La réutilisation et la factorisation de ces aspects est donc impossible.

        La programmation par aspects te permets de les structurer et de les factoriser, et propose pour cela différentes solutions pour mixer ces aspects avec ton code. Par exemple, AspectJ, un préprocesseur pour java, propose de rajouter les aspects à des endroits que tu définis (avant l'appel à une fonction donnée, après la fonction, avant chaque écriture disque, etc.).

        L'exemple ultra-classique avec les aspects : rajouter des traces à du code. Imagine que tu veuille logger tous les accès à une variable. Tu risques de devoir te taper les modifs dans tout ton programme, et en plus, faudra virer tout ça une fois les tests finis. Plutôt chiant. Là avec les aspects, tu te crée un aspect "TraceDeMaVariable" et ton source reste clean. Le jour ou tu veux plus de cet aspect, tu le vire.
        Et encore, avec une variable, on peut encapsuler ça avec un setter/getter et donc centraliser tes traces. Mais bon cet exemple montre un peu l'intérêt des aspects je pense ... et puis, tu peux vouloir logger tous les appels d'une fonction d'un objet, ou tous les accès I/O ...
        Tu peux le faire en programmation classique, mais ça va être une plaie et surtout l'ensemble de l'aspect "trace de mon programme" sera disséminé dans tout ton programme. Alors qu'avec un aspect tout reste nickel, bien séparé.

        Il y a un excellent numéro d'ACM qui traite de tout ça (octobre 2001).

        sinon le site aosd : http://aosd.net/(...) et le site d'aspectj : http://www.eclipse.org/aspectj/(...)

        En gros la plupart des développements sur les aspects ont lieu autour de java (mais il y a quelques travaux pour C/C++, SmallTalk, etc.), et honnêtement, la programmation par aspect (AOP) est quelque chose de pas mal intéressant ... si vous êtes sur lyon, allez à cette conférence, ça doit être sympa.
        • [^] # Re: Conférence sur la programmation orientée aspect et JAC, à Toulouse.

          Posté par (page perso) . Évalué à 1.

          heu bien sûr, s/lyon/Toulouse (vais dormir un peu moi)
        • [^] # Re: Conférence sur la programmation orientée aspect et JAC, à Toulouse.

          Posté par . Évalué à 2.

          Merci beaucoup pour ton explication.

          Je n'ai pas tout compris (mais alors *vraiment* pas tout), mais j'en sais au moins un peu plus ;)

          BeOS le faisait il y a 15 ans !

        • [^] # Re: Conférence sur la programmation orientée aspect et JAC, à Toulouse.

          Posté par (page perso) . Évalué à 4.

          Bon en gros, c'est le paradigme de programmation à la mode en ce moment. Pour replacer le truc, on pourrait dire "procédural -> orienté objet -> orienté aspect" ...

          A noter qu'on peut très bien faire de l'AOP avec un language non objet. Les premières exprérience ont d'ailleurs été menées avec Lisp ( ou Scheme, je ne sais plus)
        • [^] # Re: Conférence sur la programmation orientée aspect et JAC, à Toulouse.

          Posté par . Évalué à 1.

          Euh, j'ai rien compris non plus. Est-ce que le concept d'agent que l'on trouve dans certains langages est proche ?
          • [^] # Re: Conférence sur la programmation orientée aspect et JAC, à Toulouse.

            Posté par (page perso) . Évalué à 2.

            Est-ce que le concept d'agent que l'on trouve dans certains langages est proche ?

            A priori, non... Si on parle d'agents logiciels, c'est encore autre chose ... bon après ça dépends du sens que donnent ces lanages au terme d'agent :-) (quels langages ?)

            Pour revenir sur l'AOP... Le but des méthodes de programmation comme la programmation procédurale (séparer et factoriser du code dans des procédures) ou la programmation orientée objet est d'améliorer la structuration des programmes, de façon à simplifier leur programmation, leur maintenance, et accessoirement de pouvoir factoriser du code quand c'est possible.

            La programmation par aspects propose une façon de factoriser du code qui ne pouvait pas l'être auparavant (du moins, plus difficilement), car faisant *partie* d'un code déja structuré. Reprenons l'exemple des traces. Tu as un programme qui au cours de son exécution, affiche différentes traces (printf) te permettant de savoir ou en est son fonctionnement.

            Tu n'as pas de moyen simple d'isoler cet "aspect" de ton programme dans une procédure ou un objet; que l'affichage soit fait par un printf ou une autre fonction ou objet, de toute façon tu auras du aller mettre toutes les traces "à la main" dans ton source. Problème donc, si tu veux modifier ça, il faut le faire à la main. Si tu veux modifier tes printf pour envoyer ça sur le réseau dans une socket, tu est obligé de tout modifier à la main. Eventuellement tu peux encapsuler ça dans une fonction chargée de "tracer" (envoyer à l'écran, envoyer sur le réseau, etc.), mais le problème est le même: tous tes appels sont disséminés partout.

            Avec AspectJ par exemple, il te suffit de définir un aspect "Trace" qui fera ce qui t'intéresse (par exemple, un printf), et ensuite tu indique à quel endroit de ton code cet aspect Trace va s'intégrer (par exemple, dans toutes les méthodes de la classe "Toto", avant et après chaque appel) !

            Avantage : l'aspect "Trace" de ton programme est défini à un seul endroit, tu peux alors très simplement décider d'étendre son domaine d'application comme tu le souhaites (voir le virer).

            En fait grâce à la programmation par aspects, tu isoles des parties de code qui ne pouvaient pas l'être simplement avant, ou qui pouvaient l'être mais qui nécessitaient un travail de conception préalable : encapsulation, utilisation de design patterns, etc. Hors on ne peut *pas* avoir pensé à toutes les possibilitées d'évolution et tout définir, le logiciel deviendrait bien trop énorme et difficile à programmer.

            L'autre gros intérêt de la programmation par aspect, c'est la possibilité de "composer" des morceaux de code, par exemple une équipe travaille sur un logiciel, et une deuxième équipe travaille sur un autre "aspect" qui sera ensuite composé pour former le logiciel final.

            Le langage Objective-C permets quelque chose d'un peu similaire, avec l'utilisation des categories (possibilité de rajouter des méthodes à une classe au runtime, sans même avoir besoin du code source de la classe), de la méthode poseAs: (qui permets d'insérer une classe dans un arbre d'héritage), ou l'usage des bundles (possibilité de charger à la volée du code).

            L'AOP va en général plus loin (cf AspectJ et ses définitions de "pointcuts" très élaborées), mais une chose est sure, c'est que cette approche permets une conception plutôt propre et surtout, évolutive, d'un programme.
            • [^] # Re: Conférence sur la programmation orientée aspect et JAC, à Toulouse.

              Posté par . Évalué à 1.

              Le langage dans lequel la notion d'agent est implémentée est Eiffel. La définition est l'application des concepts objet à la notion d'opération. Comme je n'en sais pas beaucoup plus, que je ne l'ai jamais utilisée, et que la possibilité de créer des mécanismes transversaux me semblait proche de la notion d'aspect que tu exposes, je venais me renseigner.
              • [^] # Re: Conférence sur la programmation orientée aspect et JAC, à Toulouse.

                Posté par (page perso) . Évalué à 1.

                bah je connais pas eiffel non plus :-)
                Il est possible qu'il intègre plus ou moins un mécanisme qui peut s'apparenter à l'AOP.
                C'est pour ça que je citais Objective-C, histoire de montrer que l'AOP existait (plus ou moins) sous d'autres formes, et que ces caractèristiques étaient appréciés. C'est souvent la même chose, un langage propose des solutions intéressantes, et quelques années après on conceptualise ça de façon plus étendue.
    • [^] # Re: Conférence sur la programmation orientée aspect et JAC, à Toulouse.

      Posté par . Évalué à 3.

      Le regretté DevReference avait sorti quelques articles sur le sujet. Ils ont eu la bonne idée de laisser les anciens numéros en libre accès. http://www.weblmi.com/devreference
    • [^] # Re: Conférence sur la programmation orientée aspect et JAC, à Toulouse.

      Posté par (page perso) . Évalué à 1.

      Une version pdf d'un article paru sur DevReference sur le site de JAC: http://www.aopsys.com/devrefv210p11-13.pdf(...)

      Il y a aussi quelques trucs en français dans la section doc: http://jac.aopsys.com/documentation.html(...)
    • [^] # Re: Conférence sur la programmation orientée aspect et JAC, à Toulouse.

      Posté par . Évalué à 4.

      La POA ça sert a ajouter des traces a un programme.

      Mmm, ça ne sert pas qu'à ça? Pourtant c'est le seul exemple utile que j'ai jamais vu!

      Quelqu'un aurait-il d'autres exemples utiles?
      • [^] # Re: Conférence sur la programmation orientée aspect et JAC, à Toulouse.

        Posté par (page perso) . Évalué à 6.

        Non ça ne sert pas qu'à ça, c'est juste l'exemple type, qui montre bien le problème que résouds la POA. Tu peux imaginer bien d'autres types d'utilisations (consulte les liens sur JAC de la news), par exemple rajouter un aspect "distribué" à ton application, etc.

        Prenons un autre exemple : imaginons que tu programmes un soft de gestion du personnel. Tu en fait une belle modélisation orienté objet : tu organises ça en classes (genre une classe manager, une classe employé, etc.) et ta préoccupation est ainsi de modéliser les informations et les liens entre les personnes de la boite. Ton modèle peut servir également pour stocker les infos concernant les salaires. Il peut aussi servir à définir et garantir certaines règles de gestion, comme "un employé doit avoir au moins un manager", ou "le salaire doit être supérieur ou égal au smic".

        En fait, si tu réfléchis en terme d'aspects, ton modèle mixe un aspect "'stockage' du personnel" avec un aspect "organisation du personnel", ainsi qu'un aspect "comptabilité" et un aspect "règles de gestion". La modélisation objet capture l'aspect "données" ('stockage' du personnel), mais ne capture pas de façon pratique les autres aspects. Avec l'AOP tu peux exprimer ces différents aspects de façon claire, et définir la façon dont ils doivent se combiner pour former ton programme final.

        Si on pousse plus loin, on peut imaginer recombiner complètement les différents aspects d'un programme de façon à coller avec l'orientation voulue à un moment. En effet, on modifie très souvent un programme au cours de sa "vie" car les besoins évoluent, et le design de départ ne colle plus forcèment avec ce qui est attendu à un moment donné; non pas que le design de départ soit forcèment mauvais, mais il ne réponds plus exactement à ce qui est finalement demandé. Si le design de base est vraiment trop éloigné, on finit généralement par réécrire complètement le soft. Et bien, l'AOP peut être une réponse à ce genre de problèmatique, en autorisant la recombinaison des différents aspects.

        A ce sujet, on peut consulter le projet Hyper/J, qui traite de la séparation des préoccupations ("Separation of concerns") de façon multi-dimensionnelle, et qui personnellement me parait une approche particulièrement intéressante de l'AOP (le projet semble un peu au point mort malheureusement) :

        http://www.research.ibm.com/hyperspace/HyperJ/HyperJ.htm(...)

        http://www.alphaworks.ibm.com/tech/hyperj(...)
      • [^] # Re: Conférence sur la programmation orientée aspect et JAC, à Toulouse.

        Posté par (page perso) . Évalué à 4.

        As-tu été voir le lien "Les aspects disponibles dans JAC" ?

        JAC, en plus du classique aspect de trace, tu trouveras des aspects pour:
        • la persistence
        • l'IHM (génération d'évènement pour que les vues soient mises à jour lors de la modification d'un attribut)
        • la distribution
        • l'authentification
        • la gestion des droits d'accès
        • La confirmation ("êtes-vous vraiment sûr de vouloir effacer le répertoire $HOME ?)
        • Le cache

  • # Re: Conférence sur la programmation orientée aspect et JAC, à Toulouse.

    Posté par (page perso) . Évalué à 1.

    Jusqu'à preuve du contraire, le site de Java Aspect Components n'est pas en espagnol mais en anglais...
  • # Je commence à comprendre :)

    Posté par . Évalué à 5.

    Après avoir farfouillé longuement avec Google, j'ai fini par tomber sur un pdf en anglais de 16 pages qui m'a enfin permis de comprendre de quoi il s'agissait :

    http://www.cs.ust.hk/~scc/comp610e/assignment/reading04.pdf(...)

    Bonne lecture ! Ça semble finalement un concept porteur et prometteur (je commencais à croire que c'était du pur marketing cette chose)

    Sinon, si vous voulez vous lancer dans la recherche de doc, ce principe de programmation semble être connu sous deux noms :
    - Aspect-Oriented Programming (AOP)
    - Aspect Oriented Software Development (AOSD)
  • # XDoclet ?

    Posté par . Évalué à 2.

    Bonjour à tous,

    Je ne sais pas très bien ce qu'est la POA mais ne serait ce pas ce que fait XDoclet ?

    Xdoclet eest un outil que j'utilise et que j'adore:) ferais je de la POA sans le savoir ? :D

    a+

    http://about.me/straumat

    • [^] # Re: XDoclet ?

      Posté par (page perso) . Évalué à 2.

      XDoclet, c'est un peu de la POA "light", au sens où il te permet effectivement de gérer plus facilement certains aspects de ton code (par le biais de sa syntaxe déclarative). Cependant, à mon sens, l'intérêt futur le plus important de l' AOP, c'est de pouvoir changer l'aspect utilisé durant le fonctionnement du programme, c'est-à-dire par exemple faire évoluer dynamiquement les règles de sécurité d'un programme.
      • [^] # Re: XDoclet ?

        Posté par . Évalué à 1.

        D'après ce que j'ai lu, c ce que XDcolet va essayer de faire dans le futur.... donc je fais quand même un peu de AOP :) Cool !

        http://about.me/straumat

  • # Re: Conférence sur la programmation orientée aspect et JAC, à Toulouse.

    Posté par . Évalué à 2.

    Quand on mélange la programmation orientée objet avec la programmation orientée aspect on obtient la programmation orientée abject.

Suivre le flux des commentaires

Note : les commentaires appartiennent à ceux qui les ont postés. Nous n'en sommes pas responsables.