Rich Internet Applications (RIA) have often been associated with some type of sandbox or virtual machine environment to make desktop features available via the web. Many applications though, have left behind the restrictions and demands of those technologies, implementing RIAs as pure web interfaces. One key technology in this area is JavaScript. It’s been well documented that working with JavaScript can be problematic across various browsers. In response a number of JavaScript libraries have been created to alleviate the issues in dealing with different browsers, allowing developers to focus on application logic rather than platform concerns. One such library, focused on providing tools for building RIAs is Ext JS. For the aspiring developer looking to use Ext JS, Packt provides a guide to the library in the form of Learning Ext JS

The book is written for people with experience in doing web development. The authors state that a working knowledge of HTML and CSS are important, but experience with JavaScript is not essential. I think that a reader that has not used JavaScript may want to supplement this guide with something that covers the basics of JS. Experienced developers that haven’t worked specifically with web programming should have no trouble keeping up. Anyone completely new to the idea of programming, scripting, markup, etc. really will need to take some time to get familiar with those concepts before they dive into this book. The authors do not spend time teaching programming, they are focused purely on realistic applications of Ext JS.

The authors begin by stating that, “Ext is not just another JavaScript library…” and it is understandable that they would feel this way. I am unsure why one wouldn’t think so other than a personal preference for the product. That said Ext JS can be used alongside other JS libraries and does provide a lot of features ‘out of the box’ that make it an attractive choice. The emphasis on RIA widgets and building strong applications is nice as Ext JS is not working to be all things to all developers.

The book is heavy on code and examples but not so much so that it falls into the cook-book style of writing. Learning Ext JS is more of an extended tutorial with ample explanation to help the reader not only understand the code but why certain choices are made. Frederick, Ramsay and Blades have done a good job of working through the examples in a concise manner. While the book is the result of group work, it does not have the feeling of being written by a community. I did not run into an abundance of repetition and topics flowed well. Learning Ext JS also covers installation and integration of the library as well as a very quick survey of tools for development. While short these sections would be extremely important to anyone coming into web development with little experience.

It’s a quick read, and doesn’t delve extremely deeply into more advanced topics. Rather, a reader new to Ext JS will get a launch that should make the library usable in a practical way and also give them the framework to push deeper. The book was written and published just as Ext JS moved between versions. The new version is backwards compatible with the material in this book and a number of the changes in version three would not have fallen within the scope of this book, so it is still a good place to get started with Ext JS. Those who want to dig deeper will need to look elsewhere.

The brevity of the book wont work for those folks who want to really dig down deep into Ext JS. I on the other hand, wasn’t looking for a massive tome to lug around and grind through. I was happy to have a very accessible tool that would get me started quickly and that is what I got. On the other hand I do like to be able to find what I need quickly and nothing is more important to me when learning than a solid index. Unfortunately the only really large ding I have for the book is that the index is weak. It would be a lot worse if the book were larger, so the brevity helps here a bit, but it’s still unfortunate. This does make the ebook version a little more attractive. Packt will bundle them at a cost that makes the addition of the electronic copy very attractive. That said, the easy flow does it make it easy to read this book front to back while working the examples. Learning Ext JS just wont be my first choice when I need to quickly check a reference.

I’ve discussed the shallow coverage, but this does not mean that the book is not useful. The Ext JS library bundles enough functionality into the stock widgets, that decent applications could be written with nothing more. Creating custom widgets is covered and extending existing code as well, but this is later in the book. The material prior to that covers not only the use of the provided widgets but how to tie them together, theme an app and then handling data. This means the reader pretty much has everything in hand to build a stock application. The focus is on dealing with these issues on the client side. The examples do include a small amount of back end code when necessary for the execution of examples. All the examples are available to download from the Packt site and come packaged with all necessary scripts, images, etc.

I’ve always worked primarily with desktop applications. I’ve done some work with web applications, but it seems to me that increasingly the tools that I use the most are web based. With technology like Google Gears making those applications available whether I’m connected or not they have become much more attractive. Tools like Ext JS make it much easier for me to transition over to this new way of developing applications. I’ve found that Learning Ext JS has been a valuable resource in taking what is a great resource and allowing me to get the most out of it more rapidly than I would have otherwise.

Title: Learning Ext JS
Author: Shea Frederick, Colin Ramsay, Steve ‘Cutter’ Blades
Publisher: Packt Publishing
Pages: 309
ISBN: 978-1-847195-14-2

Rating: 8/10
Tagline: Build dynamic, desktop-style user interfaces for your data-driven web applications.

Web applications are all the rage. Web applications that function within the context of social networking sites doubly so. I think it is safe to say that pretty much anyone looking to garner a large audience on the web, for financial or any other reasons, has to be considering how they can reach people on sites like Facebook, or all those users out there accessing the web via their iPhones. Sun Microsystems has entered this arena by providing a set of web based development tools and a platform on which to host the resulting products that is now in beta and named Zembly. And while Zembly has not been open to the public for all that long, two of Zemblys architects with the help of two writers have published a new cookbook for the aspiring Zembly developer, Assemble the Social Web with Zembly.

Zembly is relatively new and the name doesn’t offer any insight into just what it is, so before I get to the book itself, I’ll explain a little about just what Zembly is. It is a Sun project. In their promotional material on the site they claim, “Over two decades ago, Sun’s motto, ‘The Network is the Computer’, foreshadowed the advent of today’s cloud computing movement.We like to say that zembly is the development environment for Sun’s bold vision…” So Zembly is an on-line development environment. But more than just being an on-line editor, it is development in a social context aimed at social tools. The code written by one Zembly user, is available to any other user.

Along with providing a social development environment, Zembly also provides the platform and resources where the applications developed there will live. To put it in literal terms the framework is comprised of Solaris, Java, Glassfish, and MySQL. It operates via Sun’s Network.com cloud-computing business. That framework supports the use of HTML, CSS, JavaScript, FBML, and FBJS. There are templates in place to develop applications for several popular social networking sites and there will be more as users add them.

Assemble the Social Web with Zembly is an introduction to all this and serves primarily as a cookbook to help the reader get their head around how all the pieces work together, giving them a jump start into the process. As Zembly is all about colaberation it seems appropriate that this book is the product of four authors. Gail Anderson and Paul Anderson are experience authors, with a number of published tech books between them. Todd Fast is the architect and CTO of Zembly. Chris Webster is another Sun employee and the Technical lead for Zembly and also a published author himself.

The book covers an overview of Zembly, a chapter on how to use the tool set and then moves through a series of chapters that provide examples of building widgets and services for Flickr, Zillow, Facebook, Dapper, and web apps for the iPhone. There is also a widget section that makes use of WeatherBug, Google Maps and Yahoo! Pipes. The results can be published as applications within those sites or embedded into other sites. I see the real potential for Zembly in places like Dapper and Pipes, where Zembly becomes an endpoint for those types of services that can consume almost anything. The usefulness of Zembly comes in allowing to integrate that into the social sites and the scaleable hosting is already built right in.

The book is well organized and black & white illustrations are put to good use in making directions clear. The index is thorough. The authors do not assume a lot of prior knowledge on the part of the reader in regard to how the various social networks operate. This did mean at times I had to plow explanations of things that really didn’t have anything to do with Zembly. The information on what Facebook applications are and what they do is a good example. This was a little annoying but fortunately these sections were short. I found the writing to be clear and to the point. The authors do not try to be hip or cool and focus on content.

To really get the most out of the book a reader should be familiar with JavaScript, html and css. It wouldn’t hurt to also understand RESTful web services. Once the first two chapters explaining Zembly are over, this really is a cook-book, or set of examples/tutorials rather than instruction on how to code or do markup. The experienced developer could probably slide by even if they were not working regularly with these technologies. Someone who has never written a bit of code may want to spend some time building some familiarity with javascript before they tack this book. Zembly itself has some quick tutorials that require almost no knowledge of programming. I watched a graphic art guy at work throw together a facebook widget/app in about 10 minutes using Zembly.

Zembly is still in what has become the ubiquitous beta state for on-line applications. And as it is under active development this book probably has a very short shelf-life. It wont be all that long before the platform moves along and leaves it behind. In an effort to shore up against that inevitability all the code and resources for the book are stored in Zembly. If changes are made today, tomorrows reader will be able to work with the updated structures. The book itself is also available in traditonal ebook formats and through Safari.

One of the nicer things about the Zembly approach is that it removes the barrier of hosting costs to participate in this space. In turn the developer surrenders up their work to be used by others. This may be problematic for those who would rather keep all their code to themselves, but fits in-line nicely with the fact that the entire stack is built on FOSS products. Of course, once again the beta status means that this free ride is not something that is guaranteed for perpetuity. I’m guessing that at some point, this type of central hosting is going to necessitate an attempt by Sun to generate some income from the service.

Getting in on the front end of a technology can often be rather difficult. The Sun folks seem to be ahead of the curve on making it easier for people to participate with Zembly. There are excellent tutorials and documentation on the site itself. For those who want to take it a step further, there is this book with a wealth of examples and explanations that will really accelerate the learning process. I’m not sure if Zembly will become the next big thing or not, but anyone who wants to gamble that it will, here is a chance to make the most of the ride.

Title: Assemble the Social Web with Zembly
Author: Gail Anderson and Paul Anderson with Todd Fast and Chris Webster
Publisher: Prentice Hall
Pages: 385
ISBN: 978-0-13-714431-0
Rating: 8/10
Tagline: Let’s Make a Social Application. Right Here. Right Now. Together.

The number and functionality of web based applications has exploded recently. Many of these applications rely heavily on AJAX to provide a more desktop-like experience for users. As the number of people using JavaScript grew, libraries were developed to assist with commonly encountered issues. Jim Harmon’s new book “Dojo: Using the Dojo JavaScript Library to Build Ajax Applications” aims to introduce readers to one of those libraries, the Dojo Toolkit.

The Dojo Toolkit, is a JavaScript library, created to increase the speed of writing JavaScript applications. It provides developers with widgets, themes, wrappers for asynchronous communication, client side storage and more. It does all this across various browsers and platforms without requiring the user to worry about differences in browsers.

The book follows an interesting pattern. It begins with a five chapter tutorial. The tutorial launches immediately into taking a straight html form and using Dojo widgets to add functionality. All of the code used in the tutorial is availble at the book’s web site. This tutorial moves quickly, introducing a number of available widgets and giving the reader a nice feel for how Dojo integrates with html markup.

What does not take place in the tutorial is the normal introductory material on just what Dojo is, how it is installed, or what it can do. I’m guessing that this will be a welcome change to those used to quickly brushing past the first chapter, or more, of any programming book. Harmon takes advantage of the fact that Dojo is available via the AOL Content Delivery Network, so the examples will work any javascript capable browser connected to the internet. He does give a quick explanation of what would need to be different to use local files.

All of the introductory material that I’m use to seeing is still in the book but it does not appear until chapter ten. There Harmon covers the motivation to develop Dojo, explains the history of the project, provides a bit of information regarding the dual-licensing of Dojo. (It is available under the BSD and Academic Free Licenses.) This leads into the last seven chapters, that cover the ‘deeper’ material in the book.

Between the tutorial and chapter ten, there are four chapters of widget documentation with examples and some explanation. Of the three sections this is the longest, though this is in part due to sometimes large sections of white space, as each widget begins on it’s own page. The documentation covers each widget and provides a visual representation where applicable. There is some repetition as this section covers widgets that were used in the first section’s tutorial.

The third section is entitled “Dojo in Detail.” It’s the level of detail that marks this book as more of an overview, rather than an in-depth treatment of Dojo. Harmon is true to the title, this book is an extremely pragmatic guide to getting started with Dojo as a means of adding Ajax to applications. It is not however going to take the reader to any great depth into the toolkit. There is plenty here to get started, and enough to hit the ground running, but anyone to get really in-depth coverage of the library will be dissapointed.

The person who will get the most out of this book is someone with some knowledge of mark-up and programming but not to an advanced level. The developer with a lot of experience will probably be frustrated with the amount of explanation and repetition of simple material combined with the lack of depth. The reader with no programming experience may struggle, though they could keep up if they are willing to look outside the book for a few resources to get a good grasp of web technologies. They may become extremely frustrated with some of the later chapters where the code examples skip steps and leave the reader to assume what has happened in between what is shown and the output.

That said, this book allows the reader to dive in quickly, get a quick overview and move immediately to making use of the Dojo Toolkit. If one is not concerned with gaining insight on every aspect of the library but would rather just get into it immediately with a little guidance, this may be just right.

With this in mind, it would have been nice if the book had provided less time on documentation and more on examples and ideas for how to best use the capabilities of Dojo. It is nice to have a book that isn’t so huge that it is overwhelming and difficult to find anything. But if something had to be given up to keep things compact, I’d have much rather lost things that are easy to find in the on-line documentation and subject to change as the toolkit develops. This keeps the book from being excellent, but it is still a solid introduction and primer.

Title: Dojo Using the Dojo JavaScript Library to Build Ajax Applications
Author: James E. Harmon
Publisher: Addison-Wesley Professional
Pages: 316
ISBN: 978-0-13-235804-0
Rating: 7/10

“Head First JavaScript” is one of the latest entries in O’Reillys Head First series. Like the other Head First books, it takes a somewhat unique approach in conveying information. The stated intent of the series is to help readers learn and retain material by formatting it in a manner that assists in meeting those goals. This means that the book is full of graphics, exercises and humor. There is also a refreshing note on who will benefit from the book. I’ve pretty much always thought of these sections in books as entertaining, in that I get to see what new way a publisher has found to say, “Everyone should buy this book!”. Head First Javascript actually does a decent job of describing who this book will help, and who it will not help. That alone had me intrigued right from the start.

And who is this book for? It is for someone looking to learn JavaScript, with access to a computer and a desire to learn the material through writing code and working through a variety of written exercises. The book begins with the very basics of scripting and as it states, is probably not going to be enjoyed by an experienced programmer who is looking for a JavaScript reference guide. There is a lot of white space, drawings, pictures and opportunities to do the exercises I mentioned as well as the answers to those exercises. For the experienced coder just looking for an api or methods and properties, this will probably feel like a bloated waste of time.

Someone like me on the other hand, who would like to take a JavaScript class but just doesn’t have the time, this book was just what I needed. I have done some programming, so I did breeze through some portions of the book, but in others I didn’t mind the review. I like having new information and ideas soak in over time. This book is paced just for that kind of learning. It is possible though for someone to be too new to the topic. Some understanding of html and css would really be helpful. Someone who doesn’t have at least an idea of how those technologies work may struggle a bit. Though I would think a little time with google would provide everything necessary to be up to speed.

There is an 8 page introduction that explains the reasoning and methods behind the books approach. The “Read Me” portion gives some great insight into just what this book is like. It begins, “This is a learning experience, not a reference book.” and follows that up with seven main points. To summarize them, the book teaches what someone needs to know to get up and running. It is not exhaustive, it does not go over the history of the language. There are many finer points not addressed. Using multiple browsers would be helpful to the reader working through the book. Skipping activities will greatly reduce the value of the experience. There is quite a bit of redundancy, it is on purpose and beneficial. The examples are as slim as possible to focus on what matters and finally, not all exercises have definitive answers. If any of that turns your stomach, this really may not be for you.

The format does pretty much make reading straight through the book without working the exercises a waste of time. This was my biggest challenge with the book. If I wanted to read it I needed a pencil, my laptop, free time and somewhere I could work through at least a whole exercise at a time. This wasn’t something I could fit in 20 minutes a night before bed. The authors recommend making it the last thing read before bed, but the end of my days are too busy to fit an exercise in. I found that a lunch hour, or a quiet week-end afternoon were my best opportunities for learning.

When I found those times, the book was thoroughly enjoyable. The humor was corny at times but almost always funny. I even chuckled out loud more than once. The exercises are widely varied as are the interspersed scenarios and stories that accompany the examples. I downloaded the necessary images for examples from the books web site though I avoided using downloaded code. It caused more errors due to typos, but I felt like I did better typing in the examples myself. I enjoyed working the cross-word puzzles and reading the ‘interviews’ with various pieces of technology. The time invested was much greater than for any other tech book covering similar ground, but I felt like the return justified the added time.

The style and humor reminded me quite a bit of the Dietel and Dietel How to Program books. I think that the scope is similar as well, as far as beginning from the very basics and building with each chapter. Head First starts with a basic description of just what JavaScript is and what it adds in the form of interactivity and finishes with a chapter that gives a good introduction to Ajax. In between the reader learns about all the basics like variables, looping, user input, validation, control flow, functions, code reuse, objects, etc.

As a hobbyist I felt like this was a great introduction to JavaScript. I think it gave me a foundation to build on and the ability to use more of the materials freely available on the web. Sometimes there is just so much of that out there, that it is difficult to know where to start. One of my primary goals in reading this book was to put together a couple simple web apps for myself as well as to get a better understanding of using the DOM for some Firefox plugins I would like to write. This book met those needs.

I think it is good to mention though, one last time, this is not a no-nonsense reference manual. In fact there is lots of non-sense and it is actually quite a bit of fun. But if the idea of 2 or 3 pages of big pictures to get across a couple simple ideas about data types bothers you, don’t spend the money on this book. It will just annoy you and you will probably feel ripped off. On the other hand, if you’ve picked up hefty programming manuals and found that you didn’t make it a quarter of the way through, and didn’t remember much of the quarter you did finish, this approach may be much more friendly and give you a taste of success. And what good is a more information dense book if you don’t read it or learn from it?

The table of contents gives a short summary of each chapter and a breakdown by section. The section titles are good for finding a place you read or stopped but wont always help find a topic. They are often named with the name of the exercise, not the subject they address. The index is good though and will help quickly track down topics. Like many new O’Reilly books, this one comes with 45 days free access to the electronic version of the book on Safari. The books site, linked above, has the table of contents, index, code examples and the complete second chapter available for viewing and/or download.

Author: Michael Morrison
Publisher: O’Reilly Media Inc.
Pages: 615
ISBN: 0596527748
Rating: 9/10
Tagline: A Brain-Friendly Guide