Enter Stoyan Stefanov who wrote a neat little blog post explaining how you can use JavaScript as a shell language.

In essence, Rhino is the answer for *nix machines but if you cuddle the penguin you most likely are a shell master anyways.

If your world features Gates and Windows, then there is the Windows Scripting Host, which has a tool to execute JavaScript on the DOS shell:

Macs have a tool called JSC which is "conveniently" located in:

To make it human usable, creating a shortcut is a good plan:

You can then execute JavaScript by starting JSC which gives you something like the Firebug JS console in the OS console (without the console is not defined messages *in* the console).

With a few more lines using the print(), quit() and load() commands available on the shell you can then use any JavaScript to mess with your files and folders.

We recently posted on Atmosphere, a new framework designed to provide an abstraction layer over Comet back-ends for Java web applications. At a personal level, this comes at an interesting time as over in the Mozilla Labs we're evaluating different Comet approaches for our upcoming collaboration release. As we looked at various options, we come across some recent postings from Ted Goddard of IceFaces fame explaining their work on making Comet as simple as possible for Java developers, including a podcast and an overview of the IceFaces approach.

Say what you will about JSF, their abstraction layer makes server and client implementation of Comet incredibly simple:

In other words, we can re-use our existing Ajax pipeline, and the application developer only needs to worry about one thing: requesting that a page be rendered. As you can imagine, this is only a few lines of code. With ICEfaces it looks like this:

PLAIN TEXT

JAVA:

1. SessionRenderer.addCurrentSession("ajaxian");
2.  
3. // somewhere else in the presentation tier
4. SessionRenderer.render("ajaxian");

Not only does the application developer not have to worry about low-level protocol details or messaging, they don't even have to worry about what has changed on the page -- this is all taken care of by the declared binding between the page and the model.

To summarize: we have dynamic pages that can be rendered on the server at any time, and the updates are pushed to the browser where the changes are applied to the DOM. From the application developer's point of view, that's all there is to it.

Are you using a stack that makes Comet this easy? Have you been able to successfully implement Comet? Do you get sufficient performance from polling?

Atmosphere 0.1-ALPHA1 is now officially released and support Tomcat, Jetty, Grizzly and GlassFish. Finally a Comet/Ajax Push framework you can build on top of it and deploy everywhere!

One of the cool features of this release is that it auto-detects which server back-end you've deployed it into.

Among the materials in the release notes are two code samples and a PDF discussing what Comet is and the motivation/design behind Atmosphere.

Comet on Java just got easier, which is a welcome development indeed.

And if you haven't heard, Ajaxian members save an extra $100 off the registration fee with the code AJAXIAN!

The full agenda is available online, but here's a sneak peek of the 5 most popular sessions being presented at TSSJS:

1. Building Next-Generation Web Applications with the Spring 3.0 Web Stack with Jeremy Grelle, Senior Software Engineer with SpringSource

2. Spring for the Advanced Java Developer with Rod Johnson, Creator of Spring

3. Just Enough Early Architecture to Guide Development with Jon Kern, Co-author, The Agile Manifesto

4. Hibernate Search: Finding Data, You Deserve Better with Emmanuel Bernard, Lead Developer of Hibernate Search

5. Navigating the SOA Mine Field Optimized Application Architectures with Heath Kesler, an open source software evangelist

If you'd like to attend simply register with the code AJAXIAN to take $100 off the registration fee.

There are a few "magic" properties on Mozilla's DOMWindow interface for supporting LiveConnect that will initialize the Java plugin and all the baggage that comes with it (which, with modern Java plugins, means launching java.exe as a subprocess). Looking up these properties on the window object is all it takes.

There are a few more of these still in the Mozilla source code and they are part of the old Netscape LiveConnect engine. They are:

• java
• Packages
• netscape
• sun
• JavaClass
• JavaArray
• JavaMember

Avoid these at all cost lest you want the performance of your JavaScript to be like a Java Applet.

Every little bit helps in this economy - register today with the code AJAXIAN to pay only $1495 for the conference, coming to Las Vegas March 18-20.

You don't want to miss:

• Intro and Advanced sessions on Google Web Toolkit with David Geary, Author of Google Web Toolkit Solutions
• Sexier Software with Java and Flex with James Ward, Platform Evangelist, Adobe
• Identifying Browser Problems in Ajax Applications with Frank Cohen, Founder of PushToTest
• Atom: From Blogging to Data Syndication with Scott Davis, Editor-in-chief of aboutGroovy.com
• DSLs in JavaScript with Nathaniel Schutta, Co-author of Foundations in Ajax
• And much more!

View the complete agenda and register to save $200.

Jerome told us more:

Full objects graphs are supported for services method's arguments and return (see provided example in the distribution), including nested collections (List and Map) and heterogeneous collection elements.
Its use is as easy as with GWT (and does not require any generation step thanks to the Objective-J runtime - interpreter step at runtime).

Usage

On the client-side:

On the server-side:

Just subclass the provided CP2JavaWSJSONServlet servlet and implement the (abstract) method:

A mapping file (see provided example) has to be put on the server-side for custom objects (maps custom Objective-J objects classname to corresponding Java custom objects classname).

More info

• Documentation and comparison with GWT
• Download, includes library and example
• Current release

We're inviting all of the Java developers out there to an event organized by our sister site, TheServerSide.com, the Web's largest enterprise Java community. As a member of Ajaxian, you save an extra $100 off the registration fee with the code AJAXIAN. (Register before January 16 to save a total of $400 and get a free book!)

TheServerSide Java Symposium explores current and emerging trends in enterprise Java and how they apply to your daily work. Choose from over 45 technical sessions on new technologies, best practices and practical tips from some of the brightest minds in the industry, including Rod Johnson, Neal Ford, Scott Davis and 35 Java experts.

Tracks include Frameworks, Architecture, SOA, Language, Tools and Techniques.

Project and spec leads dive into:

• The latest features of Spring, JSF, Wicket, Tapestry, Google Web Toolkit and more frameworks.
• New Java language features, such as EJB 3.1, Glassfish and JavaFX
• Popular open source tools, including Eclipse, Maven, Lucene, soapUI, HtmlUnit for testing SOA, Ajax and RIAs.
• Expert recommendations on the use of Groovy, Scala and JRuby
• Building and maintaining a large-scale SOA
• How to create and consume RESTful Web Services.
• How and when to use an ESB.
• Best practices and tools for optimizing performance and scalability.
• And much more!

View TheServerSide Java Symposium agenda to see all of the sessions being presented. Register now with the code AJAXIAN to save an extra $100 and to get a free book while supplies last.

DWR now supports:

• varargs
• method overloading
• typed parameters
• binary file upload/download
• it has a set of new types it can marshall

DWR will let you use JavaScript to implement Java interfaces (e.g. to register a Listener interface to publish changes to waiting browsers using Reverse Ajax), we now have 3 modes to control resource usage and there is a more scalable Reverse Ajax layer.

There are new integrations with Dojo, TIBCO GI and Aptana Jaxer, and a new DOM manipulation library.

We have special asynchronous servlet support for Tomcat and Glassfish, and our Spring and Guice integrations have been beefed up.

We now support JSONP and JSON-RPC, and there's a whole bunch of etc thrown in for good measure too.

There is a more complete list at Joe's blog, or you can just skip straight to the download page.

Jeffrey Sharkey has created OilCan a thin wrapper on top of the WebKit shipping on Android that allows you to install userscripts that allow you to access to Android "Intents".

Intents are very nice abstractions that allow you to access large components and reuse them in different ways. Romain Guy has a nice post on them.

OilCan lets you customize any website by inserting JavaScript to change the website and help it reach into the Android world using intents.

OilCan inserts some powerful buttons into normal websites, and that power comes from Android intents. We didn't write a barcode scanner or the radar app into OilCan, but using intents we can launch those apps with parameters. We can request the Barcode Scanner app to scan something and return the code to us, or launch the Radar app with a specific lat/lon.

Userscripts can do other cool stuff, like hide the navigation columns in Wikipedia to make it easier to view on small screens. This is a proof-of-concept for now, and will probably turn into a binary plugin for the default Browser in the future.

A nice piece from an example shows the intent call out:

Very cool!

The UML diagram above is from Matt Prokes as he creates Java-like interfaces for JavaScript.

He has a full example:

An example of an object which requires an implementation of the interface.

PLAIN TEXT

JAVASCRIPT:

1.  
2. //This code is valid, and the execution will be successful.
3. function executeInterface1(executeThis){
4.   var castedIface = executeThis.cast('TestInterface');
5.   castedIface.testMethod1(1,2,3);
6. }
7.  
8. //This code is valid, but the execution will not be successful.
9. function executeInterface2(executeThis){
10.   var castedIface = executeThis.cast('TestInterface');
11.   castedIface.testMethod2(4,5,6);
12. }
13.  

Alright, lets instanciate, the objects and set them to variables. Feel free to type in the variables and take a look, on the firebug window!

PLAIN TEXT

JAVASCRIPT:

1.  
2. InitedTestObject = new TestObject();
3. //variable not used in this example, but I thought I would still make it available!
4. CastedTestInterface = InitedTestObject.cast('TestInterface');
5.  

Ok, so lets try it out! We wrap it all up in some simple div tags with onclick events.

PLAIN TEXT

HTML:

1.  
2. onclick="executeInterface1(InitedTestObject)"
3. onclick="executeInterface2(InitedTestObject)"
4.  

Rodrigo Reyes has announced a new project called AbstractCanvas, a GWT project that sits on top of HTML Canvas and Java2D.

The same code can thus run in the browser, or on the server.

You can then write code such as:

Cote has some nice coverage via his interview with Danny Coward:

When I was in his neck of the woods last, I got the chance to talk with Sun’s Danny Coward, the Chief Architect of Sun’s Client Software (that is, Java SE, Java ME, JavaFX and JavaCard), about Java 6 Update 10. That seems like kind of a narrow topic to speak to, but as Danny and I discuss, it’s a big release for Sun’s RIA and client-side (re-)push.

Along those lines, we spend a lot of time detailing the re-written plugin that’s used for Java applets and JavaFX, the improved installer and update experience, and other client side features like one of the new GUI look-n-feels, Nimbus.

Update 10 is available now.

I have to admit to not "getting" JavaFX, but the Java plugin features are great to see, and it is nice to see the final release.

I have seen the GWT team working very hard indeed on GWT 1.5, and they must be very happy to see the final release shipped and complete:

GWT 1.5 delivers what we think are an impressive number of improvements, about four hundred issues if you're counting. We're also happy that one of those is issue 168, our most-requested feature, Support for Java 5.

The high level new feature sets are:

• Java 5 language support and enhanced JRE emulation
• Performance optimizations and easier JavaScript interop
• Prettier widgets, better DOM, accessibility, and bi-di

You can see a lot of this at work in the showcase area. There you will see all of the widgets and examples that come out of the box, and the community has developed even more for you. In particular, Ray Cromwell has some great real world examples that he shares in his book and talk.

Download GWT and take a look.

Dave Kuhn has put together a comprehensive guide to piecing together GWT and Spring, a nice recipe for the Java heads among you.

Dave starts out by detailing why you would want to do this, and how it changes the architecture of your application.

He then gets to a tutorial that has you creating the project correctly, and configuring an actual service. Once you are done with the code, you need to setup hosted mode to point to a nice external tom cat via:

-out www GwtWisdom/GwtWisdom.html
-noserver
-port 8080

• Generates HTML 5 markup (with data-* fields), including CSS classes
  with the property type.
• Based on prototype
• An ever-growing list of (progressive-enhancement) web components,
  including: multiple file upload, tabs, menus...
• Dead-simple javascript validation library with i18n support.
• ...which mimics the process at the server, in case javascript is disabled.

Just give it a try at the demo. Try introducing invalid input, and check the sources by clicking the "View source" link at the top right of the page. Everything in the demo should work with javascript disabled, including multiple file upload.

The framework also includes a libraries repository which pulls debug/optimized javascript from the google CDN:

This snippet of code would translate into this, if development is disabled:

Or this if not:

More details about the framework are at the reference guide. Ignacio would be grateful for any feedback!

While traditionally Java Applets and the Web have mixed together about as well as concrete and peanut butter, the upcoming revised Java plug-in might give a window for Java-based GUI toolkits to be of interest to Web folks.

While Pivot's source code is still forthcoming, a quick glance at its classes shows an architecture with a strong resemblance to Java's built-in Swing GUI toolkit, but with many of Swing's rough edges smoothed out. As a long-time Swing developer, I'd characterize it as attempt to create Swing++.

Similarities to Swing include a light-weight rendering model (i.e., it doesn't wrap native components), a nearly identical component contract, a very similar system of UI delegates, and a very similar event model. Differences include a cleaner API (by virtue of nixing direct interoperability with Java's ancient AWT toolkit), different approach to layout, fresh implementations of common GUI components, and a new collections framework (inspired by Java's collections framework but... different).

Thinlet is another, older alternate GUI toolkit for Java that draws its own components and targets Applet developers (though a new version is under development).

The applet security model, known as the sandbox, only lets applets connect to the webserver they were loaded from. They cannot connect to anywhere else unless they are signed. Signing is great when you need access to more than what is allowed inside the sandbox, but it has two problems: the user will receive an ugly warning dialog about the applet, and the applet will have full access to the user's computer. Full access is overkill when all you want to do is talk to a webservice on another server. Surely there is some middle ground between the sandbox and full access? Well now there is.

The key is supplying a backwards compatible way of tying to the new JNLP version:

Now the JNLP file points to the the unsigned jar:

Note: you should be aware of security issues with open cross domain files.

Scott Schiller has updated one of our favourite libraries, SoundManager. Being able to simply play some audio from your Ajax applications can be great, as long as you don't use it gratuitously.... although we tend to do that a little in some of our demos :) We used SoundManager in our Wii Darts application.

The new version has performance improvements so the sound happens a lot quicker, a few bugs are killed, but most of all you will see some really great demos to cover use cases from users such as "I just want to be able to click and play a MP3 link in-page."

Some of the cool new demos:

• Page as a playlist: (Muxtape.com-style UI) with a few themes, load/play progress, scrub/seek within track, timing etc.
• Play MP3s in-place demo.

Download the latest library.

Oh, and you gotta love the Web 2.0 and Web 3.0 explanations of SoundManager ;)