Rating: 
Summary: A crucial companion to ACE
Review: If you are going to program with ACE, you want this book, period. Although the web site and news groups have similar information, they are not nearly as comprehensive and well-organized as the book, and some of us actually like to read when we're not looking at the computer!
Rating:
Summary: Essential design compendium for writing networked apps
Review: The second of an invaluable 'living' text on network programming. I'd rate it six stars, so the rating scale needs revision. This second volume is probably to network programming and using a pattern language for it, what Knuth's books are to the practice of computer science, and heres why -
Schmidt and his research group has put in many years of painstaking research in this work and evolved the ACE-TAO network programming platform which these texts use to illustrate the sound guidance on the principles and practices they refer to in the texts.
The books are not meant to be exhaustive in their descriptions, rather give concise and effective pointers and guidance in the most important areas - if you need exhaustive details and full working code, go to the website and get the source and research papers.
Writing network software is hard and developing in C++ is no picnic either. Doing the two together for enterprise level of scalability and performance is an extremely complex and difficult task. Realistically it takes many revisions to get this type of software robust, and bug free. Personally, I wish I had this book when I started out in my personal quest of discovery in these areas. The book eloquently and effectively identifies and illustrates the moving parts of any generic canonical client or server side network application through patterns. These in my opinion are one of the strengths of Schmidt's work. The other is the example implementations illustrated in ACE-TAO for the diehards wanting to see the code details that work. The authors also highlight oft forgotten issues and gotchas that might surface during development. The book does this by talking about the design of the ACE toolkit. Professor Schmidt developed the ACE toolkit which he uses to express his experience for others to reuse that is another of the books strengths.
The text helps make aware the general network programming community of the power of a pattern language to create such complex software, and so manage complexity yet preserve and identify domain knowledge in creating such software. The text should be studied with the ACE-TAO toolkit freely available from the website in the book.
Rating:
Summary: A must have for all ACE users
Review: This book goes on further where C++NPv1 stopped. It describes how several of the patterns in POSA2 are designed and implemented in ACE as frameworks. The Reactor, Proactor, Service Configurator, Acceptor-Connector, Task and Streams framework are explained in detail. In the sidebars a lot of hints and tips are given which really increase your understanding of ACE.
All frameworks are described in detail and also a lot of example code is provided to give you a better overview how to use ACE. If you use ACE or think about using ACE this books is besides POSA2 and C++NPv1 a real must have. In particular, compared with POSA2, C++NPv2 provides considerably more details on how to program the ACE frameworks successfully!
Rating:
Summary: Essential for Serious ACE Users
Review: This book is loaded with practical no-nonsense real-world design philosophies and pattern techniques. As an experienced designer and developer of networking applications, I really appreciate the powerful paradigms available in ACE, and this text does a great job of describing how they work and how to effectively use them while building on the foundations presented in Volume 1. This book has definitely helped me in getting my head around the Reactor, Acceptor/Connector and Task patterns, since these are the patterns that I most actively use in ACE. It has also exposed me to several other patterns that I haven't had a chance to use yet. If you're doing network programming in C++, and aren't using ACE, it's well worth looking into. The reoccurring patterns used in designing and implementing networked applications are all contained in the ACE framework -- and as a huge bonus -- platform independence (support for most popular operating systems) is built in with ACE's wrapper facades. Also, the ACE open-source community is actively enhancing and improving the framework, so it just keeps getting better and better. The challenge with any good framework, is learning how to harness what's provided in it. C++ Network Programming Volume 2 goes a long way towards that end and both it and Volume 1 are essential for any developer serious about using the ACE framework.
Rating:
Summary: Highly recommended! Develop network apps quickly, robustly
Review: This book, as well as Vol. 1, has made life as a developer much much easier and more productive. I am involved with the design, implementation and integration of distributed real-time embedded systems. One day a co-worker and I were doing some debugging of our application code and were having some difficulty. We then reminded ourselves that the particular system we were working on was a distributed, heterogeneous, embedded, real-time, multithreaded, object-oriented, C++, web-enabled application. Each of the previous modifiers by themselves can make a project difficult, but throw them all together and you have an adventure on your hands. We needed the information in this book to succeed. Following the information in the book, we were able to easily hook our application code to these frameworks. After that point, the debugging we had to do was in our problem-domain application code. The ACE frameworks we were using under the hood were working perfectly and allowed us to concentrate our efforts on our specific application. We were very happy that much of the difficult work had been done by others and was now documented in a book such as this. The information in this book gives you the tools and frameworks you need to tackle projects like this and succeed in a timeframe that allows you to be competitive. In one of our projects we had a need for an event demultiplexing/dispatching mechanism. We were able to use the Reactor and Acceptor/Connector framework implementations described in detail in this book to solve our problem. The book describes very clearly how to use and extend these frameworks. In a different part of the project we needed a similar mechanism but based on Win32 events as opposed the select call. We found exactly what we were looking for described in the book, the WFMO reactor implementation. In very short order, we were able to have our application up and running. Shortly thereafter, we had to add some concurrency capabilities to some parts of our application. We were able to immediately apply the ACE Task framework as described in the book. Using the information in the book, we were not only able to use the frameworks, but also understand how they worked and why they worked that way. Folks, including ourselves, were very surprised at how quickly these systems came together. The book is very clearly written and includes many source code examples and applications, UML diagrams as well as detailed sidebars describing how to handle specific corner cases that you may encounter.
Rating:
Summary: Well-written book for eligant power code warriors
Review: This is a well written book documenting many of the eligant and powerful frameworks and idioms used in the ACE library. I've been using ACE for over 7 years to implement portable, concurrent, networked, distributed applications and it's great to see a well-written book like this finally being published. I would highly recommend it as a must have reference for all serious ACE programmers who strive to develop powerful, flexible and portable networked applications. It is also an extremely valuable resource for programmers who want to get introduced and up and running on the concepts and application of some very valuable frameworks.
Rating:
Summary: Well-written book for eligant power code warriors
Review: This is a well written book documenting many of the eligant and powerful frameworks and idioms used in the ACE library. I've been using ACE for over 7 years to implement portable, concurrent, networked, distributed applications and it's great to see a well-written book like this finally being published. I would highly recommend it as a must have reference for all serious ACE programmers who strive to develop powerful, flexible and portable networked applications. It is also an extremely valuable resource for programmers who want to get introduced and up and running on the concepts and application of some very valuable frameworks.
Rating:
Summary: An Excellent Sequel
Review: Volume 1 explored the traps and pitfalls of developing efficient and portable client/server applications. It took a first principles approach to explaining how C++ could be used to encapsulate the lower level OS primitives to create classes that are simpler to use, less error prone, and cross-platform. In contrast, Volume 2 takes us one level higher in abstraction and presents a number of tried and true patterns for developing robust, cross-platform distributed applications. The authors provide a clear explanation of the consequences of different design choices for threading and event demultiplexing on the design, implementation, and performance of a distributed application. An example, a distributed logging server, is followed throughout the book to help explore the consequences of the different strategies on the example server. The mixture of well-explained concepts and example code give the reader a real appreciation for complexity of building such systems, and the patterns, and frameworks that can be used to manage this complexity. To say this is just for users of the ACE framework would be wrong. The concepts are not ACE specific; rather they represent man-years in best practices of building distributed systems. However, if you are an ACE user, this will clearly explain some of the higher-level patterns and how/why they came to be.
Rating: 
Summary: Better coverage than Volume I
Review: When I bought the second volume I thought it will explain some more details about Task. Mainly covers Reactor and Service classes same as Vol I. Web site gives more information than these text books. Examples are not in detail. I have all three books( Vol I&II and patterns). I found the pattern book the best among the three.
Rating:
Summary: Excellent series
Review: When I first encountered ACE I was stunned by how completely
it solved the server side scalability and portability difficulties we always encountered. I was excited because I could instantiate the solution to my problems, rather than research, design and then implement the solution. I was able to master the inherit complexity by applying ACE components and design patterns. When the first book in this series came out, I was reminded of my initial excitement as that book detailed these issues and their solutions as implemented in ACE. Later, as I attend classes by Doug Schmidt and Carlos O'Ryan I learned about Frameworks. Here my learning's applied beyond the ACE libraries, what I learned allowed me to evaluate other frameworks and designs: I could apply the lessons of ACE even when I couldn't use the library directly. And that is what excites me about the second book in this series. While the title includes C++, this book details the knowledge contained in ACE; its a "how-to" book for developing object oriented frameworks for implementing networked applications. The lessons here are applicable regardless of whether you use the ACE library; regardless of the language you choose, because the authors layout completely the problems encountered in developing networked applications and how they can be fully addressed.
|
