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 .'' 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:
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.
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.
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++.
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).
Back to C++ Report Editorials home page.