Title
| Length | Description | Related Qualifications |
| Performance optimization and efficiency, including must-know machine architecture and the costs of code on modern hardware | 1 to 1.5 days | Covers optimization issues from temporaries and inline to single- vs. multi-threaded optimizations and how to optimize build times by managing #include dependencies. Also covers the important things to understand about the complexity of today’s commodity hardware, the ever-deepening memory hierarchy and the memory wall, and the effects on your program’s correctness (e.g., memory model effects) and performance (e.g., memory wall and cache effects). | Herb is the author of Prism, the memory model across all Microsoft code platforms, and one of the designers of the ISO Standard C++0x memory model. |
| Software and the concurrency revolution | 90 min to .5 day | Covers the reason for the industry sea change to multicore and manycore hardware, and provides a clear and authoritative description of what this means for how we must write concurrent (e.g., multithreaded) software today and from now on. | Author of the widely-cited article The Free Lunch Is Over that coined the term “concurrency revolution” to describe the sea change to parallel hardware, Herb is frequently asked to keynote software conferences on this topic. He is also an active member of groups at Microsoft and in the broader industry that are working on parallel programming systems designs. |
| Writing robust concurrent code | .5 to 1 day | Concurrency is “the” must-know item for the next decade in any code where CPU performance is important, because from now on only well-written concurrent applications will be able to exploit the CPU power in commodity hardware. Covers important design principles and best practices for multithreading and shows how to write code to implement them using C++0x and TR2 features. Whereas the first C++ standard in 1998 didn't even have the notion of threads, the new C++0x standard is adding strong support for concurrency, including useful libraries for atomic operations, threads and thread pools, locks, futures, and other important features that from now on are essential knowledge for C++ and other performance-oriented programmers. | Herb was directly involved in specifying the C++0x atomic operations and thread/future library features, and was influential in their design and presence in the standard. |
| Using C++ effectively on modern platforms and environments (chalk talks on selected topics on request) | various | From garbage collection to multithreading, from selecting among multiplatform compilers to writing C++ code for .NET, from organizing distributed systems to making effective use of the latest community libraries like Boost and Loki while avoiding their pitfalls – Herb's broad experience with the most popular compilers and libraries and deep familiarity with all the latest C++ standards can help you on your project today. | In addition to serving as chair of the ISO C++ standards committee, Herb is a contributor of a number of features now in ISO Standard C++0x. He is also the lead architect of C++/CLI, the Ecma standard extensions to ISO C++ for programming on .NET (ISO CLI). |
C++ Coding Standards
(readily customizable to target topics of principal interest to your team) | .5 to 2 days | Covers an overview and selected topics drawn from the book C++ Coding Standards, including organizational and policy issues; design style; coding style; functions and operators; class design and inheritance; construction, destruction and copying; namespaces and modules; templates and genericity; error handling and exceptions; STL containers and algorithms; and type safety. | Herb is the author (with Andrei Alexandrescu) of the authoritative book C++ Coding Standards that sets out definitive practices and guidelines for writing correct and robust C++ code. |
| Using the STL effectively | 1 to 2 days | Covers in-depth explanations of STL containers, iterators, algorithms, functors, allocators, etc., how they are designed, and how to use them effectively. | Herb has over 12 years’ experience in using the STL in production code. He led one of the first commercial development projects in the world to use the STL, starting at the same time as the STL’s acceptance into the ISO C++ draft standard in 1995-1996. (It was a solid foundation; that software project was highly successful, shipped many major releases, and is still being actively maintained and extended today.) |
| Using the new C++0x and Boost libraries effectively | 1 day | Covers key new features in the ISO C++0x standard library, including smart pointers (std::shared_ptr and std::weak_ptr) and hash-based containers (std::unordered_set, std::unordered_map). Also covers selected important features in the portable Boost open source libraries, including boost::variant and boost::any, boost::multi_index, and boost::format. This course goes beyond explaining the libraries, and gives practical guidance on how to use them effectively, and a liberal dose of context and commentary on their tradeoffs and design. | Besides being an active participant of the ISO C++ committee during the time these features were added to C++0x, Herb has also personally implemented some of these facilities and intimately understands their implementations and requirements. |
| Writing robust code: Patterns for exception safety and solid code | 1 to 1.5 days | Covers how to understand exception safety and how to write exception-safe code, and why this matters whether or not you use exceptions (because the same principles apply to using error codes). | Herb is the primary popularizer of the Abrahams exception safety guarantees in his books Exceptional C++, More Exceptional C++, and Exceptional C++ Style, and the coauthor of the landmark book C++ Coding Standards that sets out definitive rules and guidelines for writing correct and robust code, including robust failure designs, and patterns and best practices for the design and implementation of error handling. |
| Writing robust, reusable, and extensible C++ libraries using templates and namespaces | .5 to 1 day | Covers advanced template issues and techniques, namespaces issues and correct packaging, policy-based design, and how to write for supportability and maintainability. | |
| Design patterns and policy-based design | .5 to 1 day | Covers why patterns matter and how to apply them, and specific key design patterns including Factory, Visitor, Singleton, and variants on applying and implementing each of them, including a look at applying policy-based design using C++ templates for Singleton and strings. | |
