C++ Network Programming Volume 2: Systematic Reuse With Ace and Frameworks (C++ in Depth Series) (英語) ペーパーバック – 2002/10/29
Kindle 端末は必要ありません。無料 Kindle アプリのいずれかをダウンロードすると、スマートフォン、タブレットPCで Kindle 本をお読みいただけます。
Do you need to develop flexible software that can be customized quickly? Do you need to add the power and efficiency of frameworks to your software? The ADAPTIVE Communication Environment (ACE) is an open-source toolkit for building high-performance networked applications and next-generation middleware. ACE's power and flexibility arise from object-oriented frameworks, used to achieve the systematic reuse of networked application software. ACE frameworks handle common network programming tasks and can be customized using C++ language features to produce complete distributed applications.
C++ Network Programming, Volume 2, focuses on ACE frameworks, providing thorough coverage of the concepts, patterns, and usage rules that form their structure. This book is a practical guide to designing object-oriented frameworks and shows developers how to apply frameworks to concurrent networked applications. C++ Networking, Volume 1, introduced ACE and the wrapper facades, which are basic network computing ingredients. Volume 2 explains how frameworks build on wrapper facades to provide higher-level communication services.
Written by two experts in the ACE community, this book contains:
- An overview of ACE frameworks
- Design dimensions for networked services
- Descriptions of the key capabilities of the most important ACE frameworks
- Numerous C++ code examples that demonstrate how to use ACE frameworks
C++ Network Programming, Volume 2, teaches how to use frameworks to write networked applications quickly, reducing development effort and overhead. It will be an invaluable asset to any C++ developer working on networked applications.
Dr. Douglas C. Schmidt is the original developer of ACE and The ACE ORB (TAO). He is a Professor at Vanderbilt University, where he studies patterns, optimizations, middleware, and model-based tools for distributed real-time and embedded systems. He is a former editor-in-chief of C++ Report and columnist for C/C++ Users Journal.
Stephen D. Huston is President and CEO of Riverace Corporation, a provider of technical support and consulting services to companies who want to keep software projects on track using ACE. Steve has nearly ten years of experience with ACE, and more than twenty years of software development experience, focusing on network protocol and C++ networked application development in a wide range of hardware and software environments.
systems and languages looks like it should be easy, but it
is emphatically not. The nave 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
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
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.
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.
- 洋書 > Computers & Technology > Networking > Network Programming
- 洋書 > Computers & Technology > Networking > Networks, Protocols & APIs > Networks
- 洋書 > Computers & Technology > Programming > Languages & Tools > C
- 洋書 > Computers & Technology > Programming > Software Design, Testing & Engineering > Object-Oriented Design
- 洋書 > Education & Reference
- 洋書 > Medical Books