Will Briggs on Teaching C++26 and Learning to Read Code

Todd Montgomery introduces Will Briggs, a University of Lynchburg computer science professor who has taught since 1998 and wrote C++26 for Lazy Programmers. Their conversation begins with whether learning programming languages still matters when AI can generate code.

Briggs says that about once a year he tests an AI system on a medium-difficulty problem and, in his experience, it has not solved one yet. He recognizes that this can change and says he uses AI daily to ask about features and compiler errors. These are personal observations, not a systematic comparison of systems.

AI can speed him up, Briggs says, but blindly applying a suggested fix can also send him down a long unproductive path. Montgomery agrees that reading code is increasingly important because code is one way an AI communicates its response. Without understanding the language, it is hard to assess and direct the result.

Briggs recalls that knowing PHP let him change parts of a WordPress site when he wanted behavior beyond the standard options. He says people he knows in industry also report that AI can help, but developers still need to understand the work.

Montgomery asks who the book is for and suggests that a good kind of laziness means doing less work over time by maintaining less, better-written code. Briggs says the title is playful: he wants to attract people who enjoy programming.

Briggs believes becoming a good programmer takes substantial practice beyond chapter exercises, so enjoying the activity matters. He wanted a more playful alternative to textbooks he found overly serious, with graphics and games helping readers stay engaged.

The two recall older programming books and tools. Briggs points to a Pascal book with varied, entertaining examples as an inspiration, and remembers switching from an expensive multi-pass compiler to Turbo Pascal after a friend recommended it.

Montgomery says language books can become references rather than effective introductions. He appreciates that Briggs’s book tries to keep readers engaged while progressing toward more advanced C++ concepts, and asks how Briggs chose the order.

Briggs says no introductory book can cover all of C++; his goal is to prepare readers for more advanced material. Concepts depend on one another: explaining lists may require comparison with vectors and complexity notation. He tries to introduce a new idea using things the reader already knows.

At the beginning especially, he tries to add only one or two ideas at a time. He also looks for examples that do double duty: constructing a string class can teach operator overloading while deepening understanding of strings without doubling the length of the book.

Asked about C++’s evolution, Briggs complains that there are too many ways to do the same thing. He recalls a video showing a very large number of ways to initialize one value and says this proliferation can overwhelm beginners. He acknowledges that additions often provide real benefits as well as costs.

As an example, he contrasts a single const concept with additional forms such as constexpr and constinit. He prefers changes that replace a more cumbersome practice: spans, in his view, can avoid separately passing an array’s size.

When selecting C++26 material, Briggs asks which changes beginners and intermediate programmers need. He says functions are particularly difficult for students because functions, parameters and local variables introduce several ideas together. He spreads the subject over two chapters and supplies a template for writing functions.

Pointers are another common source of errors. Instead of introducing the term immediately, Briggs starts with arrays, explains what happens underneath and later introduces dynamically allocated arrays. By the time the book explicitly discusses pointers, readers have already used related ideas for a long time.

Montgomery recalls learning C after assembly and asking whether a pointer was a memory address; an unhelpful answer initially led him astray. He says the book’s gradual introduction felt natural, while acknowledging that students learn in different ways.

Montgomery says that, in his own experience, AI-generated C++ has looked better than AI-generated Java. Briggs says he can only speculate and notes that models may hallucinate more on obscure material. Montgomery wonders whether differences in the available training examples could be involved; neither presents a controlled study.

Asked whether AI will lead to new languages or a resurgence of older ones, Briggs says he is poor at forecasting. Past shifts toward the internet, scripting and memory safety surprised him. One practical use he imagines is writing code in C++ and asking AI to translate it into Rust, though that does not require a new language.

Briggs hopes readers discover that they enjoy programming enough to build a long career. He also hopes learning C++ makes it easier to pick up C and other languages. He cites a TIOBE ranking from the time of the conversation as one indication that older languages remain widely used; rankings change and measure popularity indirectly.

He argues that wrestling with C++ concepts can prepare people to learn other languages, citing alumni who adapted quickly to Java jobs. Montgomery closes by thanking him for the book and the conversation.