Mark Isaacson

speaker

Mark Isaacson is a Software Engineer at Facebook, where he works on improving the developer experience for all C++ programmers at Facebook.

Mark is the author of the tech blog “Modern Maintainable Code” that aims to open a dialogue about properties of maintainable code and teach techniques for effective program design.

Mark has a background in teaching and has been giving tech talks for several years now, most of which can be found on his blog.

website: http://modernmaintainablecode.com

 

Presentations

Developing C++ @ Facebook scale (2017)


Writing correct C++ is hard. Period. Full stop. Even if a small change to a simple 2,000-line program compiles, has tests, and passes the tests, the code might still be broken. When the code spans hundreds of thousands of files across many different projects, making sure your change is safe is orders of magnitude harder. This talk is about all of the things that make that problem manageable for a Facebook engineer to tackle.

 

Exploring C++17 and Beyond (2017)


This talk will preview what's to come on the C++17 and C++20 horizons. We'll explore real, working, code to show how new features will both change the way you handle day-to-day problems and also push the limits of what's possible in C++. We'll talk about how these language features have been put to use in the D community, which has had years of experience with them in production code.

Topics include:

  • A discussion of what's likely to come in C++17 and what's being delayed to C++20.
  • std::string_view and the day-to-day benefits it provides, including preventing the dreaded static initialization order fiasco.
  • Using operator dot for a variety of unconventional uses, such as implementing poor-man's contracts.
  • Making templates more accessible to the masses by using constexpr_if. We'll discuss how this is different from Concepts as well as how this can be used for Design by Introspection.
  • Where new features are neither implemented in current compilers nor implementable in terms of C++14, this talk will feature the D language as a proxy.

 

Fundamentals Of Type-Dependent Code Reuse (2016)


Code reuse is a tough problem. Duplicated code is almost universally frowned upon, but it's not infrequent that my peers don't know how to restructure things and fix it. The most fundamental techniques for code reuse are a blind spot in the community, misunderstood as being either too simple or too complex to be useful. In textbooks the chapters are enumerated by techniques, rather than problems. This talk will describe problems that motivate using techniques like templates, overloading, tag dispatch, CRTP, mixins, and more to create highly composable code units. The talk will be designed to be accessible to those who've never written a template before and build up to expert level techniques by the end.

 

The Set Of Natural Code (2016)


The set of code that is simple, easy, and natural to write is forever evolving. Back in the days of C, writing a container for struct meant sacrificing either performance or maintainability, then we got std::vector in C++. Today languages are tearing down more of these barriers, these choices between performance and maintainability. By electing new primitive work units and making bold changes to our compilers, languages like D can vastly improve the expressiveness of your code while at the same time sending your runtime or memory footprint down to O(1). We'll examine an enlarged lifecycle for these modern trends: both the environment in which they were conceived and experimented upon in the D programming language and also how they are reaching more mature languages like C++, where these new features are popping up left and right in language proposals.