C++ Network Programming (Volum

C++ Network Programming :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" [Tan96] 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: