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: