Archives

With the release of IT Mill Toolkit 5.3.0, the server-side RIA framework is now ready for production. I announced the initial release of 5.0 back in December of 2007. Since that time, IT Mill 5 has gone through several revisions and the release of GWT 1.5 (which means you can use Java 5 now on both the client and the server). As a reminder, server-side RIA frameworks let you write your app completely in the server and uses a client-side Ajax engine to render the interface. The nice wrinkle with IT Mill is that both the server side and the client side are written in Java, so if you want to add a component, you don’t have to break out the JavaScript (see the extensive and high quality reference manual for details on how to develop your own custom components in GWT). If you’re a Java shop, that’s got to be a good thing.

Part 3 of my colleague Brian Dillard’s series on retrofitting your web site with Ajax is now up on the IBM Developerworks site.

In this installment, you’ll tame unmanageable product-details pages by placing content inside a tabbed interface. You’ll also keep product images under control by displaying them in an image carousel. You’ll learn how to employ both techniques using simple Dynamic HTML (DHTML) or more complex Ajax code. Either way, you’ll again use the principle of progressive enhancement to keep your pages accessible even when JavaScript isn’t enabled. To accomplish all this, you’ll use two additional jQuery plug-ins: jCarousel for image slideshows and jQuery UI Tabs for tabs.

You’ll also want to look at parts 1 and 2.

Related Services: iPhone Application Development, Java Application Development, Custom Software Development

IBM developerWorks recently published my second “Ajax overhaul” tutorial. This series teaches intermediate-level developers how to layer Ajax features atop old-fashioned CRUD applications. My colleague Dietrich Kappe calls this the “Christmas tree” approach to Ajax development, and it’s a valid choice for many companies. It’s not the sexiest take on Ajax, but it often provides a lot of value for relatively little cost.

“Ajax overhaul” tackles a fictional shopping site for its use cases. Each installment examines a particular deficiency in the existing application’s user experience and improves it using Ajax and progressive enhancement. Because I focus on the interface layer, the code examples feature only client-side code. I’ve completed four installments so far, each one employing some combination of jQuery, custom JavaScript and custom CSS.

I previously posted about the first installment. Here’s the direct link to the second:

• Ajax overhaul, Part 2: Retrofit existing sites with jQuery, Ajax, tooltips, and lightboxes

Pathfinder is recruiting! Although it’s not yet listed on our career portal, we’re looking to beef up the Ajax practice at our Chicago office with a talented front-end programmer. This person should be a jack of all trades, master of several, and flexible about which warrior metaphor to adopt for professional use.

Please give me a shout if the following describes you:

• You enjoy hand-coding complex DHTML and Ajax applications. JavaScript is your passion …
• … but not your only passion. You also make room in your heart for standards-compliant HTML markup and expertly crafted CSS.
• Speaking of CSS, you’re chomping at the bit for CSS 3. Table-free, CSS-based layout is old hat to you.
• You’ve used more than a single browser and a single operating system in the last five years. You can debate the merits of Gecko vs. Webkit till the cows come home. You can rattle off browser bugs like the names of old high-school friends. The phrase "Opera 9.5 beta 2 on 10.4 Tiger" doesn’t sound like nonsense to you.
• You’ve written production code using more than one open-source JavaScript toolkit and, more importantly, you know how to code without one. You have opinions about why Dojo is better than GWT (or vice-versa) and can intelligently discuss the pros and cons of jQuery vs. Prototype vs. MooTools.
• You’re passionate about front-end developement as a discrete category of software engineering, but you can jump in on the server-side stuff when you have to. SQL, Apache and the command line don’t scare you.
• You’ve worked with templating systems in JSP, Rails, PHP or some other framework.
• If you don’t have direct experience with Flash, Flex, Adobe Air or Silverlight, you’re at least willing to give such competing UI technologies a shot.
• You aren’t necessarily a visual designer, but you don’t need somebody who went to art school to swoop in and Photoshop a rounded corner or a background pattern for you.
• You have experience working for an Agile shop – or you desperately want to.
• You may not be an information architect, but you understand the world of user experience design. You’re comfortable reading wireframes and requirements documents and participating in the design of complex software systems.
• You’re not scared of acronyms like XML, XSL and XSLT.
• In short, you know how to put the "V" in MVC.

If this sounds like you, I’d like to take you out for lunch and a little chat about Pathfinder Development. See our jobs page for all the boilerplate about relocation, etc.

Photos (Creative Commons Attribution License from Flicker): PhillipWest | R’eyes’ | dizznbon.

My colleague Brian Dillard has written a rather decent whitepaper entitled Ajax Roadmap: How to tranform your website without starting from scratch, that lays out an approach to transforming your website or application without having to reengineer the whole darned thing. It offers a number of case studies, rationals and justifications for launching Ajax projects, pitfalls, quick wins — in short, everything you need to start an Ajax transformation in your own company.

We’re quite pleased with it. Come on by and have a look.

Photo: James Duncan Davidson

Web 2.0 Expo is closing up shop. I think my talk went pretty well. Despite being the last session of the last day, I had about 100 people, most of whom stayed till the bitter end. Not a lot of questions, but quite a few folks stopped by to chat afterwards – including Mark Meeker, a friend and former colleague from Orbitz who’s no stranger himself to the conference circuit.

I made a conscious decision not to focus on code, but rather to provide tools and advice to developers who want to be a part of the conversation between standards bodies, browser vendors and library authors about the future of the web. I’m not sure how much of it makes sense without my narration, but I’ve posted my slides to Slideshare.

Now, out for Afghani food with old friends. More about Web 2.0 Expo next week!

• My slides (embedded)
• My slides (slideshare)
• My abstract
• My Crowdvine page

PESSIMISM, n.

A philosophy forced upon the convictions of the  observer by the disheartening prevalence of the optimist with his  scarecrow hope and his unsightly smile.

– Ambrose Bierce, The Devil’s Dictionary

I frequently crawl through the various GWT project hosted on Google Code, as well as the few that aren’t (like the almost venerable GWT Widget Library). One type of solution that is emerging is what I would call model synchronization libraries. These build on top of the GWT-RPC mechanism and allow a synchronization of an object model on the client-side with a corresponding one on the server-side.

Right now there are two major choices available:

• hibernate4gwt – Number one with a bullet. Elegant and powerful library that allows you to ship domain objects back and forth between the GWT client and the Java server, persisting changes, all at the cost of extending one class: LazyGwtPojo. There are two basic flavors — stateless and stateful — with a couple of different subflavors to support a variety of development use cases.
• Gwittir – Developed by the two dudes who wrote GWT in Practice, this library provides domain object bindings without forcing a dependency on Hibernate (should we add “Hibernate infected” to our lexicon along side “Maven infected?”).

It’s clear why these libraries are gaining in popularity. The whole idea of writing applications in GWT is to have a commonality of language and domain model. You want to be consistent and not have to navigate the OO/RPC boundary every time you modify or retrieve your client-side model. (An additional alternative worth mentioning is IT Mill Toolkit 5, which as a server-side ajax framework with it’s widgets realized in GWT, already has the client-server synchronization baked in.)

Of each particular thing ask: What is it in itself, what is its nature?

– Marcus Aurelius

We get asked quite often to convert Web 1.0 applications into Web 2.0 applications. We do it so often that we’ve developed tools, written frameworks, published articles and whitepapers and given conference talks on the topic.

So far, there are and remain three different approaches:

1. The Christmas Tree Approach – decorate an application with lots of Ajax widgets.
2. The Reboot – reengineer your application from scratch.
3. The Resurfacing – leverage the MVC nature of your application by turning your controllers into web services, your views from HTML into XML or JSON, and deploying a single page JavaScript client to access your new backend.

Which one to chose? That depends on what kind of application you have. Is it a Web 2.0 application masquerading as a Web 1.0 application, or is it really a rather dull Web 1.0 application that you need to tart up with a few widgets?

This idea comes from my colleague John McCaffrey, but since he’s having a bad case of blogger’s block, I get to post about it.

For anyone who has developed tests for web applications with a tool like Selenium (or Watir), you know it is a sysiphean task, rolling the boulder of automated tests up the hill of a constantly changing application. The DOM changes, the text changes, the url’s and parameter’s change, iframes and onload events don’t always play nice with your test recorder. Depending on the framework you are using, id’s may change in unpredictable ways, forcing you to hack together brittle xpath expressions. Still, functional testing is important, so you persevere, spending countless hours in making those tests run clean.