Andrei offers training services in a large spectrum of topics ranging across advanced C++ programming, design and architecture of large and large-scale systems, algorithms, and machine learning. Andrei's clients include companies such as Adobe, Amazon, Bank of America, Citadel, DRW Trading, JPMorgan Chase & Co., ENDI, Google, Intel, Synopsys, Riverbed Technologies, Lion Cave Capital, and Quantres.
Andrei's training focuses on advanced topics, to the end of providing valuable knowledge and inspiration to senior and motivated intermediate software engineers. Such level of training is difficult to find at conferences, seminars, and trade shows, which most often address the broader beginner and intermediate spectrum.
Below is a list of class offerings grouped by topic. All classes are in the format of highly interactive lecture followed by Q&A. There are no formal exercises, but code samples abound so use of computers to try the material in real time is encouraged.
When creating a schedule, keep in mind that you may combine four 1.5h classes to form one day's worth of training. However, this is only recommended if you want to cram the absolute maximum amount of information in the space of one day (the 1.5h do not include breaks and Q&A). If you instead prefer to maximize understanding of the material by the attendees, you may want to combine three such classes in one day. Classes are dense in information content and open-ended, so three 1.5h classes per day offer ample time for in-depth elaboration, exercises, and Q&A. An attractive possibility is to book four classes and let the participants decide midday what pace works best for them (pricing is independent on the number of classes booked per day). There is significant flexibility built in—any given class can take any direction within a generous spectrum around the nominal topic, depending on the background and interests of the participants.
Program Design and Implementation using C++
- So You Want to Know C++ (length: 1 day). This course is a tour of C++'s most fundamental tenets and their wide-ranging consequences. Programmers coming from other languages (including C++ pre-2000s) find this class most valuable, but seasoned C++ programmers also invariably find this course very informative and inspiring. The five-part course consists of:
- Computational model, modularity, and physical design
- Building abstractions with functions, objects, and more
- The standard library
- Generic and generative programming
- C++2011 and its impact on programming style
- Lock-Based and Lock-Free Multithreading with C++11 (length: 1.5 days). A comprehensive course on multithreading using the new C++2011 memory model and threading libraries. Part of the course materials licensed from Scott Meyers. Topics include:
- The C++ memory model and why you care
- Lock-based programming
- Single-object and multi-object transactions
- Lock-free programming
- Comparison and contrast of memory sharing with message passing
- Scalable Use of the STL (length: 1.5h). The C++ Standard Template Library is remarkaby efficient, but needs special care when used in large-scale applications such as long-running services on dedicated servers. This talk discusses issues typical in large-scale programs related to std::vector, memory allocation, threading contention, and std::string.
- BIG: C++ Strategies, Data Structures, and Algorithms aimed at Scalability (length: 1.5h). This class focuses on programming scalable systems starting from two seemingly simple examples. First, scalable dictionary structures are discussed, with a comparison and contrast of std::map and std::unordered_map. Second, the class focuses on the most efficient form of the set intersection algorithm, which is fundamental to many scalable systems. Finally, everything comes together in an overview of a distributed reverted index not unlike Google's core infrastructure. Suggested in tandem with "Scalable Use of the STL".
- Variadic Templates Are Fun—and Now Legal (length: 1.5h). Introduced in C++2011, variadic templates are a core addition with important applications and ramifications. This class motivates the feature to then discuss in depth true variadic functions, typelists, and std::tuple. The material in this class is most relevant if you use or plan to use a variadics-aware compiler such as g++ 4.4 or higher.
- Less Code More Software: Using Policy-Based Design in Component Design (length: 1.5h). Introduces Policy-Based Design (made popular by the book Modern C++ Design) and illustrates a successful application in building an efficient, highly customizable string abstraction.
- Ten Years of Policy-Based Design and Counting (length: 1.5h). The advent of C++2011 has improved approaches to component design based on policies. This class recapitulates the tenets of policy-based design and introduces new design techniques enabled by C++2011 features, mainly variadic templates and template aliases. Prerequisite: "Variadic Templates Are Fun—and Now Legal". Recommended in tandem with "Less Code More Software".
- Choose Your Poison: Error Handling using Exceptions vs. Error Codes (length: 0.5 days). A thorough treatment of program correctness issues and error handling using a variety of approaches. Studies samples and collects statistics from real codebases. Introduces helpful library artifacts such as Likely and ScopeGuard.
- A Guide to Designing C++ Types (length: 1.5h). As a multiparadigm language, C++ offers a dizzying array of choices when it comes to defining a new type. Value or polymorphic type? Are there types "in between"? How to handle creation, copying, moving, visitation of various type categories? This class is a thorough, authoritative analysis of type design principles leading to simple, well-motivated prescriptions. It is of particular interest in wake of move construction semantics introduced by C++2011.
- Memory Allocation: Either Love It or Hate It (or just think it’s okay) (length: 1.5h). Time spent in memory allocation is frequently near the top of CPU usage histograms. As a consequence, significant effort has been invested over the years in improving the performance of memory allocation, to the extent that some firmly believe that the problem has been solved, whereas others believe just as firmly that the problem is insoluble. This class investigates modern memory allocators and teaches approaches and techniques for improving memory allocation profile of applications.
- Designing Allocators that Don't Not Work (length: 1.5h). An in-depth analysis and synthesis of amemory allocator designs. This class is the in-depth successor of the one above.
- Declarative Control Flow (length: 1.5h). Scope Guard is nice, but it's just the beginning of an entire approach to control flow in general, and error control flow in particular. This class introduces SCOPE_FAILURE and SCOPE_SUCCESS, which beautifully complement the old SCOPE_EXIT for a powerful troika.
- Writing Fast Code (length: 3h). Andrei draws from his long-time experience in optimizing code in this class chock-full of information hard to find anywhere else. This is where the rubber hits the road: write, analyze, tune, and deploy code for utmost performance.
- Optimization Tips (length: 1.5h). Per popular demand! Andrei rummages again through his toolshed for tools and techniques that make C++ as fast as humanly possible.
The D Programming Language
- Introduction to the D Programming Language (length: 0.5 days). A thorough introduction to the D programming language for practicing programmers, focusing on language fundamentals and major features that differentiate D from other languages.
- Functional Programming in the D Programming Language (length: 1.5h). This talk illustrates the unique approach taken by the D programming language to mixing and matching functional style with classic imperative programming.
- Three/Six Cool Things About D (length: 1.5 h or 0.5 days). Figuring out some practical advantages offered by the D programming language is the next logical step after gaining a basic understanding of it. This class focuses on three (or six) specific examples in which using D offers significant advantages over using other programming languages. Suggested in tandem with "Introduction to the D Programming Language".
- A Fresh Look at Containers and Iterators (length: 1.5h). The containers/iterators design pioneered by C++'s Standard Template Library has been very successful, but has a number of issues. Iterators are only meaningful in pairs or triplets, are difficult to compose with, and pose issues such as undue invalidation. This class introduces a design based on higher-level ranges instead of iterators, and compares and contrasts the two approaches. The range-based design has been implemented in the standard library of the D programming language.
- Machine Learning using Neural Networks and Support Vector Machines (length: 0.5 days). The power of Machine Learning is notoriously difficult to harness in the form of black-box libraries. This is because feature selection and overall system design are crucial additional steps that require a good understanding of the learning process. This math-intensive course focuses on the theory and practice of building classifiers using neural networks and support vector machines. It explains the mathematical basis of learning but also builds powerful, memorable intuitions of the phenomena involved. Attendees must be reasonably comfortable with college-level math.