[OpenAjaxIDE] Bootstrapping

Jon Ferraiolo jferrai at us.ibm.com
Wed Oct 24 05:42:14 PDT 2007


I'm glad everyone is contributing to this discussion!

One thing I will point out is that the reason why I proposed standard names
such as OpenAjaxWidget.xml is because the IDE could auto-discover all of
the widgets by looking for all files that had exactly that name without
requiring a central manifest that lists all of the metadata files.
Therefore, I believe an early decision is whether there must be a central
manifest that points to the other metadata files or whether we do without
the manifest file and have the IDE discover the metadata files by some
other means, such as file naming convention. (I chose the file naming
convention because that appears to be how jMaki works, where it looks for
./resources/<toolkit>/<widgetname>/widget.json.

I'll point out that if we have a manifest file that points to the other
metadata files, then we will already have two different XML grammars (i.e.,
the manifest grammar and the metadata grammar). I think multiple XML file
formats for different purposes is inevitable.

Jon



                                                                           
             Jonathan                                                      
             Bond-Caron                                                    
             <jbondc at gdesoluti                                          To 
             ons.com>                  ide at openajax.org                    
             Sent by:                                                   cc 
             ide-bounces at opena                                             
             jax.org                                               Subject 
                                       Re: [OpenAjaxIDE] Bootstrapping     
                                                                           
             10/24/2007 05:05                                              
             AM                                                            
                                                                           
                                                                           
             Please respond to                                             
             jbondc at gdesolutio                                             
                  ns.com                                                   
                                                                           
                                                                           




I agree with all points though I'm also uneasy about the naming.

As a convention, something like the following could be interesting:
Ms:
OpenAjaxLib.xml    -> ms.library.xml
OpenAjaxWidget.xml -> ms.toolkit.PasswordStrength.xml
OpenAjaxAPI.xml    -> ms.toolkit.PasswordStrength.api.xml OR?
ms.toolkit.PasswordStrength.doc.xml

Spry:
OpenAjaxLib.xml    -> spry.library.xml
OpenAjaxWidget.xml -> spry.widgets.Tooltip.xml
OpenAjaxAPI.xml    -> spry.widgets.Tooltip.api.xml OR?
spry.widgets.Tooltip.doc.xml

...

I was happily surprised by the w3c widgets draft and how they plan to deal
with widget 'resources':
http://www.w3.org/TR/widgets/#widget0

Somewhere along these line, it would be nice to allow automatic discovery
by reading the library’s xml or unpacking a container and
discovering new required resources.

i.e.         Based on ooa registry?
<resource Id="YAHOO" type="library" uri="file://YAHOO/YAHOO.library.xml" />
                <resource Id="Spry" type="library" uri="
file://Spry/Spry.library.xml" />
<resource Id="ms" type="library" uri="http://somewhere/ms.library.zip" />


      From: ide-bounces at openajax.org [mailto:ide-bounces at openajax.org] On
      Behalf Of Rich Thompson
      Sent: October 23, 2007 4:54 PM
      To: ide at openajax.org
      Subject: Re: [OpenAjaxIDE] Bootstrapping


      I too would prefer to not start by doing separations where we do not
      have well developed reasons for the distinctions. It is likely some
      such distinctions will arise as we move forward and that seems like
      the appropriate time to separate the information.

      I also wonder about an approach that seems to be focused on a
      downloaded directory structure. In particular I'm concerned about how
      it maps to a web widget model. What about more of a URI approach
      where "discovering" the widget/component/library means one has been
      handed a defined set of metadata. This could be by ingesting the
      response from a URI or by reading a file. If it makes sense to
      partition the metadata, this top level set can point to other
      metadata (and thereby also support deferred loading of unused
      information ...).

      Rich Thompson




                                                                           
       From:            Bertrand Le Roy <Bertrand.Le.Roy at microsoft.com>    
                                                                           
       To:              Jon Ferraiolo/Menlo Park/IBM at IBMUS                 
                                                                           
       Cc:              "ide at openajax.org" <ide at openajax.org>              
                                                                           
       Date:            10/23/2007 04:35 PM                                
                                                                           
       Subject:         Re: [OpenAjaxIDE] Bootstrapping                    
                                                                           







      Well, it’s also still not clear to me why we need different formats
      for lib, api and widgets. What’s the difference between lib and api?

      From: Jon Ferraiolo [mailto:jferrai at us.ibm.com]
      Sent: Tuesday, October 23, 2007 1:27 PM
      To: Bertrand Le Roy
      Cc: ide at openajax.org
      Subject: RE: [OpenAjaxIDE] Bootstrapping



      Bertand,
      Does your response mean that everything else in my email is good? I
      assume that the answer is no, and that your response represents only
      the subset of things you could think of at the moment. In any case,
      it would be good if you and others could respond with what parts
      sounded good and which ones didn't.

      Thanks.
      Jon


      Inactive hide details for Bertrand Le Roy
      <Bertrand.Le.Roy at microsoft.com>Bertrand Le Roy <
      Bertrand.Le.Roy at microsoft.com>


                                                                           
       Bertrand Le Roy <                                                   
       Bertrand.Le.Roy at microsof                                            
       t.com>                                                              
                                                                           
                                                                           
       10/23/2007 01:18 PM                                                 
                                                                           
                                                                        To 
                                                                           
                                       Jon Ferraiolo/Menlo Park/IBM at IBMUS, 
                                       "ide at openajax.org" <                
                                       ide at openajax.org>                   
                                                                           
                                                                        cc 
                                                                           
                                                                           
                                                                   Subject 
                                                                           
                                       RE: [OpenAjaxIDE] Bootstrapping     
                                                                           
                                                                           
                                                                           
                                                                           
                                                                           
                                                                           
                                                                           
                                                                           
                                                                           
                                                                           
                                                                           
                                                                           
                                                                           
                                                                           





      A few points:
      · I’m a little uneasy about having the name OpenAjax (or even
      something generic such as metadata) as the file name because if the
      file gets separated from the library or gets out of the folder, you
      can’t guess what’s in there without opening it. I’d prefer a
      convention that is a variation of the library’s file name. i.e.
      prototype.js -> prototype.metadata.xml
      · We shouldn’t force people to put different libraries in different
      folders if they don’t want to.
      · The file should be discoverable from the directory where the file
      sits as well as from some central directory on the file system that’s
      determined by the IDE itself. This enables web authors to not have
      the metadata file pollute the web site if they don’t want it there.

      From: ide-bounces at openajax.org [mailto:ide-bounces at openajax.org] On
      Behalf Of Jon Ferraiolo
      Sent: Tuesday, October 23, 2007 12:52 PM
      To: ide at openajax.org
      Subject: [OpenAjaxIDE] Bootstrapping


      (I'm only sending this to ide at openajax.org because this is mostly
      centered on IDE workflows, not mashup workflows, although this
      proposal does attempt to address some of the expected requirements
      from the Gadgets TF)

      We have looked at various grammars (XML, JSON and JSDoc) for
      representing library metadata (APIs and widgets). At our last phone
      call, there was a sense that we would be able to take the best
      features from each of the proposals such that we could define a
      unified XML grammar that might address all of our requirements. This
      is all good.

      My question today is how does it all get bootstrapped (i.e.,
      discovered, loaded, initialized)? Let's assume we have an IDE and two
      Ajax libaries, "A" and "B". How does the IDE discover A and B, make
      them available to the IDE, and how does it find (or possibly
      auto-generate) the XML metadata files that describe the APIs and
      widgets?

      Here is one approach that might work:

      1) An Ajax library is assumed to have a root folder, and everything
      needed by the library descends from that root folder. It is assumed
      that the IDE "discovers" a given library either because the library
      ships with the IDE or the library can be imported into the IDE
      somehow (post-installation), and the key thing that the IDE needs to
      know is the name of the root folder for the library.

      2) To bootstrap library metadata, a file named OpenAjaxLib.xml file
      SHOULD exist in the root folder. This file provides overall metadata
      about the library (e.g., version#). But note the word "SHOULD". It is
      OK if OpenAjaxLib.xml is separate from the library, in which case the
      IDE will need to collect the metadata some other way, such as prompt
      the user provide the location of the OpenAjaxLib.xml file.

      3) API metadata and widget metadata can be scattered around the
      directory structure. Assume that the IDE will recursively search
      through directories to find those files. No need for a master
      manifest file, which is difficult to keep up to date. We simply have
      to come up with a standard filename for the metadata files, such as
      OpenAjaxAPI.xml and OpenAjaxWidget.xml. (Note: we might provide an
      optimization feature in OpenAjaxLib.xml where explicit search paths
      could be defined and the toolkit developer can choose different names
      than OpenAjaxAPI.xml and OpenAjaxWidget.xml)

      4) We make sure that OpenAjaxAPI.xml can be generated dynamically by
      the IDE through a just-in-time transformation (e.g., transforming
      MS's inline XML annotations into OpenAjaxAPI.xml or transforming
      JSDoc inline annotations into OpenAjaxAPI.xml)

      5) We attempt to define the format for OpenAjaxWidget.xml such that:
      a) it can be used to serve all common definitions for "widget"
      (WUI=UI controls, WMASH=Mashup widgets, WDASH=Installable desktop
      gadgets such as Dashboard)
      b) we make sure there are lossless transformations to/from selected
      existing WMASH and WDASH widgets formats (e.g., Apple Dashboard,
      Google Universal Gadgets)

      6) Allow OpenAjaxWidget.xml to include API definitions that apply to
      the given widget. Therefore, inside of OpenAjaxWidget.xml there might
      be tags from OpenAjaxAPI.xml.

      Relationship to the proposals from Adobe, Aptana, and MS, plus also
      jMaki:

      a) OpenAjaxWidget.xml should be largely analogous to jMaki's
      widget.json file, but needs to (roughly) support the union of
      features from Adobe's proposals and IBM's proposal to the Gadget's
      TF, plus offer an extensibility approach such that a rich UI system
      like dijit could embrace this format down the road. (Not saying that
      dijit should do this, but the format should allow this as a future
      possibility.)

      b) OpenAjaxAPI.xml should be extensible in a manner that address's MS
      needs for supporting other languages. (As we discussed at the last
      phone call.)

      c) Under the extensibility veneer per (b), the description of
      JavaScript APIs probably should look a lot like Aptana's markup
      language

      Bottom line, my thinking today is that we need 3 different formats,
      OpenAjaxLib.xml, OpenAjaxAPI.xml and OpenAjaxWidget.xml.



      _______________________________________________
      IDE mailing list
      IDE at openajax.org
      http://openajax.org/mailman/listinfo/ide
      _______________________________________________
      IDE mailing list
      IDE at openajax.org
      http://openajax.org/mailman/listinfo/ide


-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://openajax.org/pipermail/ide/attachments/20071024/c2b6ff3a/attachment-0001.html 
-------------- next part --------------
A non-text attachment was scrubbed...
Name: graycol.gif
Type: image/gif
Size: 105 bytes
Desc: not available
Url : http://openajax.org/pipermail/ide/attachments/20071024/c2b6ff3a/attachment-0004.gif 
-------------- next part --------------
A non-text attachment was scrubbed...
Name: pic18043.gif
Type: image/gif
Size: 1255 bytes
Desc: not available
Url : http://openajax.org/pipermail/ide/attachments/20071024/c2b6ff3a/attachment-0005.gif 
-------------- next part --------------
A non-text attachment was scrubbed...
Name: ecblank.gif
Type: image/gif
Size: 45 bytes
Desc: not available
Url : http://openajax.org/pipermail/ide/attachments/20071024/c2b6ff3a/attachment-0006.gif 
-------------- next part --------------
A non-text attachment was scrubbed...
Name: 26546366.gif
Type: image/gif
Size: 105 bytes
Desc: not available
Url : http://openajax.org/pipermail/ide/attachments/20071024/c2b6ff3a/attachment-0007.gif 


More information about the IDE mailing list