Bon petit topo sur les Frameworks AJAX
 
+1 pour Chaos Inte stinal
 
Les infos de Pros à Bottom line viennet de l'article, On m'avais dis quelles avaient été trouvé  sur infoworld
 mais javais pas eu le lien... :  
 
http://www.infoworld.com/pdf/speci [...] SRajax.pdf
 
Le reste vient de mes recherches pour mon sujet...
 
Pour The-Shadow...désolé c'est en langue pas français
 
Je fais plutot un topik spécial ??
 
I  Dojo
       *link : http://dojotoolkit.org/
       *Pros :  
              * Broad collection of flashy and sophisticated widgets
              * Hierarchical package system speeds loading
              * Corporate support from IBM, Sun, Other
       *Cons :  
              * Spotty documentation with large holes
       *Bottom line :  
              *Dojo hass an excellent editing package, a wide selection of animating boxes, some drag-and-drop tools and a slew of customizable widgets. It's a broad and well-packaged open source AJAX project with many features that are often, but not always documented.
       *License : Academic, Free License and BSD license
       *Documentation Quality :  
              * http://dojotoolkit.org/api/
              * A lot of examples, with all the documentation and a API very easy to use in JavaDoc format.
              * note 9/10
       *Community size - reactivity :  
              *The don't have a specific place for developer, but it's easy to find the information about your questions. But it's could be a problem, for advanced project.
              * Apreciation: -
       *Ease of use :  
              * Just need to find the good classes.
              * And prgamming in JS
              * 9/10
       *Ease of extend :  
              * Specificaly function to easy implements new Widgets. Facility of re-use.
              * 8/10
       *Accessibility 508 :  
              * All the informations about Accessibility in Dojo : Accessbiility section
              ** http://manual.dojotoolkit.org/Wiki [...] ook/Book97
              * Apreciation: ++
       *Blocking points :  
       *Skinability :  
              * They have a system of templates for their widgets, so you just need to implement CSS in the right file.
       *Browser Compatibility :  
              * Grade : A
              * IE 5.5+
              * FF 1.0+
              * Latest Safari (on up-to-date OS versions)
              * Latest Opera
              * Latest Konqueror
       *Misc. Notes :  
              *1st Place (WINNER)
              * Notes: 50/60
              * Apreciations: A & ++ / -
 
II  Google web Toolkit (GWT)
       *link : http://code.google.com/webtoolkit/
       *Pros :  
              * Fasinating translation mechamism makes integration with Java simple
              * Includes a wide collection of basic widgets
              * Builds a full Swing-style application in Java that runs in JavaScript
       *Cons :  
              * Working in Java makes it complicated to integrate with other JavaScript apps
       *Bottom line :  
              *Google's AJAX toolkit is an amazing tool for turning Swing like Java code into a web application that runs in JavaScript alone. The Java/JavaScript translation may cause some integration concerns for developpers, but the Google system is surprisingly easy to use.
       *License : Java librairies under the Apache license 2.0
       *Documentation Quality :  
              * http://code.google.com/webtoolkit/documentation/
              * A very good documentation, with a lot of clear examples. API very good same like JavaDoc.  
              * note 9.5/10
       *Community size - reactivity :  
              *I found all the informations I ask about the GWT easily.
              * they have created a forum for the developer : http://groups.google.com/group/Google-Web-Toolkit Google groups.
              * and a blog to see the advance of project : http://googlewebtoolkit.blogspot.com/ Blog.
              * Apreciation: +
       *Ease of use :  
              * Execute few command, to create the projet and than simply write Java Code
              * 9/10
       *Ease of extend :  
              * Create your own classes and re-use them.
              * 8/10
       *Accessibility 508 :  
              * Google does not evoke any information on this law in their site, but we can maybe have a beginning of answer here :Accessbiility section
       *Blocking points :  
              *Integration of 3rd party libraries ?
       *Skinability :  
              * Easy to implements
              * http://code.google.com/webtoolkit/ [...] heets.html StyleSheets
       *Browser Compatibility :  
              * Grade : A-
              * Browser compatible : Your GWT applications automatically support IE, Firefox, Mozilla, Safari, and Opera with no browser detection or special-casing within your code in most cases.
       *Misc. Notes :  
              *3rd Place
              * Notes: 52.5/60
              * Apreciations: A & + /
 
 
III  Open Rico - Prototype
       *link : http://openrico.org/ - http://prototype.conio.net/
       *Pros :  
              * Clean, crisp code
              * Many sophisticated widgets with true AJAX integration
       *Cons :  
              * No package management
       *Bottom line :  
              *Rico and Prototype share more of an emphasis on animated effects and less on some of the pragmatic tools. The Prototype library is a set of basic low level tools aimed at programmers. Rico is a collection of some of the most popular widgets and animation built atop Prototype.
       *License : Open rico : Apache license 2.0, Prototype under MIT License
       *Documentation Quality :  
              * http://www.sergiopereira.com/artic [...] pe.js.html
              * http://ajax.phpmagazine.net/upload [...] pe1280.png
              * http://openrico.org/rico/docs.page
              * Good doc for prototype, but no documentation for rico, neither package at this time, only few tutorial. There's a forum but not very active, and there's some cool example.
              * notes (Rico) : 4/10
              * notes (Prototype) : 8/10
       *Community size - reactivity :  
              *Prototype seems to be the most used framework on the net. There's a many unofficial documentation, much more better than the original, demo, tutorial, forum, and the community seems very big.
              * Apreciation: ++ (for Prototype)
       *Ease of use :  
              * Notes : 8/10  
              * Prototype is the easiest way to build simple Ajax page. the syntax is clear and intuitive, the event mechanism is very impressive, and the ajax exchange seems good.
       *Ease of extend :  
              * Notes : 8/10
              * It's very easy to implement our own widget in Prototype thanks to their extension of the Class object (Class.create), which means that the source code of Rico is perfectly readable and understandable. However, it demands a strong base in javascript do be use at his full potential.
       *Accessibility 508 : -
       *Blocking points :  
       *Skinability :  
       *Browser Compatibility :  
              * Grade : B
              * Safari 2.0 : Drag and drop not supported
              * Opera 9 : Display anomaly in the first motion effects demo and the Ajax Weather widget demo fails.  
       *Misc. Notes :  
              *2nd Place
              * Notes: 49/60
              * Apreciations: B & ++ / -
 
 
IV  Yahoo UI Ajax library
       *link : http://developer.yahoo.com/yui/
       *Pros :  
              * Wonderful documentation concentration on example code and design
              * Tools have interface that's easier for beginning programmers and HTML designers to understand
              * Sophisticated animation
       *Cons :  
              * Lack of larger widgets, such as an editor or a live table
       *Bottom line :  
              *Yahoo's AJAX toolkit is a well documented collection of tools and widgets that handle many of the simpler tasks. It has many of the standard tools, such as an animation library and a tree collection, but few of the bigger more substantial tools such as an editor or a live table.
       *License : BSD license
       *Documentation Quality :  
              * http://developer.yahoo.com/yui/docs/index.html
              * Good documentation, who explain all the important points of each widget.<p style="text-decoration:line-through"> But the API is not easy to used. You can't have a global view of them</p> new one available since few days.
              * notes :
              ** 8/10
       *Community size - reactivity :  
              *Like Google they have :
              * a forum for developer : http://tech.groups.yahoo.com/group/ydn-javascript/  
              * a blog http://yuiblog.com/  
              *And many people are using this Framework.
              * Ne pas oublier anapajari    
              * Apreciation: +
       *Ease of use :  
              * Notes : 8/10  
              * Need good knowledge in Javascript
       *Ease of extend :  
              * Notes : 8/10
              * Create a new namespace, and implement en javascript. Facility of re-use. But you need strong base in javascript.
       *Accessibility 508 : -
       *Blocking points : -
       *Skinability :  
              * They have some predefined css style like :
              ** http://developer.yahoo.com/yui/reset/
              ** http://developer.yahoo.com/yui/grids/
              * And you can easily create you own stylesheet in code
       *Browser Compatibility :  
       *Misc. Notes :  
              *5th Place
 
 
V  Zimbra Kabuki Ajax toolkit
       *link : http://www.zimbra.com/community/ka [...] nload.html
       *Pros :  
              * Crisp efficient widgets and clean examples
              * Complete sources code to a large office application is also available
       *Cons :  
              * No simple package management system
              * Documentation is shorter than ideal
       *Bottom line :  
              *A basic collection of some of the more crutial tools for building client-based applications. Zimbra's Kabuki doesn't have the sophisticated animations of some of the other AJAX toolkits in this evaluation, but it does have an excellent editor and nice tree package.
       *License : MPL License and Apache License
       *Documentation Quality :  
              * http://www.zimbra.com/pdf/Zimbra%2 [...] epaper.pdf
              * A correct documentation (a bit small), who presents a list of each pre-build widget and event, but neither an API, nor a list of function are available. You need to take a look at the examples and demos (rather exhaustive and commented) if you want to learn this framework.
              * notes : 5/10
       *Community size - reactivity :  
              *There is absolutely no comunity for this framework. The part of AjaxTK in the forum of Zimbra has only two post. In one of them, we can read an answer by a developper for a user asking about the development of this framework : "We've been super busy working on the Zimbra suite and maintaining the examples has fallen to the side. We hope to have this up and working again in the future".
              * Apreciation: -
       *Ease of use :  
              * Notes : 7/10
              * Like AWT or SWT, but small API (only a pdf with the list of the different class)
       *Ease of extend :  
              * Notes : 6/10
              * the lack of documentation makes the extension difficult. We need constantly to take a look at the pre-built widget to "try to guess" the meaning of several functions. However the event model is quite simply to use.
       *Accessibility 508 : -
       *Blocking points : -
       *Skinability : -
       *Browser Compatibility :  
       *Misc. Notes :  
              *5th Place
 
 
VI  ZK
       *link : http://www.zkoss.org/
       *Pros :  
              *NA
       *Cons :  
              *NA
       *Bottom line :  
              *NA
       *License : GPL License or commercial
       *Documentation Quality :  
              * http://www.zkoss.org/javadoc/
              * A Very Good documentation, with a real true developer guide (around 200 pages, full of examples) and an API in javadoc format. There are plenty of demos with an efficient menu to choose them.
              * notes : 9/10
       *Community size - reactivity :  
              *ZK is a quite new framework. the original use of ZUML and AJAX brings the interest of many user. There's lot of tutorial growing on the net, and  
this framework was the top ranking on the Ajax related project on sourceforge. His community keeps on growing.
              * Apreciation: +
       *Ease of use :  
              * Notes : 8/10
              * Overall the framework is a joy to use. The ZUML makes it easy to do quick iterations -- edit, test, edit, etc. -- without a long compilation step.
       *Ease of extend :  
              * Notes : 7/10
              * There's two way to implement our own component. The easiest is a macro by using the other component. The other, and the more interesting and flexible, is to implement a class deriving from the AbstractComponent. This method seems to be explained in the Component Development Guide, but it's not yet available on their website. With this complement the note will be around 9.
       *Accessibility 508 :  
              * http://sourceforge.net/forum/messa [...] id=3848173
              * Some way to implements the section 508 compliance on the forum, but no futurework in the development of this framework.
       *Blocking points :  
              * GPL license ?
              * Bad browser compatibility
       *Skinability :  
              * http://zk1.sourceforge.net/smallta [...] k-css.html
       *Browser Compatibility :  
              * Grade : D+
              * IE 6 : The tab boxes drew themselves painfully slowly
              * Safari 2.0 : %u201Cunsupported browser%u201D message
              * Opera 9 : javascript error message
       *Misc. Notes :  
              * 3rd Place
              * Notes: 48/60
              * Apreciations: D & + /
 

 
On été plusieurs à donner des notes, ...ceci est le résultat dune moyenne...Et YUI n'avait pas l'air dêtre le poulain de la boite  
Même si j'ai tenté moi d'être le plus objectif possible...
 
Enfin au final, c'est pas la doc, qui a eu le plus de poid dans le choix final.  

je plussoie allegrement Masklinn, surtout que dans les cons tu mets:

Bon et puis c'est un peu nawak parce que tu compares des frameworks et des toolkits, alors que clairement ça n'a rien a voir.
 
Mais bon pour le reste je suis assez d'accord avec ce qui est dit...

Et si je puis me permettre je ne vois pas comment des mecs qui ne connaissant pas correctement le JS peuvent donner des notes sur un framework et/ou un toolkit

 
Comme dis les cons, viennent directement de l'article donné plus haut.
 

 
Merci gatsu, pour cette bonne claque dans ma gueule.
Mais ouais je suis en rien du tout pro du JS...Peut être que ce sera mieux dans 2-3mois.
Mais il faut donc voir, les notes en fonction de notre approche. Et donc, pour faire mes tests: Hello world, etc..Faut pas être un dieu du JS pour y arriver, et voir ce que ces différents outils te donne comme soluce pour t'aider à le faire.
 
Alors je répéte, ces résultats sont intéressants, surtout pour avoir une vue global de ce qui existe, et des avancements de chacun.
Certain, n'ont aucune utilité de savoir si c'est facile ou pas à implémenter, mais ils veulent savoir si ça génére du code accessible, ou savoir si niveau lincence, ils vont pouvoir s'y retrouver..etc.
 
Gatsu: moi aussi je t'aime  

Je ne parlais pas pour toi, mais pour tes collegues

Et tu trouves pas étrange qu'en te basant sur cette article tu arrives à des conclusions différentes?

[My point of view] tous les toolkits js que tu evoques ont certes leurs avantages et leurs inconvénients, mais ils ne sont pas inutilisables "directement" dans un projet. Tu vas forcément avoir besoin de modifier tel ou tel widget, en créer un nouveau qui hérite de plusieurs, ce genre de chose.
Dans ce type d'utilisation tu verras sans doute que tes "conclusions" seront quelques peu modifiées.
Par exemple sur le point de la doc tu mets en avant Dojo sur YUI. C'est entièrement vrai pour la doc utilisateur "bateau" genre comment créer une fenetre drag&droppable. Maintenant le jour ou tu auras besoin de créer ta classe fenêtre qui hérite de celle-ci tu verras que la doc "technique" de Yahoo est, AMHA, bien plus claire et complète.
En gros à un moment pour YUI tu écris:

Pour moi c'est obligatoire pour tous ces toolkits, sinon tu pourras jamais faire ce que tu veux. Uniquement rajouter des trucs qui pouetent et qui clignottent sur ton projet.
[/My point of view]

L'article ayant 4 mois, non ça me dérange pas trop...Mais j'aurais pu changer les données, il est vrai...
 
Car a noté, l'effervescence qui tourne autour de ces outils...
En 3 semaines de tests, jai eu le droit à :
_une nouvelle version de Dojo.
_Pour google la mise à disponibilité de son toolkit pour les maceux...ce qui m'a bien aidé
_Pour Yahoo UI, une refonte de leurs docs, surtout pour les classes...
 
Donc ça bouge, ça bouge, des données, émissent ici seront très vite faussé.
 
Après je suis d'accord avec toi au niveau docs :
Là encore, j'ai noté avec mon utilisation première...mon avis changera peut être avec le temps
 
Mais j'ai quand même souligné pour Dojo :

 
Donc, ça a aussi été pris en compte.
 
Mais bon, je table sur le fait que lorsque que j'arriverais à une structure plus avancée du projet...Mon niveau me permettra d'être plus à l'aise...
Après rentrerons en jeu, les méthodes de travail, qui sont elles indépendante du langage...
 
Voilà
Te passerais le bonjour anapajari si j'ai un souci    
 
Donc voilà ce qu'il faut garder à l'esprit...Je pense que ce domaine, n'est pas encore à la fin de son évolution, pleins de choses sont encore à faire. Donc patience....

s'pas un toolkit GWT

et pour continuer sur le sujet tu veux pas nous faire un comparatif des IDE
genre Aptana VS Eclipse ATF steup

Ben là moi j'ai installé que Eclipse ATF

Et m'en fou que GWT soit pas un toolkit, car au final, il génére une appli AJAX... ...Mais ferait attention aux mots

Bon j'ai un petit souci.
 
Je sais pas si c'est un truc général à tout ce qui est génération de code, par Javascript.
 
Bon j'ai une fonction qui exécute un évènement.
Et selon certains état, je construit un nouveau élément dans mon DOM avec la même consistance, que l'élément cliqué précédemment, en changeant, l'id bien sur.
 
Mais après je souhaite binder, cet élément avec le même évènement.
Et c'est là qu'il à du mal à me trouvé cet objet....
 
ex:
 

 
en faisant un alert du bouzin
 
j'ai :

 
Mais quand j'ai fait ma moulinette, et que j'ai généré derrière la même chose.
 
ben j'obtient undefined...
 
Alors pourquoi, parce que les attributs que je génére garde pas la case...
Parce qu'il sait pas chercher dans la partie généré du code JS...
 
Je sais pas..Merci

problème de portée de ta variable button à mon avis. Celle-ci n'est connu que dans la fonction init et tu dois chercher à y accèder en dehors!

Je pense pas, bon reprenons le coup de la fonction init, c'est un exemple

Donc dissons on charge la page, le code précédent s'execute, okay.

Now, en cliquand sur le button , jaffiche Hello world...Puis là je crée un button :

Puis juste après :

je fais :

Okay, il me dis c'est un object button

Me dis undefined...

alors sais pas! connais pas dojo et donc le fonctionnement de la méthode byId

Pas de souci, j'ai enfin trouvé
 
http://manual.dojotoolkit.org/WikiHome/DojoDotBook
 
C'est pas mal quand même, niveau doc..Faut juste bien chercher
 
Merci
 
Et donc soluce...Faut (pour mon exemple créer juste avant):