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

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


MUST HAVE, One for the bookshelf!   November 21, 2002
Andrew T. Finnell (Palm Bay, FL United States)
4 out of 4 found this review helpful

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.


A crucial companion to ACE   November 21, 2002
J. Lilley (Boulder, CO USA)
3 out of 3 found this review helpful

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!


Essential design compendium for writing networked apps   November 22, 2002
Shahzad Aslam-Mir (San Diego, CA, USA)
2 out of 2 found this review helpful

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.


Essential for Serious ACE Users   November 23, 2002
Michael Searles (Garland, TX United States)
2 out of 2 found this review helpful

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.