Customer Reviews

Building Scalable and High-Performance Java Web Applications Using J2EE Technology

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

 

 

There are few authors who can clearly impart the complexities of attaining scalability and performance as design and construction goals. Greg Barish is among the anointed few. He achieves this with conversational prose--as though he were mentoring you--and examples that reinforce each concept as it's presented.

If you work in multiple development environments this book is doubly valuable because it's divided almost equally between generic concepts and techniques, and J2EE-specific advice. While the performance and scalability techniques presented in this book don't approach those embodied in books by Daniel A. Menasce and Virgilio A. F. Almeida, or Raj Jain, they are more than sufficient for software engineers and architects. Therein lies the value of this book - it sidesteps the queuing theory, probability and regression analysis and presents scalability in down-to-earth terms, using relatively simple math. This realistic, practical approach ensures that the design and development team will actually use the information in this book. Yes, the more formal approaches are better - they are just ignored, and the lite techniques in this book are far better than nothing, and will inspire developers to dig deeper after they've seen the results.

What I like about this book: (1) each chapter builds upon the preceding one, (2) all of the major aspects of web services development are addressed with a focus on scalability and performance in every chapter, (3) special skills, such as database connectivity, and the building blocks, such as XML and SOAP, are covered, and (4) while the book seems simple it delves into nuances of J2EE with respect to scalability and performance. The 'simplicity' is an illusion that comes from the author's ability to write well.

The value of this book is that it does make scalability and performance techniques accessible to most developers, even those who are math-challenged (and there are quite a few of them out there). I read it twice - once for the subject matter and the second pass to dissect the way the book was written. I gained much from both passes.

I am designing a web site for my own business that will provide an on-line service for which organizations can purchase subscriptions for their members.

This book quickly finalized my decision on the extent to which I would use the following technologies in my design. JSP, Servlets, Stateful Session Beans, Stateless Session Beans, Entity Beans, CMP, and BMP. This is exactly why I bought the book. It also gave me some unexpected insights such as how JMS, JNDI, and JTA could be helpful.

I am an experienced programmer, but my Java experience consists of a few months of servlet development. If you have already done a commercial application using these technologies, then this book has nothing to teach you.

While this book uses J2EE as the basis for scalability and performance strategies in web application development, it is also useful regardless of the development and technical environment.

The author begins this book with the clearest and easiest-to-follow descriptions of performance and scalability and how to measure them that I've ever read. The same treatment was given to web applications architecture, which is the second topic in sequence. I like Mr. Barish's straightforward, conversational writing style and use of simple (but effective) illustrations, graphs and examples that make complex concepts easy-to-grasp.

I stated above that this book can be used outside of the J2EE environment, and here are the chapters that are generic enough to accomplish this: 1 (Scalable and High Performance Web Applications), 2 (Web Application Architecture), 4 (Scalability and Performance Techniques), 5 (HTTP Client/Server Communication), 10 (Effective Database Design) and 12 (The Future of Web Applications). While each of these chapters are well written and go into sufficient detail for developers and architects I particularly liked chapter 10 because he explained relational database fundamentals and SQL programming with such clarity that I got more from the 42 pages that comprise this chapter than I did from a 300+ page book on the topic. The follow-on chapter on JDBC and SQL is as well written. Another reason why I liked chapter 10 is many developers understand how to develop servlets and components, but do not have sufficient understanding of relational databases. This book rectifies that, which is particularly important since most real world applications are data intensive and need to connect to databases.

Additional strong points about this book include: code examples are only given to reinforce a concept or show an example. Don't expect to find a recipe book based on code - this book is about making it scalable and giving it performance characteristics. The J2EE-specific parts of the book use realistic examples and propose real world approaches. However, the strongest aspect of this book is the author stays focused on scalability and performance throughout the book, always ending each chapter with scalability and performance hints that are related to the chapter's topic.

This book is for architects and software engineers who are building applications that support business-critical needs. It's clear, concise and exceptionally well written.

This is a good architectural primer on performance and scalability issues in general, and their consideration in web application design in particular.

Every chapter has introductory material explaining a specific technology, how to use it, and related performance hints. Excellent reasoning on every point and no fluff whatsoever make this book stand out among others.

This is one of those rare books in which even the material that I know well was a pleasure to read.

This book takes an interesting approach to using J2EE technology. Rather than concentrating on a single aspect (servlets, JSPs, etc) or spending hundreds of pages to explain all technologies in detail, the author has chosen to lightly cover all the important aspects. In a sense, this book is an "executive summary" of J2EE. The readers who would probably get the most from this book are architects who need to understand J2EE but don't need to write much code and developers who are unfamiliar with J2EE and need an introduction to the technologies. This is especially helpful to developers who have completed the Java Programmer Certification but are unfamiliar with server-side development. There are two things that make this book unique and especially valuable to those new to server side development. First, the book covers the complete end-to-end solution. The author spends several chapters explaining the architecture of web applications. All the basics of server side development are discussed (JSP, servlets, EJBs, JMS, JDBC) but the author also covers other important issues such as the http protocol, web services, database design, and SQL. Second, the author explains which issues are likely to have an impact on the scalability and performance of your web applications. The entire book is under 400 pages and is very readable. Code samples are interspersed throughout the book to help explain the topics. If you are new to J2EE and are looking for a well written introduction then this book is very good choice.

Building Scalable And High Performance Java Web Applications Using J2EE Technology by Greg Barish (professional consultant specializing in the design and architecture for scalable and high-performance Web applications) is a definitive, superbly presented, step-by-step programming guide for web designers who already have experience in the basics of Java. From assorted methods for effective HTTP Client/Server Communication to proper request processing with J2EE to using Java Beans to build application servers, the methodology for functional J2EE coding is all mapped out with concise and clear guides. Lines of sample code help to clearly illustrate the principles being presented, and an accompanying CD-ROM (which requires a Windows-based operating system to run) is filled with useful source code from the chapters of this textbook. Building Scalable And High Performance Java Web Applications Using J2EE Technology is strongly recommended for all web application designers using Java and J2EE.

I agree with the reviewer before me that this book is clear and pragmatic. Where the more traditional methods for scalability and performance are more scientific and will give more confidence in the end results they are usually cast aside because developers do not understand them. With this book they have no excuse. The methods given are easy enough to be understood by code jockeys, and effective enough to be used by software engineers working with tight deadlines.

This book is valuable for other reasons too. The author obviously understands the Java development environment and its pros and cons, and also knows databases. Any developer who reads this book will come away with a better understanding of web application design and development, and will also understand the backend systems, such as relational databases, XML and web services.

Web design with Java was a very complicated concept for me to understand. I just couldn't grasp the logic behind the code. After reading this book, there are still some areas I have trouble understanding but for the most part I am now beginning to see just how powerful J2EE really is.

Barish's 400 page manual is well documented and the author tries to keep the level of understanding to middle level technical person. While there are some sections that require a higher technical level, section like client/server communications require a lower level understanding.

The book explains how request processing works, how to work with JDBC and SQL together, how to use Java beans and an abundance of other topics. The author make sure that as much information as possible is included.

The cd-rom included has code that pertains to section from the book and with the examples in the book, any developer should be able to have an excellent starting point. With a subject like this the manual could have been 3 or 4 times the amount of pages, the author has put together the most important points and what you have is the best I have seen.

Overall I found this book to not only benefit myself and enhance my personal knowledge, but several of my friends have also read parts of the book and found it to be something they could use in the their jobs as well.

I originally picked up this book thinking that it would serve as a design guide. As I started reading it I realized this was not quite the case. This book describes how J2EE in general can be applied to create scalable and reliable web applications. The book introduces the various aspects of J2EE technologies such as JSP, Servlets, EJB's, JMS, JDBC, etc. and explains how those technologies contribute to web application performance. The book does not provide what I would consider OO design patterns or any real pattern related design information. Regardless, I found the book informative, enjoyable and one of the quickest to read books I have encountered regarding Java. It solidified my understanding of the capabilities of the J2EE platform and did so in a concise way. There were just enough code examples in the book to exemplify the various technologies without becoming tedious.

I would definitely recommend this book to anyone wanting to learn J2EE technologies, possibly just after reading a first book on the Java language itself. I recommended this book to my manager as it would give someone a clear understanding of the usage of the overall platform without getting into gory API level details.

The only reason I give this book 4 stars instead of 5 is due to the fact that the title, possibly unintentionally, is a bit deceiving. While performance was discussed, I would consider it cursory. A title along the lines of 'An Overview of J2EE, A Scalable and High Performance Application Development Platform.' might have been closer to appropriate than its current title. I believe I am now better prepared to jump into an actual J2EE design pattern book.

I found the book to be extremely readable, informative, and well-presented. It's a nice introduction for people who are new to web server applications programming and performance/scalability issues in distributed systems, and it's a nicely written and well-organized refresher/reference for people who already are somewhat familiar with those topics.