Today, if you have a question, you search the web or have ask an AI chatbot. In the early 1980s there was the C Programming Language, but:

The C++ programming language had a creator, an organically emerging user community followed by a standards committee, and a vibrant ecosystem of writers and contributors.

The ecosystem part is often forgotten.

The Way We Were

The story of one of the premier publications of that ecosystem, The C/C++ User Journal, begins with the BDS C Users’ Group, a community formed around Leor Zolman’s BDS C compiler for CP/M systems. The group published a small newsletter beginning in 1981 and grew out of the early user-group culture that flourished before the Internet became widely available.

Knowledge traveled through:

The user group was often the center of the community. Many groups operated BBSes, where members dialed in over noisy modems to exchange messages, source code, and software. Those systems were the social networks of their day. 

As the C language grew, the newsletter evolved into the C User’s Group Newsletter (CUG), and by 1985 there was also a separate publication called The C Journal, edited by Rex Jaeschke. Eventually those efforts merged to become C Users Journal (CUJ).

By the late 1980s and early 1990s, CUJ had become one of the central publications for professional C programmers. Looking at old tables of contents is like reading a who’s who of the then thriving C community: P. J. Plauger (also the senior editor), Rex Jaeschke, Dan Saks, and many others. I joined CUJ in 1992 as the “Code Capsules” columnist and later became its senior editor. Initially I uploaded my articles to the CUJ BBS by a modem attached to an acoustic coupler holding my phone’s handset.

In 1994 the magazine became known as the C/C++ Users Journal (but still using the “CUJ” moniker) and became one of the premier venues for C++ publications, with pieces by the likes of Bjarne Stroustrup, Andrew Koenig, Herb Sutter, Scott Meyers, Andrei Alexandrescu, Steve Dewhurst, Pete Becker, Matthew Austern, Greg Colvin, and many more.

Then came another transition.

The C++ Source

The web was changing how technical information was distributed. Print magazines were under pressure. When C/C++ Users Journal was ultimately absorbed into the orbit of Dr. Dobb’s and discontinued in late 2003, an important gathering place for C++ writers disappeared.

As the then-dismissed senior editor of CUJ I reached out to the community of C++ writers for ideas on to find a new home. What struck me most was how quickly the community rallied around the idea. The result was The C++ Source, graciously hosted by Bill Venners at artima.com. To my delight, many of the most respected voices in the C++ community agreed to participate. The editorial board included David Abrahams, Andrei Alexandrescu, Matthew Austern, Walter Bright, Jim Coplien, Kevlin Henney, Howard Hinnant, Andrew Koenig, Angelika Langer, Dan Saks, Herb Sutter, Bjarne Stroustrup, and many others.

Looking through the archive today is a reminder that many ideas we now take for granted were already being discussed. Howard Hinnant, Bjarne Stroustrup, and Bronek Kozicki published an early article on move semantics years before the feature became part of the language standard.

Looking back, The C++ Source represented a transitional moment. The community had outgrown print, but the modern ecosystem of blogs, podcasts, social media, and isocpp.org had not yet fully emerged. For four years, The C++ Source provided a home for writers and readers during that transition.

Today anyone can publish a technical article with a few keystrokes. In 2004 the challenge was different: preserving a community after one of its most important institutions disappeared. The C++ Source was our attempt to do exactly that.

How a Practical MS‑DOS Problem Contributed to C++

std::bitset feels like one of those standard library components that must have existed forever — a compact, efficient, type‑safe abstraction for working with fixed‑size collections of bits. But behind this ordinary feature lies a very human story: one that begins in an MS‑DOS application and winds through the earliest days of C++ standardization.

This is the story of how std::bitset came to be.

A Practical Problem in a Constrained World

In the early 1990s I was working as a technical lead in the Information Systems Department of the Church of Jesus Christ of Latter‑day Saints in Salt Lake City. Our Mission Management System ran under MS‑DOS and was written in C. Memory was tight (640K RAM was the limit in those days) and every byte mattered.

One of my many tasks was to implement drop‑down picklists, and I wanted a compact way to record which entries a user had selected. The solution was simple: associate with each picklist a set of bits stored in an integer and provide an interface that treated that integer as an indexable array of bits.

It solved the problem cleanly—and, as it turned out, planted the seed for a future standard library component.

From Local Utility to Committee Proposal

I had just begun serving on the C++ standards committee (then J16) at the time. At the third committee meeting in Lund, Sweden in June 1991, I volunteered to survey existing third‑party C++ libraries. When I reported back at the next meeting, we began assigning follow‑up work, and I took on the task of exploring bit‑handling classes.

It was natural to generalize the bit‑array abstraction I had already built. The result was two classes: bitset (originally named just bits) and bitstring. I documented them in a paper titled “Two Bit Handling Classes for C++.” Committee member Stephen Clamage, with characteristic wit, joked that these were just "two‑bit classes.”

Solidifying Templates

This was the dawn of templates in C++.

Language designer Bjarne Stroustrup had, with incredible vision, specified template syntax and behavior, featuring both type and non-type parameters, in The Annotated C++ Reference Manual (ARM), which served as the basis for standardizing the language. The power of templates was manifest, but as is always the case, some details had to be worked out to make them standard-ready, even in those early days before template metaprogramming was discovered.

When I presented my initial bitset design, iostreams designer Jerry Schwarz suggested that the number of bits could be a template parameter. That opened my mind to what templates in C++ were capable of. (This was when we were still using macros to implement templates, and few people knew what was coming. The Standard Template Library/STL had yet to migrate from Alex Stepanov’s Lisp implementation.) My proposal gave the committee a concrete use case for fleshing out the semantics of non‑type template parameters. To my knowledge, it was the first class in standard C++ to use a non-type template parameter.

Acceptance and Standardization

I completed the proposal and reference implementation in 1993, and the committee accepted it in 1994, about the same time as STL was revolutionizing what C++ would become. When C++98 was published, std::bitset appeared as a fully integrated part of the standard library. Bruce Eckel’s foreword in my first book, C & C++ Code Capsules (Prentice-Hall, 1998), comments on my authorship of std::bitset, providing a contemporaneous record of its origins and its role in the early standardization process.

The Parallel Lineage: bitstring, vector<bool>, and dynamic_bitset

The second class from my original paper, bitstring, followed a different path. It evolved into the well‑known (and controversial) specialization vector<bool> (not my idea!). Years later Jeremy Siek packaged my original reference implementation for inclusion into the famous Boost library as dynamic_bitset, which still carries structural traces of its origins. Boost::dynamic_bitset has been used in commercial software shipped on millions of machines.

A Small Abstraction with a Long Shadow

std::bitset is a reminder that the C++ standard library was not handed down from a monolithic design team. It was built by individuals solving real problems, sharing their ideas, and shaping the language through practical insight and working code. In my case it was a picklist, a few bits, and just showing up willing to participate.

Many opportunities came my way because of my years-long association with the C++ Standards Committee, most notably with P. J. Plauger, who invited me to be a columnist for the C/C++ Users Journal, and with Bruce Eckel, who invited me to be a presenter at Software Development Conference and to later co-author Thinking in C++, Volume 2 with him. Bjarne Stroustrup himself graciously acknowledged my modest editorial contributions in the second and third editions of his Tour of C++.

I often felt quite ordinary in the presence of the great ones who fashioned such an amazing programming language (Bjarne Stroustrup, Andy Koenig, Jerry Schwarz, Tom Plum, Matt Austern, John Spicer, Pete Becker, and then-chairs Dmitri Lenkov and Stephen Clamage, to name just a few—it’s a long, long list…), but I’ll always be grateful I was in the room where it happened.