Distributed Computing Books

I'm fairly new to java (less than 1 year) and I thought, given what the other reviewers had to say, that this book would have been a more impressive work, especially to a newbie like me. I worked through the whole book and was not very impressed.

The writer constantly refers the reader to other authors' discussions of the topics, which is really distracting. Just boil it down and keep using the foot notes (which he does as well).

A lot of the patterns were geared toward re-use. I guess that's fine if your designing a product for re-sale, but I was looking for more in the way of "did you know you could do this or that". I guess it is really my own fault. I did read the other reviews and bought it anyway thinking this book would contain some useful insight. Most of the stuff he mentioned I had already implemented as the design patterns were fairly logical and common sensical.

It was decently written, I was just hoping for more in the way of a not so overly simplified approach to understanding how java can be easily used to create servers. I already understood that. If there is one thing this book has taught me - or more accurately - confirmed for me is that sometimes programmers over-complicate things to make them re-usable. I have definitely found it is much more efficient to create many components from scratch rather than trying to figure out what some other programmer was thinking in their implementation. In other words, re-use, I think, gets blown out of proportion in the business application development environment. In the time it takes to figure out what that developer's strategy was, I could have already created a perfectly functional, scalable component. Leave the over complication to the development teams creating commercial products like high end web servers, data access components, etc... I've got work to do.

One of the best books I have read. It goes through the process of creating and Enterprise Application Server. This is not a J2EE application developer book; it is a book that can help you to write your own application server.

This is the first book i've seen on server-side Java that does not focus exclusively on J2EE. While the J2EE API and application servers are a tremendous boon to quick development, a tremendous amount of simple, elegant solutions provided by the base JDK are overlooked as too low-level or complicated.

As with all tools, EJB/Servlet/JSP should be applied where they fit into your problem, and not shoehorned into every application.

Would you believe that there is a Java Server book that has almost nothing to do with Servlets, JSPs, and Enterprise JavaBeans? If you are an advanced Java programmer and have felt a need to write your own application server then this may be the book for you. The author starts off with a well written discussion of class loaders and then goes on to show how to design your own application server using your own class loader. For most developers this may be interesting but of little real value. The thread chapters will provide little new information for anyone who has studied for the SCJP. The next few chapters discuss RMI, sockets, persistence, serialization and other issues that are required for the application server that the author is developing throughout the book. Servlets are briefly discussed but mostly on how they can be used to replace sockets and RMI within the application server framework. This is followed by a discussion of modeling business objects that seems somewhat out of place. The middleware section is very interesting and covers a wide array of topics from JMS to CORBA. The JNI section will probably not be used by many Java developers. Although the book is interesting I am left with the feeling that the author has missed the point. Why would a team of developers spend tens of thousands of dollars developing a service framework when inexpensive and robust application servers are readily available on the market?

I'll be honest, I'm an O'Reilly fan. If there's a book on a subject with a furry little animal on the front, then that's the one for me. So I was a little leary when a friend of mine passed this book along to me. Well let me tell you, this book is fantastic.

This is the first book I've found with such a thorough coverage of java server programming. Be forewarned, when they talk about Server-Based Java programming, they aren't talking about servlets and JSP for web projects. If you're looking for such a book, you're better off looking elsewhere. This book has excellent coverage of issues involved in programming middle-tier and backend server java for use in enterprise level systems. The sections on server threading issues and code deployment are worth the cost of the book alone. But then they throw in RMI, Corba, and JNI for helping you integrate your components with other applications.

The book is noticeably light on EJB's, but this is by design. So you may wish to pick up a companion book if that's your aim. However, even if your focusing on EJB's, this is a highly useful book for the underlying server architecture that the EJB's will reside on.

I have to agree with Chung Yeung Choi's review. Look at Advanced .Net Remoting by Ingo Rammer for a good review of .Net Remoting, but for COM+/Enterprise Services, I have yet to see a better treatment! It may be because that is what my focus is these days (rather than .Net Remoting), but it really helped me get up to speed quickly on the issues/problems/advantages (he points to all of these -- excellent coverage!) of Enterprise Services.

This is an outstanding book for anyone learning .Net Remoting. I have a background in Java remoting technology like RMI and EJB's but find the .Net remoting architecture to be a better model. The book is both comprehensive and easy to read. All of the book examples work. All I can say is that the coverage is outstanding!

Audience:

This book, Distributed .NET Programming in C#, is intended for experienced Microsoft developers and architects.
It expects the reader to be familiar with the basics of C#, the .NET framework, and object-oriented practices.
It also clearly assumes the reader is at least somewhat experienced with both COM and distributed programming.
If you have this background and want to learn about distributed programming in .NET, then this book is for you.

Pros:

This books covers nearly every topic in distributed .NET programming in enough detail to get you going yourself.
While this book is not solely about .NET remoting, it has three very thorough chapters that are sufficient for me.
If you are not familiar with the concept of .NET remoting, it is the centerpiece of the distributed .NET model.
It basically is the replacement for DCOM, and thus you can see that it is essential for the distributed developer.
I had read some about remoting to be familiar with the basic concepts before reading this book, but that was all;
now I could easily go out and implement .NET remoting, with this book being a great supporting reference to keep.

Of course, if you are an experienced Microsoft developer, then you also want to know about COM+ and MSMQ in .NET.
This is actually why I picked this book to read, since it covers these essential topics as well as .NET remoting.
There is one chapter on Component (or COM+) Services in .NET, and another one on Message Queuing (MSMQ) in .NET.
Both of these assume the reader is already familiar with the concepts, and gets right into their .NET details.
This included thorough discussions of Just-In-Time (JIT) activation, object pooling, and transactional support.
There were also chapters on COM Interop and Web Services, as well as an advanced "overview" of some .NET topics.

Cons:

While this book is a very good book on distributed .NET programming, there are also some things I did not like.
First, you have too read (or skip) the first 90 pages to even get to .NET remoting, and then just an introduction.
That said, I did learn several things from the author's advanced discussion of assembly binding and other topics,
but I can't help believing that this was too much -- it could have been mixed in later or put into an appendix.
Next, the chapter on Web Services, while clearly being part of distributed programming, just seemed out of place.
It was too short and too shallow -- it could have either been dropped completely or more should have been added.

Although the book was thorough with .NET remoting and some other COM+ topics, there were also some items missing.
I would have liked to have seen a short section or chapter on COM+ Events, also called Loosely Coupled Events.
To be fair, this topic is mostly left out of COM+ books too, but it is actually a very important part of COM+.
Next, as the author himself notes, there were no "real world" examples, only short code snippets as examples.
There was also little, if any, discussion of the whys and why nots of distributed programming, only the hows.
Both of these items may not matter to many readers, especially those already experienced, but they were missing.

Notes:

I have one other issue with this book that didn't really belong anywhere else -- its just one of my complaints.
There is a long (74 pages) appendix in this book called "Data Access with ADO.NET" that just doesn't belong.
It is actually a complete chapter out of another book, C# and the .NET Platform, written by Andrew Troelsen.
I have heard Andrew speak before, and I do respect his work, but it is here only because he is a colleague of
this book's author, Tom Barnaby, since it clearly isn't relevant to this book, nor the audience of this book.
I appreciate cross-marketing, doing it myself whenever possible, but this just seems to be an excessive case.

This book is very well written for any level developer. The layout is very clear and easy to follow. Clear and organized examples. Walks you through latest techniques and abilities of the .Net platform using C#.

I've read that "Remoting is the unsung hero of .NET". This is a great book that introduces an aspect of the .NET Framework that is not yet widely understood. While this is not an in-depth reference on Remoting, neither is it a book for beginners. In the words of the author, this is a book "that leads the reader through a logical progression of topics while clarifying complex concepts."

The first thing I liked about the book is that the obligatory introduction to the .NET Framework (and C#) really contained some valuable information--not just an overview for beginners. In my opinion, the introductory sections alone are worth the read.

While the book is filled with sample code, the author stays with a simple example consistently throughout the book. There is no attempt to show real-world examples; but rather a simple example in real-world situations. An in-depth study of real-world remoting scenarios.

This book truly provided me with a great head start on understanding and using .NET Remoting concepts.

Many thanks to Tom Barnaby for a great book.

This book should only be purchased by those individuals that have just heard the letters S, A, and P all in a row for the first time. If you have absolutely no idea what SAP is, have no idea what an ERP is, or your company is still using punch cards, then this book is for you.

The authors provide an excellent overview of what to expect when embarking upon the implementation of an enterprise resource planning system like SAP. They provide thoughtful insight on factors that should influence the decision to proceed with such a project as well as sufficient detail on the particulars of SAP.

This book is obviously a bit outdated but since finding good books giving you an overview of SAP is so hard, it may still be worth having a look at this one.

I bought this before starting a project as coordinator of data migration and found it gave me some good insights.

As mentioned though, a bit outdated.

This book is designed for managers and deciders who are in an evaluation phase and compare different ERP solutions. R/3 is a world-class integrated ERP solution and the less risky possible choice. If there is any doubt left, this book will convince the reader. SAP is not just a piece of software, it's also a culture and a club. Belonging to it is a real asset in someone's career.

An excellent introduction to SAP by people who live and breath it.

This book has excellent sections on Business Case, Functionality (showing the links between modules, not just functions)and Deployment Options. It really helped me understand what I was going into implementing SAP for my company.

The Book has only two dissappointing sections. The chapter on process reengineering could have been better structured and applied, Hammer has better material. The walk through of methodology in chapters 17 and 18 was dry, uninspiring and again unapplied. More could have been written on ASAP.

ASP.NET Distributed Data Applications, is an excellent book for learning ASP.NET database programming. At the moment I am on chapter 8 all the examples which I downloaded from wrox, all work. The book is very detailed with many methods and ideas of contructing a database web application. its not a book for beginners. A person with good basic asp.net or vb.net knowledge will get most from this book. Excellent buy and worth the money.

...

The Good

There are a lot of things to like about this book if your main interest is in data driven applications that require many remote devices to be able to update data on a central server, possibly after being disconnected for some period of time. I've personally skirted such projects several times in my ASP3 consulting days, but thankfully never had to build one, mainly because at that time the infrastructure was not there to support such applications within the budgets of my clients. Today, however, that's changed, and I think we will see more and more commercial applications being written that use the kind of distributed data techniques described in this book.

In addition to the source code files and a other resources available on the website, the authors have also set up several live examples from their book. This is something I wish more books would do, since I think it really helps readers to be able to see examples from the book in action. Especially since so many book examples don't work, so seeing them working on a live server helps to reassure the user that the code does in fact work. Obviously, this works best if the source for the online examples is also available, and for this book, it is. ... >Another thing I like about the book is that it uses a fairly consistent scenario for its examples, that of an ECommerce store. While certainly there are plenty of books out there that have used this particular scenario for their examples, what sets this book apart is that it takes it to the next level. In addition to the tried-and-true postback and web form examples, this book covers data update scenarios using rich clients, remoting, web services, client-side XML, and more. If your users are not sitting at a desk with a constant Internet connection but they still need to update data in your systems, this book's examples can take you further than any other ASP.NET book out there today.

In addition to covering data applications across a variety of clients, the authors also hit on topics like how to set up an efficient concurrency control mechanism and how to handle conflicts that occur during data updates. Another feature covered by the book is the use of components for data access, something I am a big proponent of. Encapsulating data access logic into components has many benefits, which this book explains in one of its early chapters.

There is a lot of very practical information in this book. Be warned, however, that this is not (and was not intended to be) a reference book or an academic overview. This is a book for programmers, and specifically experienced programmers who are faced with the challenges of managing distributed data applications using ASP.NET.

The Less Good

There were only a few things about this book that I could think of to mention in this section of my review, and none of them are particularly bad. However, I tend to think that a review that doesn't include at least a little constructive criticism hasn't really accomplished its objective.

As I mentioned, I really favor using components for data access. Chapter 2 of this book covers a wide range of functions for returning various data types from such components, but one thing it lacks is any coverage of code generators or helpers. In this case, although the code described in the book is solid, it is also some of the most dull code in the world to write and occupies a huge portion of the total lines of code in any given application. As such, it should be automatically generated or reduced through the use of helper libraries as much as possible. I can't blame the authors too much, since data components was not really the focus of the book and spending any more time on them would have probably been off-topic. ...

Beyond this minor criticism, the only other thing I found myself disliking about the book is that it is so focused on solving the actual problems that, not having a need to solve those problems at the moment, I found myself losing interest from time to time. This is not really a criticism of the book, since it is dedicated to helping developers who are "in the trenches" trying to solve these problems. There is perhaps a need for a similar (probably smaller) companion book that would provide a higher-level view of the issues covered by this book, and would be appropriate for a project leader or architect, as opposed to a developer.

Overall, this book provides deep coverage of its topic with a huge amount of practical code and examples, and would be an excellent addition to the library of any developer who will be faced with the challenges of distributed data applications using ASP.NET.

If you're seeking to build a data-driven ASP.NET application that provides any kind of a user experience beyond the classic approach of posting the page back to the server every time you select or edit data, this book is a MUST READ. It shows how to maximize the user experience and client responsiveness under whatever set of design constraints your client-side scenario imposes-from basic HTML-enabled browsers to IE 4.0 and IE 5.0, with or without the distributable .NET framework, and small-screen HTML-enabled devices, mobile devices, and cell-phones.

The list of technologies you can employ to achieve these ends can be daunting-n-tier design, ASP.NET, ADO.NET, client-side scripting, XML, web services, web service behavior, .NET remoting, WML. The beauty of this book is that the authors put each into perspective as to the role they may or may not play in each design scenario. Then they go on to demonstrate a solution that integrates the relevant technologies to achieve the end. Their discussion of batch updating issues in a disconnected world and several solution approaches is especially valuable.

And, like most Wrox books, they don't just plunk you down in the middle of the forest to leave you wondering why and how you got there. They briefly introduce each technology with an overview and short discussion on its relevancy to what you want to accomplish, a viewpoint that tends to be sorely lacking in many other books and help files. And-a dash of wit and humor here and there helps the medicine go down in a most enjoyable way!

This book is practical and well written. If you want to write the type of app they cover, you'll find all the nitty-gritty details here. I deducted a star because the book goes into too much detail; it gets boring. They should have assumed a sharper reader and picked up the pace.

BUT... Do you really want to build the type of app they spend the most time on? This would be an app that makes heavy use of XML and DOM within IE (no discussion of XML and DOM in other browsers) to simulate a true client/server architecture. It all seems very complicated, error prone, and hard to maintain.

P. S. You could learn a lot for free just by downloading and examining the sample code from the Wrox web site.

If you're anything like me, you've spent the past couple of months dredging over hundreds of pages worth of material online... and like most, you've probably said to yourself, "How does it all fit together and how do I use .NET effectively to build a distributed data application?"

This is the book that, for me at least, closed the gap. I had remained dormant on a project for days due to important design decisions that I needed to make BEFORE I started programming. Unfortunately, I didn't have the answer and I couldn't find what I wanted online.

This book goes WAY beyond what I thought I needed to know and contains a magnitude of information that I didn't realize I needed to know!

I came upon this book during my quest for some tools that would help me put some perspective on current software design and architecture issues. I am sure I was not alone in my efforts to understand the evolving client / server paradigm and the performance issues involved.

I am a believer in the need to build performance into systems, that it can not be conveniently added afterwards. I also believe that scalability and adaptability are characteristics that result from good design. I was more than a little overwhelmed by all the marketing hype for the latest generation of Internet-related tools and the general level of discussion of "middleware". Then, I found this book!

I was very pleased to see that the issues of partitioning logic across physical and functional layers were treated as equally important. The models proposed (a five-tier functional model spread over the traditional three-tier physical one) provide a very clear image of the role of the three main classes of middleware.

In my opinion, this element of the book justifies the cost of the purchase many times over all by itself. The inevitable and inexorable evolution of the client / server model is well documented and the conclusions are well justified. The newest model is very pertinent to the issues being faced by architects everywhere and does a much better job of separating the data locality issues from the similar issues related to the granularity and coupling of the application logic in modern computing environments.

The role of the Internet technologies in enabling and driving this evolution is clearly described. The authors also provide a background that will allow the reader to follow the future evolution of the model and the eventual introduction of still more functional layers with ease. The paradigm is, indeed, that powerful.

The book manages to address two disparate audiences very well. First, readers such as myself looking for design and management background material on the topic are very well served. At the same time, practitioners will find very comprehensive summaries of much of the current state of knowledge in the field. There are supplemental reading lists which will lead the reader to more focused discussions of any specific topics that may require further detail.

I would expect this book to prove to be very influential. It challenges several established notions about client / server architectures which have led many shops to struggle with their implementations. The proposed model, properly applied, should lead to more robust designs that will prove to be more scaleable and adaptable than many we have seen.

Highly Recommended!

Now that client-server is mainstream, it is OK to knock it. Specifically, performance problems arise with enterprise client-server systems due to the complexity of the distributed processing. The more hops between platforms, the more overhead, and the more points of failure. Client-server architecture is inherently distributed and often has to occur across multiple platforms connected by skinny wide area network (WAN) pipes. What can help? This wide-ranging diagnosis and treatment of the many aspects of the dilemma is highly recommended for its extent, depth, humor, and penetrating insight. Part One on performance fundamentals list 23 components of response time, offering incisive distinctions for both the beginner and the advanced practitioner. When cross-referenced in the extended application resource usage matrix to identify bottlenecks, these components become powerful drivers of response time tuning using trade-offs, choices, and priorities to squeeze every once of performance out of the available computing configuration. Part Two treats the software performance engineering process. One important goal is to build a performance model out of the hardware/software environments, application flow, data structures and business factors. In addition to complex interrelations of computing components, Loosley provides pointers to some very simple principles and methods for tuning complex systems. Part Three on principles is the heart of the book. Software engineering principles - formality, completeness, simplicity - provide the foundation for design principles of abstraction, decomposition, and information hiding - which, in turn, support refinement, independence, and localization (p. 207). These are explained and applied in sufficient depth and detail so that practicing performance engineers will find both helpful tips and techniques, amusing anecdotes, and theoretic principles. Queuing theory is explained but not treated mathematically other than the marshaling of a few simple metrics of practical interest. With the emergence of parallel processing as a relatively new candidate solution for decision support and data warehouse applications, the Chapter on The Parallelism Principle contains one of the best concise explanations I have seen in the literature of the differences between massive parallel processing, non-uniform memory architecture, and clusters as a processing resource. Part Four on Applications drills down into middleware and performance. The authors argue the concept of logical unit of work transaction management is sound and well proven in the world of host-centered (i.e., mainframe) computing. However, when the architecture of synchronous communications is transferred to distributed client-server, then problems arise. As soon as one of the multitude of processors waits, the entire system is at risk of log jamming. And since all computers wait at the same speed - both a humorous and sobering anecdote called "Bell's Law" - no amount of souped up hardware or software will make a difference. The authors document at least twenty points in which enterprise client-server - that is, three tiered - systems can experience bottle necks. The problem with client-server is that frequently only the database and the client workstation are suitably instrumented to gather performance metrics and data; and, even then, it is the interaction between the component that is most significant, not what goes on within each taken in isolation. Therefore, there is no easy answer. The bottlenecks must be worked and pushed down stream and squeezed out of the system. However, in the view of the authors, what will make a difference is a high performance architecture built on a form of asynchronous multi transaction workflow using decoupled processes (sometimes called "message-queuing" or "MQ" middleware). This is a major conclusion for which the authors argue persuasively in the climatic Chapter 16 on Architecture for High Performance. Part Five on Technologies looks at the inner workings of relational database management systems, transaction managers and monitors, and data warehousing technologies such as OLAP, ROLAP, and multidimensional data analysis (MDA). The availability of this material rounds out the completeness and comprehensive scope of the treatment provided. The authors set a high standard for collecting insightful and humorous one-liners, with proper credit to many other brilliant contributors, which also cut to the heart of the challenges of delivering performance in a client-server environment. "Software workloads expand to consume the available computing capacity" (p. 11). "There is nothing so useless as doing with great efficiency what should not be done at all" (p. 80). "Always work on the biggest bottleneck" (p. 113). "If you can't see the bug, you are looking in the wrong place" (p. 333). These zingers kept me returning to this text time and again. The book contains a rich assortment of illustrative and instructive graphics. The figures and tables are superbly drawn and produced in attractive gray scale. The performance guidelines - and as benefits a thorough compendium of over 700 pages of encyclopedic proportions - are separately listed at the back in a voluminous section of over 500 entries, extensive enough to be designated as Part Six. Given the challenges of mainstream client-server, Loosley and Douglas are like the cavalry to the rescue with a comprehensive and richly-ladened resource of distinctions and methods for understanding, addressing, and resolving the dilemmas faced by those tasked with building and managing distributed client-server. -- review originally submitted to Computing Reviews in 1998 -- but the good folks there already had someone else reviewing the book, so they decided not to publish it

I found this book very helpful as I was developing a paper on improving performance for my company's enterprise application. It is the only book I could find that generically dealt with the techniques for designing applications with performance in mind. It covers a broad range of topics explaining the causes of performance problems and possible solutions. I particularly liked the realistic view of a "distributed" architecture which is a hot topic. I did have some problems relating to the "standard" architectures presented; none of them exactly matched the current popular standards like J2EE.

The authors introduce this book as one that is different than most of the others on client/server technology that are on the market. They wanted to write a book that addresses the practical issues that arise in the effective use of client/server technology in a business environment. Certainly such a book is needed, especially for understanding the behavior and performance of applications in client/server or in more complicated multi-tiered environments. The need for understanding application performance in multi-tiered environments is now more important than in ordinary client/server environments. Thus this book, published in 1998, is to a large degree outdated. The client/server paradigm has been replaced in the last five years with the multi-tiered paradigm, consisting typically of Web, application, and database servers, all with a lot of redundancy put in, and typically being load-balanced with content switching. There is a chapter on "middleware" in the book, but this is very distant from the complexity of the "back-end" now used by most enterprise applications.

For a reader who is a newcomer to application performance issues, this book might be a good start in allowing the reader to get comfortable with some of the terminology that is used in performance studies. However, its approach is very qualitative, and therefore does not give any sound advice, supported by empirical data and mathematics, for addressing the real performance issues involved in application deployment. In addition, the performance monitoring tools recommended are very out of date. Current technology makes heavy use of intelligent agents, which are a lot more resilient and sophisticated than they were at the time of publication of this book. These agents are more than just the rule-based systems that the authors mention and downplay in the book. Intelligent agents are now able to engage in system tuning and performance management at a level of expertise that is approaching, if not exceeding in many cases, the human expertise and ingenuity that the authors extol in the book.

This book should be required reading for all professional software systems engineers and software development engineers. It is an outstanding overview of the performance engineering discipline as it applies to client/server architectures. I am a practicing systems performance engineer with 20 years experience--10 in development and the last 10 in systems engineering. Many of the things I've learned through "experience" are included in this book. It is definitely worth the money.There is only one area which is not addressed in the book--how to apply SPE to one-of-a-kind complex multiprocessing/multitasking shared resource systems development which are without precedent (as far as I know this is not addressed anywhere in the literature). Such systems do not lend themselves to the preassigned quantitative software budgets required by the literal application of SPE. But because I am major proponent of designing in flexibility and performance all the other SPE principles certainly apply. Again, I highly recommend this book.

A must for any WebSphere Administrator working on large distributed systems! The best book about WebSphere Network Deployment Platform Edition! Highly recommended!

"IBM WebSphere Application Server for Distributed Platforms and z/OS" is a wonderful compendium, very readable, supplies lots of background information and puts good light on the different platform implementations of WebSphere. I love it, good job!!!

If you're an administrator for an IBM WebSphere Application Server (WAS), you're always looking for sources of information. If you're running WAS 5.0 or 5.1, get a copy of IBM WebSphere Application Server for Distributed Platforms and z/OS (IBM Press). It's definitely full of information you'll need for installation, configuration, and administration...

Chapter List:
Part 1 - WebSphere Environment Overview: Introduction; Compare and Contrast: WebSphere on z/OS and the Distributed Platforms; WebSphere Architecture and Design; WebSphere Topology: Distributed and z/OS; WebSphere Installation - Distributed; WebSphere Installation - z/OS; Getting Started with WebSphere - An Overview
Part 2 - WebSphere Configuration: Configuring WebSphere Application Server; The WebSphere Naming Service; The Web Server Plug-in; The Java Message Service; Web Services - An Overview; WebSphere Security on the Distributed Platform; WebSphere Security on the z/OS Platform
Part 3 - Assembling and Deploying Applications in WebSphere: Assembling Applications in WebSphere; Securing Applications in WebSphere; Deploying Applications in WebSphere
Part 4 - WebSphere Management: Workload Management Overview: Distributed; Workload Management Overview: z/OS; Automated WebSphere Administration
Part 5 - WebSphere Performance: Monitoring WebSphere Performance; WebSphere Performance Tuning; WebSphere Performance Tuning - z/OS
Part 6 - Troubleshooting WebSphere: WebSphere Problem Determination Tools - Logging and Tracing; Problem Prevention and Determination Methodology; WebSphere Problem Determination and Troubleshooting for z/OS
Part 7 - Appendices: Trade3 Application; WebSphere Tooling Reference; WebSphere Plug-in Definition; WebSphere Message Component IDs; Custom Strategy Bindings File DTD; Common z/OS Terms; Comparison of Common Tasks on z/OS versus Distributed; z/Linux Considerations; Automated WebSphere Administration Examples
Bibliography; Index

Coming in at nearly 1000 pages, you can see it is a pretty comprehensive guide on getting WAS up and running on both distributed network platforms as well as mainframe z/OS systems. While I don't think that you'd find one shop running WAS on both platforms (although I could be wrong), I still found the comparison between both systems interesting. There is definitely a different mindset between the two, and the comparisons will help you understand the side you don't work with. I was impressed with the level of detail included also. If you were sitting down with the WAS CDs and this book, you'd stand a very good chance of getting the system up and running, as well as having some troubleshooting material to help you out over the hard parts. The only down side of this book is that WAS 6 has already been released, so it could be that the book is living on borrowed time. New shops will probably go straight to 6, while shops already running WAS on 5 may be stable, in which case this book becomes more of a reference manual than an aid to installation.

People running WAS on distributed platforms have a number of books and IBM redbooks to choose from. The options for z/OS platforms seem to be much more limited in terms of documentation and material, so I think this book would be far more valuable to those people than to the distributed networking side. Not to say it's not good for distributed information, but I acknowledge they have more options to choose from.

If WAS is part of your professional existence, this would be a good book to have on your shelf.

"IBM WebSphere Application Server for Distributed Platforms and z/OS" from IBM Press targets WAS admins. The book covers WAS 5.0 and 5.1, highlighting the differences. It covers almost every OS: UNIX, Linux, Windows and Z/OS. A differentiating factor from other books is that the authors focus on Network Deployment throughout, starting with chapter 2.

One thing to note is that there is a lot of duplicated information. Five (out of 26) chapters have separate chapters for distributed and Z/OS. The remaining 16 chapters, sprinkle distributed and Z/OS differences within. In a way, it is two books in one. However, if you are only using one type of OS, the book is thicker and more expensive than necessary.

The authors are quite thorough in discussing most options. They also refer to the InfoCenter, papers and redbooks for more details. There are also many tips and gotchas in each chapter. The step-by-step instructions and screenshots are very helpful.

A running example shows the steps for deploying, configuring and maintaining a sample application. The app is of sufficient complexity to seem real. Tools such as MQ, ASDK and wsadmin are shown in parallel.

The authors intend for each chapter to stand alone. As a result, there is a fair amount of repetition. Aside of one dependency on a future chapter, the book reads well linearly too. This book serves a good reference and I recommend it to those maintaining both distributed and Z/OS systems.

For several years, IBM has built up and refined WebSphere as one of its flagship products. Here is its latest sysadmin manual. The size of which is a good indicator of the capabilities built into it.

Maybe the biggest change from earlier versions is how much of the code base for versions running under (linux, unix, MS Windows) has now been unified with that for z/OS. The immediate and ongoing beneficiary of this is IBM itself; greatly simplifying maintenance and extensions. Opaque to outsiders. But to a WebSphere sysadmin, you also benefit. Because basically most operations are true across these operating systems, it increases your marketability.

The only minor omission I could find in the text is that the chapter on Web Services could need enhancement. Or, rather, that WebSphere itself have greater Web Services ability. The latter field is changing rapidly and perhaps WebSphere deliberately wants to stay a pace behind, in order to see what new features are actually useful, before implementing them. For example, Business Process Execution Language is rising, as a more expressive language than WSDL, to describe Web Services. If BPEL persists, perhaps the next version of WebSphere might support it?

This book was great. I was looking for a book that would give me a familiarity with the past-present-future of distributed computing and that is exactly what I found. I'm a somewhat seasoned programmer, but I have not had much experience with NDC, so I felt I needed a high level introduction to the theory and practice of NDC before I started getting into the nitty gritty details of programming. That said, you won't find any code to cut and paste into your projects. However, the distance from the "nitty-gritty" allows one to see how one could implement Goff's ideas (or not implement them if you consider the "eight classic fallicies" he discusses) in any language. I finished the book in just a few days - Goff's writing is very clear - and now I feel ready to tackle the subject.

Today I was able to finish the review on the book Network Distributed Computing by Max K. Goff (Prentice Hall). If you're looking for a high-level work that deals with much of the theory and direction of NDC, you'll get a lot from this book.

The chapter breakout:
Fitscapes and Fallacies; Ten Technology Trends; The Scope of NDC; NDC Theory; NDC Protocols; NDC Messaging; NDC Datacom: Wireless and Integration; Today's NDC Frameworks; Tomorrow's NDC Framework Options; Fallacies and Frameworks; Composability: Real-Time, Grids, and the Rise of an NDC Meta-Architecture; Innovation and Convergence; Index

Now let me go on record right away. I deal much better with practical hands-on material. I want to see code and systems. From that perspective, this book was a let-down. You aren't going to find code you can cut and paste to build a peer-to-peer client. Having said that, this *is* an excellent book to understand exactly what types of issues are involved in conceiving, designing, and building NDC systems and architectures. In fact, I could easily see this as a textbook for a college-level course on the subject. The author stays remarkably vendor- and platform-neutral, so you won't get an overdose of *just* Sun or .Net approaches.

Not having spent much time thinking about all that goes into NDC systems, I was amazed at the complexity and issues that come into play for even the simpliest applications. With the increasing significance of distributed computing, I think most IT professionals could benefit by reading through the material and becoming aware of trends that will be here in very short order.

I love this book! It gave me ideas that would have not occurred to me and is as insightful as it is easy to read and understand. I am not a computer programmer, but my friend suggested I read this, and that I would understand it, and she was right. I would recommend this book to anybody who is interested in where technology (especially the Internet) is taking things.

The impact on the book of Max spending ten years at Sun Microsystems from 1993 to 2003 is clear. Those were essentially the years that the world learned about the Web. Sun was not shy at investing research dollars on technologies needed to prove that the network is the computer. Max had access the Sun thought machine, including thought leader thinkers like Bill Joy and James Gosling, and the everyday exceptional thinkers like the engineers on the JINI team. These were the thinkers behind the Internet. And while it turns out that the pragmatists like Bill Gates built huge software businesses on Internet technology, Fitscapes and Fallacies makes me believe there is a huge untapped potential for distributed software applications.

Fitscapes and fallacies might have been better titled "The Nature and Nurture of the Internet." Fitscape is Max's word to describe the nature of distributed computing. Charles Darwin wrote about "autonomous agents competing for resources" and Max draws the conclusion that you can apply the same description to processes running in a grid of networked computers. The book begins with an explanation of the attributes of a fitscape and then talks about the protocols that are used to build a distributed application. Fitscapes and Fallaces then compares a number of fitscapes - yes, there are more than one - using Deutsche's 8 fallacies of network computing.

While the work is slightly academic, it delivers messages I wish every beginning software developer, QA technician, and IT manager would learn.

-Frank

In this speculative discourse, Goff offers us a vision of the future direction of computing. He takes 10 trends in technology and suggests how these might proceed, and interact with each other in unexpected ways. To us, perhaps the best known trends are the wireless computing (cellphones), robotics and Web Services. With the latter, he includes what Tim Berners-Lee termed the Semantic Web. Another trend is grid computing, which IBM is pushing hard.

An important enabling technology for this future is JXTA, for mobile p2p networks. He suggests that it may have greater impact than Jini. In fact, he does a point-by-point comparison of the two, to Jini's disadvantage.

While the book is put out under Sun's rubric, and Sun has the copyright on the book, the above comparison suggests a commendable objectivity. JXTA is derived from Sun's Java, but it is now independent, whereas Jini is wholly owned by Sun. Now it should be said that other sections of the book describe quite favourably Sun's products; most notably Java. But since Sun's founding, it has indeed pushed the industry envelope on networking.

A very interesting side note he made was in comparing Java with C#/.NET. As you may know, a strongly claimed advantage for the latter is that you can write in other languages like Pascal or Visual Basic, that have been suitably extended to handle .NET, and then combine the resultant binaries made from different languages, into one functional form. But, independently of Sun, others have written "translators" that take source code in various non-Java languages, and produce Java bytecode. It turns out that there is relatively little demand for this. Goff suggests that it is because the bytecode is optimised for Java, and Java is expressive enough that you might as well write in it. Similarly, he says that the multilanguage capability of .NET may find little demand. If this indeed turns out to be so, it negates the main advantage of .NET.

Some parts of the text has Goff waxing lyrical on complex adaptive systems in a fashion reminiscent of George Gilder's fevered silicon dreams, and of the longings of Extropians. NOT a typical Sun book!

I have read about 4 books on basis administration and I dint find this one any differant. They all have basically the same content. Not worth the price

Unfortunately by the time I got this book, I had to learn many things from other sources or simply by guessing and trying. Its first two parts confirmed most of my beliefs on the topics or put right the rest. The third part gave me tremendous help to become more effective and confident in the use of the tools. Having read it half way through I am pretty sure that what I am doing is right. Time to time I use it as a manual as well. Worth every cent!

I love this book even though its really thick. It covers TMS in excruciating detail while remaining quite readable for new Basis administrators and consultants. Much clearer than the confusing training materials for the SAP course I took recently. Get it and become a TMS SAP expert!

This well-written book has been immensely helpful in bringing me up to speed on R/3 change management practices. It certainly goes far beyond R/3 on-line help. It is both well-organized and of great depth and breadth. The glossary alone was worth the purchase price.

This book has a multi level view of the change and transport system in SAP. It gives the Functual team a good overview of why things are being done the way they are. It also gives the Basis team the nuts and bolts of the whole transport process and landscape. This is a must have for your SAP R/3 library.

This book presents a clear and high-level overview of the issues and topics of client/server and OO computing. I've worked in the field for a while, so there was not much new material for me. Nevertheless, I still found it a useful read. It presents a coherent and comprehensive conceptual framework for thinking about the many of issues and tradeoffs in the field. The book's layout, format, and style make it readable and useful. It has a reasonable index, bibliography, and glossary. The beginning and ends of each chapter clearly summarize the material. The book's stated goal was to give the reader a fundamental understanding of essential issues rather than a barrage of incidental technical details. I believe it succeeded. I wish I had this book five years ago when I was new to the field of OO applied to business applications.

This book was a pleasant surprise. I think it stands out. Here is why: many books don't survive the test of time. Either the technology is moving to the next buzzwords and the terminology in a just-published book is already slightly obsolete, or a book style is such that it concentrates only on extremely volatile and time-sensitive skills that it usefullness only lasts a couple of years. Of course an author can publish a new edition every two or three years to keep up with the terminology and what is in vogue, and that is why Orfali's "martians" book on client/server is now in its third edition. A better solution would be to have a web site with documents in PDF format that update a published book. While this book is published only two years ago, and it seems to show some of its age by not mentioning the latest Internet buzzwords, such omissions are deliberate exactly to withstand the test of time. Examples abound of different architecture configurations and topologies without ever looking old. The writing style has a nice flow, with wide margins on each page showing summaries written in italics. It never displays too much information, but just what is needed. And it relates how choosing a correct configuration, is actually an evaluation of the best compromises, never dictatorialy stating what is the correct and only solution. The words are carefully crafted, and this book is a good source if you are preparing a presentation and need examples of one-liners or one-page concepts. It is not a reference book of treasure-chest solutions and code snippets. It is more a book to read next to a fireplace and "harden" and make sense of information that you may already have but you are not sure how to frame it, organize it, or rationalize it. The nice flow in this book shows the path.

This book is a little bit dated, but most of what is here still applies. As long as new people are making the shift to OO devleopment, this book will be of great benefit.

First of all, the authors give a very objective view of OO devleopment without a bunch of hype. Then, the book begins by addressing the non-OO way of developing client/server applications and explains how objects can fit in.

After giving a road map of the possible ways to introduce objects into existing systems, the authors go in great detail of client, server, and "glue" OO development. The glue is essentailly the communication mechanism used between the client and server.

To round out the book, the authors give good introductions to object persistence, performance, scaleability, and security. These are all important topics with books dedicated to each of them. Readers will be ready to read the more advanced material after having read what the authors present.

The last two chapters are more speculation than fact, and it would be nice to have a second edition of this book to account for the changes since the book was published in 1998.

As a final note, managers with a techincal background but no OO experience will find the material very useful in coming up to speed on OO client/server development.

This is one of the top five technical book I have ever read. Unlike most technical books that are 40% filler, every page in this book contains interesting and useful information.

Very well written. It is a great introduction to the latest object technology that is taking over enterprise computer.

Every paragraph in the book has a one sentence summary of the paragraph in the margin. I found this feature very helpful and I wish more authors did this.

I highly recommend this book!!!

Taylor's book is a good update to Oram's Peer to Peer book from 2000. There has been much activity in the subsequent years and Taylor provides a useful summary. JXTA and Jini get an analysis. Perhaps not as successful as Sun might have wished, as least for Jini.

More generally, all the major p2p networks are described. With their different topologies. Napster, of course, gets a mention, as the first major p2p network. Then we see Web Services, about which much has been speculated. And the Grid and Globus, for massive scientific computing.

The biggest omission is BitTorrent, which was only getting started when the book was being drafted. But this is now the biggest worry of all the p2p networks, for the movie companies.

I recently read Ian Taylor's book, "From P2P to Web Services and Grids, Peers in a Client/Server World". I became acquainted with Ian when I read his online classes note on P2P and distributed systems several months back. Later, Ian asked me to review his book. This new book is based on those class notes. The book includes new material and has expanded discussion on several technologies. For example, the book has added chapters on Globus / OGSA, Freenet, and web services, and gives extended looks on scalability and security.

The book has four parts, I - Distributed Environments, II - Middleware, Applications and Supporting Technologies, III - Middleware Deployment, and IV- From Web Services to Future Grids. The Part I functions as an orientation. It talks about what are P2P, web services, and grid computing technologies. It covers the concept, the history, the social impact, and the applications. The Part II explores several well-known P2P and distributed computing technologies, e.g. Jini, Gnutella, Freenet, and JXTA. It also gives in-depth look at several important concerns, e.g. scalability and security. The chapter on security is well written and clearly explains what are cryptography, hashing, and digital signature. Additionally, the chapter on Freenet clearly explains how Freenet works and organizes content. The author has effectively used analogy to describe key concepts, "virtual organization", storing and addressing contents, network topology, etc. The Part III includes chapters on several demo applications. Due to my busy schedule, I did not have time to download and build those software applications. The Part IV is a section dedicated to Grid technologies, particularly on Globus. This section expands the discussion from chapter 4.

As the editor-in-chief of P2P Journal, I have found reading this book was well worth my time. It is concise and clear. The book uses unambiguous language to cover some abstract and difficult to grasp concepts. It can be a useful book for people who want to understand those technologies, whether as a general purpose or as a handbook.

This book, "From P2P to Web Services and Grids", provides an up-to-date and comprehensive tour of the new distributed computing technologies arising out of the convergence of computing and communications. Readers with a telecommunications background will find many of the concepts surprisingly familiar whilst those coming from a background in enterprise information systems will discover new approaches for solving today's enterprise application integration problems.

The text, whilst aimed at and suitable for an undergraduate study module, is supplemented by an extensive list of references to more detailed sources for those that need the extra detail. Chapter by chapter the author, who is clearly knowledgeable, explains peer-to-peer systems, Grids, Web Services, service-oriented architectures and distributed object technologies. This is done both in general terms and with reference to specific examples of the technologies in action: Gnutella, Napster, Jini, Jxta, Globus, SOAP, WSDL and UDDI. The final chapter covers the latest developments in Open Grid Services Architecture (OGSF) and Web Services Resource Framework (WSRF). As well as exploring specific technologies, there are two general purpose chapters on scalability and security of distributed systems in general.

I feel that this book was a good read and really makes a lot of complex issues simple and easy to understand. The writing style of the author was very approachable. The book is pretty small (and paperback) which makes it easy to carry around, which actually inspired me to read the whole thing, unlike a bunch of longer books I have on my shelf.

The book focuses on decentralized networks, web services and p2p. It does a good job of showing how these are all interrelated and ties them in nicely to the new technologies of the Grid (I work in Grid computing, so this was very interesting for me to see).

I definately recommend this book to anyone working in this field, or just people who are curious about p2p, web services, or the Grid.