Notes 8.5 Public Beta 1 Client for Mac OS X and Linux

I stumbled across this announcement earlier today:

On 30 May, 2008 a newer version of the Notes 8.5 Mac OS X client was posted as part of the FULL Notes/Domino 8.5 Beta 1 release. 

Based on comments on a post I made March 2008, I decided to download the 355 MB tarball for Mac OS X.
On my first pass, I attempted to install over top of the private-beta client I described in that earlier post. Unfortunately, the provisioning step was partially successful. When I launched the Notes client, Eclipse started up … and shut down … 
I used the uninstall app that came with this latest tarball to remove the private-beta client. I then reinstalled the public-beta client, got acknowledgement that provisioning was successful, and ran the Notes client. 
In the words of Borat: “Great success!” 
The 500-MB-plus public beta client looks similar to the private-beta client, but it feels snappier. Your mileage may vary. 
Regardless, it’s encouraging to witness this progress. 
In addition to installing IBM Lotus Notes 8.5 Public Beta 1 on Mac OS X (Leopard), I also installed it on a Dell laptop running Ubuntu Hardy Heron – IBM offers a build of the Notes client packaged as a number of .deb files. This was my first experience with a native Notes client for Linux. So far, so good. 
Thanks IBM!
P.S. I expect the Release Notes cover off some of the sillyness I’ve shared here …

IBM Lotus Notes 8.5 Beta for Mac OS X: Same Look, Better Feel

After a few minutes, with the 192 MB DMG file downloaded (available online after registration), I ran the installer for Notes 8.5 beta for Mac OS X.
Installation proceeded impressively fast, with the installed client weighing in at just under 80 MB. This hefty client is the first one I’ve used that’s apparently based on the Eclipse Rich Client Platform (E-RCP). 

Aside 

This was not my first exposure to the impressive E-RCP. While I was working for Scali, a major release of Scali Manage made use of the E-RCP. (Scali Manage was subsequently acquired by Platform Computing – another former employer of mine. Small world!) 

On launching the 8.5 client for the first time my configuration specifics were rapidly acquired, and I was using the client in short order. Nice.
FTR, my previous experience with Notes clients has been with versions 6.5 through 7.3. I’ve used the Notes client on both Mac and Windows platforms.
The Notes 8.5 beta looks like the previous versions I’ve become accustomed to. 
However, it feels different. 
There are subtle differences whose overall impact are very welcome. For example:
  • Responsiveness – I find the 8.5 beta much more responsive than previous Notes clients I’ve worked with. And since my interaction over the past 48 hours has been via wireless laptop to my broadband connection at home, I’m expecting even better results when I am hard-wired to the University’s network from my office. This is a huge win that I’m very pleased with. This comment applies to all interactions – from message composition to searches to address completion.
  • Interactive spell-check – As you type, misspellings are underlined with a wavy red line. You don’t need to instantiate the spell checker separately. I expect this improvement rides completely on the heels of the E-RCP. I expect there are additional features/functionalities of this sort that I’ll discover over time. 
  • Look – Other than updated icons, the interface looks the same. Although there’s value in preserving the legacy experience from a look perspective, I wouldn’t have been disappointed by the UI receiving a major facelift. And all of this leads me to conclude that this is primarily a feature/functionality-neutral port of the Notes client to the E-RCP. In other words, there are minimal feature/functionality improvements – except those I’ve already identified above. While that’s OK for now, it won’t satisfy me moving forward. Presumably, however, that’s one of the reasons IBM adopted E-RCP, as it frees them from their legacy implementation, and provides a much broader/deeper and modern spectrum of possibilities moving forward. 
The upshot? The Notes 8.5 beta for Mac OS X looks the same but feels better. And that’s worth blogging about! 

Book Review: Google Web Toolkit

Automagically convert Java to JavaScript. 

Thus begins the seemingly curious proposition of the Google Web Toolkit (GWT). 
Of course, it’s about a lot more than that. 
For one thing, GWT addresses a key gap in the rapid delivery of the Asynchronous JavaScript and XML (AJAX) based applications that are driving eyeballs and mindshare to Google’s Web site.
By the time you’ve read Prabhakar Chaganti’s book on the GWT, you’ll be significantly wiser on at least two fronts. You’ll know that:
  1. There’s a broad-and-deep software engineering ecosystem around the GWT that is fueling progress and delivering highly significant results. 
  2. Chaganti is an excellent guide with the ability to negotiate this ecosystem and drive you towards tangible outcomes.

Using a task-oriented approach, the book proceeds as follows:

  • Chapter 1 rapidly places the GWT in context, and gets you started by downloading, installing and working with the samples provided. Available for Apple Mac OS X, Linux and Microsoft Windows, the GWT only requires the Java SDK as an installation prerequisite. The GWT is made available via the Apache Open Source license; this allows for the development of commercial and Open Source applications. 
  • With the Java SDK, the GWT and the Eclipse IDE, the developer has a well-integrated and powerful platform on which to develop applications. After illustrating the development of the obligatory “Hello World!” application at the outset of Chapter 2, attention shifts rapidly to use of Eclipse. Google’s Web-wired DNA is evident in everything they do, and the GWT is no exception. The GWT leverages the Java SDK and Eclipse to the fullest, while closing the gaps in developing AJAX-based applications in a very organized way. By the end of this Chapter, the reader knows how to develop a simple application with both client and server-side components and execute the same in both hosted (i.e., non-deployed) and Web hosted (i.e., executing within a Web-hosted Tomcat servlet container). Made explicit in this latter deployment is GWT’s ability to support a variety of Web browsers – i.e., Apple Safari, Microsoft Internet Explorer, Mozilla Firefox and Opera.
  • The creation of services is the focus of Chapter 3. To quote from this Chapter, and in the GWT context, service “… refers to the code that the client invokes on the server side in order to access the functionality provided by the server.” The author is quick to point out that this is a separate and distinct notion from that used in the context of Web services. True to its billing, this Chapter works the reader through the creation of a service definition interface (a client/server contract that defines the service’s functionality and establishes rules of usage) and service implementation. Particularly important in this Chapter is the creation of an asynchronous service definition interface, as this facilitates remote calls in the background to the server, and capitalizes on the AJAX support in the GWT. With definition and implementation taken care of, the remainder of the chapter focuses on use (i.e., consumption of the service by a client). Conceptual illustrations compliment screenshots to effectively convey this content. 
  • Whereas the previous chapter delivered a prime number service, Chapter 4 introduces no less than six services that really showcase the capabilities of this application paradigm. With ample explanation and illustration live searches, password strength checks, auto form fills, sorting tables, dynamically generated lists and Flickr-style editable labels are each considered. Not only does one recognize these as design patterns that are already in everyday use (e.g., Flickr, Google Docs, Maps and Search, etc.), one also realizes their potential for re-use in one’s own projects. 
  • Chapter 5 introduces five interfaces that are more complex than those presented in the previous chapter. These interfaces are pageable tables, editable tree nodes, log spy (the GWT spin on the UNIX tail utility), sticky notes and jigsaw puzzle. To reiterate, one recognizes these as design patterns already in everyday use, and the potential for re-usability.
  • Browser effects are the subject of Chapter 6. Here the author introduces the JavaScript Native Interface (JSNI) as a vehicle that allows JavaScript libraries (e.g., Moo.Fx and Rico) to be accessed directly from Java classes. A wrapper-based approach, independent of JSNI, is also introduced to leverage the Script.aculo.us effects. Although compelling effects can be achieved, cautionary words are included in this Chapter, as the impact may be diminished by browser-level incompatibilities.
  • By the end of Chapter 7, impressive calendar and weather widgets have been created, and readied for re-use. 
  • In Chapter 8, JUnit is introduced in the context of unit testing. Standalone tests plus test suites are given consideration; this includes tests involving asynchronous services.  
  • Although this is only the second book I’ve ever seen from Packt Publishing (the first I’ve reviewed elsewhere), I’ve become accustomed to expecting bonus content towards the end of the book. Chapter 9, which addresses internationalization and XML support, falls into this bonus category. Of course, it’s no surprise that Google expertise on internationalizations ranks high, and this is evident in GWT support for the same. The author provides an hors d’oeuvre of the possibilities. XML support is of particular personal interest, so I was delighted by the degree of support for creating and parsing XML documents. I share the author’s sentiments with respect to XML support wholeheartedly: I too hope that future releases of the GWT will provide broader and deeper support for XML.  
  • In the final chapter (Chapter 10), attention is given to increasingly automated methods for deploying GWT-based applications. Starting with a manual deployment in Tomcat, then an automated deployment with Ant, and finally an Ant-based deployment from within Eclipse. 
  • A single appendix details how to access and execute the examples provided throughout the book.
With the possible exception of a concluding chapter, page, paragraph or even sentence(!), to provide some sense of closure to the book, I am at a loss to report any omissions, oversights or errors of any consequence. And although it will have to wait for a follow-on contribution of some kind, additional discussion might be given to topics such as Google Gears or even Google Android.
Even though the book I reviewed was a complimentary copy provided by the publisher, I would happily pay for my own copy, and heartily recommend this book to others having interests in the GWT. 
By the way, Packt has an articulated scheme when it comes to Open Source projects:

Packt Open Source Project Royalty Scheme Packt believes in Open Source. When we sell a book written on an Open Source project, we pay a royalty directly to that project. As a result of purchasing one of our Open Source books, Packt will have given some of the money received to the Open Source project.In the long term, we see ourselves and yourselves, as customers and readers of our books, as part of the Open Source ecosystem, providing sustainable revenue for the projects we publish on. Our aim at Packt is to establish publishing royalties as an essential part of the service and support business model that sustains Open Source. 

I cannot suggest that Packt is unique in this approach. Regardless, their approach is certainly welcome.

Book Reviews: Coming Soon!

Packt Publishing has kindly sent me the following books to review:

Please stay tuned as I expect to share my feedback here on my blog over the next few weeks …

Leveraging Your SOAP Toolkit via the Eclipse Web Tools Platform

Just over three months ago, I wrote:

Because so much value is being driven through SOAP, you must choose your SOAP toolkit wisely. More specifically, toolkit choice will determine, for example, which [Second Generation Web Services] specifications are supported via implementations.

Ultimately, this lead me to suggest that:

Your choice of SOAP toolkit may be the most important decision you make in implementing a Service Oriented Architecture (SOA) based on Web Services.

I still subscribe to this perspective.

Because it’s increasingly unlikely that developers will author SOAP and WSDL documents directly, however, your choice of Integrated Development Environment (IDE) is also increasingly important.

I’m coming to appreciate the value of a solid IDE as I dig into Web services more and more. Of late, I’ve been particularly impressed with the Eclipse Web Tool Platform (WTP).

Stay tuned.