Customer Reviews

Creating Applications with Mozilla

5 star:		(0)
4 star:		(2)
3 star:		(2)
2 star:		(2)
1 star:		(2)

 

 

It's doubtful that, on its own, Creating Applications with Mozilla would enable a developer -- even with a reasonable knowledge of JavaScript, HTML, CSS and C++ -- to do anything interesting with Mozilla. It certainly won't teach you how to create templates, package applications, or even use JSLib (which should be simple!), let alone write XBL or manipulate RDF files.

To be realistic, however, this book is often more handy than using Mozilla documentation online, and it has the usual high quality O'Reilly binding, paper, type design and layout. Buy it if someone else is paying or if you do a lot of Mozilla programming.

In a nutshell, the main problems I had with the book are as follows.

1. Technical writing should be judged in adversity -- how well it handles the hard stuff -- and on that count, this book fails miserably. When the going gets tough, the explanations become impenetrable and seem to be "preaching to the choir", assuming a deep knowledge of Mozilla programming. Even relatively simple concepts,such as the chrome URL, are poorly explained, and much of the sample code and technical reference material is, unnecessarily complex.

2. Much of the material is limited and incomplete: there are odd gaps in explanations, unenlightening overview sections (such as the description of using Perl with Mozilla), methods and properties listed with limited information (or no information) about their implementation, and incomplete references (such as the list of Mozilla CSS extensions). Crucial information (you can't manipulate datasources unless working via a chrome URL, for example) is often missing or buried.

3.There are numerous typos: misspellings, incorrect punctuation and errors in illustrations (at least three in figure 7-2 on page 181).

4. Code samples have errors and inconsistencies.

5. Much of the code and reference material is out of date (and was obsolete even before the print version was published).

6. The code examples are unfocused (there's too much emphasis on context) and don't always work (and didn't work online).

7. The index is often unhelpful and incomplete, without good conceptual indexing.

Mozilla programming is highly promising and, for the most part, not all that difficult once you know how, but finding accurate information about it is a tantalising process of trial and error. You have to rely on guesswork, intuition, word of mouth, limited or obsolete and inaccurate documentation, and the help of a very few (though extremely helpful) insiders available via the Mozilla newsgroups. Given that the project has been around for a few years now, I think that's unacceptable: I'd hate to see Mozilla wind up as a good technology that died for lack of decent documentation.

I happened to be experimenting with XUL and Mozilla at the time that I ran across this book, so I was very eager to get into it and see if it could help clarify some of the gaping holes in the existing XUL documentation within Mozilla. As an exhaustive reference to XUL and the associated technologies that are used to build Mozilla applications, it was very successful. As a higher level tutorial that explains the relationships between the different technologies and their uses, it was not quite as successful.

Chapters 1-6 lead the reader through the progressive steps required to build and package a Mozilla-based application. The authors create a demo application called xFly which is used as a test bed to show the different features of XUL, CSS, and JavaScript. By the end of Chapter 6, this application contains a tree control, a bunch of sample menus, and various other assorted UI widgets. But it doesn't really _do_ anything. Maybe I'm too picky, but I'd rather see an application that has some function, even if all it does is play tick-tack-toe. Then, to me at lease, it's much clearer how the different pieces would fit together in a "real-world" application.

Chapters 7-12 cover more exotic and difficult aspects of Mozilla
programming such as the Extensible Binding Language (XBL), XPCOM (Mozilla's component object model), and accessing web services from XUL applications. These chapters are very dense in technical details, with good references to online resources for further study. Overall, I found this book to be a very succinct source of accurate information about building applications with Mozilla. Its only weakness seems to be that it focuses too much on low-level implementation details without giving the reader (who may be new to the idea of XML-based GUI
application programming entirely) a good high-level overview of the benefits of this type of development and which technologies serve which purpose. Chapter 1 is the only chapter that explicitly addresses high-level application architecture, and it is only 8 pages long.

The bottom line is that this is a good reference book for people who already know how and why to build applications based on Mozilla, but a not-so-good introduction and tutorial for people who are completely new to the XUL-CSS-JavaScript paradigm of application development.

I was always interested in creating my own apps for Mozilla. I had played around with some of the custom CSS files and peeked at the XUL files, and I wanted to learn more. I figured that buying this book would be a no-brainer because of the O'Reilly name and my good experiences with the ... Hacks series. This could of been a good book, but it seems like they were rushed to meet a publishing deadline. It starts out building a skeleton application (xFly) to explain the simpler concepts. One would expect that they would continue to flesh out the framework, and they would show how to add function to the various widgets. After Chapter 2, they abandon this idea. The examples they do provide don't work correctly. If you get the finished xFly demo program from mozdev.org, it does not work either. The site reads "This requires serious attention". I agree. This book is a good reference manual, but a poor tutorial. If you want a good tutorial on how to build Mozilla apps, try xulplanet.org instead. Co-incidentally, this entire book is available at the aforementioned site if you would like to preview this book for yourself before plunking down $40 to buy it.

The reviews sounded so upbeat. Lots of examples that work easily. Unfortunately the examples don't work. This is readily apparent in the first few chapters.

Visiting the book site at mozdev.org confirms that it is not just me. A multitude of readers complain that even the authors' Examples download is riddled with errors. Many readers offer some good suggestions there, although most sound extremely frustrated.

But there are no words of encouragement from the authors. I emailed them at the O'Reilly site, and one replied by suggesting that I search the web for help.

Too bad because I love Mozilla and have been looking forward to this book for a long time.

This book gives a solid grounding in the principles involved and acts as a primer to the nitty gritty of producing a XUL application. In practice, XUL is pretty easy but it's easy to be caught unawares which is where a book like this comes in. If you've ever wondered how to extend Mozilla with a new button, or why your chrome doesn't work, or why Mozilla ignores it, or how to write a new chrome application then this is the book for you. Learn the principles of XUL and things fall into place very easily.

I am puzzled that other reviewers claim XUL and Mozilla are not ready for mainstream since the fact that an entire browser, mail, chat, editor, JS debugger and hundreds more third party extensions and apps have been written using it demonstrates it is. It certainly needs tools and add robustness, but it is already a viable and strong technology for producing platform neutral applications.

It is well worth the money, however it should be revised to reflect the latest Mozilla developments. As an added bonus, the source for this book is actually online so you can evaluate it yourself at books.mozdev.org before buying it.

This was the first Mozilla XUL book that I read; I now have Nigel McFarlane's book as well. I find it useful to have more than one reference book as I can often find things in one that are not in the other.

I found this book quick and easy to read and a good introduction whilst also going into sufficent detail.

Importantly for me it contains information on how to go about creating a remote application to run over the Internet and using serverside PHP, neither of which have I seen mentioned elsewhere.

The book is not perfect but it is useful and I think some of the other reviewers have been unduly harsh; I am glad that I was not put off.

I only just got the book, but the people who complained that it doesn't stand up to the usually high O'Reilly standards are spot on. The second chapter, which is all about "getting started" ought to explain basic concepts clearly. Instead it throws out all kinds of mumbo jumbo and forward references like "You could also define this style rule in an external stylesheet and make that stylesheet part of the package for your application, as we do later in this chapter ...." Why? Why should I keep reading to find out? Why does the first chapter of real content (chapter one understandably explains more background on mozilla and XPFE) seem to have a forward reference every third paragraph?

Clearly, the authors did not sit down and make a coherent plan of what the best way to introduce each topic to the neophyte. This stands in stark contrast to the various O'Reilly Perl books that always seem to give the overview in clear terms and then flesh it out, instead of diving into the middle and trying to explain it as you go.

The only reason right now to get this book is because it appears to be the only (or one of the only) ones on the topic at this time. Hopefully _Rapid Application Development with Mozilla_ due out in November this year will get it right.

One of the first big examples is proof that this technology isn't quite ready for prime-time. Several users report problems with the examples working once and then on a second try, literally seconds later, the example does not work.

For this reason, I would recommend waiting until this technology has stablized a bit more before purchasing this book.