A Zest for Programming

Douglas C. Schmidt
C++ Report
January 1996

Greetings and welcome to the start of the C++ Report's third generation. As many of you know, Stan Lippman has ``retired'' as the editor of the C++ Report to pursue an animated career of sun worshiping in Southern California. This month's C++ Report marks the first issue edited by me. It also marks the first issue where the editor wasn't a member of the original group of cfront developers at AT&T Bell Labs.

Both Stan and founding editor Rob Murray have done a stellar job with the C++ Report over the past seven years. Stan and Rob were ``producers'' of the first C++ compiler (cfront). In contrast, I'm a ``consumer'' of C++ who develops reusable communication frameworks. In a sense, the transition from Rob and Stan to me is a sign of the times: under their tutelage C++ has become a mainstream programming language. I'm honored to inherit their legacy of success with this magazine.

I'd like to kick off my first editor's corner with a brief recap of how I got here and to share my vision of where I see C++, and the C++ Report, heading in the next few years. In an industry full of magazines that generate more heat than light, it's refreshing to write for and edit a widely read publication like the C++ Report that's devoted to publishing quality, practical, multi-vendor technical information. I am deeply committed to continuing this tradition.

I first discovered C++ back in the mid-80's, when I was a graduate student in computer science at University of California, Irvine. At the time, I was looking for an outlet for my irrepressible zest for programming. UC Irvine, like all too many other universities, was long on theory and short on practice.

During my quest for programming challenges, I became fascinated with the GNU G++ compiler and GNU libg++ class library developed by Michael Tiemann and Doug Lea, respectively. Michael and Doug were perfect role models: exceptionally talented, receptive to new ideas, and obsessed with C++. Using their freely available software, I wrote my first substantial C++ program: a perfect hash function generator called GPERF, which was later used to create the keyword recognizers in the GNU C and GNU G++ compilers.

My work on GPERF had another important consequence since I first met Stan Lippman at the 2nd USENIX C++ conference in San Francisco. I attended a tutorial Stan gave on cfront internals at that conference and he attended my technical paper presentation on GPERF. When we met, Stan jokingly mentioned that if AT&T doubled the price of cfront I could replace him as a cfront compiler writer so he could move on to other things. Little did we know at the time that five years later I'd replace him as editor of the C++ Report so that he could move on to other things!

Over the years, my interests have evolved from language processing tools to communication software frameworks and design patterns. I'm now a faculty member in the computer science department at Washington University in St. Louis, Missouri. My research focuses on developing and experimentally evaluating concurrent and distributed object communication frameworks running over high-speed ATM networks. In addition to my research, I also consult for a number of major telecommunication and medical imaging companies who are building large distributed communication systems.

The two constant factors throughout my evolution have been an irrepressible zest for programming and C++. I view programming as an important link between the past and the future of C++. Bjarne's original goal for C++ was to make it ``a general purpose programming language designed to make programming more enjoyable for the serious programmer [1].'' Early generations of the C++ Report focused extensively on C++ as a programming language. In the past years, there have been many articles describing the syntax, semantics, and implementation techniques for language features like pointers to members, multiple inheritance, overloaded class new and delete, templates, exception handing, and RTTI.

As the ANSI/ISO C++ standard nears completion, however, the challenges and opportunities for C++ over the next few years are increasingly in the frameworks and applications we build and use, rather than in the language itself. In recent years Stan has been broadening the magazine to cover a range of application-related topics. I plan to continue in this direction.

From my vantage point, the three most important opportunities for the continued popularity and growth of C++ are:

  1. Completion of the ANSI/ISO Standard -- this will (finally) allow compiler vendors to build robust tools and to enable the development of C++ applications that can compile easily on more than one platform and more than one compiler.

    The C++ Report will continue to provide excellent coverage of the standardization effort brought directly to you by people (such as Josee Lajoie, Andy Koenig, and of course Bjarne) who are intimately familiar with the committee and the C++ standard.

  2. Standard library -- programmers will (finally) be able to reuse common components (such as collections and generic algorithms), rather than repeatedly reinventing them. The Standard Template Library (STL) is of particular importance since its novel programming paradigm supports highly efficient, reusable, and extensible programs. This month's issue features a new column on ``STL in Action'' by Graham Glass. We'll be hearing much more from Graham and from others about this important topic in the coming months.

  3. Design patterns -- the growing focus on design patterns and idioms will enable C++ programmers to benefit from successful techniques known to expert C++ programmers, as well as to leverage useful strategies and tactics from other language communities. In turn, this will increase the flexibility and extensibility of C++ programs, without having to switch languages. The C++ Report is fortunate to have regular columns by two top experts on design patterns: Jim Coplien and John Vlissides.
In spite of all of its growth potential, however, there are three important challenges faced by the C++ community:

  1. Stablizing the language definition and its implementations -- the ANSI/ISO C++ standards committee has done a remarkable job creating a document that captures and articulates the essence of C++. However, the resulting language has many features (such as exceptions, templates, namespaces, and RTTI) and library components (such as STL) that will require time to understand and to learn how to use properly.

    A related problem is that most C++ compilers are inadequate, particularly with respect to important features like templates and exception handling. Unfortunately, vendors have had to devote a great deal of time tracking the standard and revising their implementations accordingly, rather than providing production quality tools. Hopefully, as the standard stablizes their focus can move to providing high quality and high performance compilers and environments. Cay Horstmann and others will continue to review the latest language processing tools and development environments to update you with an objective assessment of the C++ marketplace.

  2. Coping with complexity -- C++ is clearly not the world's simplest programming language. Much of its complexity reflects the wide spectrum of domains where it can be used successfully. However, there are many traps and pitfalls that can trip up unsuspecting programmers. Ideally, I'd like the C++ Report to focus less on language features and focus on more strategic design issues facing C++ programmers. Realistically, we'll continue to address language topics to build a solid base of programming expertise in the C++ community.

    One of the most vexing features in C++ is exception handling. Over the next few months there will be a series of articles on how to use C++ exception handling effectively. This month features the first article in this series by Harald Mueller of Siemens. I strongly recommend that you read this article carefully before integrating exception handling into your systems.

    Coping with complexity goes beyond programming language features, however, and must be addressed by thoroughly understanding core software engineering principles. Therefore, starting this month, I'm pleased to announce a new column by Robert Martin, where he'll cover the key principles of good software design with C++.

  3. Integrating with new domains and new languages -- the world of programming has changed significantly since the mid-80's. Personal computers have become the norm, the standard mode of interacting with these computers are graphical user interfaces, the Internet has become wildly popular, and object-oriented techniques are now firmly in the mainstream, even in legacy domains like corporate information systems.

    To compete successfully in today's marketplace, therefore, C++ programmers must become adept at much more than just programming language features. They must be highly proficient with cross-platform development environments, multi-threading, object-oriented databases, GUI frameworks, distributed object computing, and the World Wide Web, just to name a few of the hot topics of today.

    When I work with developers in the field these days I find we're repeatedly confronted with the task of integrating C++ to work with a myriad of multi-threaded OS platforms, OODBs, GUIs, and distributed object computing tools. Dealing with this is so frustrating that it makes me long for those halcyon days where the hardest part of using C++ was remembering cfront's naming mangling scheme in order to debug a program using dbx! Therefore, over the next few months we'll be focusing extensively on topics such as OODBs and multi-threading, along with regular columns on Windows programming (by Don Box and Fritz Onion), distributed object computing (by Steve Vinoski and myself), and even an overview of Java (by the infamous C++ Gadfly, Tom Cargill).

I'm excited to have an opportunity to help shepard the C++ Report into its third generation. I welcome your participation, support, and suggestions for improvement. Please feel free to send me email at schmidt@cs.wustl.edu. I hope that together, all of editors, columnists, authors, and staff at SIGS can share our zest for C++ programming with you.

[1] Stroustrup, Bjarne, "The C++ Programming Language," First Edition, Addison-Wesley, 1986.

Back to C++ Report Editorials home page.