XForms Titan Interview with Joern Turner (of Chiba fame)

Hello,

  Welcome back to the XForms Titan Interview series.
Today let's welcome Chiba project lead Joern Turner.

Q: Can you tell us a little bit about yourself?

Joern Turner: Leaving the ancient days of the C64
aside i started to work on (and earning money with)
computers in the late 80s. These were the days of 4GLs
and i spent about 5 years in developing database
applications 
which financed my studies on Information Science and
Philosophy at the University of Berlin, Germany.
Thanks to the great infrastructure there i started to
explore the Internet in the early 90s and was soon
infected with the exciting possiblities the web
offered. I started working in web development and as
soon as Java arrived worked on applets and servlet
applications. After finishing my studies i founded my
first company for Web and Java Development. Since then
i worked as Project manager, IT Consultant, Software
Architect and Senior Java Developer in and for several
companies. Since the second half of the 90s my work
focussed
more and more on multi-tiered Java Enterprise
applications.

Q: How did you get started on W3C's XForms?

Joern Turner: My first contact with XForms was
motivated by some really practical problem: i had to
find a way to manage structured requirement documents
and share them among a team of developers and
consultants in a more consistent way than simply
setting up a file-server with a bunch of Office
documents. After the first prototype with typical
web-technologies like servlets, jsps and the like i
was unhappy with the effort such a small application
required. After searching the web for better ways i
stumbled about XForms. I was impressed by the ideas
expressed therein and decided to give it a try.


Q: How did you get started on Chiba?

Joern Turner: Even though XForms was promoted as a
client-side technology back in these days i saw no
reason why a server-side implementation shouldn't
work and be usefull for a large range of enterprise
applications. Nearly all these application require
structured data input along with validations and
calculations and potentially have to support different
clients. One of the most important goals of Chiba was
(and is) to keep it independent from a specific
client. This enforced a server-side architecture and
coming from the server-side Java world it was natural
to start with that approach anyway.

Q: Can you tell us a little bit about Chiba's history?

Joern Turner: In February 2001 Chiba was accepted as
Sourceforge project and after i managed to implement a
first running prototype i quickly found some
supporters and fortunately also a sponsor that paid
the work for about one and a half year. Gregor Klinke
and later Ulrich Nicolas Lissé joined the project and
together we rolled the first versions out and 
integrated them in a CMS system for our sponsor. In
the middle of 2002 Uli became second project
administrator and we started working closely together.
Since then the project has received countless big and
small contributions and now has 21 members with
project level access.

Q: Can you briefly sketch out Chiba's architecture and
its building blocks?

Joern Turner: Chiba consists of 4 major pieces:
ChibaBean provides the core implementation of XForms.
It implements the complete XForms processing
model, the action and event-handling, the dependency
module and all other bells and whistles of XForms. As
ChibaBean is designed as a typical JavaBean it can be
integrated in any Java environment either
client- or server-side.

Second important building block is the Adapter
interface which connects ChibaBean to its application
or server platform. In the standard Chiba
distribution this is represented by ChibaServlet and
ServletAdapter. TheAdapter works as controller for
ChibaBean and can handle state changes inside the
processor either by accessing DOM directly or by
listening to the defined events.

Third there's our Connector layer which allows to read
data from or submit data to arbitrary sources. The
standard XForms protocols file, http, https are
implemented as Connectors as well as some extensions
such as XMLRPC or SMTP. As Connectors are pluggable
and very easy to implement Chiba can be connected to
virtually any datasource.

Fouth component is optional and its usage depends on
the architecture you'd like to use. The UIGenerator is
an interface to generate code understood by the
respective client connecting. Currently Chiba offers 
a XSLTGenerator to transform XForms to html4. The
standard stylesheets are generic and can be patched or
extended for customization. Client-side
implementations may choose to drop the UIGenerator and
connect eventlisteners to the processor to handle UI
changes.

Q: Can you tell us some challenges you faced building
Chiba using Java and XSLT?

Joern Turner: First of all we're very happy to do it
in Java - without all these wonderfull Apache libs
we'd never have come that far. A potential problem is
that Chiba is still tied to DOM which happens to be
memory-hungry and not that fast.

XSLT was a different story. It turned out to be hard
to transform XForms directly into client-renderable
markup. We ended up with huge stylesheet
that became nearly unreadable. After we decided to
proxy the model state and instance values in our UI
the task became significantly easier and now we ended
up with a reasonably good HTML4 output that gives
quite a
few options for layout and CSS styling.

Q: Can you tell us what Chiba can do today? What works
and what needs to be done?

Joern Turner: Chiba just released version 1.0.0 a few
days ago which we consider production quality. It's a
full implementation of the XForms 1.0 standard and can
be embedded either client- or server-side. Besides 
that it provides some additional interfaces to plugin
your own connectors or extension functions.

There's already a bunch of serious, production quality
applications that embed Chiba and we used it ourselves
successfully in our customers' projects for quite a
while. There's a growing list of operating 
systems, servers and frameworks that make use of
Chiba.

Of course, there still will be issues and a few gaps
should also be noted. We don't have support for the
'copy' element yet and for select1 selection="open".
There are a few less important attributes that aren't
understood yet and the event handling does not
implement the full XForms
Event Spec yet. We try to document these gaps on our
homepage where you can find a status page listing
these issues.


Q: Can you tell us a little bit about Chicoon and how
it all got  started and how it builds on Chiba?

Joern Turner: Several requests for Chiba as part of
the Cocoon platform started the discussion in early
2002. Thorsten Mauch and others raised this topic 
on our mailinglist and about one year later we
released a first version. This consisted of only a
handfull of classes and a sitemap but was already
fully functional. After that Uli and me didn't found
time again 
to update it with latest Chiba core and it got
outdated. Nevertheless there were always some people
around that still worked with it and even 
enhanced it for their projects.

When Andrzej Jan Taramina joined our team in late 2003
he picked up the project and worked out an adapted
version which a slightly patched version of our core.
To avoid the patches i reworked Andrzej's version 
and version 0.9.9 is now our current download. It's
our intend to keep Chicoon in sync with Chiba from now
on.

Chicoon wraps ChibaBean inside a single Cocoon Action
and makes it available in any pipeline you have. A
file demo of Chicoon can be accessed at
http://81.169.173.189:8080/cocoon/chicoon/index.

Q: Can you highlight some more Chiba goodies or addons
besides  Chicoon?

Joern Turner: We have 'Convex' which is an faceless
java applet running in IE6 with java plugin currently
and has been released as preview back in December.
This is able to process XForms fully client-side (and
offline) and render HTML in the browser. Due to an
unfortunate bug in Mozilla Liveconnect loading it 
has not yet been released for Firefox/Mozilla yet.
It's quite similar to the formplayer. We've using that
currently in customers projects.

Another popular tool is the Schema2XForms builder.
Although it's not supporting the full Schema syntax
there are lots of users using it or being interested
in this automated generation facility.

Q: Can you tell us how popular Chiba is? (e.g. How
many downloads? Are there any applications/projects
using Chiba? What's the interest in the XForms/Java
community? etc.)

Joern Turner: Chiba has now been downloaded over
20.000 times from the beginning of the project. We
have about 180 people subscribed to our mailing lists
with about 100 messages a month. 21 people are members
in our project and while not all of them are comitting
we think we can Chiba call 'alive' at least.
 
Q: Who else is behind Chiba? Do you work on your own?
How much time do you spend on chiba development? How
can someone get involved in  Chiba?

Joern Turner: First of all, there's Ulrich Nicolas
Lissé (Uli) my partner at Chibacon
and second admin of the project. We're working closely
together (actually in pair-programming often) to
improve Chiba and 'stay on the scene'. He implemented
big parts of the hard core stuff and we're 
constantly discussing XForms and Chiba. Many others
have contributed code during the life-time of the
project. The list is too long to be 
mentioned here. An up-to-date list of our authors and
contributors is part of every release.

Q: Can you tell us what professional services you
offer for Chiba?

Joern Turner: We offer years of XForms and Java
development practice for users that have a serious
application to build or maintain and need professional

help to get started with the powerfull XForms
features.

We provide help on XForms development in general and
offer integration strategies for the Chiba component
and toolset in specific application scenarios. As
Chiba is designed to be plugged into applications or 
platforms one main focus of our work is the
implementation of customer-specific Connectors and
Adapters.

XForms is still young and you just can't expect any
developer or architect to know it in detail -
therefore we offer teaching of the XForms basics,
working out 'XForms patterns' for specific customer 
requirements and the development of more advanced
add-on tools like form generators or adaption of Chiba
to a new device.

For strategic users of Chiba who need in-time response
to their requests we offer individual support
contracts. Later this year Chibacon will 
start an enterprise version with value-added tools and
other goodies to simplify XForms development and
maintainance.

Q: What's next for Chiba?

Joern Turner: Now that the 1.0.0 release is out, the
API has been stabilized so far that further
enhancements and the new XForms 1.1 features have a
solid ground. Besides ongoing quality improvements,
fixes and the like we plan to provide better
interactivity for the html client through javascript 
code-generation.

The current Chiba distribution will be split up into a
core part and the 
servlet/Adapter classes which are currently the
default integration. Future releases of ChibaServlet,
Chicoon and Convex will incorporate the 
core module and be offered as a standalone download.

The Schema2XForms tool is already quite powerfull but
has a few quircks and does not fully support Schema
syntax. We plan to work on this. And further it's
likely that more integrations will be offered during
2005.

Thanks Joern Turner.

Links:

* Chiba Project - http://chiba.sourceforge.net


______________________________________
XUL News Wire - http://xulnews.com
XUL Alliance  - http://xulalliance.org


		
__________________________________ 
Do you Yahoo!? 
Meet the all-new My Yahoo! - Try it today! 
http://my.yahoo.com

Received on Tuesday, 15 February 2005 03:10:18 UTC