I have launched the XUL News Wire also known as the xul-announce mailing list to help promote all things XUL and create an independent XUL news source.

I invite you to send in your XUL news or to announce your XUL motor, browser, app, book, article or whatever you can dream up to the galaxy by posting a blurb (that is, a brief description) along with the web address (URL), for example, to the xul-announce mailing list.

For a start I will profile new XUL motors/browsers/apps here in the Richmond Post and add interesting XUL links to the Richmond Post Link-opida. I am sure others will also pick up your news and announcements and will help to fuel the XUL revolution and promote your app, motor, article or whatever. Let the good time roll.

You can read up on XUL news by browsing the archive @ http://news.gmane.org/thread.php?group=gmane.comp.lang.xul.announce or @ http://sourceforge.net/mailarchive/forum.php?forum=xul-announce or catch breaking news live from the wire by subscribing @ http://lists.sourceforge.net/lists/listinfo/xul-announce

I (Gerald Bauer) invite you to send your XUL news straight to the XUL News Wire also known as the xul-announce mailing list online @ http://lists.sourceforge.net/lists/listinfo/xul-announce

You are more than welcome to announce your XUL app, article, tutorial, toolkit or whatever goody you dreamed up to the universe by sending a blurb (that is, a brief description) along with the web address (URL) to the xul-announce mailing list.

If you want to stay anonymous or if you want stay away from the mailing list for whatever reason you can send your news tips to my private email, that is, gerald@vamphq.com. However, before you fire off an email to gerald@vamphq.com, please read the rules below; otherwise your email might end up unread in my trash.

Use plain text only. Please avoid sending HTML or "Stylelized" email as my mail reader cannot handle it and your message body will end up in an attachment. Please read on.

No attachments. Unfortunately my inbox gets swamped with junk mail daily using fake addresses and subject lines. I only can protect myself from viruses and unwelcome multimedia tutti-frutti by automatically deleting all emails infected with attachments as soon as the hit my inbox.

Use descriptive subject lines. Fast-track your mail using a nospam marker. The more detail you can squeeze into the fewest words in the subject line, the better. Avoid generic lines such as "Your Website" or teasers such as "Apache Foundation". Fast-track your mail by starting your subject line with the word "[Richmond]" marking it as nospam.

Christian Holm, Mike Kruger (SharpDevelop Project Lead) and Bernhard Spuida write in chapter 2 "Designing the Architecture" in the hot-off-the-press dev book titled "Dissecting A C# Application: Inside SharpDevelop":

Another important decision was to use XML for every data file, and to move as much data from the code to XML as possible. [...]

XML helps us in cleaning up code; often the code is bloated with information that could be easily stored in a separate file. In this code many properties are being set, and objects are created without doing anything with them. [...]

A good example is the GUI code where buttons, forms, group boxes, and other controls are defined. Each of these has properties assigned to it, information on where it is, which label it has, and other details. This code doesn't really add functionality to a program. It just defines the way something looks. XML is a good way to collect all this data in a file. So we began to use XML to reduce the actual code size.

[...] one of our next steps will be to design a better XML format for dialogs and panels. We plan to use a format that works with layout management. SharpDevelop should run under a wide range of operating systems with different languages.

This is especially important if we want to be able to switch the GUI API. History has shown us that GUI APIs come and go. If you know a bit about Java you may have noticed that Java AWT (the first version of a Java GUI framework) was replaced by Java Swing, and some time back IBM released SWT (the most recent Java GUI toolkit from IBM). This could easily happen with the .Net platform, too.

SharpDevelop XML UI Sampling. For a first impression check out the dialog below that displays the GPL license in a rich text box.

<System.Windows.Forms.Form>
   <Text       value = "${res:Dialog.ViewGPL.DialogName}"/>
   <ClientSize value = "{Width=724, Height=400}"/>
   <ShowInTaskbar   value = "False"/>
   <MaximizeBox     value = "False"/>
   <MinimizeBox     value = "False"/>
   <Icon            value = "Icons.16x16.CopyLeftIcon"/>
   <FormBorderStyle value = "FixedDialog"/>
   <StartPosition   value = "CenterScreen"/>
   <AcceptButton    value = "okButton"/>
	
   <Controls>
      <!-- The rich text box in which the GPL is shown -->
      <System.Windows.Forms.RichTextBox>
         <Name     value = "licenseRichTextBox"/>
	 <TabIndex value = "0"/>
	 <ReadOnly value = "True"/>
	 <Font     value = "Times New Roman, 12"/>
	 <Width    value = "724"/>
	 <Height   value = "371"/>
	 <BorderStyle value = "${BorderStyle}"/>
      </System.Windows.Forms.RichTextBox>
		
      <!-- OK Button -->
      <System.Windows.Forms.Button>
         <Name    value = "okButton"/>
	 <Width   value = "64"/>
	 <Height  value = "24"/>
 	 <Location value = "{X=330, Y=371}"/>
	 <TabIndex value = "1"/>
	 <Text     value = "${res:Global.OKButtonText}"/>
	 <DialogResult value = "OK"/>
	 <FlatStyle value = "${FlatStyle}"/>
      </System.Windows.Forms.Button>
   </Controls>
</System.Windows.Forms.Form>

Full story at http://www.icsharpcode.net/opensource/sd and http://sourceforge.net/projects/sharpdevelop and http://www.wrox.com/books/1861008171.htm.

Wolf Paulus - of Theodore fame (XUL Forms Designer for Thinlet) - has created a tiny (less than 30k) open-source XUL motor for Swing dubbed Swix licensed under an Apache-style license. Swix lets you create UIs for your apps or applets using a XUL dialect that holds on to Swing names wherever possible (e.g. class names such as JFrame or JPanel map to tag names such as <frame> or <panel>; method names such as setSize() or setTitle() map to attribute names such as size or title). For the full battery of supported tags and attributes see the Swix Tag Reference.

Bring-Your-Own-Markup Swix Applet. Wolf has also created a small servlet that lets you try out Swix UI markup through a web page titled Swix Live. Type in (or cut and paste) your Swix markup into the textbox and click "Show Me" to kick off a web page housing a Swix applet showing your very own creation.

Swix Forms Designer Upcoming. Wolf has also started work on a XUL Forms Designer for Swix code-named Franklin.

Full story at http://www.swixml.org and http://sourceforge.net/projects/swix

Denis Cardon launched the Luxor Contrib Website sporting tutorials, tag plug-in examples and more.

For full story check out http://luxor-contrib.sourceforge.net

Richer Browsers or Rich Clients avoid excessive server roundtrips, allow offline and nomadic use, and offer a rich UI a la Word or Lookout using

• first-class trees, tables or tabs
• instant in-place form data checks
• drag and drop
• and much more without an avalanche of DHTML/Javascript trickery.

With the rise of XML web services, rich XML UI markups a la XUL and built-in, secure, auto-installation using XML startup scripts over HTTP a la Web Start the difference between Rich Clients and Richer Browsers will blur.

Selected quotes from the Gartner and InfoWorld analyst reports sprinkled with plugs for their ad-paying clients' ware:

The Triumph of High-Fidelity ("Smart") Clients. By 2005, as much as 60 percent of new .Nyet applications will be designed with high-fidelity client deployment in mind (0.7 probability).

Translation: 2005: 60 % Windows Forms Rich Clients; 40 % Web Forms Thin Clients

Bottom Line. Enterprises should prepare for a resurgence in client-side application deployment, which will, this time around, result in more of a hybrid approach that shares code between clients and middle-tier application servers. This will mean more-capable desktop hardware requirements, but without the increase in TCO [Total Cost of Ownership] typically seen in this deployment model.

Translation: XUL + Web Start + Web Services is the future

Read the full Gartner report by D. Smith entitled "The Return of Client/Server - or, at Least, Rich Clients" online at http://www.gartner.com/reprints/microsoft/104982.html.

Emerging distributed servies-oriented computing models further call for faster, smarter workflow than is attainable via browser-based DHTML and Javascript.

Translation: Web Services call for rich UIs a la XUL and SVG

The one commonality among all vendors, however, is the mission to create a smart-presentation layer and rely on localized processing to streamline interaction.

Many of the capabilities from today's innovator may ultimately take root directly within next-generation Web browsers, or the may be embedded natively within operating systems and application servers.

Translation: Only open standards such as XUL, SVG and XHTML will get wide distribution; the Internet is for everyone; XML UI markup will relegate single-vendor runtimes to device driver status.

Rich Internet application vendors will enable developers to bring to market more useful applications in less time.

Translation: XML UI markup makes building rich Internet apps as easy as building Web pages.

Read the full InfoWorld report by James R. Borck entitled "Building a better browser" online at http://www.infoworld.com/articles/ap/xml/02/10/14/021014apclientdev.xml.

How does XUL compare with Microsoft Foundation Classes (MFC) or Windows Forms? Check out the three "Hello World" contestants and see yourself.

MFC Contestant

// HelloMFC.H

class CSimpleApp : public CWinApp
{
  public:
    virtual BOOL InitInstance()
    {
      m_pMainWnd = new CSimpleFrame;  
      m_pMainWnd->ShowWindow( m_nCmdShow );
      m_pMainWnd->UpdateWindow();
 
      return TRUE; 
   }
};

class CSimpleFrame:public CFrameWnd
{
  public:
    CSimpleFrame()
    {
      Create( NULL, "Hello MFC" );
    }
  protected:
    DECLARE_MESSAGE_MAP();
    afx_msg void OnPaint();
};
--------------------------------------------
// HelloMFC.CPP

CSimpleApp helloApp;

BEGIN_MESSAGE_MAP( CSimpleFrame, CFrameWnd )
  ON_WM_PAINT()
END_MESSAGE_MAP() 

void CSimpleFrame::OnPaint()
{ 
  CPaintDC dc( this );
  dc.TextOut( 200, 200, "Hello World from MFC" );
}              

Windows Forms Contestant

using System;
using System.Windows.Forms;

public class SimpleForm : Form 
{
  private Label label1;

  public SimpleForm() 
  { 
    label1 = new Label();
    label1.Text = "Hello World from Windows Forms";
    Controls.Add( label1 );
  }
  [STAThread()]
  static void Main() {
    Application.Run(new SimpleForm());	
  }  
}

XUL Contestant

<window>
  <label value="Hello World from XUL" />
</window>

And the winner is... Do I need to comment?

Paul DiLascia, King William's Court Jester of Windows++ fame, wrote a tiny XUL motor for Windope Forms in C# dubbed Motlib. Motlib (http://motlib.net) shows how a bunch of XML tags break the Visual Studio generated spaghetti code lock-in.

 #region Visual Studio generated spaghetti code
 /// <summary>
 ///  required method for Visual Studio lock-in - do not dare
 ///  to touch this code by hand; always use the latest
 ///  and greatest Micropoly Milk Machine
 /// </summary>

 private void InitializeComponent()
 {
   this.mainMenu1 = new System.Windows.Forms.MainMenu();
   this.menuItem2 = new System.Windows.Forms.MenuItem();
   this.menuItem3 = new System.Windows.Forms.MenuItem();
   this.menuItem4 = new System.Windows.Forms.MenuItem();
   this.menuItem5 = new System.Windows.Forms.MenuItem();
   this.menuItem6 = new System.Windows.Forms.MenuItem();
   this.menuItem7 = new System.Windows.Forms.MenuItem();
   this.menuItem8 = new System.Windows.Forms.MenuItem();
   //
   // mainMenu1
   //
   this.mainMenu1.MenuItems.AddRange( new System.Windows.Forms.MenuItem[] {
     this.menuItem1,
     this.menuItem3});
   //
   // menuItem1
   //
   this.menuItem1.Index = 0;
   this.menuItem1.MenuItems.AddRange( new System.Windows.Forms.MenuItem[] {
     this.menuItem2});
   this.menuItem1.Text = "&File";
   ...
 }     

vs.

 <!-- feel free to change the XUL markup with 
      whatever text or XML editor you like     -->

 <mainmenu id="MondeMainMenu">
   <menuitem text="_File">
     <menuitem text="E_xit" />
    </menuitem>
    ...
 </mainmenu>

Read the full story entitled ".Net GUI Bliss: Streamline Your Code and Simplify Localization Using an XML GUI Language Parser" in the Micropoly Prawda November issue online at http://msdn.microsoft.com/msdnmag/issues/02/11/NETGUIBliss/

Paul DiLascia Quotes:

No human programmer would code this way, so why accept it from a mechanical one? A code generator is fundamentally a workaround for something that's missing. You can call it a wizard, but the wizard has no Brain.

GUI resources like menus and forms belong in files that are easily translated not embedded in procedural code instruction.

It's not hard to write a mini-XUL that supports only the widgets you need. XUL - or something like it - is just the ticket to GUI greatness!

I'm on vacation and on the road in the Pacific Northwest. I will be back on air in October to kick off the fall season. Enjoy the summer.

Martin Weindel hacked together an Eclipse SWT ("Standard" Widget Toolkit) Luxor prototype proving that XUL works with any GUI toolkit not just Swing. Get your two-meg Luxor SWT seeing-is-believing package today.

Chak Nanga started the Mozilla Runtime Environment (MRE) project. Similar to a Java runtime the Mozilla runtime allows stand-alone Mozilla apps to share the core libraries sparing you from bundling the Mozilla runtime with every Mozilla app.

The Mozilla runtime includes the following libraries and services: Core XPCOM Libraries, NSPR Libraries, DOM, Caps, Docshell, Editor, Jar Support, Profile Support, Session History, XPConnect JavaScript Engine, Java LiveConnect, Accessibility, Embedding Support, Layout, Preferences Support, PSM and Wallet, L10N/I18N Support, XML Image Decoding Libraries, NGLayout (gkgfx.dll, gkgfxwin.dll etc.), Appshell, Cookies, Find Functionality, Necko, Plugin Support, RDF, URI Loader

Full story at http://www.mozilla.org/projects/embedding/MRE.html

Seth Spitzer started the XUL Runtime Environment (XRE) project to help developers create stand-alone Mozilla apps in XUL and JavaScript without a single line of C.

Full story at http://www.mozilla.org/projects/xul/xre.html

Droplets Inc., a New York startup (http://www.droplets.com), going nowhere with yet another single-vendor, closed-source remote GUI toolkit dubbed Droplets, ignores Web Start and XUL.

Sun headlines a Droplet article entitled "Droplets Brings GUIs to the Internet: Droplets enable developers to combine the Web's ubiquity with a desktop GUI". Check out samplings where Droplet head honchos boasting Harvard degrees blissfully ignore Web Start:

"Droplets are apps, written in Java, that look and feel exactly like locally installed desktop apps," explains Lou Franco, chief software architect for Droplets. "They have all the speed and responsiveness and interactivity of apps that are locally installed, but they are deployed like the Web."

The need for easy-to-create Internet apps with the interactivity of desktop apps is now being met by Droplets.

Droplets enable developers to create apps that combines the convenient, instant deployment benefits of the Web's thin client architecture with the high usability and rich UI of fat clients.

Read the full article at http://java.sun.com/features/2002/08/droplets.html

An older article published in the XML Journal entitled "The Next-Gen User Interface: How remote GUIs are making old-style Web UI programming obsolete" written by Russ Atkind and Sean Harvey (Droplets Inc.) proclaims Droplets as the UI of the future outshining XUL and other contenders:

XUL is not quite like anything else UI developers have worked with before, but its component technologies will seem familiar. Like HTML, the widgets in a window are described using XML. Cascading Style Sheets (CSS) provide the appearance parameters, and JavaScript is used to handle events and invoke business components. But the end result is quite different: XUL renders component-based GUI applications that behave like traditional desktop software.

Now the attack begins:

Is XUL the UI of the future? If it could be served remotely via a thin client (like HTML), it could solve a number of "Web services" UI delivery problems. Unfortunately, its bandwidth requirements are extremely high and it can't provide the asynchronous UI updates to support interactive applications like stock watchers or IM.

Wake up boys. You can play with the XUL UI on the client as easily as with any other UI toolkit (such as Swing, Gtk# or whatever) and without any server-roundtrips.

There are several obstacles. First, to be a truly ubiquitous remote UI platform, a UI needs to adapt for display on different devices. While XUL shows promise in this area because of the inherent transformability of XML, it currently requires an extremely heavyweight client-side engine. In addition to an HTML renderer, the engine must embed a JavaScript interpreter and an XML parser, and support for CSS, the XUL language, and the XPCOM component model - essentially the entire Mozilla browser.

XUL no longer is a Mozilla only-affair. Web Start lets you pull down the Luxor XUL toolkit with a single-click. And more important Luxor unleashes the power of Java and Phyton and frees you from JavaScript.

Second, there needs to be a way to communicate between the front and the back end. Unlike HTML forms, XUL doesn't automatically send the data entered by the user back to a server whenever the user clicks on a widget. This is in fact an advantage, since there's potentially much finer-grained control over how and when that data is sent. But the plumbing has yet to be built.

Using Java you have whatever plumbing you wish for (XML-SOAP, XML-RPC, RMI, HTTP, JMS, JDBC, CORBA, IIOP, TCP, and so on) and you can even pull-down not-yet-invented plumbing automatically using Web Start.

Read the full article at http://www.sys-con.com/xml/articleprint.cfm?id=297

James Strachan, of Jaxen and dom4j fame and Guinness World Record candidate for most prolific open-source hacker kicking off an open-source project every other day, created JellySwing. James comments in his blog (http://james.weblogger.com):

JellySwing is similar to Thinlets in that XML markup is used to define a Swing UI, but JellySwing can support dynamic XML, that is embedding expressions (like Velocity or the new JSP expression language), custom tags, iteration over SQL, XML or just simply working with bean models and the like. So a single JellySwing script can create the view and bind in the model and controllers in a similar way to you might do in a web application via MVC model II.

Swing over for Jelly to http://jakarta.apache.org/commons/sandbox/jelly/jellyswing.html

Luxor tallies up 2.000 downloads in July and joins the Sourceforge 1000. Luxor will break through the 10.000 download barrier any minute now.

No cooked books. See the stats yourself at http://sourceforge.net/project/stats/index.php?report=months&group_id=28946

Can archaic, closed-source, single-vendor GUI toolkits halt the Xul desktop liberation campaign? Join the discussion in the Java lobby - http://www.javalobby.org/thread.jsp?forum=61&thread=4666 and http://www.javalobby.org/thread.jsp?forum=61&thread=4651

James Strachan (of Jaxen and dom4j fame) and Martin van den Bemt launched the Xulux project (http://xulux.org). James writes in his weblog (http://james.weblogger.com):

The Xulux (pronounced zoolooks) project is gathering steam. Its going to be an ASF licenced open source XUL framework. The aim is to simplify the development of rich/thick clients using XUL to define more traditional, rich user interfaces. The XUL can then be transformed into HTML / DHTML / JavaScript for old HTML browsers such as IE while still supporting rich in XUL browsers such as Mozilla or Flash (thanks to ZULU). So the aim is to build a HTML, Swing and SWT clients for XUL as well as a server side framework for developing XUL applications.

So rich clients (Swing, SWT, Mozilla, Flash) can be supported while still using XML and web application development technologies.

It looks like the jXUL guys, who've stopped maintaining jXUL are happy for Xulux to adopt the codebase, ASF licence it and improve it. They may even join Xulux and help out at some point in the future.

Check out their logo. No code yet.

Check out the VanX screenplay for the Luxor episode The "Linux Kernel" for Desktop Apps - Uniting XUL, SVG, HTML, Velocity, Web Start, XSL/T, Python and more at http://luxor-xul.sourceforge.net/talk/vanx-jul-2002/slides.html

Episode Review. Gerald gives you a no-fluff, fast-paced, example-packed XUL tour and dispells some XUL myths (XUL needs Javascript or Mozilla; XUL is an arachic XForms predecessor) on the way.

Gerald explains the Five Freedoms of the XUL charter and how all the pieces fit together. After praising Mozilla XUL Gerald trashes some XUL-like wannabes and explains how and why Luxor XUL dares to differs from Mozilla XUL.

Experience the future and get a taste of the Free World.

Episode Reruns. Luxor: Beyond Swing and HTML: Building Rich, Cross-Platform, Zero-Admin Desktop Apps on Open Standards Today online at http://luxor-xul.sourceforge.net/talk/jug-oct-2001/slides.html

Can closed-source, single-vendor, Windope-first rich client milk machines match open-source XUL alternatives? Join the discussion at "The Server Side" - http://www.theserverside.com/home/thread.jsp?thread_id=14311

Grab a copy at http://sourceforge.net/project/showfiles.php?group_id=28946. New attractions in Beta 5 include:

• Modul-mania. New modules include: Apollo, Caramel, Houston, Rachel, and Salsa
  • Apollo - Test Skeleton for Web Start/JNLP
  • Caramel - Java Extensions (non-GUI only)
  • Houston - Yet Another Status and Logging Toolkit
  • Rachel - Resource Loading (includes HTTP web service)
  • Salsa - Swing GUI Add-Ons
• Python interpreter added (thanks to Jython)
• More Docs (e.g. framed XUL tag reference, framed JNLP tag reference, etc.)
• More Examples (e.g. Calc, a simple calculator)
• Numerous bug fixes and minor improvements

First Call. Be the first to know about Luxor releases and sign up for Freshmeat's notification service at http://freshmeat.net/projects/luxor. For Apollo and Rachel sign up at http://freshmeat.net/projects/apollo and http://freshmeat.net/projects/rachel.

Peter Bojanic composed the hymn "The Joy of XUL" praising XUL's key benefits including:

• Powerful widget markup (XML, Babe)
• Builts on proven standards (Reuse, Reuse, Reuse)
• Platform portability (Runs Anywhere)
• Splits presentation and application logic (Beyond Hairballs and Spaghetti Code)
• Easy customization, localization, or branding (Your Way or the Highway)

Selected lyrics:

XUL lets you build rich cross platform apps that can run connected or disconnected from the Internet. You can easily customize your apps with alternative text, graphics and layout to brand or localize your apps for different markets.

Dynamic application logic benefits from a UI presentation layer that is standards-based, scriptable, extensible, and distributable over the Internet.

XUL blurs the distinction between desktop apps and Internet browser apps because it combines the best of both worlds.

Full hymn at http://www.mozilla.org/projects/xul/joy-of-xul.html

Besides "The Big Three" dozens of Xul motors blossom or fade away.

• Peter Köker's GUI Builder builds Swing apps from a Xul dialect dubbed "GUI Design Language" (GDL) and supports scripting in Pnuts (http://javacenter.sun.co.jp/pnuts/). GUI Builder also includes a JavaDoc-like tool dubbed GuiDoc that automatically creates HTML documentation from Xul files (source available under the GNU Lesser Public License) - (Note: German site ahead) - http://www.guibuilder.de.
• Jim Wissner's Xybrix builds Swing apps dressed up in Kunststoff L&F from a Xul dialect that includes XForms support (source available under an MIT License) - http://www.jbrix.org/kits/xybrix/overview.html, http://sourceforge.net/projects/xybrix.
• Thinlets - a Xul motor packed into a 24 k jar runs Java 1.1 applet oldies - http://www.thinlet.com
• Pierre Morel's Proto, a Xul forerunner, builds Swing apps from XML descriptions and supports scripting in Javascript or Tcl (frozen since 1999) - http://www.pierlou.com/prototype/.

No army can stop an idea whose time has come. -- Victor Hugo

You can consult a Javadoc-style framed Xul tag reference sporting cherry-picked real-world examples from around the globe at http://luxor-xul.sourceforge.net/xulref/.

If you prefer an all-in-one Xul tag reference instead of a heap of loose ends for printing on a papyrus roll, swing over to http://luxor-xul.sourceforge.net/luxorref.html.

Take away. I will bundle the framed Xul tag reference with the upcoming Luxor Beta 5. Check back in a week to get your offline copy.