This eBook includes the following formats, accessible from your Account page after purchase:
EPUB The open industry format known for its reflowable content and usability on supported mobile devices.
PDF The popular standard, used most often with the free Adobe® Reader® software.
This eBook requires no passwords or activation to read. We customize your eBook by discreetly watermarking it with your name, making it uniquely yours.
As networks, devices, and systems continue to evolve, software engineers face the unique challenge of creating reliable distributed applications within frequently changing environments. C++ Network Programming, Volume 1, provides practical solutions for developing and optimizing complex distributed systems using the ADAPTIVE Communication Environment (ACE), a revolutionary open-source framework that runs on dozens of hardware platforms and operating systems.
This book guides software professionals through the traps and pitfalls of developing efficient, portable, and flexible networked applications. It explores the inherent design complexities of concurrent networked applications and the tradeoffs that must be considered when working to master them.
C++ Network Programming begins with an overview of the issues and tools involved in writing distributed concurrent applications. The book then provides the essential design dimensions, patterns, and principles needed to develop flexible and efficient concurrent networked applications. The book's expert author team shows you how to enhance design skills while applying C++ and patterns effectively to develop object-oriented networked applications.
Readers will find coverage of:
With this book, C++ developers have at their disposal the most complete toolkit available for developing successful, multiplatform, concurrent networked applications with ease and efficiency.
Click below for Web Resources related to this title:
Supporting Web Site
Click below for Web Resources related to this title:
Author's Web Site
Click below for Sample Chapter related to this title:
Download the sample pages (includes Chapter 0 and Index)
(NOTE: All chapters end with a Summary.)
About This Book.
Design Challenges, Middleware Solutions, and ACE.
Challenges of Networked Applications.
Networked Application Design Dimensions.
Object-Oriented Middleware Solutions.
An Overview of the ACE Toolkit.
Example Application: A Networked Logging Service.
I. OBJECT-ORIENTED NETWORK PROGRAMMING.1. Communication Design Dimensions.
Connectionless versus Connection-oriented Protocols.
Synchronous versus Asynchronous Message Exchange.
Message Passing versus Shared Memory.2. An Overview of the Socket API.
An Overview of Operating System IPC Mechanisms.
The Socket API.
Limitations of the Socket API.3. The ACE Socket Wrapper Facades.
The ACE Addr and ACE INET Addr Classes.
The ACE IPC SAP Class.
The ACE SOCK Class.
The ACE SOCK Connector Class.
The ACE SOCK Stream and ACE SOCK IO Classes..
The ACE SOCK Acceptor Class.4. Implementing the Networked Logging Service.
The ACE Message Block Class.
The ACE InputCDR and ACE OutputCDR Classes.
The Initial Logging Server.
The Client Application.
II. CONCURRENT OBJECT-ORIENTED NETWORK PROGRAMMING.5. Concurrency Design Dimensions.
Iterative, Concurrent, and Reactive Servers.
Processes versus Threads.
Process/Thread Spawning Strategies.
User, Kernel, and Hybrid Threading Models.
Time-shared and Real-time Scheduling Classes.
Task- vs. Message-based Architectures.6. An Overview of Operating System Concurrency Mechanisms.
Synchronous Event Demultiplexing.
Limitations with OS Concurrency Mechanisms.7. The ACE Synchronous Event Demultiplexing Wrapper Facades.
The ACE Handle Set Class.
The ACE Handle Set Iterator Class.
The ACE::select() Methods.8. The ACE Process Wrapper Facades.
The ACE Process Class.
The ACE Process Options Class.
The ACE Process Manager Class.9. The ACE Threading Wrapper Facades.
The ACE Thread Manager Class.
The ACE Sched Params Class.
The ACE TSS Class.10. The ACE Synchronization Wrapper Facades.
The ACE Guard Classes.
The ACE Mutex Classes.
The ACE Readers/Writer Lock Classes.
The ACE Semaphore Classes.
The ACE Condition Variable Classes.A Design Principles for ACE C++ Wrapper Facades.
Use Wrapper Facades to Enhance Type Safety.
Simplify for the Common Case.
Use Hierarchies to Enhance Design Clarity and Extensibility.
Hide Platform Differences Whenever Possible.
Optimize for Efficiency.B The Past, Present, and Future of ACE.
The Evolution of ACE.
The Road Ahead.
Over the past decade, concurrent object-oriented network programming has emerged as an effective paradigm for developing software applications whose collaborating objects can either be
When objects are distributed, the various entities that constitute these objects must communicate and coordinate with each other effectively. Moreover, they must continue to do so as applications change over their lifetimes. The placement of objects, the available networking infrastructure, and platform concurrency options allow for a level of freedom that's powerful, yet challenging.
When designed properly, concurrent object-oriented network programming capabilities can add a great deal of flexibility to your application options. For instance, in accordance with the requirements and resources available to your projects, you can use
You'll likely encounter complex challenges, however, when developing and porting networked applications on multiple operating system (OS) platforms. These complexities appear in the form of incompatible networking protocols or component libraries that have different APIs and semantics on different hardware and software platforms, as well as accidental complexities introduced by limitations with the native OS interprocess communication (IPC) and concurrency mechanisms themselves. To alleviate these problems, the ADAPTIVE Communication Environment (ACE) provides an object-oriented toolkit that runs portably on dozens of hardware and OS platforms, including most versions of Win32 and UNIX, as well as many real-time and embedded operating systems.
Some would have you believe that de facto or de jure OS standards, such as POSIX, UNIX98, or Win32, are all programmers need to shield their applications from portability challenges. Unfortunately, the adage that "the nice thing about standards is that there are so many to choose from" is even more applicable today than it was a decade ago. There are now dozens of different OS platforms used in commercial, academic, and governmental projects, and the number of permutations grows with each new version and variant.
We've developed many multiplatform, concurrent, and networked systems for the past two decades. We can therefore assure you that OS vendors often choose to implement different standards at different times. Moreover, standards change and evolve. It's likely that you'll work on multiple platforms that implement different standards in different ways at different times. Programming directly to OS APIs therefore yields the following two problems:
In this age of economic upheaval, deregulation, and stiff global competition, it's becoming prohibitively expensive and time consuming to develop applications entirely from scratch using native OS APIs and algorithmic design techniques.
If you've been developing networked software systems for many years, you may have learned to accept some of these problems as a fact of life. There is a better way, however. In this book, we show how C++ and ACE provide object-oriented capabilities that allow you to avoid many traps and pitfalls, while still leveraging standards--and even certain platform-specific features--whenever possible. Object-oriented designs exhibit greater stability over time than algorithmic designs, which makes them the preferred basis for developing many types of networked applications.
Not surprisingly, there's a price for all this flexibility: you may need to learn some new concepts, methods, patterns, tools, and development techniques. Depending on your background, this learning curve may be trivial or it may initially seem steep. The bottom line, however, is that the object-oriented paradigm can offer you a mature set of techniques that alleviates many challenges of networked application development. This book presents a series of concrete examples to illustrate the object-oriented techniques used to develop and apply the classes in the ACE toolkit. You can use the same techniques and ACE classes to simplify your own applications.
This book is intended for "hands-on" developers or advanced students interested in understanding the strategies and tactics of concurrent network programming using C++ and object-oriented design. We describe the key design dimensions, patterns, and principles needed to develop flexible and efficient concurrent networked applications quickly and easily. Our numerous C++ code examples reinforce the design concepts and illustrate concretely how to use the core classes in ACE right away. We also take you "behind the scenes" to understand how and why the IPC and concurrency mechanisms in the ACE toolkit are designed the way they are. This material will help to enhance your design skills and to apply C++ and patterns more effectively in your own object-oriented networked applications.
This book is not a comprehensive tutorial on object-oriented development, patterns, UML, C++, systems programming, or networking. We therefore assume readers of this book have some familiarity with the following topics:
We encourage you to use the extensive bibliography to locate sources of information on topics about which you want to learn more.
This book is also not an ACE programmer's manual; that is, we don't explain every method of every class in ACE. For that level of detail we refer you to the extensive online ACE documentation, generated by Doxygen. at http://ace.ece.uci.edu/Doxygen/ and http://www.riverace.com/docs/. Instead, this book focuses on
This book describes how C++ and middleware help address key challenges associated with developing networked applications. We review the core native OS mechanisms available on popular OS platforms and illustrate how C++ and patterns are applied in ACE to encapsulate these mechanisms in class library wrapper facades that improve application portability and robustness. The book's primary application example is a networked logging service that transfers log records from client applications to a logging server over TCP/IP. We use this service as a running example throughout the book to
The book is organized into 11 chapters as follows:
Throughout Parts I and II we present a series of increasingly sophisticated implementations of our networked logging service to illustrate how the ACE IPC and concurrency wrapper facades can be applied in practice.
Appendix A summarizes the class design and implementation principles that underlie the ACE IPC and concurrency wrapper facades. Appendix B explains the inception and open-source evolution of ACE over the past decade and outlines where it's heading in the future. The book concludes with a glossary of technical terms (including the italicized terms in this book), an extensive list of references for further research, and a general subject index.
This book focuses on resolving complexity using specific C++ features, patterns, and ACE. The second volume in this series--C++ Network Programming: Systematic Reuse with ACE and Frameworks--extends our coverage to include object-oriented network programming frameworks provided by ACE. These frameworks reify common usage patterns of the ACE wrapper facade classes presented in this book to support broader, more extensible levels of systematic reuse. A distinguishing factor between the ACE wrapper facade classes covered in this book and the ACE framework classes covered in Volume 2 is that the ACE wrapper facade classes have few virtual methods, whereas the ACE framework classes have mostly virtual methods.
This book is based on ACE version 5.2, released in October 2001. The ACE software and all the sample applications described in our books are open-source and can be downloaded at http://ace.ece.uci.edu and http://www.riverace.com. These sites also contain a wealth of other material on ACE, such as tutorials, technical papers, and an overview of other ACE wrapper facades for IPC and synchronization mechanisms that aren't covered in this book. We encourage you to obtain a copy of ACE so you can follow along, see the actual ACE classes and frameworks in complete detail, and run the code examples interactively as you read through the book. Precompiled versions of ACE can also be purchased at a nominal cost from http://www.riverace.com.
To learn more about ACE, or to report any errors you find in the book, we recommend you subscribe to the ACE mailing list, email@example.com. You can subscribe by sending e-mail to the Majordomo list server at firstname.lastname@example.org. Include the following command in the body of the e-mail (the subject line is ignored):
subscribe ace-users emailaddress@domain
You must supply
emailaddress@domain only if your message's
From address is not the address you wish to subscribe. Postings to the ACE mailing list are also forwarded to the USENET newsgroup
comp.soft-sys.ace. Archives of postings to the ACE mailing list are available at http://groups.yahoo.com/group/ace-users.
Click below to download the Index file related to this title: