Distributed

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!

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#.

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?

Now this was a refreshing book!

When I first glanced through the contents of "Server-Based Java Programming" at the bookstore, I almost immediately put it back on the shelf. After all, it barely even mentioned J2EE. Who on earth writes a book about using Java on the server without covering J2EE? That's the hot technology and everyone is focusing on and certainly the basis for Java development on the server. Using an application framework provided by J2EE provides too much to ignore - why would you write anything else?

Well, I was wrong. Long story short - I ended up with a copy at my desk. Finally I picked it up and started reading.

Hours later and I still couldn't put it down.

Ted Neward's book Java-Based Server Programming, published by Manning Publications covers much more than simple J2EE development. It gives you the tools you need in order to understand and develop your own servers, application or otherwise. While this may not seem important at the surface (see my own remarks earlier), it becomes readily apparent only a few pages in just how valuable these skills are. Having the depth of understanding that's presented in this book gives you the ability to write code of greater robustness than otherwise, whether you're writing J2EE apps or not.

The first thing that struck my fancy was the discussion about the 3 zeroes - zero development, zero deployment, and zero administration. I've long been an advocate of building "lights out" systems - put it on the servers, shut off the lights and go home and wait for the checks. But Ted takes it beyond what I had considered. Lofty goals, no doubt, zero development, deployment & administration is exactly what we should be shooting for. As the saying goes, "Shoot for the stars and hit the sky, shoot for the sky and hit the mud."

If that was all he had to say it would have been a good purchase, but Ted then goes on to describe and produce code that actually moves us toward these goals.

I appreciated the frequent references to design patterns. In many circles patterns are new concepts that people are just starting to experiment with. It is refreshing to see a book where the audience is expected to understand them. UML is used where appropriate, adding yet more evidence that this is written by an architect and software engineer - not just someone throwing code together quick and dirty.

It's not as though all the material in the book is new and doesn't exist elsewhere. There are many texts that cover threads and their proper use. Texts about n-tier architectures abound. Application frameworks are not new concepts; sockets, persistence, servlets, middleware and JNI have been around and are well-understood. The power comes through the stated objectives and the practical application of these different technologies in a holistic manner toward them that produces a very worthy text.

Real-world, architecture-centric, holistic, practical, proven. All appropriate words to describe this book. Don't believe that one size fits all? Me either, and it's refreshing to see a work with the depth of this one. Don't know Java yet? Read some of the other fine books first. Then, when you understand the language and want to get serious about server-side development, get a copy of Server-Based Java Programming and dig in. Personally I consider the $50 I spent on this book one of the best purchases I've made.

Now if you'll excuse me, I'm going to get back into this book. It's 5am so I still have some time before I have to go to work...

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 book is ideal for beginning to develop applications and for the need for a better understanding of the different COM aspects. The variety of examples is however limited and builds upon previous shown examples. However the author limits the need of useless repeating. Read this book if you want to understand the different tools but for real development the book is not practical enough.

I found this book to be an excellent reference from the minute I opened it. I began by paging through the chapters but almost immediately found areas that helped with the project I was currently working on.
Unlike most books that spend the first several chapters covering basic topics that are covered by every other book, this one actually presented a more concise and in depth look at those topics. The chapter on IDL was well worth the reading.
This is difinately not a book for the beginner or for those looking to use languages other than C++. I did find some pieces questionable. The authors implementation of a resource sharing mechanism seems unnecessary. Why is it that authors know how to write better code than anyone else?

This is one of the best books written to provide an indepth view of Microsoft technologies and opens up new arenas for a developer. The author is very knowledgable about the COM+ and C++ programming and demonstrated a very logical approach to unraveling the topics which are very difficult to understand otherwise.

The front & back cover didn't mention that the book's examples are all in Visual Basic.Net. It would have been nice to know that, since I bought the book expecting C#. I wouldn't recommend the book unless the reader is fluent in Visual Basic.NET... or unless the author posts C# versions of the example code on the book's companion website.

This is one of the books that deals with Distributed Applications using Web Services and .NET Remoting. It provides you in such a length that you probably do not need any other book.

Excellent writing, examples and and every thing. The only reason for the "but..." part is that the code is in only VB.NET. It would have been nice to have both C# and VB.NET examples. Also, I could not get the code to compile with the latest .NET framework. May be things changed a bit, but not knowing VB and not being able to compile will limit and hinder the progress I made while reading the book.

Still, I would still keep this book at my fingertips for many reasons. If you are into Distributed Applications and want to take a look at how Web Services and .NET can help you build the applications, you *must* own this book.

This book is absolutely one of the best materials i have read that is written for an intermediate level. I think the author does a great job at explaining things and providing "real life" examples.

One such thing that struck me was his explanation of "business objects" in Chapter 10 and giving a real life example of it, including the disadvantages and the alternative solutions. (You should know that there are several red books out there that deal purely about business objects but just beat around the bush hardly providing anything useful!). In other words straight forward information without buzz words or hype.

Good examples of Threads and ThreadPools. Information that you can use in a multi-threaded application and not some superficial exposure.

Great remoting coverage including the crucial examples of how to use interfaces.

Bottom line: Buy It!

The book gives pretty good Jini overview, but it's just that: overview. Don't expect any code examples. Also there is a lot of repetition where the author goes over the same points in different chapters.

Authoritative yet simple to understand "Jini technology: An Overview" provides very authoritative yet simple to understand language in introduction chapters. Graphics and examples are well presented with relevant and realistic examples. This book describes the various concepts using simple examples involving real world entities creating a perspective and excitement on things to come in future. I recommend this book for any one who would like to know Jini technology.

I happened to review this book, which has been
nominated for "2002 Jolt Awards" yesterday. I liked
the architectural layout of the subject matter and its
presentation. In spite of me not being a core
Java/Jini developer, this book provoked me to continue
through the chapters till the end, which very few
books deliver. It helped me to get a peep into the
Jini window. I strongly recommend for any one who
would like to get an overview about the Jini
technology!

Since it has so many glowing reviews, I'll give it a review that may be uselful to the authors for future additions.

I don't understand why Sun Microsystems, on their website and in thier books, (and this book is no exception) do not use UML to describe their libraries and frameworks. I, for one, learn a lot about dependencies and collaborations between classes when UML is employed. In the sections that have real code examples, it would be helpful to have a snippet of UML describing the section of Jini critical to that example, for instance.

Furthermore, in the earlier sections of the book, the overview, the authors use what I call "system collaboration diagrams", even better would be when they are explaining code snippets to highlight in their system collaboration diagrams what part of the system they are showing an example of.

I guess I just found the explaination of the examples lacking. The examples themselves are excerpted, making them hard to follow. For instance, it is confusing to see an ordinary method being called (from within an excerpt) with no class or object qualified before it. Is it in the superclass? In the implementation? If in the superclass, how far up? This is especially difficult when referring to the DEM of Java, which sometimes seems counterintuitive to beginners.

My rule of thumb is one should never look at a piece of code and get "nervous" about what a symbol or method is supposed to be doing there.

I put off buying this for about a year because I was fooled by the title. Think of it as a primer on how to use Jini the way the people who developed Jini intended (rather than as a spec). That makes it very useful. Not ideal for someone who is considering using Jini and wants an overview, but a great "second book" on Jini. Similar to Keith Edwards' Jini "Example by Example".

Jini has to be about the hottest new Java technology to be released in years. Imagine a world of plug-and-play networked devices, which can be installed and seamlessly integrated with your LAN simply by connecting them to your network. A laptop on-the-go can just plug in to an unfamiliar network, and access the printer or Internet proxy server, without the need to install any drivers. Mixing Unix and Wintel devices? Not a worry. Jini promises to let them talk to each other.

That's the vision behind Jini. But that vision goes much further. Not only can hardware devices talk to one another, but also software services. In a Jini world, you won't care whether how a device works, or whether it is software or hardware based. An Internet based fax service will act as a fax, as will a hardware device. You'll just look for a fax service, without worrying how the service is implemented. Of course, someone needs to write the software that will power Jini services. That's where The Jini Specification comes in.

The book is divided into two main sections, an overview and the specification for Jini. The overview provides an easily accessible overview of what Jini is, how it works, and what it can achieve. There are also several examples of Jini services and clients, to give you some practical experience with building Jini software applications.

From there, the book dives headfirst into the actual specification. The first part of the book is good for managers, and software developers alike. The coverage of the specification, however, is designed as a reference for developers as they construct Jini software. This is where many readers could become lost, unless they are already using Jini in action. The first part of the book is a guide to Jini, the second intended only as a reference during development. Finally, a glossary of Jini terms and an essay on distributed computing is included, along with the full source code from the overview.

The Jini Specification is a must-have for anyone considering Jini development. It provides an excellent guide to Jini technology for those considering designing Jini-based systems, and a comprehensive printed reference for those who will implement them.  -- David Reilly, for the Java Coffee Break

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.

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.

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.

If not for its minor typo errors in the text and code, I would have given this book 5 stars.
If you're a bedroom Java programmer like me, then you can repair the code easily. Also the code examples weren't "perfect" implementations of Object Oriented Programming concepts but I believe this was intentional considering the latter would have been an additional layer of complexity and would have detracted from the book's instructional value.

The chapter on Servlets could have been longer by providing simulated web-based transaction (i.e. two-player tic-tac-toe or even against the server, or a simple business transaction using a non-database source -> text file).

The bonus JavaMail chapter was superb! If you excel in AWT/SWING, then you could make a GUI-based e-mail client with this chapter!

In my opinion, the RMI and CORBA chapters could have provided a little background on distributed computing theory. While the book overall is clear and well-organized, those without distributed computing theory background (like me) would have trouble understanding these chapters (i.e. where did the words stub and skeleton come from?) I bought this book for the networking and not the distributed computing chapters, anyway, so don't let my inexperience with distributed computing make this book any less worthwhile.

I'm just being my own opinionated self but I found this book to be truly excellent and personally give it 4.5 stars!

Most of my experience in network programming comes from W. Richard Stevens' "UNIX Network Programming", where there's lots of detail in the TCP/IP protocol, and using C to implement it. At the time, the professor teaching the course tried to provide us with comparable programs in Java, but not having a good Java networking book to consult from was a drawback to those segues.

This book serves as an excellent companion to Stevens' book, so that you can get the feel for how Java accomplishes networking capabilities. I still prefer the TCP/IP detail that Stevens' book provides, but that's mainly because I like the language independent concept of networking.

I created a small client2client messaging applet, sent it to a couple of friends for testing, and enjoyed how quickly and easily it was to get it working. Java abstracts a lot of the detail away from the user, since it was designed from the get-go to include networking capabilities, and this book uses those abstractions to its advantage. I'll probably want to get my hands dirty and see how much hands-on control I can get with Java sometime later.

(Reilly*2)'s book is a great way to just jump into network programming without getting your head too tangled with TCP/IP intricacies. This is not to say that the book doesn't cover those details, but it doesn't delve into them as deeply as Stevens' book does. In my view, that's a drawback to it being an absolute reference, but for many who just want to start developing client/server apps, this may be just what you're looking for.

One of the best books I've purchased.

I bought "Java Network Programming and Distributed Computing" for Sun's Developer certification exam which requires knowledge of the information given in every chapter, for example RMI, sockets, serialization, and threading.

The book progressively gives you information you need to understand how the different protocols work, when, where, why, and how to use them and gives good explanations of its source code examples.

I feel I received more than my money's worth and will be looking for more titles by David Reilly and Michael Reilly.

...

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.

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.

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 an okay supliment to another book, but alone I wouldn't expect to pass the test with it. It would be an alright book for the novice, or to just brush up on your knowledge. It does not conatin enough information on TSQL statements. Everything they go over is geared towards using Enterprise Manager. Also, it doesn't go into enough depth on many critical topics. I haven't taken the test yet, I'm getting another book. I can tell from previous MS SQL exams that this book alone will not prepare me for exam 70-028.

This book was a great study aid while preparing for the 70-028 test. Does it give you the answers for the test, no. Does it review key subject area necessary for passing the test, yes. Too many paper MCSEs (or wannabes) expect to get the answers to the test before taking the test. The purpose of these exams is to test your knowledge of the product and not how well you memorized the questions from practice exams. Using a book like this, BOL, and the product, you should be able to pass the exam. And for you people who expect to get the answers to the test before you take the test, there are at least two questions that I saw from this book on the test.

This is a good book to prepare for 028 exam. It helps great and saves time for a successful test. I gave 5 stars not only because it helped to pass the exam, but because it helped my job as well. The questions in the end of each chapter helps to understand tricky points in SQL 7 (helpful for even non test-takers). Most answers have good explainations (some are not detailed enough). Use this book together with OL book. Also play with the product itself A LOT, A LOT, A LOT. Anyway, this book does let me feel SQL 7 less overwhelming.

The book is not for SQL 7 beginers. In addition, as an SQL 7 DBA, I would say this book is definately not a main tool to train a DBA, although it helps to pass the exam.