Today, I'm please to announce a technical preview of Ajax-enabled JSF tooling for
Workshop. The new feature offers a WTP project facet, smart editing, and visual page construction, for
ICEfaces®. ICEfaces is a library of Ajax-enabled JSF tags, distributed under a number of
open source licenses (Apache 2.0 and the Mozilla Public License among them), that will run
under either the Sun RI or Apache MyFaces implementation of JSF -- see the description of the product
here.
The ICEfaces tooling feature is an extension of the award-winning JSF tools already shipping in Workshop.
It's fully AppXRay enabled, which provides edit-time error detection, Smart Editor assistance with tag attributes,
and smart navigation between markup, JSF configuration files, and Java types -- all the familiar capabilities
that Workshop JSF tooling offers can now be used to help develop an Ajax web application.
The ICEfaces extension was developed by Tom Stamm, an engineer on the Workshop team, who has published
a tutorial about it here.
You can obtain the feature at http://dev2dev.bea.com/eclipse/icefaces-tooling/; it's an Eclipse update that
installs on top of our recently released
Workshop 10.1.
The tech preview period will run from now through September 2007.
Please try it out, and post feedback and questions to the
Workshop Tech Preview forum.
We're anxious to hear from you!
Next week, I'll be moderating a panel at JavaOne (Thursday, 10 May, 1:30PM -- TS-6713:
JavaServer Faces Technology and Ajax Panel Discussion)
that will discuss the marriage of JSF and Ajax. Two of the panelists come from the organizations
that have created JSF implementations: Sun and Apache MyFaces. The others are all from companies which offer
shipping products that combine an Ajax runtime with a JavaServer Faces programming model. The panelists will be:
Dennis Byrne, Apache MyFaces PMC, ThoughtWorks
Ed Burns, Senior Staff Engineer, Sun Microsystems
Mark Schiefelbein, VP Product Development, Backbase
Igor Shabalov, CTO, Exadel
Stephen Maryka, CTO, ICEsoft
Here is the agenda:
Why are Ajax and JSF a good match?
Best practices and design considerations for JSF/Ajax web applications
Framework interoperability pitfalls
What to look for when choosing a framework
Future directions
It should be a great discussion! Come and participate. Hope to see you at JavaOne.
Jess Garms, Walter Harley, and I gave a short tutorial at Eclipsecon yesterday (Monday) morning about processing JSR 175 annotations in Eclipse. Although the API is binary compatible between the two, it turns out that an annotation processor written to run in the command line container (i.e. APT in Java 5, javac in Java 6) won't always behave well when it runs inside the IDE (as an extension of the interactive Eclipse compiler). This tutorial was an introduction to the annotation processing API, as well as a distillation of best practices and design principles harvested from our experiences at BEA in the past couple of years, adding this API to Eclipse, and helping people use it. The presentation materials, including slides, coding exercises and solutions, and other sample code, are all available here (click on the Presentation File link at the top). We plan to publish a more detailed dev2dev article on this topic soon.
We've seen a lot of interest in integrating PHP with WebLogic Server over the past few months.
The option of using the Zend PHP engine, with one of the two available PHP-to-Java bridges has
always been available (see my recent article on working with PHP Java bridge technology
here).
We think this is a good short term solution to the problem, but because the bridge is work to
understand and configure, and presents some management challenges, we have spent some time working
on a JVM based integration of a PHP engine.
That project involved experimenting with technology from a third party, with whom we failed
reach an agreement about terms for distribution. We still remain excited, though, about a
byte-code implementation of the PHP engine. Similar efforts are going on with other dynamic
languages, e.g. JRuby, JavaScript, Groovy, and Visual Basic. The most glaring omission in
that list is surely PHP, since it's the most popular dynamic language being used right now
by Java EE developers.
What would the advantages of a JVM-based PHP engine be? At first glance there are several:
Easier installation and configuration than the current PHP-Java Bridge solutions,
and less moving parts for customers to manage.
Reuse of the JEE Server infrastructure for management, clustering, failover, database
connection pooling, etc.
Performance: since the PHP source would be compiled to bytecode, the JIT compiler
would be able to optimize it just like Java code. Furthermore, there would be reduced
overhead with regard to inter-language communication with Java code, because no data
would need to be marshaled across address spaces.
The tuning capabilities offered by JRockit's deterministic garbage collection.
Security: in a managed execution environment like the JVM, problems like buffer
overruns don't exist.
New possibilities for tooling: a JVM implementation would make it possible to
create tools like a cross-language debugger that allowed breakpoints in both PHP and
Java code in the same session. With a little tweaking, you could also use existing
Java profiling tools with PHP code, and for profiling across languages.
The JVM could serve eventually as a common integration point for a number of different
languages, like the Microsoft CLR does: PHP, Java, Ruby, JavaScript, Python, etc.
Here is a glance at what a roadmap for such a feature might look like at the macro level:
JVM-based PHP engine, with limited library support in the first release, but growing
quickly over time. Library module support would be released piecemeal, since the new
functionality would be additive (i.e. will involve no changes to the core engine).
Workshop based tooling: cross-language debugging, based on the Eclipse PDT project,
and profiling, taking advantage of the JRockit Mission Control Suite of tools.
Further work integrating PHP with other dynamic languages.
Possible further work integrating PHP better with JEE frameworks like Struts and ORM technologies.
Would any of you WLS customers be interested in being design partners for such a feature? It would be great
to have you on board! Email me at ghoren@bea.com.
I am currently the program manager on the BEA Workshop team for Ajax and Languages. I'll be posting here from time to time about stuff going on in the Workshop organization in those areas.
I published an article this past December about exploring Ajax runtime offerings, which you can read here. In the recent past, I've given a few talks about Ajax, and tooling for Java annotations in Eclipse, at JavaOne, EclipseCon, and BEA World.
Using PHP-Java Bridges with WebLogic Server
How can you run both PHP and Java side by side and reap the benefits from both of these technologies? In this tutorial Gary Horen shows how to utilize two different PHP-Java bridges to do just this. Feb. 13, 2007
Exploring Ajax Runtime Offerings
This article defines an Ajax Comparison Framework Space that lets the author explore many of the current Ajax frameworks. This guide provides invaluable tips for choosing and using an Ajax solution. Dec. 6, 2006
