Customer Reviews

C++ Network Programming, Volume 2: Systematic Reuse with ACE and Frameworks

5 star:		(17)
4 star:		(3)
3 star:		(2)
2 star:		(0)
1 star:		(0)

 

 

Writing networked applications using modern operating
systems and languages looks like it should be easy, but it
is emphatically not. The na‹ve designer of networked
applications will encounter a thicket of problems including
lack of portability, distributed performance bottlenecks,
maintaining correctness during shutdown, and managing
recovery from partial failures.

"C++ Network Programming, Volume 2, Systematic Reuse with
ACE and Frameworks" by Douglas Schmidt and Stephen Huston

provides some powerful help in the design and implementation
of networked applications. This help comes in the form of
several frameworks.

A few words about the definition of "framework." The first
step up from writing applications that interface directly
with operating systems is to insert object-oriented wrappers
between the application and lower level services. These
wrappers are classes that encapsulate the low level,
functionally specified, services such as operating systems

and protocol stacks. This first step was taken in the
predecessor volume to the present book, "C++ Network
Programming, Volume 1: Mastering Complexity with ACE and
Patterns", by the same authors, where a collection of
wrappers, called the ACE wrappers, is provided that not only
raises the level of the application interface from
functional to object-oriented, but also provides portability
at the same time.

For example, consider an application that directly uses
sockets. This application would depend on the syntax and
functional details of that operating system's s operating
system's socket implementation. By inserting the ACE
wrappers, the application acquires an object interface to
socket capabilities, and in addition becomes portable across
a large number of compilers, operating systems, and
communication protocols.

But a set of wrapper classes does not solve the networked
application designer's problems, any more than a pile of
bricks is a house.

Frameworks, which are the subject of the present book, are
the next step up in power from wrappers. A framework is an
integrated set of classes into which application designers
plug code that is unique to their applications. The
frameworks described in the present book handle a large part
of the difficulty inherent in network programming, leaving
application designers to deal primary with their
applications' local functionality.

For example, one of the frameworks described in the book is
the Acceptor-Connector Framework. This framework relieves
the user of dealing with the numerous tricky details
inherent in the conceptually simple process of connecting
clients with servers, such as address formats, protocols,
initialization, and message queue locking.

Readers should be aware that the present book is not a
general-purpose text on network programming using C++; this
book is a focused exposition of the ACE frameworks. Readers
will be most comfortable reading this book if they are
already familiar with software design and architecture
patterns, including those described in "Pattern-Oriented
Software Architecture: Patterns for Concurrent and Networked
Objects, Volume 2" by Douglas Schmidt et al, and in the
famous Gang of Four book: "Design Patterns: Elements of
Reusable Object-Oriented Software" by Eric Gamma et al.

The large amount of code that implements the wrappers of
volume 1 and the frameworks of volume 2 is available for
download for free. This code is in wide use today.

Designers of networked applications, when offered a large
pile of code that purports to do a lot of what needs to be
done, must trade off the anticipated saving in design and
implementation time against the anticipated time to
understand what the offered code is intended to do and what
it actually does. This tradeoff can lead a reasonable
designer to ignore existing code in favor of hand-writing an
entire application. In the case of the ACE wrappers and
frameworks, as documented and explained by the two books
mentioned here, combined with the open-source nature of the
implementing code and its widespread employment in real
applications, make the result of this tradeoff pretty clear:
read the books, use the code.

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.

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!

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.

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.

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

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.

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.

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.

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.