BN.com Gift Guide

The ACE Programmer's Guide: Practical Design Patterns for Network and Systems Programming

Paperback (Print)
Used and New from Other Sellers
Used and New from Other Sellers
from $1.99
Usually ships in 1-2 business days
(Save 97%)
Other sellers (Paperback)
  • All (17) from $1.99   
  • New (8) from $46.95   
  • Used (9) from $1.99   

Overview

If you're designing software and systems that must be portable, flexible, extensible, predictable, reliable, and affordable, this book and the ACE toolkit will enable you to be more effective in all of these areas. Even after spending over a decade developing ACE and using it to build networked software applications, I find that I've learned a great deal from this book, and I'm confident that you will, too.
--Douglas C. Schmidt, Inventor of ACE, from the Foreword

This book is a must-have for every ACE programmer. For the beginner, it explains step-by-step how to start using ACE. For the more experienced programmer, it explains in detail the features used daily, and is a perfect reference manual. It would have saved me a lot of time if this book had been available some years ago!
--Johnny Willemsen, Senior Software Engineer, Remedy IT, The Netherlands

With a large C++ code base, we rely on ACE to enable a cross-platform client-server framework for data quality and data integration. ACE has improved our design and smoothed over OS idiosyncrasies without sacrificing performance or flexibility. The combination of online reference materials and printed "big picture" guides is indispensable for us, and The ACE Programmer's Guide earns top-shelf status in my office.
--John Lilley, Chief Scientist, DataLever Corporation

In SITA air-ground division, we are one of the major suppliers of communication services to the airline industry. We started using ACE about a year ago and are now moving most of our new communication-related development to it. I can say that using this toolkit can reduce the development and testing time by at least 50% in our type of application.
--Jean Millo, Senior Architect, SITA

The ADAPTIVE Communication Environment (ACE) is an open-source software toolkit created to solve network programming challenges. Written in C++, with the help of 30 core developers and 1,700 contributors, this portable middleware has evolved to encapsulate and augment a wide range of native OS capabilities essential to support performance-driven software systems.

The ACE Programmer's Guide is a practical, hands-on guide to ACE for C++ programmers building networked applications and next-generation middleware. The book first introduces ACE to beginners. It then explains how you can tap design patterns, frameworks, and ACE to produce effective, easily maintained software systems with less time and effort. The book features discussions of programming aids, interprocess communication (IPC) issues, process and thread management, shared memory, the ACE Service Configurator framework, timer management classes, the ACE Naming Service, and more.

The accompanying CD-ROM contains the complete ACE toolkit, including installable kits for Windows, Solaris, and HP-UX; complete reference documentation for all of the ACE classes; and source code for every example in the book.

0201699710B10142003

Read More Show Less

Product Details

  • ISBN-13: 9780201699715
  • Publisher: Addison-Wesley
  • Publication date: 10/17/2003
  • Edition description: New Edition
  • Pages: 506
  • Product dimensions: 7.45 (w) x 9.06 (h) x 1.06 (d)

Meet the Author

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.

0201699710AB06232003

Read More Show Less

Read an Excerpt

ACE (the ADAPTIVE Communication Environment) is a powerful C++ toolkit that helps you develop portable, high-performance applications, especially networked and/or multithreaded applications, more easily and more quickly with more flexibility and fewer errors. And, because of ACE's design and frameworks, you can do all this with much less code than with other development approaches. We've been using ACE for years and have found it exceedingly helpful and well worth any price. What's better is that it's available for free! The historical price many developers have paid to use ACE is a steep learning curve. It's a big toolkit with a large set of capabilities. Until recently, the best documentation has been the source code, which is, of course, freely available, and a set of academic papers born of the research that produced ACE, approachable only by advanced professionals and upper-level students. This barrier to learning has kept ACE's power and easy-to-use elegance one of the best-kept secrets in software development. That's why we're very excited to write this book! It flattens out ACE's learning curve, bringing ACE's power, elegance, and capabilities to all.

This book teaches you about ACE: a bit of its history and approach to development, how it's organized, how to begin using it, and also how to use some of its more advanced capabilities. We teach you how to do things the ACE way in this book, but we could not possibly fit in a complete reference. Use this book to get started with ACE and to begin using it in your work. If you've been using ACE for a while, there are probably descriptions of some capabilities you haven't seen before, so the book is useful for experiencedACE users as well.Who Should Read This Book

This book is meant to serve as both an introductory guide for ACE beginners and a quickly accessible review for experienced ACE users. If you are an ACE beginner, we recommend starting at the beginning and proceeding through the chapters in order. If you are experienced and know what you want to read about, you can quickly find that part of the book and do not need to read the previous sections.

This book is written for C++ programmers who have been exposed to some of the more advanced C++ features, such as virtual inheritance and class templates. You should also have been exposed to basic operating system facilities you plan to use in your work. For example, if you plan to write programs that use TCP/IP sockets, you should at least be familiar with the general way sockets are created, connections are established, and data is transferred.

This book is also an excellent source of material for those who teach others: in either a commercial or an academic setting. ACE is an excellent example of how to design object-oriented software and use C++ to design and write high-performance, easily maintained software systems.Organization

This book is a hands-on, how-to guide to using ACE effectively. The many source code examples illustrate proper use of the pieces of ACE being described. The source code examples are kept fairly short and to the point. Sometimes, the example source is abridged in order to focus attention on a topic. The complete source code to all examples is on the included CD-ROM and is also available on Riverace Corporation's web site. The included CD-ROM also includes a copy of ACE's source kit, installable versions of ACE prebuilt for a number of popular platforms, and complete reference documentation for all the classes in ACE.

The book begins with basic areas of functionality that many ACE users need and then proceeds to build on the foundations, describing the higher-level features that abstract behavior out into powerful patterns.

Part I introduces ACE and provides some generally useful information about the facilities ACE provides. Part I also explains how to configure and build ACE, as well as how to build your applications that use ACE. Widely used programming aids, such as logging and tracing, command line processing and configuration access, and ACE's container classes, are also described.

Part II discusses ACE's facilities for interprocess communication (IPC), beginning with basic, low-level TCP/IP Sockets wrapper classes and proceeding to show how to handle multiple sockets, as well as other events, such as timers and signals, simultaneously using ACE's Reactor and Proactor frameworks. Part II also describes ACE's Acceptor-Connector framework and then ends with a discussion of some of the other IPC wrapper classes ACE offers, many of which are substitutable for TCP/IP wrapper classes in the covered frameworks.

Part III covers a wide range of topics related to process and thread management using ACE. This part explains how to use ACE's process management classes and then covers signals, followed by three chapters about multithreaded programming, thread management, and the critical areas of thread safety and synchronization. Part III ends with discussions of Active Objects and various ways to use thread pools in ACE—critical topics for effective use of multithreading in high-performance applications.

Part IV covers advanced ACE topics: shared memory, the ACE Streams framework for assembling modular data-processing streams, and how to make your applications more flexible and configurable by using the ACE Service Configurator framework. Part IV concludes with an in-depth discussion of ACE's timer management classes and the ACE Naming Service, one of ACE's network services components to assist with often needed networked application programming tasks.

The book concludes with a bibliography and an extensive subject index.Conventions Used in This Book

All ACE classes begin with ACE_. When we refer to patterns instead of the classes they implement, we omit the prefix. For example, the Reactor pattern is implemented by the ACE_Reactor class.

All class member variables are suffixed with '_'. This convention is used in the ACE sources, and we carry it through to the examples in this book as well.

C++ code and file names are set in this font. Command lines are set in this font.

Steve Huston
James CE Johnson
Umar Syyid

Read More Show Less

Table of Contents

Illustrations.

Tables.

Foreword.

Preface.

I. ACE BASICS.

1. Introduction to ACE.

A History of ACE.

ACE's Benefits.

ACE's Organization.

Patterns, Class Libraries, and Frameworks.

Porting Your Code to Multiple Operating Systems.

Smoothing the Differences among C++ Compilers.

Using Both Narrow and Wide Characters.

Where to Find More Information and Support.

Summary.

2. How to Build and Use ACE in Your Programs.

A Note about ACE Versions.

Guide to the ACE Distribution.

How to Build ACE.

How to Include ACE in Your Applications.

How to Build Your Applications.

Summary.

3. Using the ACE Logging Facility.

Basic Logging and Tracing.

Enabling and Disabling Logging Severities.

Customizing the ACE Logging Macros.

Redirecting Logging Output.

Using Callbacks.

The Logging Client and Server Daemons.

The LogManager Class.

Runtime Configuration with the ACE Logging Strategy.

Summary.

4. Collecting Runtime Information.

Command Line Arguments and ACE_Get_Opt.

Accessing Configuration Information.

Building Argument Vectors.

Summary.

5. ACE Containers.

Container Concepts.

Sequence Containers.

Associative Containers.

Allocators.

Summary.

II. INTERPROCESS COMMUNICATION.

6. Basic TCP/IP Socket Use.

A Simple Client.

Adding Robustness to a Client.

Building a Server.

Summary.

7. Handling Events and Multiple I/O Streams.

Overview of the Reactor Framework.

Handling Multiple I/O Sources.

Signals.

Notifications.

Timers.

Using the Acceptor-Connector Framework.

Reactor Implementations.

Summary.

8. Asynchronous I/O and the ACE Proactor Framework.

Why Use Asynchronous I/O?.

How to Send and Receive Data.

Establishing Connections.

The ACE_Proactor Completion Demultiplexer.

Using Timers.

Other I/O Factory Classes.

Combining the Reactor and Proactor Frameworks.

Summary.

9. Other IPC Types.

Interhost IPC with UDP/IP.

Intrahost Communication.

Summary.

III. PROCESS AND THREAD MANAGEMENT.

10. Process Management.

Spawning a New Process.

Using the ACE_Process_Manager.

Synchronization Using ACE_Process_Mutex.

Summary.

11. Signals.

Using Wrappers.

Event Handlers.

Guarding Critical Sections.

Signal Management with the Reactor.

Summary.

12. Basic Multithreaded Programming.

Getting Started.

Basic Thread Safety.

Intertask Communication.

Summary.

13. Thread Management.

Types of Threads.

Priorities and Scheduling Classes.

Thread Pools.

Thread Management Using ACE_Thread_Manager.

Signals.

Thread Start-Up Hooks.

Cancellation.

Summary.

14. Thread Safety and Synchronization.

Protection Primitives.

Thread Synchronization.

Thread-Specific Storage.

Summary.

15. Active Objects.

The Pattern.

Using the Pattern.

Summary.

16. Thread Pools.

Understanding Thread Pools.

Half-Sync/Half-Async Model.

Leader/Followers Model.

Thread Pools and the Reactor.

Summary.

IV. ADVANCED ACE.

17. Shared Memory.

ACE_Malloc and ACE_Allocator.

Persistence with ACE_Malloc.

Position-Independent Allocation.

ACE_Malloc for Containers.

Wrappers.

Summary.

18. ACE Streams Framework.

Overview.

Using a One-Way Stream.

A Bidirectional Stream.

Summary.

19. ACE Service Configurator Framework.

Overview.

Configuring Static Services.

Setting Up Dynamic Services.

Setting Up Streams.

Reconfiguring Services During Execution.

Using XML to Configure Services and Streams.

Configuring Services without svc.conf.

Singletons and Services.

Summary.

20. Timers.

Timer Concepts.

Timer Queues.

Prebuilt Dispatchers.

Managing Event Handlers.

Summary.

21. ACE Naming Service.

The ACE_Naming_Context.

A Single-Process Naming Context: PROC_LOCAL.

Sharing a Naming Context on One Node: NODE_LOCAL.

Sharing a Naming Context across the Network: NET_LOCAL.

Summary.

Bibliography.
Index. 0201699710T11042003

Read More Show Less

Preface

ACE (the ADAPTIVE Communication Environment) is a powerful C++ toolkit that helps you develop portable, high-performance applications, especially networked and/or multithreaded applications, more easily and more quickly with more flexibility and fewer errors. And, because of ACE's design and frameworks, you can do all this with much less code than with other development approaches. We've been using ACE for years and have found it exceedingly helpful and well worth any price. What's better is that it's available for free! The historical price many developers have paid to use ACE is a steep learning curve. It's a big toolkit with a large set of capabilities. Until recently, the best documentation has been the source code, which is, of course, freely available, and a set of academic papers born of the research that produced ACE, approachable only by advanced professionals and upper-level students. This barrier to learning has kept ACE's power and easy-to-use elegance one of the best-kept secrets in software development. That's why we're very excited to write this book! It flattens out ACE's learning curve, bringing ACE's power, elegance, and capabilities to all.

This book teaches you about ACE: a bit of its history and approach to development, how it's organized, how to begin using it, and also how to use some of its more advanced capabilities. We teach you how to do things the ACE way in this book, but we could not possibly fit in a complete reference. Use this book to get started with ACE and to begin using it in your work. If you've been using ACE for a while, there are probably descriptions of some capabilities you haven't seen before, so the book is useful for experienced ACE users as well.

Who Should Read This Book

This book is meant to serve as both an introductory guide for ACE beginners and a quickly accessible review for experienced ACE users. If you are an ACE beginner, we recommend starting at the beginning and proceeding through the chapters in order. If you are experienced and know what you want to read about, you can quickly find that part of the book and do not need to read the previous sections.

This book is written for C++ programmers who have been exposed to some of the more advanced C++ features, such as virtual inheritance and class templates. You should also have been exposed to basic operating system facilities you plan to use in your work. For example, if you plan to write programs that use TCP/IP sockets, you should at least be familiar with the general way sockets are created, connections are established, and data is transferred.

This book is also an excellent source of material for those who teach others: in either a commercial or an academic setting. ACE is an excellent example of how to design object-oriented software and use C++ to design and write high-performance, easily maintained software systems.

Organization

This book is a hands-on, how-to guide to using ACE effectively. The many source code examples illustrate proper use of the pieces of ACE being described. The source code examples are kept fairly short and to the point. Sometimes, the example source is abridged in order to focus attention on a topic. The complete source code to all examples is on the included CD-ROM and is also available on Riverace Corporation's web site. The included CD-ROM also includes a copy of ACE's source kit, installable versions of ACE prebuilt for a number of popular platforms, and complete reference documentation for all the classes in ACE.

The book begins with basic areas of functionality that many ACE users need and then proceeds to build on the foundations, describing the higher-level features that abstract behavior out into powerful patterns.

Part I introduces ACE and provides some generally useful information about the facilities ACE provides. Part I also explains how to configure and build ACE, as well as how to build your applications that use ACE. Widely used programming aids, such as logging and tracing, command line processing and configuration access, and ACE's container classes, are also described.

Part II discusses ACE's facilities for interprocess communication (IPC), beginning with basic, low-level TCP/IP Sockets wrapper classes and proceeding to show how to handle multiple sockets, as well as other events, such as timers and signals, simultaneously using ACE's Reactor and Proactor frameworks. Part II also describes ACE's Acceptor-Connector framework and then ends with a discussion of some of the other IPC wrapper classes ACE offers, many of which are substitutable for TCP/IP wrapper classes in the covered frameworks.

Part III covers a wide range of topics related to process and thread management using ACE. This part explains how to use ACE's process management classes and then covers signals, followed by three chapters about multithreaded programming, thread management, and the critical areas of thread safety and synchronization. Part III ends with discussions of Active Objects and various ways to use thread pools in ACE--critical topics for effective use of multithreading in high-performance applications.

Part IV covers advanced ACE topics: shared memory, the ACE Streams framework for assembling modular data-processing streams, and how to make your applications more flexible and configurable by using the ACE Service Configurator framework. Part IV concludes with an in-depth discussion of ACE's timer management classes and the ACE Naming Service, one of ACE's network services components to assist with often needed networked application programming tasks.

The book concludes with a bibliography and an extensive subject index.

Conventions Used in This Book

All ACE classes begin with ACE_. When we refer to patterns instead of the classes they implement, we omit the prefix. For example, the Reactor pattern is implemented by the ACE_Reactor class.

All class member variables are suffixed with '_'. This convention is used in the ACE sources, and we carry it through to the examples in this book as well.

C++ code and file names are set in this font. Command lines are set in this font.

Steve Huston James CE Johnson Umar Syyid

0201699710P11042003

Read More Show Less

Introduction

ACE (the ADAPTIVE Communication Environment) is a powerful C++ toolkit that helps you develop portable, high-performance applications, especially networked and/or multithreaded applications, more easily and more quickly with more flexibility and fewer errors. And, because of ACE's design and frameworks, you can do all this with much less code than with other development approaches. We've been using ACE for years and have found it exceedingly helpful and well worth any price. What's better is that it's available for free! The historical price many developers have paid to use ACE is a steep learning curve. It's a big toolkit with a large set of capabilities. Until recently, the best documentation has been the source code, which is, of course, freely available, and a set of academic papers born of the research that produced ACE, approachable only by advanced professionals and upper-level students. This barrier to learning has kept ACE's power and easy-to-use elegance one of the best-kept secrets in software development. That's why we're very excited to write this book! It flattens out ACE's learning curve, bringing ACE's power, elegance, and capabilities to all.

This book teaches you about ACE: a bit of its history and approach to development, how it's organized, how to begin using it, and also how to use some of its more advanced capabilities. We teach you how to do things the ACE way in this book, but we could not possibly fit in a complete reference. Use this book to get started with ACE and to begin using it in your work. If you've been using ACE for a while, there are probably descriptions of some capabilities you haven't seen before, so the book is useful for experienced ACEusers as well.

Who Should Read This Book

This book is meant to serve as both an introductory guide for ACE beginners and a quickly accessible review for experienced ACE users. If you are an ACE beginner, we recommend starting at the beginning and proceeding through the chapters in order. If you are experienced and know what you want to read about, you can quickly find that part of the book and do not need to read the previous sections.

This book is written for C++ programmers who have been exposed to some of the more advanced C++ features, such as virtual inheritance and class templates. You should also have been exposed to basic operating system facilities you plan to use in your work. For example, if you plan to write programs that use TCP/IP sockets, you should at least be familiar with the general way sockets are created, connections are established, and data is transferred.

This book is also an excellent source of material for those who teach others: in either a commercial or an academic setting. ACE is an excellent example of how to design object-oriented software and use C++ to design and write high-performance, easily maintained software systems.

Organization

This book is a hands-on, how-to guide to using ACE effectively. The many source code examples illustrate proper use of the pieces of ACE being described. The source code examples are kept fairly short and to the point. Sometimes, the example source is abridged in order to focus attention on a topic. The complete source code to all examples is on the included CD-ROM and is also available on Riverace Corporation's web site. The included CD-ROM also includes a copy of ACE's source kit, installable versions of ACE prebuilt for a number of popular platforms, and complete reference documentation for all the classes in ACE.

The book begins with basic areas of functionality that many ACE users need and then proceeds to build on the foundations, describing the higher-level features that abstract behavior out into powerful patterns.

Part I introduces ACE and provides some generally useful information about the facilities ACE provides. Part I also explains how to configure and build ACE, as well as how to build your applications that use ACE. Widely used programming aids, such as logging and tracing, command line processing and configuration access, and ACE's container classes, are also described.

Part II discusses ACE's facilities for interprocess communication (IPC), beginning with basic, low-level TCP/IP Sockets wrapper classes and proceeding to show how to handle multiple sockets, as well as other events, such as timers and signals, simultaneously using ACE's Reactor and Proactor frameworks. Part II also describes ACE's Acceptor-Connector framework and then ends with a discussion of some of the other IPC wrapper classes ACE offers, many of which are substitutable for TCP/IP wrapper classes in the covered frameworks.

Part III covers a wide range of topics related to process and thread management using ACE. This part explains how to use ACE's process management classes and then covers signals, followed by three chapters about multithreaded programming, thread management, and the critical areas of thread safety and synchronization. Part III ends with discussions of Active Objects and various ways to use thread pools in ACE--critical topics for effective use of multithreading in high-performance applications.

Part IV covers advanced ACE topics: shared memory, the ACE Streams framework for assembling modular data-processing streams, and how to make your applications more flexible and configurable by using the ACE Service Configurator framework. Part IV concludes with an in-depth discussion of ACE's timer management classes and the ACE Naming Service, one of ACE's network services components to assist with often needed networked application programming tasks.

The book concludes with a bibliography and an extensive subject index.

Conventions Used in This Book

All ACE classes begin with ACE_. When we refer to patterns instead of the classes they implement, we omit the prefix. For example, the Reactor pattern is implemented by the ACE_Reactor class.

All class member variables are suffixed with '_'. This convention is used in the ACE sources, and we carry it through to the examples in this book as well.

C++ code and file names are set in this font. Command lines are set in this font.

Steve Huston
James CE Johnson
Umar Syyid

Read More Show Less

Customer Reviews

Be the first to write a review
( 0 )
Rating Distribution

5 Star

(0)

4 Star

(0)

3 Star

(0)

2 Star

(0)

1 Star

(0)

Your Rating:

Your Name: Create a Pen Name or

Barnes & Noble.com Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & Noble.com that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & Noble.com does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at BN.com or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation

Reminder:

  • - By submitting a review, you grant to Barnes & Noble.com and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Noble.com Terms of Use.
  • - Barnes & Noble.com reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & Noble.com also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on BN.com. It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

 
Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously
Sort by: Showing all of 4 Customer Reviews
  • Anonymous

    Posted November 20, 2003

    Tries to decouple C++ from specific OS details

    Network programming can be very difficult, given such issues as latency and different hardware/operating systems on your net. At the very least, the latter can have different byte orderings an datatype sizes, if you write in C or C++. Now in C, by the late 1980s, such headaches caused several unix vendors (mainly Sun) to converge on supporting a key utility, rpcgen (and affiliated routines). This let you write common C code for client/server applications, and compile these on various platforms. Lo, things usually worked! But as software projects grew in complexity, writing in a procedural language like C became harder. Hence the rise of C++. Well, wouldn't it be nice to reimplement and extend rpcgen? (It had numerous limitations.) The idea was to finesse/bury OS specific details at a lower level of the code, where you could often ignore it. You can imagine ACE as filling this need. I'm not saying that this is how or why ACE was developed. But I am trying to argue from YOUR background, which I assume is C++ and C. The book describes significantly more functionality in ACE than merely an extension of rpcgen. Even if you don't have a C++ networking application, but are writing a standalone application, ACE may be useful. It increases your chances of writing portable code. For one thing, it heavily downplays the use of OS-supplied compiler macros. In both C++ and C code that will be maintained on several platforms, this is a notorious source of bugs. Very brittle. Just having ACE subsume these issues should give a maintenance productivity gain. You won't see this immediately when coding the first version of your application. But experienced developers should see the payoff. Plus, ACE also offers higher level design patterns. Here, I don't know how applicable they might be to your specific problems. But just having the patterns increases your coding arsenal.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted December 11, 2003

    Great way to learn the ACE Framework

    This is probably the most practical book ever written on this topic. I have read the C++ Network Programming books, and I believe that this Programmer¿s Guide is even better. ACE, the ADAPTIVE Communication Environment, has been around since the early 90¿s and thanks to over 1700 contributors over the past decade or so, it has become a very powerful, reusable, Object Oriented, beautifully engineered, designed, and developed framework that is creeping its way to the hearts of developers, project leads, and managers all around the world and in many industry verticals. ACE has made one of the hardest things to do as a developer, network programming much simpler, but that¿s not all. That¿s where this book comes into play. The other books focus on the network programming of ACE, and even though they cover the topic VERY well, they don¿t convey the other powerful features that ACE has: ACE Logging Facility ACE Runtime and configuration facility ACE (STL like) containers, allocators, etc¿ Right of the bat, this book covers those details and shows the reader concrete examples and ways to apply these examples in real life. The author spends the next 4 chapters (6-9) going over the IPC facilities of ACE. It starts from basic SOCKET programming, to SIGNALS, to the use of TIMERS and it ends with the odds and ends of IPC. These topics were covered in the C++ network programming books before, but this book, instead of talking about it, SHOWS the reader how things are done. The Reactor and the Proactor frameworks are covered in chapters 7 and 8. As the author mentions in chap 7: The ACE reactor framework was designed to implement a flexible event-handling mechanism is such a way that applications need never write the central, platform-dependent code for their event-handling needs. Then the author goes into an extensive detail of how this is done, and in its closing remarks, he says the following: With little ingenuity, your reactor-based application can turn on the foyer light when someone pulls into your driveway or mute the television when the phone rings. The Proactor framework is covered in full detail in the following chapter. The author does a great job at telling and showing the differences between the two design patterns and when to use one vs. the other. When all said and done, the author explains how these two design patterns can make a killer combo. The book is more like a personal notebook that you would create for yourself in that you write down notes, hints, do¿s and don¿ts and few lines of code at a time telling yourself how you made something to work properly.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted August 13, 2009

    No text was provided for this review.

  • Anonymous

    Posted February 16, 2010

    No text was provided for this review.

Sort by: Showing all of 4 Customer Reviews

If you find inappropriate content, please report it to Barnes & Noble
Why is this product inappropriate?
Comments (optional)