Customer Reviews

Professional Portal Development with Open Source Tools: JavaTM Portlet API, Lucene, James, Slide

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

 

 

There seems to be a new breed of technical cookbook book that involves throwing a lot of different technologies into a stew and hoping that what comes out is flavorful. Unfortunately, the result is more often than not, a less than tasty meal. This book is a prime example. Although it claims to be a guide to portal development using Java, it is mainly a bare bones discussion of lots of open source technologies without tying them together.

The book starts with an introduction to the Java Portlet API. This should be the heart of the book but in 35 pages we get a glance at some aspects of portals and some tables that give us a little on what but virtually nothing on how or why. Thinking that this was simply a quick introduction I wasn't too let down but then the book moves on to short chapters on Lucene, Apache James, Apache OJB, and Jakarta Slide. The book talks about security, planning, JavaScript, deployment, web services, etc. The one thing that is lacking is a feel for how this should all fit together within the Portlet API.

Taking each chapter by itself, some of them are good while others cover little more than the surface of each topic. Overall, the book fails to be a guide to developing a portal using Java. It should be considered as a series of articles dealing with different aspects of portal development but without any real connection.

Enterprise portal based on Portlet is very flexible for rapid development. A good practice is to plug-in quickly a variety of portlets as placeholders to compose a mock-up portal as the baseline for further detailed discussion with stakeholders. Of course, all the parties involved know that the mock-up presented is still a mock-up and they expect there is a production release at the end.

This book is also a mockup, though we readers did not know this until we paid this book as the final deliverable.

This book has two parts. The first part, Open Source Portals, contains 6 chapters. Chapter 1, The Java Portlet API (JSR 168), mainly lists lengthy attribute names and descriptions for CSS Style Definitions and for User Information Attributes, without much explanation. Much better material may be found online just a google away. Many pages are given to the code of a sample portlet. The explanation is as much as the comments made by poor programmer, almost none. Why do we readers have to pay in order to have the pleasure to read poorly commented coding? The sample is built upon Apache Lucene API, though it has not been introduced at this stage at all.

The remaining 5 chapters in the first part introduce several subjects that may be used to support a portal development, researching with Lucene, messaging with Apache James (for mail), object to relational mapping with Apache OJB, content management with Jakarta's Slide, portal security. The authors take these pieces of the components of their portal framework. A problem with this book is that the authors keep introduce a large amount of terminologies and software components without much insight. For instance, they never bother to explain why they use Apache OJB in their portal framework. Isn't Hibernate also a popular O-R mapping tool? I wish the authors explained to us other alternatives and at least some hints of why they choose certain open source tools instead of the others in portal development. This is particular important for using open source tools since there are often many alternatives.

The second part is titled How to Build a Portal. Again, you will discover many placeholders without much substance. For instance, under Design Pattern Consideration in Your Portal, nine standard design patterns are presented, several lines of description for each. The authors just do not bother to explain why they consider these 9 patterns are important for portal development and other are not, or they merely provides a partial list to demonstrate design patterns are still important to portal development as it is for any other development. I will give you another example here. Chapter is devoted to Effective Client-Side Development Using JavaScript. The coverage here is just common for any web development. I do not understand why the authors make this subject an entire chapter, in particular since this book covers a large amount of subjects in a moderate 400 pages, and in particular some fundamental subjects are still missing, such as the coverage of portal servers/containers.

I am not kidding. Open source portal/containers are not covered much in this book for Professional Portal development. Open source portal servers are briefly mentioned in the introductory part in about one page, each in several lines. Apache Jakarta Pluto is covered in a bonus chapter on the book's companion Web site. Apache Jakarta Jetspeed is mentioned in 7 linesJ. Liferay Enterprise Portal is introduced in 15 lines. This books give more coverage on EXo Portal. is introduced in 8 lines and it is introduced briefly again at Chapter 9, when a moderate Portlet is demonstrated.

According to the publisher, "An outstanding team of authors provides a complete tutorial and reference guide to Java Portlet API, Lucene, James, and Slide, taking you step-by-step through constructing and deploying portal applications." The book fails to deliver this promise.

As other reviewers have noted, this is far from being a professional (ie advanced) guide to portal development in Java. It is more of strange mix of articles and brief tutorials (of the kind that you might find on the net) vaguely related to portlet technology. A pitiful attempt to cash in on the first wave of a new and poorly known technology.

The content of this book is top notch. Each chapter stands alone as an insightful overview of a particular topic (like Lucene).

But the chapters are not tied together into a cohesive whole. I still highly recommend the book but it is not what you may think it is. You are not going to get a working portal from this book.

I ordered this book back in November 2003 and received it late in February of 2004. Needless to say, I was happy when I received it, but I was even happier to find that it contained a wealth of material that helped to me to understand the nature of portal development and therefore make more educated decisions in my own portal projects.

I have been investigating a number options including PHP / Mambo, .Net's iBuySpy, and the various Apache offerings as well as Plumtree. The investigation has been daunting because there are so many disparate perspectives on the subject when it comes to standardization and implementation.

This book does not necessarily solve the "grand design" problems associated with portal development, but it certainly helps to solidify one's understanding of the JSR 168 portlet spec and the tools available develop upon that spec. Given that understanding, one can gain a more coherent perspective of not only the solution, but really the problem itself.

One of the problems with the open source community is that it doesn't have the same type of backing that folks like Microsoft have. Compare Jetspeed to .Net's iBuySpy. The .Net offering has way more documentation and it is far more cohesive and direct. Of course, that's because they want you to try it out and subsequently get entrenched in their product and so on. As an open source developer one is often left to fend for one's self through experience and hearsay. The learning curve can be discouraging to say the least. This book, however, helps to alleviate that suffering greatly.

Also, it doesn't put me to sleep like O'Reilly books.

I have been developing software for three years and found this book helpful in writing portlet code for a BEA 8.x portal program i have been on for two months now. This book was also helpful for some javascripting that was needed for client side form validation i needed to implement

Having read the book description I was excited by what this book might have to offer. As it turned out I was utterly disappointed with my purchase.

I think the word "Professional" listed in the title of the book is totally misleading. There is nothing professional about this piece of trash. The authors appear to have done little more than scrape together as much open-source documentation as they could muster, with very little original material to hold it all together. Explanations are either poorly written or very thin on content, there is no flow between chapters, and basically no focus to the book. Just a mish-mash of technology descriptions wrapped up in a Wrox cover.

Overall I would rate this as one of the worst IT books I have every bought, and I've collected plenty over the last few years. If you're after a decent portal development book you'll be disappointed/annoyed with this one.

As others have noted this book is a rip off. Of the 12 Chapters 6 are completly unrelated to Portal deveelopment. Chapter 2 is Searching with Lucene, 3 - Messaging with Apache James, 4 Object to Relational Mapping with Jakarta OJB and 5 is Content Management with Jakarta Slide.

In fairness there are a couple of useful sections - but overall its quite incomplete.

I was pleasantly suprised to find a book on JSR 168 and even more surprised with the excellent content of this book. The authors explain what it takes to make your portal's portlets JSR 168 compliant and they also give you valuable examples with popular open source tools. Nicely done - I highly recommend this book!

I concur with just about every other reviewer. At a time when there's such a dearth of introductory material on jsr 168, I expected a lot from this book, but unfortunately got very little out of it, and worse yet, I have had to un-learn some of the practices I picked up from this book.

I got really excited looking over the first chapter's example portlet -- a Lucene search portlet. But there are some glaring mistakes in the code. One fundamental mistake I see a lot is their use of request.getParameter("mode") to retrieve the portlet mode, when it's much better to use request.getPortletMode(). The mode parameter is not always set and can sometimes be null; it's much safer to use the getPortletMode() method. In general, I would have liked more explanation in chapter one on jsr 168 basics. There simply aren't enough texts out there that do this well.

But I do laud the fundamental premise of the book -- using powerful, mature open-source projects (apache lucene and james) -- to build a portal. Search and mail are the foundation of any commercial portal and I think the open source alternatives compete well here; however, they haven't been tied into a framework that you can deploy out of the box, so I think the authors tried to meet a very real need.