Rating: 
Summary: A good overview (Vol. 1 continued)
Review: A good book to begin learning ACE (not TAO!). Well written, illustrated. Very high level though, keep that in mind, no depth. Also, some parts are overloaded with trivialities, for a book of this kind that's out of place, I think. Very similar to the online docs. Not brilliant, but decent; a good read for those starting to work with ACE, move to it after having read vol.1.
Rating: 
Summary: A real timesaver
Review: A must for those who are (planning to) develop concurrent network applications with ACE.
Also recommended for those who want to learn a lot about advanced C++ frameworks for concurrent networking software.The book gives a good understandig of the major frameworks inside ACE, and an idea of how little self written code is necessary for building industrial strength systems with it. The various annotated code examples are a real timesaver for understanding and using the frameworks.
Rating:
Summary: Essential reading for any ACE user
Review: ACE is a big framework that offers different things to different people. For some it's just a platform abstraction library. For others, it offers a very nice object-oriented wrapper facade around many operating system services like threads, timers, sockets, synchronization mechanisms, and so on. This book covers the bigger picture of what ACE has to offer by showing and explaining how to use its framework aspects. The framework is implemented in terms of the "lower level" objects and interfaces that are documented in C++ Network Programming Volume 1, and these are the features that really make ACE unique and a pleasure to use. It is through these framework pieces that you can really achieve the benefits of this library. As a reviewer of the book, I have read this in depth, from cover to cover, and recommend it to ACE users. With the title of "C++ Network Programming", do not confuse it as a "modernized" replacement Stevens network programming books. It is really about how to make the best use of ACE possible. The core parts of ACE are the various reactor implementations, the task ("thread object"), streams, accepter-connector patterns, and the service configurator. These are all covered in detail, developing a realistic application many times using different techniques (highlighting the framework piece(s) being described at the time.) The coverage of TCP/IP is good at a high level, assuming you are already familiar with the concepts of how TCP/IP works in general, with examples throughout the entire book. (For example, low-level socket options, etc., are still best covered in Stevens books.) If I have to gripe about anything, it would be that only TCP/IP networking is really covered, and no coverage of multicast.
As an ACE user, I found that this information is very good at introducing the reader to the different parts of the ACE framework, showing when you would use those features, and examples of how to do so. Though we've been using ACE for several years, I still learned a lot through reading this (primarily because I have only used some parts of ACE, mainly the TCP/IP socket wrappers and the Reactor.) This book was more interesting for me to read than Volume 1 because it demonstrated how to actually make use of ACE, rather than just documenting the parts that constitute the library. I believe that volume 1 and volume 2 really should be one book, because they really need each other to form the complete picture. ACE users have been waiting for this kind of book for a very long time, and finally it has been written.
Rating: 
Summary: Quite not what I expected it to be
Review: After reading the Vol. 1, I expected quite a bit from the volume 2. May be I am not there yet to understand what the authors are trying to emphasize here. I found some of the material from vol.1 covered to much deeper extend. But the framework from the reusability point of view is missing. Some of the topics covered here are great indeed, especially chapter 5, 6 and 7. Other than that I found this book to be a quick browse and keep it away.
Rating:
Summary: Detailed coverage of the ACE frameworks
Review: As in the ACE toolkit itself, C++NPv2 builds on the work described in volume 1 with a focus on the more powerful and (in my opinion) more interesting aspects of ACE...the frameworks that make developing network applications a pleasure. Although the book recommends that you be familiar with the underlying patterns before delving into the details, I think that anybody who has experience developing network applications will be able to fully grasp the power of these frameworks without necessarily having knowledge of the patterns. The areas of the book I found most useful were the description of the ACE Reactor framework (Ch 3), Reactor implementations (Ch 4), the description of the ACE Task framework (Ch 6) and the description of the ACE Streams framework (Ch 9). Use of UML sequence diagrams made it easier to understand the interaction between application and framework code. However, I think more space could have been devoted to the class diagrams to give a clearer picture of the relationship between application and framework classes. I also found the highlighting of common techniques in sidebars to be very informative. The only complaint I have is that this book wasn't available in January 2001 ;-(
Rating:
Summary: Order out of chaos
Review: Beautifully written and well organized, Doug Schmidt's and Steve Huston's newest volume in the C++ Network Programming series literally brings order out of chaos. Trite as that may sound, it's exactly what Schmidt has been trying to do ever since he started the ACE project over 10 years ago. This volume as well as the success of ACE and its sister project, TAO, are testiments to the power pattern based frameworks have in bringing order to the complex and chaotic world of network programming. Many of the patterns presented in this volume, e.g, Reactor & Proactor, Component Configurator, Acceptor-Connector, etc., originally appeared in POSA2. Although you don't need to fully understand the patterns in order to use them, a good understanding of POSA2 definitely helps, since this volume complements and greatly extends the depth of the discussions on patterns that appear there. C++NPv2 builds on the first volume, C++NPv1, so it's important that the reader fully understand that material first. Although developers can use these wrapper facades from C++NPv1 directly, the frameworks Schmidt and Huston present in this volume are much more powerful. Just as patterns aren't meant to be used in isolation, neither are frameworks. Frameworks are what ACE is all about and with the authors' expert guidance we are introduced one by one to the major frameworks in ACE and shown how they inter-operate. The Networked Logging Service from C++NPv1 is used as a vehicle for describing how to apply frameworks and use them together. This is a very powerful technique. After reading each chapter, you will be armed with enough information to integrate that framework into your own project. Not only that, but since the frameworks are designed to work together, project evolution gets easier, not harder--you can easily pick and choose the appropriate frameworks for your particular problem without having to start from scratch. How often can you say that about a software project? By the end of the book, the example program will have evolved into a full fledged distributed application--not a toy. The reader can use the Logging Service example directly--the source code is provided with the ACE distribution and is freely downloadable--or use a more sophisticated, production quality version which is part of the ACE Network Services, that is also distributed with ACE. Finally, all the books in the C++ In-Depth Series have eye catching cover photos, and C++NPv2 is no exception. Maybe it's because I partly worked my way through school doing construction work, but I found the photo of the fully assembled pre-fab, i.e., pre-built, roof trusses (in case you didn't know what they were called ;-) to be an excellent analogy for ACE. I've put up my share of pre-fab roof trusses, as well as roofs requiring you to custom cut and fit each stick. Using pre-fab roof trusses allows you to quickly put up a complex roof in much less time than it would take to measure, cut, fit, and nail each individual piece, even though the steps are almost exactly the same each time. Not only that, but with a pre-fab truss system, only the architect and truss designer need to be experts in materials and methods; the guys who actually put it all together don't need to worry about or even know how it works, just that it does. Which makes construction safer, cheaper, and less error-prone, etc... -- hmmm, starting to sound familiar? For me, this is the key to ACE's success. ACE makes it easy to reuse the knowledge and experience of experts to quickly put together complex applications that work--the first time. Not only that, it makes it easy to do it right, and difficult to do it wrong. I whole heartedly recommend both ACE and this volume. It's well worth the time and effort, as well as the price...
Rating:
Summary: Order out of chaos
Review: Beautifully written and well organized, Doug Schmidt's and Steve Huston's newest volume in the C++ Network Programming series literally brings order out of chaos. Trite as that may sound, it's exactly what Schmidt has been trying to do ever since he started the ACE project over 10 years ago. This volume as well as the success of ACE and its sister project, TAO, are testiments to the power pattern based frameworks have in bringing order to the complex and chaotic world of network programming. Many of the patterns presented in this volume, e.g, Reactor & Proactor, Component Configurator, Acceptor-Connector, etc., originally appeared in POSA2. Although you don't need to fully understand the patterns in order to use them, a good understanding of POSA2 definitely helps, since this volume complements and greatly extends the depth of the discussions on patterns that appear there. C++NPv2 builds on the first volume, C++NPv1, so it's important that the reader fully understand that material first. Although developers can use these wrapper facades from C++NPv1 directly, the frameworks Schmidt and Huston present in this volume are much more powerful. Just as patterns aren't meant to be used in isolation, neither are frameworks. Frameworks are what ACE is all about and with the authors' expert guidance we are introduced one by one to the major frameworks in ACE and shown how they inter-operate. The Networked Logging Service from C++NPv1 is used as a vehicle for describing how to apply frameworks and use them together. This is a very powerful technique. After reading each chapter, you will be armed with enough information to integrate that framework into your own project. Not only that, but since the frameworks are designed to work together, project evolution gets easier, not harder--you can easily pick and choose the appropriate frameworks for your particular problem without having to start from scratch. How often can you say that about a software project? By the end of the book, the example program will have evolved into a full fledged distributed application--not a toy. The reader can use the Logging Service example directly--the source code is provided with the ACE distribution and is freely downloadable--or use a more sophisticated, production quality version which is part of the ACE Network Services, that is also distributed with ACE. Finally, all the books in the C++ In-Depth Series have eye catching cover photos, and C++NPv2 is no exception. Maybe it's because I partly worked my way through school doing construction work, but I found the photo of the fully assembled pre-fab, i.e., pre-built, roof trusses (in case you didn't know what they were called ;-) to be an excellent analogy for ACE. I've put up my share of pre-fab roof trusses, as well as roofs requiring you to custom cut and fit each stick. Using pre-fab roof trusses allows you to quickly put up a complex roof in much less time than it would take to measure, cut, fit, and nail each individual piece, even though the steps are almost exactly the same each time. Not only that, but with a pre-fab truss system, only the architect and truss designer need to be experts in materials and methods; the guys who actually put it all together don't need to worry about or even know how it works, just that it does. Which makes construction safer, cheaper, and less error-prone, etc... -- hmmm, starting to sound familiar? For me, this is the key to ACE's success. ACE makes it easy to reuse the knowledge and experience of experts to quickly put together complex applications that work--the first time. Not only that, it makes it easy to do it right, and difficult to do it wrong. I whole heartedly recommend both ACE and this volume. It's well worth the time and effort, as well as the price...
Rating:
Summary: Excellent explanation of ACE and C++ network programming
Review: C++ Network Programming, volume 2, continues in the tradition
of volume 1, of doing an excellent job of explaining how to
program robust network software in C++ using the ACE framework. The book is well-structured, and easy to read. Each section explains: - the general concepts associated with a specific network programming
topic, for example reactive event loops, or asynchronous I/O
- the underlying operating system API's associated with each topic, for
example, for reactive event loops, the Unix select()
or the Windows WaitForMultipleObjects() calls
- the underlying design patterns for properly using these facilities,
such as the Reactor, Proactor, Service Configurator
- and the accompanying C++ class in ACE for using this design pattern The text and code examples are very clear and easy to follow.
I particularly like the technique of using sidebars throughout the
text, which draws your attention to particularly interesting
nuggets of information. My favorite parts of this book were the parts which covered in depth three
of the most core concepts in the ACE framework:
- the Reactor (reactive event loops),
- the Proactor (using asynchronous I/O for dispatching events),
- the ACE_Task (using concurrency/multithreading efficiently in an
object-oriented fashion) Understanding these core concepts is essential for building
high-performance middleware and networked software. These concepts were used extensively by Schmidt, when his team used ACE to build
The ACE ORB (TAO), a C++ CORBA implementation, so this book
will help with understanding some of the internal implementation
details of TAO. For new users of ACE, this book is a good introduction, alongside volume 1.
For experienced users of ACE, this book is an excellent
refresher, and concisely explains many core ACE concepts, accompanied
with illustrative examples. This book will make an
excellent addition to the bookshelf of anyone serious
about C++ network programming.
Rating:
Summary: MUST HAVE, One for the bookshelf!
Review: Finally, a book that presents, clearly and concisely, the philosophy and design patterns behind the ACE framework. It is refreshing to read from two authors so well-versed in design patterns and gifted in what it takes to create a robust, cross-platform, network programming framework.
"Systematic Reuse with ACE and Frameworks" reads as a tutorial for the seasoned C++ programmer, but also presents the material in small digestible chunks that you can refer to again and again. It lays out a series of best-practices, and is a "must-have" for any programmer who wants to CORRECTLY create strong networking software or even wants to see good examples of how patterns can simplify effort in such a complex environment.
Rating:
Summary: A solid guide to working with ACE
Review: I found the book to give a solid introduction into the world of using ACE to build real world network application. I find the book to be more useful for ACE novices but it also includes material for ACE veterans.
I enjoyed the evolution of the sample application through the use of the ACE features, and think it is a good way to introduce its ideas.
| 
