CppCon 2017: David Sankel “So, you inherited a large code base...”

—
—
This is a talk about solving the most difficult problem a software engineer ever faces, converting a large codebase with antiquated designs and spotty quality into a state-of-the-art, modern system. We'll be covering clang-based refactoring, mnemonic reasoning methods, safe rewrites, coding standards, and, oh yes, migration paths.

If you've ever been tasked with making a legacy codebase the best-in-class, or think you might, then this talk is for you.
—
David Sankel: Bloomberg

David Sankel is a professional software developer/architect based in the USA and an active member of the C++ Standardization Committee. His prolific software developments have included CAD/CAM, computer graphics, visual programming languages, web applications, computer vision, and cryptography. He is a frequent speaker at the C++Now conferences and is especially well known for his advanced functional programming in C++ talks. David’s interests include large-scale development, dependently typed languages, semantic domains, EDSLs, and functional reactive programming. David's current research interests include dependently typed languages, semantic domains, EDSLs, and functional reactive programming. He currently works for Bloomberg.
—

*-----*
*-----*

[MinusBrain]

Very entertaining and informative talk. Thanks for sharing!

[chiwbaka]

🎯 Key Takeaways for quick navigation:

00:00 📚 Skills and expertise in writing code
01:05 🗂️ Characteristics of large projects
03:09 🚽 Assuming and making dangerous assumptions
04:14 🛠️ Pitfalls with large codebases
08:16 ✨ Shiny new things and neophilia
09:18 🛡️ Pitfalls and consequences of not following through
12:19 🚀 Strategies for dealing with large projects
14:18 🤖 Automation and code formatting
17:14 🛠️ Setting up clang-format and automation
19:39 📁 Organizing and navigating a large codebase
23:41 🧠 Mnemonic methods for code comprehension
24:41 🧠 Mnemonic methods for code comprehension
27:10 🚧 Gauging difficulty and measuring impact
29:09 ⚖️ Choosing priorities and considering business value
32:33 ⚖️ Considering timeline and changing business priorities
34:37 🔄 Replacing a piece of code
36:03 🏗️ Thinking ahead for code evolution
38:05 🎯 Weighing long-term costs and following best practices
40:06 🧩 C++ as a large-scale software example
42:09 💼 Key questions for the C++ committee and community

Made with HARPA AI

[ABaumstumpf]

Ah, even medium sized codebases.
"Dangerous assumptions"...
test coverage - we know only a tiny fraction is covered and those tests are incoplete or wrong.
documentation accuracy - we can't even make that assumption as there is NO documentation what so ever. Yep - management decided "the code is the documentation" (yes, we have that line black on white).
Use cases - nobody knows.
ease/cost of migration - we know that is not true - hence why it is constantly sold to customers (and sales-department always acts surprised when we tell them that would be a lot of work).
semantics - the only assumption we have is "the code does not do what the name implies" as we have "checker"-classes that manipulate

[mrlithium]

why do i have a feeling Titus raised his hand at the beginning?

[ianedmonds]

With him until 17 minutes but my large code base is not written using Functional programming techniques in c++, .
It's all very old procedural c# from 5 years ago and it wasn't even close to cutting edge then.
The first part of this video is useful but c'mon there is no FP solution to my problem.
No blame on you.
Your advice is sound I just think you underestimate the problems out here in Corporate land.
Luv and Peace.
Watched all the rest of this.
I loved C++ at University and used it just once in work in 2003 writing a probing program for Unigraphics.
Spent my whole life in c# and javascript in web programs.
More Luv and Peace.

[warp]

Am I the only person who thinks that there are no Ninjas and there are no Beautiful APIs. Reality is astonishingly complex. Abstractions leak. There is no large C++ codebase with zero accidental complexity. There is no large codebase in any language that has zero accidental complexity. There are awkward bugfixes. There are workarounds. There are mitigations. There are many many reasons why the code which is useful won't be pure and beautiful.

[conorhoekstra]

first comment! i loved the Software Capital talk! this one is a fantastic follow up!

[bruteforce]

Amazing talk 👏 👏👏
Btw, I prefer Samurai to Ninjas: Samurais were warriors who usually belonged to noble classes of Japanese society. Ninjas were trained as assassins and mercenaries and usually belonged to the lower classes of Japanese society.

[MrTralyalya]

Very depressing talk. In short - don't change anything. You'll make it worse