13 of 13 people found the following review helpful:
5.0 out of 5 stars
Open-Source Framework Facilitates Network Programming, December 9, 2002
This review is from: C++ Network Programming, Volume 2: Systematic Reuse with ACE and Frameworks (Paperback)
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.
Help other customers find the most helpful reviews
Was this review helpful to you? Yes
No
4 of 4 people found the following review helpful:
5.0 out of 5 stars
MUST HAVE, One for the bookshelf!, November 21, 2002
This review is from: C++ Network Programming, Volume 2: Systematic Reuse with ACE and Frameworks (Paperback)
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.
Help other customers find the most helpful reviews
Was this review helpful to you? Yes
No
