Rating: 
Summary: Inside ACE
Review: While Pattern-Oriented Software Architecture, Volume 2 (POSA2) describes network and concurrency patterns, i.e. what infrastructure for networked applications you should provide before starting development of functional layer; this book is about the concrete implementation of above patterns as ACE Frameworks and how to apply ACE to build you own networked application. At the same time it is self-contained and if you do not have a chance to look at POSA2, this book will provide you with necessary knowledge of main network design patterns.
It covers the core ACE frameworks - Reactor, Service Configuration, Task, Acceptor-Connector, Proactor, and Streams- in great detail.
The book is well organized in form of "design pattern" - "chapter-per-framework" - with each framework overview, component description, example step-by-step how to use it, and summary. It makes the book easy to read and clear to understand. Sidebars focus your attention on tips and very important details of implementation. They can save time even for ACE developers, releasing them from digging through the ACE source code. So if you need a book "Inside ACE", you already got it. In my opinion, this book is all what you need to build real scalable network applications. Moreover, instead of thinking how to resolve platform-depended technical problems, such books force you to think what patterns suit the best for each particular case and what kind of networked pattern-oriented applications you could build more.
Rating:
Summary: Open-Source Framework Facilitates Network Programming
Review: 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.
Rating:
Summary: Open-Source Framework Facilitates Network Programming
Review: 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.
| 
