Customer Reviews

IBM(R) WebSphere(R) Application Server Programming

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

 

 

Learn WebSphere from the inside out. This book dispenses with the usual abstractions and details step by step every example and technique. The book starts with installation, moves onto administration and builds on this knowledge to build an application database and finally a complete application. This book contains advanced chapters on performance and monitoring.
What sets this book apart is the depth, it moves below the usual abstractions and reaches the inner WebSphere core.

Based on purely freely downloadable tools, this book is great for students on a budget and contains sufficient grunt for the seasoned professional code cutter or sysadmin.

I guarantee you will never read a WebSphere book quite like this one, it has introduced me to a completely different way of viewing WebSphere and J2EE.

This is a book about WAS -- WebSphere Application Server -- whose contents stick concisely to its title.
As a reader, I was surprised that the author really took the opposite tack using standard UNIX commands
than every other WebSphere book to discuss the administration and programming in WebSphere Application
Server while totally avoiding WSAD or Visual Age.
Any reader can just start with a Linux machine, a text editor, and WebSphere Application Server solely
to learn the inside and out of the latter.

The book teaches you a step by step installation, followed by testing the installation and administration;
then progressively programming a web application that flow from one chapter to another; then stress
testing the web application; and finally monitoring, tuning, and risk managing WAS and the web applications.

The book teaches you how to deliver WebSphere applications with maximum performance and availability.
This book also offers free download for a toolkit and the WebSphere monitoring application for
anyone who would like to supplement his or her computer system executable with extra tools to benchmark
Web applications, to monitor processes and threads, to add a WAS risk management application, etc.

The writing is solid and the technical approach using the standard UNIX shell scripts and the make
utility untied this book from a specific version of WAS.
The learning vehicle focuses on concrete commands that show you what is happening behind the scene
of web applications programming.

Being a book whose contents stick to its title, this is a 4+ stars book (and a 5+ stars once the electronic
typos are corrected).

This is a fine book in distributed systems to be added to the computer science library.

Excellent book for all Linux and UNIX users. This book offers plenty of insight into the administration and programming of WebSphere that helped me to understand many interesting points such as J2EE classloading under WebSphere runtime, HTTP session persistence (persisted to database), the web container and JAAS-securing servlets, beans to be turned into web services, etc.
This book is highly technical, and it offers also insight into the administration way of thing. I recommend it for real enterprise application development.
Absolutely to be read.

From the many books that I have read, this is the first and only one that
addresses WebSphere Risk Management. The author did an amazing job in
introducing his monitoring applications: WASLED / WASMON (a totally
free application for non-commercial use).

The monitoring is totally independent from any WebSphere
API's, which set this monitoring application far above applications that
impact the performance of WebSphere.

Though too short, the performance and tuning chapter is really amazing. A
Brief section about EJB-container performance is thoughtfully and
comprehensively written.
A competent yet non-pedantic use of real computer
science nomenclature sets this book apart from run-of-the-mill computer
trade books. It is balanced writing that is careful (for the most part) to
please both the reader of highly technical material and the new comer to
WebSphere as well.

The programming flow from chapter-to-chapter ensures a pre-mature
optimization, where the notation of throwable exceptions is kept to a minimum.
Yet. this is the first book to show full-blown exception handlers that can be
put in the center of any enterprise web application: a total working code --
gratis!

I have no reason to give this book less than a well deserved 5 stars. This
is a fine book and a great value...

I brought this book seeing the reviews of many thank full friends and i am impressed.

I have read the first 4 chapters untill now, and I liked the new topics and ideas the author has introduced. They are very usefull in every stage of developing J2EE applications. I am sure any one who read this book wil have a thorough grip of websphere functionality.

Also this book is for versions 3.5 and 4 but the author has mentioned the version 5 specific changes also.

I am giving 4 stars for its detail explanation of websphere install,configuration, programming and fine tuning.

I bought this book from a discount store and paid almost nothing for a wealth of info. Contrary to other reviewers, I think

that scripts included are not platform-specific -- I develop

for WAS on Windows, and use cygwin, as do many other of

my colleagues. While I've used WSAD in the past, it's useful,

but not all organizations can purchase it. Plus, working with

this book gives you detail about WAS that is abstracted

away by WSAD and similar tools -- and comes in quite handy

when troubleshooting.

The book provides a detailed picture of using WebSphere, in particular the books attention to administrative issues made it stand out against other WebSphere books. Wouldn't hesitate to recommend, if your looking to add a WebSphere book to your library this is the one!

I particularly like the flow from one chapter to the next and the reuse of
the code. The author carefully used a development tree to prove WAS run-time
effect in classloading. The reader will realize how the tree hierarchy and
its organization can impact the visibility of the classes. This is the only
book I've found that explains WAS run time and the classes loading and
visibility. Chapter 15 is a corner stone to understanding WAS classloading.

I use the IBM Infocenter as a reference, but the real meaning of hot
deployment is realized practically in this book; a set of cleverly written
scripts are utilized throughout Part III to hot deploy a web application
quickly.
I liked the development from servlet to EJB, taking code the readers should
be familiar with and putting an EJB wrapper around it was a fine idea.
Using Apache SOAP and writing a serializer and a deserializer to access these
EJBs was also a great idea.

Our company still uses CGI, and I found this book an excellent resource as
it is quite direct in showing the utility of using both CGI and Servlets in
the same context of a Web site.
Strange enough, I am not a Perl programmer (in fact, I quite often avoid
ir). Now that I have read this book, I bought the Perl Cookbook to
supplement my library.

The system processes and network ports and socketsused are clearly
demystified. The book is straightforward and clear. There is no single
reference to WSAD and Visual Age, except in Chapter 1 where the author made
it clear that neither WSAD or a Visual Age product will be used this book.
This is really a book for the community as it opens AS to the public without
using any of IBM proprietary software or tool-sets to the understanding and
programming of J2EE web application in WAS. Interesting nomenclature. A well
organized book. Couple of typos. But overall I will give it 4 and 1/2 stars.

To start with a good point, this book does contain some very useful information regarding J2EE and Websphere.

Still I find the book almost useless because the information I'd want to see is buried beneath a mountain of platform-specific little shell scripts that are fully spelt out, including tips on where to store and run them.

Not all Websphere developers always work on unix, they don't always like shell scripts, want to know about perl, and so on. Yet at least 70% of the book seems to be covering just that, instead of talkng about Websphere.

I do NOT wish to read about handy unix scripts, but this book even gives shell scripts for changing the words 'true' to 'false' in a text file, to name just one of the deplorable examples from this book. I know how to edit text files thank you, I might even use Notepad on a Microsoft machine yes, but that's not what I bought this book for. The same goes for all the tips about using Lynx and Perl and how to write log files: either obvious, off-topic, or only interesting to a small subculture of certain-platform adepts.

The book is excessively fat and you are likely to miss any bits of useful information in it because, there it goes off again page after page with some platform-specific script that finds certain words in log files, or so.

This book should have been about Websphere, its J2EE extensions and its idiosyncracies. Perhaps tips on deployment using platform-independent means like Ant/XML configurations would also have been an asset.

As it is, I do not recommend to buy this book unless you are attracted to exactly what I'm complaining about. You are better off just fiddling with Websphere yourself, using your favourite or required platform and text-editing strategies.

For a book that claims to be a guide to programming applications for WebSphere, this book wastes an awful lot of time explaining how to do administrative tasks like installing WebSphere and DB/2, and how to monitor resource usage with UNIX tools. The book is right around 800 pages long and there's not a single line of Java code in the first 250 or so pages.

In all fairness, the rest of the book does go into considerable detail about developing, testing and debugging J2EE applications on WebSphere, but the author's insistence on writing command-line scripts for every conceivable task (instead of using a GUI like WSAD or Forte) does less to illustrate good programming techniques and principles and more to just show off how handy the author is at writing shell scripts.

My organization uses WSAD to develop software and I purchased this book in hopes of gaining insight into Java programming principles. Unfortunately, the contents of this book are so clouded with platform-specific scripts and non-programming-related material that I've shelved it. I would recommend downloading and printing Redbooks before spending money on this one.