Human society and computing are rich in concurrency and distribution. End users, programmers, and computing systems alike perform their work independently and interactively. This interaction is increasingly distributed across time zones and continents, as global communication systems like the Internet and World Wide Web enable humans and computers to exchange information rapidly and directly.
Concurrent and distributed systems have always been hard to program. In earlier times, the challenges centered largely on efficient use of expensive computer and network hardware resources (such as memory, disk, CPUs, and bandwidth). This emphasis on performance remains important today in domains like telecommunication, medical imaging, and real-time financial services. In addition, users and organizations are increasingly demanding efficient storage and retrieval of information content. Digital libraries, electronic commerce, and the WWW are being developed to meet this demand. However, guaranteeing the quality of service these applications need requires concurrent and distributed computing systems that can handle large amounts of information reliably, securely, and efficiently.
Over the past decade, advances in VLSI technology and fiber optics have yielded dramatic increases in network and computer power. However, the effort required to develop software for concurrent and distributed systems remains high. One source of complexity arises from limitations with our development tools. For instance, in my work on object-oriented communication frameworks, I continuously wrestle with diverse hardware and software platforms. This diversity makes it difficult to directly reuse algorithms, detailed designs, interfaces, and implementations. For instance, writing complex multi-threaded applications that are portable across UNIX and Windows NT is quite hard. In addition, many legacy libraries (e.g., X windows and early releases of MFC) and tools (e.g., debuggers and source control systems) aren't well suited to building and maintaining concurrent and distributed applications. For example, most debuggers can't step across a remote procedure call to inspect the server's internal behavior.
The tool-based limitations of developing distributed systems can largely be addressed by building middleware wrappers, components, and distributed object computing frameworks that shield us from tedious and error-prone programming details. However, a more pernicious source of complexity arises from inherently difficult concurrent and distributed programming tasks. These tasks include eliminating race conditions for shared objects, avoiding deadlock among distributed objects, and minimizing the overhead of context switch, synchronization, and data movement in complex systems. Solving the inherent complexities of concurrent and distributed programming requires more than just abstract interfaces, Object Request Brokers, and IDL compilers -- they require deep knowledge of successful patterns, protocols, and system architectures.
In the past, the patterns and techniques needed to program efficient and reliable concurrent and distributed systems existed largely in programming folklore. Today, these patterns and techniques are becoming more thoroughly documented and more widely understood. This in turn is allowing developers to benefit from the skills and insight gained collectively by expert developers over many years. I've found that many new application challenges can be solved by applying lessons learned by examining existing systems and architectures.
The articles and columns in this issue of the C++ Report present a number of patterns, architectures, and tools for building successful concurrent and distributed systems. Jim Coplien evaluates several fundamental patterns for building efficient and robust real-time telecommunication switching systems, Steve Vinoski and I discuss another model for building concurrent CORBA servers, Soeren Henkel and Wilhelm Dangelmaier evaluate various C++ toolkits for network programming, and Tim Harrison and I illustrate how communication mechanisms ranging from sockets, to C++ wrappers, to CORBA perform over high-speed and low-speed networks. As is so often the case, using C++ in concurrent and distributed systems helps to balance the competing forces of programmer productivity, software quality, and computer and communication performance.
Back to C++ Report Editorials home page.