Programming Books

An excellent book for combinatorial optimization. This book provides with the basis of the integer programming problems and theories behind it.

A great book, with whatever information you need regarding integer programming and Combinatorial Optimisation. A bit out of date perhaps!

I first used this book as a text for a graduate course in Integer Programming. At first it seemed to be a very poorly organized book, but as I read it and grew familiar with the subject, I realized that this is a hybrid textbook-handbook. Though the title says "Integer and Combinatorial", the authors go a step ahead and present topics in advanced linear programming, computational complexity, polyhedral theory in a fashion appropriate to the learning of this subject. The exercises are challenging and it has a very good list of references (only up to 1988). Our professor had to supplement the text with recent papers to cover the latest advances. My only complaint is that model formulation could have been dealt with in more detail. You might want to use HP Williams' "Model Building in Mathematical Programming" to look up good Math Prog models.
Though this is an excellent book in all respects, I would recommend Papadimitriou's older book on combinatorial optimization for a good discussion of P, NP problems and decision / optimization problems.

Nemhauser is a great professor and this book is text book for IP. But this book requires that you are familiar with Linear programming. So read this book only after you had LP. Bertsimas book is really good for Lp. Or even Bazaara's book is a goo start.

This book starts with the mathematical basics behind linear programming and develops on these introducing new techniques like Bender's decomposition, various cuts, etc. The way the mathematics is dealt is flawless but I thought the methods required more examples for better understanding. But ofcourse the book had to be concise....

I have no opinion on the combinatorial optimisation part.

Don't let the title fools you. This book goes beyond Integer and Combintarial optimization. While there are many books talk about NP and proof, this book makes you "understand" it! Still, I agree with others that this book is a reference tool for Integer and Combinatorial optimization. I'm so glad this book published in paperback so it will be more affordable for others.... still expensive though :(

The book talks about scripting and it accomplishes it's goal. There are examples of vbscript, jscript, an hta, and vba. It is apparent that the author favors jscript. The quality of scripts are better then the vbscript examples.

There are 14 chapters: How to use this book, Why scripting, Windows Scriptable Technologies, Enumerating and Dumping the Users, Groups, and Computers of Active Directory, Dumping a Domain User's Detail Account Information, Listing Soon-to-Expire Domain User Accounts, Move Away from Batch Files-A New Logon Script, Foundation: A Directory Computer-Dump Tool, Browser-Based Computer Information Diagnostics, Worm Vulnerability Detector, Remotely Enumerate Local Computer Accounts, Local Password Audit and Change Tool, E-mail Script Notification, Where to Go from Here.

As I mentioned this is not a book for people new to scripting. However, it is useful in that it will show the use of modules and it does go about explaining the code examples by the blocks and functions.

I found the descriptions of the modules useful even though I don't use JScript. Probably the most useful script was an HTA script for local diagnostics.

The CD has the scripts mentioned but you might want to go through the effort of typing and debugging the code. Especially, if you are new to windows scripting.

Overall, a good book to have for a reference on what it gives you. It expanded my knowledge.

No long-winded review here. This book is a great read for anyone with a small to medium sized IT organization. I bought a copy for each system admin in my group. Not many books pay for themselves in time savings with just one example as this book has done.

This book now sits on my desk instead of on the shelf full of other resources. The book comes with a CD to get you off and running and it steps through at a good pace for beginners like me. Being a Win2K SBS admin I don't have money for enterprise tools. I was eager to "empower" myself and this did the trick. I like the format because it's progression from introduction to scripting is thorough enough for me but not boring.

So what are the top 10 scripts? - Enumerating and Dumping the Users, Groups, and Computers of AD; Dumping a Domain User's Detailed Account Information; Listing Soon-to-Expire Domain User Accounts; Move Away from Batch Files- A New Login Script; Foundation: A Directory Computer- Dump Tool; Browser- based Computer Information Diagnostics; Worm Vulnerability Detector; Remotely Enumerate Local Computer Accounts; Local Password Audit and Change Tool; E-mail Script Notification. BUT WAIT- This doesn't tell the whole story- I especially liked the tie in with Excel for execution and output! Fellinge's book got me off the ground which is exactly what I needed.

Honestly, I really do not feel this book is ideal for the novice. Users should have some administration sensibility with Active Directory. Yet, what I do find profound, is that there are both (1) very practical applicable scripts and techniques, and (2) there are some truly amazing scripts.

I am at a loss of words for some inspirational things that I found that can give you the ability to generate spreadsheets reports on the fly and also have a live spreadsheet that can go out to the net and pull info. There is this fascinating example script that creates a web page wizard-like HTA application.

To some things up, this book is powerful. This adds a lot of good material one's admin collection. Using this book, you won't become just a scripter, but you'll be down right incredible, such that lightning will ignite from your fingertips (metaphorically speaking) as you create masterpiece killer scripts.

I am one of the Technical Writers who contributed to the Microsoft Windows Scripting Guide for Microsoft Press. Since working on that book, Mr. Fellinge's book is the first I've reviewed on scripting. The author does a great job of exploring some common scripting tasks and demonstrating how to solve them using JavaScript and VBScript. His understanding of both ADSI and WMI is impressive. These two technologies are at the core of automating Windows system administration. What makes this book especially interesting is the author's focus on real-world sysadmin tasks. He is clearly writing from experience.
I recommend this book for anyone with a basic understanding of scripting who is interested in really putting that knowledge to good use.

What can I say:"WOW".
This book is well structured into different aspects of J2EE(example: servlets, JSPs, webservices, EJBs etc). Each of the sections are given detailed coverage with regards to design and architectural decisions that can go wrong.
This is not a start to end read. This book is better usable as a reference while we execute or plan during technical development cycle.
For each anti-pattern, a detailed background, symptoms, refactorings and example are provided. At the end of the book we are provided a Anti-pattern and Refactorings catalog.
The book also covers capacity planning type of antipatterns at the beginning. This will help give broader perspective about making design and possible implementation decisions on a enterprise scale.
A must read for enthusiastic J2EE practitioners who strive for quality output.

Why should you read this book?... I mean you've read the J2EE Blueprints and that's supposed to be the best practices and you've followed all it's advice... didn't you? You should read this book because it gives you a way to see what you "didn't" do and how to fix it.

In this book the Antipatterns (APs) are grouped by J2EE topical area, several are identified for the area and then solutions proposed for each AP. Not only do they expose issues with designs that are common mistakes, but they then go on to not only tell you a possible solution(s) and also impart good principles on why.

Each AP has the following sections: Background, General Form, Symptoms and Consequences, Typical Causes, Known Exceptions, Refactorings, Varations, Example(s) and Related Solutions. The catalog of AP's in the appendix of the book provide a quick summary of each AP also, so you can see if your Symptoms are listed quickly.

One example is from the "Distribution and Scaling" chapter. The just of it is that in an enterprise system you use layering, workflow and the idea that the network is the computer to model and solve your problems. If you haven't you'll notice all of your code linking into libraries of many different types when library access should be localized to one workflow point that other workflow tasks utilize. By doing what they suggest you'll end up with a highly distributable solution and a weakly coupled system that will be flexible to change.

So save yourself some future troubles, or help yourself fix your current ones, read this book! It imparts knowledge you can't get from a Blueprint!!

Did you ever have the feeling that there was something wrong with your application design but you just couldn't put your finger on the problem? The authors of this book have taken their own experience developing J2EE applications and produced a book that will help you avoid many mistakes in application design. The book is geared toward helping the experienced designer/developer produce robust, maintainable applications and fixing applications that are not robust and not easily maintained.

The book covers most of the J2EE spectrum. There are sections on JSPs, Servlets, Entity and Session Beans, JMS, and Web Services. There are also sections on general J2EE architecture including distribution, scaling, and persistence. Each chapter gives a background on a specific antipattern, discusses the typical symptoms of the antipattern, and then covers various refactorings that can be used to correct the antipattern. Some of the antipatterns discussed may sound familiar ("too much code in JSPs") but the list of refactorings will provide useful information for even these obvious coding errors if you happen to be supporting an application that suffers from that antipattern.

The authors have done a great job of clearly explaining each antipattern, both explaining why it is an antipattern and what you can do to fix the problem. Each refactoring is demonstrated with code samples as well as with UML diagrams where appropriate. Overall, this is an excellent book that should be on the shelf of anyone involved in designing J2EE applications.

Often, managers of medium to large scale software projects do not have the time (or inclination) to learn the technical nuances of the development environment they're managing. This lack of understanding can quickly give birth to worry and stress. "If only I knew the right questions to ask..." is a common lament among project managers as they wonder "why is module X so brittle?" and "why can't we ever meet the performance spec for subsystem Y?"

"J2EE AntiPatterns" is a useful guide for helping project managers with technical (but not necessarily J2EE) backgrounds zero-in on the major pitfalls the development team must circumvent. The Background, General Form, Symptoms and Consequences, and Typical Causes sections of most AntiPatterns provide the manager with sufficient information to recognize, understand, and (hopefully) avoid technical problems. (The exceptions are the AntiPatterns for entity, session and message-driven beans - the book assumes a basic understanding of J2EE beans.) Project managers do not need to fully comprehend the code examples (the book has many) to employ the lessons described in "J2EE AntiPatterns" - simply recognizing and understanding the AntiPatterns will be valuable to the team.

If I had read this book before (or during) my last project, I would have been able to recognize some significant problems by simply observing and listening to the engineers discuss their challenges, including the following AntiPatterns:

"Too Much Code" - our LOC metrics would have fleshed this one out quickly;
"Using Strings for Content Generation" - we spent many hours debugging HTML that rendered properly in IE but not Mozilla;
"When In Doubt Make it a Web Service" - it can be expensive mistake to implement something purely for technology's sake.

Coupled with a book or two describing J2EE at a high level, "J2EE AntiPatterns" is essential reading for technical project managers. This book will undoubtedly increase the project manager's effectiveness and help him/her better communicate with the team. A little knowledge for project managers is NOT always dangerous!

This book is a very worthy addition to the pattern literature for j2ee. It is at about the same level of sophistication as the two now-standard j2ee pattern books (Alur, Malks and Crupi 2nd edition, and Marinescu).

If I were new to j2ee (but had some experience with Java, Design
Patterns, Enterprise Architecture and Refactoring) I would read Ed Roman's book, then Marinescu, then Alur's (noting that some of the patterns are now deprecated) and then this book.

The book is divided into 10 sections, each of which covers one aspect of j2ee technology, such as JSPs or Entity Beans. Overall it is well written and enjoyable to read. Each section is divided into a set of anti-patterns (things not to do) and a set of refactorings (what to do after you do the things they told you not to do). Although this leads to some redundancy (repeating the problem in the refactoring section) it
sucessfully deals with the many to many issue (antipatterns to
refactorings); the alternative would be to repeat or reference the refactoring in each antipattern section that it is applicable to.

The book is well edited with few problems. One issue is that some of the diagrams seem to be missing - what is presented is duplicates of previous diagrams. I assume this will be fixed in a future printing.

Like other pattern books, one of the advantages of this book is in the names we can now associate with common patterns we have all seen. A perfect example is "Ad Lib TagLibs", which are large taglibs which include business logic and control logic. The suggested refactoring include beanifying (the model data) and separating out a delegate controller.

Its a shame this book is now hard to get. I had to track it down in a crisis. This book for me achieved no small feat. I was able to refactor an app based on Core J2EE patterns. That book, while explaining the patterns in this book, is vague. I really spent a lot of time on the Core book. For those types this book will be appreciated that much more.

This book is about code - about %90 of the pages have source. Perhaps the first book I ever seen that has compilable, working code. Also, I think the examples and interfaces in this book are much better than the Core book.

In short, if you have the core patterns book and are stuck, this indeed could be exactly what you need. I would say you could skip that book and start with this one.

I've read a lot of patterns books. Most didn't really help. Some got me to the point of asking new questions. This book, and "design patterns explained", are in my view indispensable classics. They left me with a clear understanding of what I was trying to learn.

One negative point: I read the comparison between "service to worker" and "dispatcher view" several times and I still don't get what they are trying to say. This is one of the few places in the book where there is no code, and it probably could have helped me here. To be fair, it does have some nice sequence diagrams but its seems lacking compared to the rest of the book.

This book is really excellent. It contains the Core J2EE
patterns and theserverside.com patterns (in <Patterns>>) and explain you the relationship between them. It
contains lots of demonstrable code.

Web tier patterns can be used as template for web tier for
any j2ee project; persistence framework explained the
Data Access Object and Value object in the clearest way;
it always contains security patterns and integration
patterns, which are not discussed too much in other books
as <>. This book is the perfect companion
for the J2EE Core Patterns book and <>,
and even wider than them.

This book presents patterns inside frameworks, so you can
easily see how it is used in real life. This book uses UML
in a very elegant way so it's also useful to learn UML
in J2EE.

A must for J2EE lovers.

Daniel

SCJP, SCJD, SCWCD, SCJEA and IBM Certified XML Developer.

Definitely a good, simple, clear introduction to J2EE design patterns, this book has the advantage of presenting example code in the form of little applications instead of just snippets and lacks all the 'mystical yadda yadda" that pattern books often employ to make their simple content pass for rocket science. I have been somewhat disappointed by the security chapter which is basically just an overview of the J2EE standard security model. Also, being a book "practice oriented" I would have loved to see details on the deployment of the source code presented. Overall a 3 and 1/2 star book that gets a little bonus for being simple and practical.
Previous knowledge of design patterns in general would certainly help you to get the most from this text. For a simple,clear, no bs introduction I recommend Design Patterns Explained: A New Perspective on Object-Oriented Design
by Alan Shalloway, James R. Trott.

THE book to understand and use J2EE patterns effectively! Excellent concept introduction to begin with, to tide over the pattern non-gurus, comparison with established OO design patterns to ones mostly used in the J2EE community including ones on theserverside.com, plenty of demonstrable code some of which found their way into our deployed apps, great emphasis on patterns applied to specific layers of an application like persistence, web, security, performance etc. Great insight into usually tricky integration topics.

The web tier chapter details patterns that could be used for request processing with session management, view manipulation, validation and security. The persistence framework chapter was perfect for our implementation with its data access layer strategy based on DAOs and value objects, though we would have liked to see some transaction management patterns. The scalability and performance concerns have been closely investigated, as have all security designs like single-access, check-point and role patterns. A working example targeted for a leading app server could have proved useful here, though there is plenty of code available for download. After all is said and done, the chapter on integration where everything comes together nicely, scores top marks for topics not usually found in other books.
An excellent addition to anyone's J2EE repertoire.

From the number of reviews on this site(just 3)it appears that this book is not getting the attention it deserves!

This book starts where "Core J2EE Patterns" ends. Instead of being one more book on patterns catalog and snippet code, it plucks related patterns and weaves them into a framework. This framework-oriented approach starts with the simple but pertinent observation that standard J2EE patterns like Service-to-Worker and Dispatcher View can be reinterpreted as micro-frameworks and continues throughout the rest of the book. For example, chapter 3 combines 3 patterns( DAO, VO, Service Locater)together to lay the foundation of a persistence framework.

Another positive aspect of this book is that it devotes complete chapters to security and integration patterns.Of late, integration patterns have become important enough to merit a web site of their own ( integrationpatterns.com ) and it is quite hard to find other good references on security patterns.

Thus this book has a lot of new things and perspectives to offer and deserves more attention than it seems to be getting.

Finally a criticism : This book mentions other books by name and ISBN numbers without mentioning the author(s) of the books. This is the first time in my life I have seen such a practice. This is definitely a bad practice and an antipattern and a cruelty to poor authors who deserve to be mentioned by name.

I have bought the first edition and now the second. I also have other books written by John Hunt. His writing is as always clear, sharp and insightful. It shows through in this book too. Whereas some other bible books would need 1,000 pages, John can do with much fewer ones. And yet it can be much more far reaching. Teaching solid OO concepts while bringing the best out of Java, this book is a pleasure to read. So much that it will keep you wondering why other books never manage to be so clear and at the same time so complete. You will not be sorry.

Object oriented programming was a difficult concept to understand after years of procedural languages. I was scared of being left behind and chose Java to take me into the 21st century. After flittering between several books I finally found John Hunt's book and am now making my living out of programming in this amazing and versatile language.

I went searching through the library for a book to help with my software engineering class project and eventually found Java and Object Orientation. All I've got to say is this book is incredible. The writing is clear and to the point. Example code turned out to very helpful (and useful). This book really helped to understand not only how to design good object-oriented programs, but also how to design a good object-oriented GUI. I recommend it to any computer science student or professional in search of a good book on Java and OO design and programming.

The book is very logical and i think is one of the best available.

I had bought a number of Java books before this one and been left confused by Java. This book clarified everything for me and now I understand Java - Excellent

i love java and i'd like to receive java tutorial cop

I found this textbook very well written, organized and clear. The author provides code for perhaps 100 to 150 short applications and applets, each of which demonstrates an element in the language or Toolkit. He then explains the code well. Each chapter builds on the previous. Most, (but not all), of the exercise problems have answers posted on his website. The book is aimed at individuals with some-to-moderate programming experience, who are new to Java. It would be an excellent textbook for a Junior College level course in Java.

Excellent book. Professional, consistent. Examples are thorough and well presented. I'd recommend it. Even if your employer won't buy it for you, buy it for yourself. It'll pay for itself.

This book was great in its day.

Elliotte Rusty Harold seems to latch on to new technologies and write excellent introductions to them. Unfortunately, he does not seem to care to write second editions -- he just moves on to other subject matter.

This book is almost useless now except for the basics of the Java language.

An excellent resource for those who wish to begin programming in Java. I found this book very helpful in learning Java. By far the best I've read. EE261 students should check this one out.

Most accurate. Most comprehensive. Unfortunately it is now out of print and I really do not know why they have not produced an updated edition for the Java 2 and 3/ Enterprise platforms?!

Wigglesworth and Lumby do an outstanding job of introducing Java in the context of C++. Liberally scattered through the book are highlighted sections titled "Moving from C++" which compare the Java material just presented to the equivalent (or similar) constructs in C++. A tutorial on IBM's Visual Age for Java is also included, as is a CD which includes all the exercises and solutions. For any C++ programmer who has been wondering how or when to make the jump to Java, now is the time to do it with the help of this excellent book.

This book has a good mix of both in-depth information and handy references that call out specific points of interest. This allows one to skim easily and then focus in on areas of interest.

My primary motivation for buying this book was because I wanted to learn Java quickly -- taking advantage of what I already knew from C++.

Well, I got my money's worth! The book presents the Java language very thoroughly, while at the same time, providing me the ability to just focus on C++/Java differences or similarities.

I found the "Moving from C++" tips very useful, as well as the tables that quickly summarize the language differences. The exercises section is also useful to make sure that I got the main points of the chapter.

Overall, this book is well-written and organized.

By reading this book and doing most of its exercises, I became a knowledgeable Java programmer.

I think that this book is very good if you want to be are a real professional Java programmer. The explanations are very deep, and with all the text in the book there is hardly any detail that is written more then once.

While learning from the book, I felt that the writers have invested a huge amount of energy making the explanations exact and clear.

I would like to thank the authors for writing this book.

-Maor

This book is a handy documentation for jDK 1.1, however, in current JDK 1.3, a lot of changes have taken place, making this book somewhat obsolete, unless you are programming applets, which are still using JDK 1.1, due to the browser wars. One of the good parts of this book is that it describes all the keywords, shows a ASCII table with Octal, Decimal, and Unicode numbers for each character, and covers all classes and their properties and methods in JDK 1.1

If you want to make Applets using the built in JVM of most browsers, this book is a good buy. However, it is possible now to make an Applet using the Java Plug-In, which uses JDK 1.3 or JDK 1.4. Also, Mac OS X now has the Java 2 JVM built into their operating system. But to make sure your applet runs on all browsers, using the deprecated methods, this book will be useful.

Essentially, apart from the Keywords listing, the ASCII table, and some extra comments and examples, this book is not much different than a Javadoc Documentation that you can view on the internet at Sun's site free, which shows all the classes, all the methods, all their parameters, with links to go from class to class documentation for any JDK version. Also, it is a very large book, making it unlikely a version 2 book, with twice as many classes and methods, will be published. So, this book may be viewed as a convenience when you don't have internet access.

From the day I first received this book it has proven a valuable resource. I was looking for something that I could use just as a language reference and this goes way beyond that. My only complaint is the hard cover, makes it a heavy book to lug around

My thanks to the author for an excellent reference . While it's not a tutorial, it still manages to give short but clear summaries on various aspects of the language. Nice examples too. Wouldn't want to be without it or the Core Java books by Horstmann & Cornell.

If you're looking for a book chock full of examples and code, this is the ONE. If you are looking for a tutorial, this isn't it. Highly, highly recommended ...

Great Book. If you look for a method, a class, a deprecation or for the Java-hierarchy, You will find it in this boook. Good explanation (short!) on the methods. Good examples. Shame there is not a book like this on the JDK 1.2 or the JFC.

This is an excellent book that demystifies the basic concepts of peer to peer computing. It then goes on to explain JXTA in extensive detail with tons of code to experiment with. I always like books that have a complete application to build on the concepts that you have learned throughout and the example provided in this book is great. All in all a great book which i highly recommend and which i will be using for an online course that i will be teaching on Peer to Peer computing technology.

The core of the JXTA is six protocols and this book covers all of them deeply and systematically.

For example, the book first introduces the Peer Discovery Protocol (which will definitely be used by every JXTA application to discover the resources). The book explains how to realize the Discovery Protocol by using the lower layer Resolver Protocol. Then the book teaches us how to use the Discovery Protocol in a JXTA application and actually gives us a useful example.

Every protocol covered in this book follows this pattern - explanation and example.

In addition to the protocols, programmers also need to know how to use some sub-system of JXTA to increase the flexibility of JXTA application and decrease the implement burden. Fortunately, the book covers them, such as CM (cache manager) in chapter4, Document (advertisement) in chapter4, module framework in chapter10, and so forth.

You definitely need to put this book on your bookshelf because give you more than just example code. It includes how the protocols are implemented and how to use the protocols.

Developers, if you want the whole scoop on a new architecture that will enhance the way we use the internet, then you need to get this book. Brendon, the author, does a superb job of presenting JXTA, peer-to-peer, and how you can apply it. This is not just an overview and it's not another "copy & paste" book. You will get hands-on experience on how all this works. Its easy to read and very concise.

As a IT contractor, its important to know what is out there and how it works. Sooner or later you will be affected by this new architecture. Why? Because it's an improvement over the way things are done today. Companies are always looking for an edge and this would give them that by distributing resource power among a wide array of servers and not drop the load on just one.

You will learn what P2P and JXTA are in the first 2 chapters. Then it's hands-on from chapter 3. Unlike other books being offered on JXTA, Brendon did not gloss over anything in this book and does a lot more then just talk about it. After understanding the basics and terminology associated with P2P and JXTA, you begin doing some hands-on experience with the JXTA shell. As the book progresses, you get a good understanding of how it works in detail. Then the grand finale, a sample application shows you how to put to put what you've learned to practice for your own application.

About myself:
IT Contractor - 9 years
6 years experience Java(Sun certified) programming
"always checking to see which way the wind is blowing!"

JXTA is a new platform from Sun for peer-to-peer computing. JXTA is a short form of juxtapose, meaning side-by-side. Thus JXTA is not meant to replace client-server but to co-exist with it.

At its core JXTA is just a specification for protocols needed for P2P computing. These protocols can be implemented in any language(Java,C,C++ etc)and on any platform. At present the specs define six protocols.

The book under review has done a good job of defining JXTA and its 6 protocols. It consists of 3 parts. The first part gives a general intoduction to JXTA concepts (like peer, peer group, pipe, endpoint, and advertisements) and JXTA protocols.The second part is for those who want to go further and study all the 6 protocols (Discovery, Resolver, Rendezvous, Information, Binding, and Endpoint) in all their gory details. The third part is for those who want to go still further and develop their own applications. Here they will find a 100-page chapter covering a sample application. Thus the reader can decide at what stage he wants to quit.

I found two main defects in the book: First the text in the UML diagrams is so small that I had to buy a magnifying-glass.Secondly the book does not compare JXTA and Jini very well. I think the comparison of Jini with later technologies like Web Services and JXTA is very important for a logical analysis of the direction IT is taking. From a logical point of view, Jini is the inspiration behind both JXTA and Web Services. And it is from this (purely logical) point of view that we will compare Jini with JXTA.

Jini starts with a very powerful unifying principle,namely,the distinction between hardware and software is artificial, and therefore both these concepts must be replaced by a more general concept of services.This is the third unifying principle in IT in over a decade.

First came objects which unified attributes and methods and put them in one basket. Then came components which unified software development. And now we have services which unify hardware and software.Staying on this logical track, what could be the next unifying principle of IT.My "guess" is as follows:

If the difference between physics (hardware) and what it does(software) is artificial, then the seperation of biology (user)from these two is also artificial.Thus hardware,software,and geneware must be unified into a more general concept which covers all three. The concept of services is not enough for this unification even though terms like "user experience" have started floating around in the IT industry.

Well, returning to JXTA, we can look at it as a special case of Jini restricted to P2P and not covering client-server.Alternately, JXTA is Jini minus its dependence on Java and RMI plus new terminology and protocols suitable for only P2P.I hope this is not the end but just the beginning of purely logical comparisons of Jini, JXTA, and Web Services.

Experts are welcome to tear down this argument to pieces. That can only lead to greater logical clarification of the subtleties involved.

I have no experience in network programming. I had to learn JXTA for a graduate class in P2P, so I picked up this book. My groupmate, on the other hand, picked up the book by Brookshier. I found my book an easy read and quickly breezed through all twelve chapters. My groupmate said that with his book, he couldn't get past the end of Chapter 1 before feeling sleepy. He eventually switched to this book.

The two things I liked in the book were, one, it's conversational tone, and two, it's learning-by-doing approach. Much of the book consists of coding exercises, covering each of the six JXTA protocols. The 11th chapter is a complete chat application, with both client and server code.

In summary, the best book for a jumpstart to JXTA.

This is a complete and comprehensive handbook which shall be used by all involved in the planning and design of chemical, biochemical, and other kinds of laboratories. It is a comprehensive reference covering guidelines for site selection, the design of laboratory rooms and wings as well as of complete facilities. It provides the most up-to-date criteria for the design of sustainable type of labs. It also gives a unique process for the analysis of needs and the determination of what type of building should be acquired for each set of circumstances, in the context of strategic master planning. It is an excellent tool for architects, engineers and project managers, as well as for those who commission, operate and manage laboratories at every level from schools to industry.

As an architect who is actively engaged in the planning and design of laboratories I found this book to be an indisposible resource. Mr. Dahan's knowledge of what makes a good lab work comes through on every page.

This is a complete and comprehensive handbook which shall be used by all involved in the planning and design of chemical, biochemical, and other laboratories. It is a comprehensive reference covering guidelines for site selection, the design of laboratory rooms and wings as well as of complete facilities. It provides the most up to date criteria for the design of sustainable type of labs. It also give a unique process for the analysis of needs and the determination of what type of building should be acquired for each given set of circumstances, all in the context of strategic master planning. We feel here in our laboratory that it is an excellent tool for architects, engineers, and project managers as well as for those who commission, operate, and manage laboratories at every level from schools to industry.

This is a complete and comprehensive handbook which shall be used by all involved in the planning and design of chemical, biochemical, and other laboratories. It is a comprehensive reference covering guidelines for site selection, the design of laboratory rooms and wings as well as of complete facilities. It provide the most up to date criteria for the design of ustainable type of labs. It also give a unique process for the analysis of need and determination of what type of building should be acquired for each given set of circumstances, and that in the context of strategic master planning. We fell here in our laboratory that it is an excellent tool for architects, engineers, and project managers as well as for those who commission, operate, and manage laboratories at every level from schools to industry.

This book not only provides state-of-the-art technical information related to laboratory design such as layout, mechanical & electrical systems, air quality, instruments, special purpose labs, etc. but it also deals with information useful in the planning process for a new facility which should be valuable to lab users. I know of no other source for this type of information. This book virtually provides a step-by-step guide for providing a laboratory facility.