C++ Network Programming, Volume I: Mastering Complexity with Ace and Patterns: 1 (C++ in Depth) [Englisch] [Taschenbuch]

ACE stands for the Adaptive Communicative Environment. ACE is a software toolkit that provides a number of patterns, libraries, and frameworks creating portability on dozens of hardware and operating system platforms. It is open-source, powerful, and 00. It enables software engineers to create complex distributed systems in less time than traditional methods. Systems written with ACE are high-performance and easily maintained. This is extremely important now that developing applications from scratch has become prohibitively expensive and time consuming.

With the Adaptive Communication Environment (ACE), developers have what they've long sought: a mature, open source, object-oriented framework for building enterprise applications more rapidly and cost-effectively. Now, ACE's creator and one of its leading consultants present the first comprehensive guide to ACE -- and to building extensible object-oriented software with C++ in distributed, heterogeneous environments. The authors begin by describing the key design challenges that arise when objects are distributed beyond a single thread in a single process. They demonstrate how middleware and the ACE toolkit can be applied together to address many of these challenges; and introduce a taxonomy of middleware layers for understanding and solving distributed design problems. It then shows how ACE provides flexible, portable, and efficient support for each of these design dimensions. Extensive C++ code samples are provided. For all developers, analysts, and architects using C++ to build enterprise applications.

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: C++ network programming, including an overview and strategies for addressing common development challenges The ACE Toolkit Connection protocols, message exchange, and message-passing versus shared memory Implementation methods for reusable networked application services Concurrency in object-oriented network programming Design principles and patterns for ACE wrapper facadesWith this book, C++ developers have at their disposal the most complete toolkit available for developing successful, multiplatform, concurrent networked applications with ease and efficiency.

Douglas C. Schmidt is a faculty member at the Electrical and Computer Engineering department at the University of California, Irvine. His research interests focus on experimental techniques to develop high-performance and real-time distributed object computing middleware.

Stephen D. Huston is President and CEO of Riverace Corporation, the premier provider of technical support and consulting services for companies looking to work smarter and keep software projects on track using ACE.

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

1. Collocated within one process or computer or
2. Distributed across a set of computers connected by a network, such as an embedded system interconnect, a local area network (LAN), an enterprise intranet, or the Internet.

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

• Real-time, embedded, or handheld systems
• Personal or laptop computers
• An assortment of various-sized UNIX or Linux systems
• "Big iron" mainframes and even supercomputers

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:

1. It's error-prone since native OS APIs written in C often lack typesafe, portable, reentrant, and extensible system function interfaces and function libraries. For example, endpoints of communication in the widely used Sockets API (discussed in Chapter 2) are identified via weakly typed integer or pointer I/O handles, which increase the likelihood of subtle programming errors at run-time.
2. It encourages inadequate design techniques since many networked applications written using OS APIs are based upon algorithmic design, rather than object-oriented design. Algorithmic design decomposes the structure of an application according to specific functional requirements, which are volatile and likely to evolve over time. This design paradigm therefore yields nonextensible software architectures that can't be customized rapidly to meet changing application requirements.

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.

Intended Audience

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:

• Object-oriented design and programming techniques, for example, frameworks, patterns, modularity, information hiding, and modeling
• Object-oriented notations and processes, such as the Unified Modeling Language (UML), eXtreme Programming, and the Rational Unified Process (RUP)
• Fundamental C++ language features, such as classes, inheritance, dynamic binding, and parameterized types
• Core systems programming mechanisms, such as event demultiplexing, process and thread management, virtual memory, and IPC mechanisms and APIs commonly available on UNIX and Win32 platforms
• Networking terminology and concepts, such as TCP/IP, remote operation invocations, and client/server architectures

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

• The key concepts, patterns, and C++ features that shape the design of successful object-oriented networked applications and middleware and
• The motivation behind, and basic usage of, the most commonly used ACE TCP/IP and concurrency...