\documentclass{beamer}
\usepackage{slides}
\usepackage{setspace}
\usepackage{placeins}  % \FloatBarrier

\usepackage{booktabs}
%\usepackage{tabularx}  % \extrarowheight

% Title.
%
\title{What to Expect from a \\Next-Generation C++ Build System}
\author{Boris Kolpackov}
\institute{Code Synthesis}
\date{v1.0, September 2018}

% Logo.
%
\pgfdeclareimage[height=0.7cm]{logo}{cs-logo}
\titlegraphic{
\begin{beamercolorbox}[sep=20pt,center]{black}
\pgfuseimage{logo}
\end{beamercolorbox}}

% Document.
%
\begin{document}

%
%
\begin{frame}
\titlepage
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{Change is in the Air}
\begin{center}\alert{\LARGE Our \emph{``\texttt{git} moment''}}\end{center}
\end{frame}

% Why Now? What has changed that all of a sudden we need a next-gen
% build system?
%
\begin{frame}[fragile]
\frametitle{Why Now?}
\begin{center}\alert{\LARGE What's changing?}\end{center}
\bigskip
{\large
\begin{itemize}
  \itemsep0.7em
  \item C++ Modules
  \item Packaging \& Dependency Management
  \item Distributed Compilation and Caching
  \item C++ Std is Paying Attention (SG15)
  \end{itemize}}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{Which One?}
\begin{spacing}{1.5}
\begin{center}{\LARGE \emph{``I am happy with any build system \\
as long as it's the one I use.''}}\end{center}
\end{spacing}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{Values}
\begin{center}\alert{\LARGE What are C++ Community Core Values?}\end{center}
\bigskip
\begin{center}{\large ``\colorhref{Platform as Reflection of Values}{https://@@}}''\end{center}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{Values}
\bigskip
\begin{center}
{\large
\begin{tabular}{p{3.6cm}p{3.4cm}p{3cm}}
Approachability  & Integrity       & Robustness   \\ \addlinespace[.8em]
Availability     & Maintainability & Safety       \\ \addlinespace[.8em]
Compatibility    & Measurability   & Security     \\ \addlinespace[.8em]
Composability    & Operability     & Simplicity   \\ \addlinespace[.8em]
Debuggability    & Performance     & Stability    \\ \addlinespace[.8em]
Expressiveness   & Portability     & Thoroughness \\ \addlinespace[.8em]
Extensibility    & Resiliency      & Transparency \\ \addlinespace[.8em]
Interoperability & Rigor           & Velocity     \\
\end{tabular}}
\end{center}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{C Values}
\begin{spacing}{1.3}
\emph{\large C is a \textbf{general-purpose} programming language which
  features \textbf{economy} of expression, modern control flow and data
  structures, and a rich set of operators. C is \textbf{not a ``very high
  level''} language, \textbf{nor a ``big''} one, and is not specialized to
  any particular area of application. But its absence of restrictions and its
  generality make it more convenient and effective for many tasks than
  supposedly more powerful languages.}
\begin{flushright}The C Programming Language\end{flushright}
\end{spacing}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{C Values}
\bigskip
\begin{center}
{\large\color{lightgray}
\begin{tabular}{p{3.6cm}p{3.4cm}p{3cm}}
Approachability  & Integrity       & Robustness   \\ \addlinespace[.8em]
Availability     & Maintainability & Safety       \\ \addlinespace[.8em]
Compatibility    & Measurability   & Security     \\ \addlinespace[.8em]
Composability    & Operability     & \textcolor{black}{Simplicity}   \\ \addlinespace[.8em]
Debuggability    & \textcolor{black}{Performance} & Stability    \\ \addlinespace[.8em]
Expressiveness   & \textcolor{black}{Portability}     & Thoroughness \\ \addlinespace[.8em]
Extensibility    & Resiliency      & Transparency \\ \addlinespace[.8em]
Interoperability & Rigor           & Velocity     \\
\end{tabular}}
\end{center}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{C++ Values}
\begin{spacing}{1.3}
\emph{\large C++ is a \textbf{general-purpose} programming language designed
  to make programming more \textbf{enjoyable} for the \textbf{serious}
  programmer. Except for minor details, C++ is a \textbf{superset} of the C
  programming language. In addition to the facilities provided by C, C++
  provides \textbf{flexible and efficient} facilities for defining new types.}
\begin{flushright}The C++ Programming Language, 1st ed\end{flushright}
\end{spacing}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{C++ Values}
\bigskip
\begin{center}
{\large\color{lightgray}
\begin{tabular}{p{3.6cm}p{3.4cm}p{3cm}}
Approachability                     & Integrity       & Robustness   \\ \addlinespace[.8em]
Availability                        & Maintainability & Safety       \\ \addlinespace[.8em]
\textcolor{black}{Compatibility}    & Measurability   & Security     \\ \addlinespace[.8em]
Composability                       & Operability     & Simplicity   \\ \addlinespace[.8em]
Debuggability                       & \textcolor{black}{Performance} & Stability    \\ \addlinespace[.8em]
Expressiveness                      & \textcolor{black}{Portability} & Thoroughness \\ \addlinespace[.8em]
\textcolor{black}{Extensibility}    & Resiliency      & Transparency \\ \addlinespace[.8em]
Interoperability                    & Rigor           & Velocity     \\
\end{tabular}}
\end{center}
\end{frame}


%
%
\begin{frame}[fragile]
\frametitle{C++11 Values}
\begin{spacing}{1.3}
\emph{\large C++ is a \textbf{general-purpose} programming language
  emphasizing the design and use of \textbf{type-rich}, \textbf{lightweight}
  abstractions. It is particularly suited for \textbf{resource}-\\\textbf{constrained}
  applications, such as those found in software infrastructures. C++ rewards
  the programmer who takes the time to master techniques for writing
  \textbf{quality} code. C++ is a language for someone who takes the task of
  programming \textbf{seriously}.}
\begin{flushright}The C++ Programming Language, 4th ed\end{flushright}
\end{spacing}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{C++11 Values}
\bigskip
\begin{center}
{\large\color{lightgray}
\begin{tabular}{p{3.6cm}p{3.4cm}p{3cm}}
\textcolor<4->{black}{Approachability}  & Integrity       & \textcolor<3->{black}{Robustness}   \\ \addlinespace[.8em]
Availability                            & Maintainability & Safety       \\ \addlinespace[.8em]
\textcolor{black}{Compatibility}        & Measurability   & Security     \\ \addlinespace[.8em]
Composability                           & Operability     & Simplicity   \\ \addlinespace[.8em]
Debuggability                           & \textcolor{black}{Performance} & Stability    \\ \addlinespace[.8em]
\textcolor<2->{black}{Expressiveness}   & \textcolor{black}{Portability} & Thoroughness \\ \addlinespace[.8em]
\textcolor{black}{Extensibility}        & Resiliency      & Transparency \\ \addlinespace[.8em]
Interoperability                        & Rigor           & Velocity     \\
\end{tabular}}
\end{center}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{Modern C++ Values}
{\large
\begin{itemize}
  \itemsep0.7em
  \item Performance
  \item Extensibility \& Expressiveness \uncover<2->{ \texttt{==} \emph{Unconstrained}}
  \item Portability \& Compatibility
  \item Robustness
  \item Approachability
  \end{itemize}}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{JavaScript Values}
\bigskip
\begin{center}
{\large\color{lightgray}
\begin{tabular}{p{3.6cm}p{3.4cm}p{3cm}}
\textcolor{black}{Approachability}                    & Integrity       & Robustness   \\ \addlinespace[.8em]
Availability                        & Maintainability & Safety       \\ \addlinespace[.8em]
Compatibility                       & Measurability   & Security     \\ \addlinespace[.8em]
Composability                       & Operability     & Simplicity   \\ \addlinespace[.8em]
Debuggability                       & Performance     & Stability    \\ \addlinespace[.8em]
\textcolor{black}{Expressiveness}   & Portability     & Thoroughness \\ \addlinespace[.8em]
Extensibility                       & Resiliency      & Transparency \\ \addlinespace[.8em]
Interoperability                    & Rigor           & \textcolor{black}{Velocity}     \\
\end{tabular}}
\end{center}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{C++ Values}
{\large
\begin{itemize}
  \itemsep0.7em
  \item Performance
  \item Extensibility \& Expressiveness
  \item Portability \& Compatibility
  \item Robustness
  \item Approachability
  \end{itemize}}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{Build Systems}
\begin{center}\color{links}{\LARGE Meta-Questions and Overall Design}\end{center}
\end{frame}

%
%
\begin{frame}[fragile]
\begin{center}\alert{\Large Build System-Less?}\end{center}
\bigskip
\begin{spacing}{1.5}
\begin{center}{\Large \emph{``The best build system is the one you don't need.''}}\end{center}
\end{spacing}
\end{frame}

%
%
\begin{frame}[fragile]
\begin{center}\alert{\LARGE Native or Meta (Project Generator)?}\end{center}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{Meta Build System}
\begin{spacing}{1.5}
\begin{center}{\LARGE \emph{Race to the bottom, \\ to the lowest common
      denominator.}}\end{center}
\end{spacing}
\bigskip
{\large
\begin{itemize}
  \itemsep0.7em
  \item C++ Modules
  \item Generated Source Code
  \item Distributed Compilation/Caching
  \item Compilation Database
\end{itemize}}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{Meta Build System}
\begin{center}\alert{\Large What about IDE support?}\end{center}
\bigskip
\begin{center}{\Large Tail wagging the dog?}\end{center}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{Native Build System}
\begin{spacing}{1.7}
\begin{center}{\LARGE Uniform: works the same everywhere, \\ no project generation step.}\end{center}
\end{spacing}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{Meta vs Native: Values}
\begin{center}
{
\setlength{\aboverulesep}{.3em}
\setlength{\belowrulesep}{1em}
\begin{tabular}{p{5.6cm}p{5.3cm}}
Meta                        & Native                         \\
\midrule
\textcolor{orange}{Performance}                    & Performance                         \\ \addlinespace[.8em]
\textcolor{red}{Extensibility} \& Expressiveness   & Extensibility \& Expressiveness     \\ \addlinespace[.8em]
Portability \& Compatibility                       & Portability \& \textcolor{orange}{Compatibility}        \\ \addlinespace[.8em]
\textcolor{orange}{Robustness}                     & Robustness                          \\ \addlinespace[.8em]
Approachability                                    & Approachability                     \\
\end{tabular}}
\end{center}
\smallskip
\begin{center}\alert{\Large Meta would be a Fundamental Mistake}\end{center}
\end{frame}

%
%
\begin{frame}[fragile]
\begin{center}\alert{\LARGE Black Box or a Concept of Build?}\end{center}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{Black Boxes and Magic}
\begin{code}{basemake}
# make
#
hello$(EXE): hello.$(OBJ)
    $(CXX) -o $@ $^

hello.$(OBJ): hello.cxx

%.$(OBJ): %.cxx
    $(CXX) -o $@ -c $<
\end{code}
\bigskip
\begin{code}{basemake}
# CMake
#
project (hello)
add_executable(hello hello.cxx)
\end{code}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{Black Box vs Build Model: Values}
\begin{center}
{
\setlength{\aboverulesep}{.3em}
\setlength{\belowrulesep}{1em}
\begin{tabular}{p{5.6cm}p{5.3cm}}
Black Box                        & Build Model                         \\
\midrule
Performance                      & Performance                         \\ \addlinespace[.8em]
\textcolor{red}{Extensibility} \& Expressiveness  & Extensibility \& Expressiveness     \\ \addlinespace[.8em]
Portability \& Compatibility     & Portability \& Compatibility        \\ \addlinespace[.8em]
Robustness                       & Robustness                          \\ \addlinespace[.8em]
Approachability                  & \textcolor{orange}{Approachability}   \\
\end{tabular}}
\end{center}
\end{frame}


%
%
\begin{frame}[fragile]
\begin{center}\alert{\LARGE Implementation Language}\end{center}
\bigskip
\begin{spacing}{1.5}
\begin{center}{\Large \emph{Should we depend on another ``system''?}}\end{center}
\end{spacing}
\bigskip
\begin{center}{\Large \emph{Is C++ inadequate for the task?}}\end{center}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{Implementation Language: Values}
\begin{center}
{
\setlength{\aboverulesep}{.3em}
\setlength{\belowrulesep}{1em}
\begin{tabular}{p{5.6cm}p{5.3cm}}
Java/Python/...                                   & C++                                 \\
\midrule
\textcolor{red}{Performance}                      & Performance                         \\ \addlinespace[.8em]
\textcolor{red}{Extensibility} \& Expressiveness  & Extensibility \& Expressiveness     \\ \addlinespace[.8em]
\textcolor{orange}{Portability} \& Compatibility  & Portability \& Compatibility        \\ \addlinespace[.8em]
\textcolor{orange}{Robustness}                    & Robustness                          \\ \addlinespace[.8em]
\textcolor{red}{Approachability}                  & Approachability                     \\
\end{tabular}}
\end{center}
\end{frame}

%
%
\begin{frame}[fragile]
\begin{center}\alert{\LARGE Declarative or Scripted?}\end{center}
\smallskip
\begin{center}{\Large \emph{problem warrants a purpose-built language}}\end{center}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{Declarative vs Scripted: Values}
\begin{center}
{
\setlength{\aboverulesep}{.3em}
\setlength{\belowrulesep}{1em}
\begin{tabular}{p{5.6cm}p{5.3cm}}
Scripted                                                & Declarative                         \\
\midrule
\textcolor{orange}{Performance}                         & Performance                         \\ \addlinespace[.8em]
Extensibility \& \textcolor{orange}{Expressiveness}     & \textcolor{red}{Extensibility} \& Expressiveness     \\ \addlinespace[.8em]
\textcolor{orange}{Portability} \& Compatibility        & Portability \& Compatibility        \\ \addlinespace[.8em]
Robustness                                              & Robustness                          \\ \addlinespace[.8em]
\textcolor{red}{Approachability}                        & Approachability                     \\
\end{tabular}}
\end{center}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{Declarative vs Scripted}
\begin{center}\alert{\LARGE Hybrid, Mostly Declarative?}\end{center}
\bigskip
{\large
\begin{itemize}
  \itemsep0.7em
  \item Typed variables.
  \item Pure functions.
  \item Exclusions (\texttt{if-else}).
  \item Repettions (\texttt{for}-loop).
  \item Custom functions and rules.
\end{itemize}}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{Next-Generation C++ Build System}
{\large
\begin{itemize}
  \itemsep0.7em
  \item Native
  \item Has a conceptual model of build
  \item Implemented (and extensible) in C++
  \item With mostly declarative, type-safe build language
  \item<2-> Part of the dependency management toolchain
  \item<3-> Available as a library for easier IDE/tools integration
\end{itemize}}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{\texttt{build2} Values}
\begin{spacing}{1.3}
\emph{\large \texttt{build2} is a native, cross-platform build system with a
  terse, mostly declarative description language, a conceptual model of build,
  and a uniform interface with consistent behavior across platforms and
  compilers. \texttt{build2} is an ``honest'' build system without magic or black
  boxes. You can expect to understand what's going on underneath and be able
  to customize most of its behavior to suit your needs.}
\begin{flushright}The \texttt{build2} Build System\end{flushright}
\end{spacing}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{Black Boxes and Magic}
\begin{code}{basemake}
# make
#
hello$(EXE): hello.$(OBJ)
    $(CXX) -o $@ $^

hello.$(OBJ): hello.cxx

%.$(OBJ): %.cxx
    $(CXX) -o $@ -c $<
\end{code}
\smallskip
\begin{code}{basemake}
# CMake
#
add_executable(hello hello.cxx)
\end{code}
\smallskip
\begin{code}{basemake}
# build2
#
exe{hello}: cxx{hello}
\end{code}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{Build Systems}
\begin{center}\color{links}{\LARGE Current-Generation Functionality}\end{center}
\end{frame}

%
%
\begin{frame}[fragile]
\begin{center}\alert{\LARGE In/Out of Source Builds}\end{center}
\end{frame}

%
%
\begin{frame}[fragile]
\begin{center}\alert{\LARGE Wildcard Patterns}\end{center}
\bigskip
\begin{center}{\Large \emph{``build-system-less'' model for simple projects}}\end{center}
\end{frame}

%
%
\begin{frame}[fragile]
\begin{center}\alert{\LARGE Cross-Compilation is the Norm}\end{center}
\smallskip
\begin{center}{\Large (and not an afterthought)}\end{center}
\bigskip
\begin{center}\alert{\LARGE Cross-Testing}\end{center}
\end{frame}

%
%
\begin{frame}[fragile]
\begin{center}\alert{\LARGE Additional Operations:}\end{center}
\smallskip
{\large
\begin{itemize}
  \itemsep0.7em
  \item \verb|test|
  \item \verb|install/uninstall| (with \verb|pkg-config| support)
  \item \verb|dist| (preparation of source distributions)
  \item \verb|configure|
\end{itemize}}
\end{frame}

%
%
\begin{frame}[fragile]
\begin{center}\alert{\LARGE Integrated Configuration Management}\end{center}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{Build Systems}
\begin{center}\color{links}{\LARGE Next-Generation Functionality}\end{center}
\end{frame}

%
%
\begin{frame}[fragile]
\begin{center}\alert{\LARGE Project Composability}\end{center}
\bigskip
{\large
\begin{itemize}
  \itemsep0.7em
  \item Importation
  \item Suprojects/Amalgamations (bundling)
  \item Import Installed
\end{itemize}}
\end{frame}

%
%
\begin{frame}[fragile]
\begin{center}\alert{\LARGE Scripted Testing}\end{center}
\smallskip
{\large
\begin{itemize}
  \itemsep0.7em
  \item Concise
  \item Portable
  \item Input generation
  \item Output analysis (regex)
  \item Parallel execution
  \item Incremental testing
\end{itemize}}
\end{frame}

%
%
\begin{frame}[fragile]
\begin{center}\alert{\LARGE High-Fidelity Hermetic Builds}\end{center}
\smallskip
\begin{center}{\LARGE detect/prevent changes to:}\end{center}
\smallskip
{\large
\begin{itemize}
  \itemsep0.7em
  \item Environment
  \item Tools (compilers, linkers, etc)
  \item Options
  \item Source code sets
\end{itemize}}
\end{frame}

%
%
\begin{frame}[fragile]
\begin{center}\alert{\LARGE Precise Change Detection}\end{center}
\bigskip
\begin{center}{\Large avoid recompiling of \emph{ignorable} changes}\end{center}
\end{frame}

%
%
\begin{frame}[fragile]
\begin{center}\alert{\LARGE C++ Modules}\end{center}
\smallskip
{\large
\begin{itemize}
  \itemsep0.7em
  \item How to discover imported modules
  \item How to map module names to file names
  \item Provide feedback to WG21 (\colorhref{P1052R0}{https://wg21.link/p1052r0}, \colorhref{P1156R0}{https://wg21.link/p1156r0})
  \item ``\colorhref{Building C++ Modules}{https://youtu.be/E8EbDcLQAoc}'' (CppCon 2017)
\end{itemize}}
\end{frame}

%
%
\begin{frame}[fragile]
\begin{center}\alert{\LARGE Distributed Compilation and Caching}\end{center}
\bigskip
\begin{center}{\LARGE \emph{reliable and generally-available}}\end{center}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{New C++ Build Model}
{\large
\begin{itemize}
  \itemsep0.7em
  \item C++ Modules
  \item Auto-generated headers
  \item Distributed compilation
  \item Ignorable change detection
\end{itemize}}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{Old C++ Build Model}
\bigskip
\begin{center}
\begin{tikzpicture}[
  node distance=8mm,
  action/.style={rounded corners,
                 fill=blue!50!black!20,
                 minimum height=.8cm,
                 draw=blue!50!black},
  code/.style={fill=green!50!black!20,
               minimum width=2cm,
               minimum height=.8cm,
               draw=green!50!black},
  group/.style={fill=black!10,draw=none,rounded corners,inner sep=6pt},
  arrow/.style={->,shorten >=1pt,>=stealth',thick},
  rarrow/.style={<-,shorten <=1pt,>=stealth',thick}]

  \fontsize{8pt}{9pt}\selectfont

  \tikzstyle{every node}=
  [
    inner sep=3pt,
    thick,
    anchor=north west
  ]

  \coordinate (DUMMY1) at (0,0);
  \coordinate (DUMMY2) at (11,2);
  \path (DUMMY1) (DUMMY2);

  \node (SRC) at (0, 4) [action,minimum width=2cm] {\texttt{source file}};
  \node (OBJ) at (4, 4) [action,minimum width=2cm] {\texttt{object file}};
  \path (SRC.east) edge[arrow] node[above] {\texttt{compile}} (OBJ.west);

  \filldraw (3, 3.58) circle (3pt);

  \node (DEP) at (2, 2) [code,minimum width=2cm] {\texttt{header dep}};
  \path (3, 3.58) edge[arrow] (DEP.north);

\uncover<2->{

  \node (SRC1) at (7, 4) [action,minimum width=2cm] {\texttt{source file}};

  \filldraw (10, 3.58) circle (3pt);

  \path (SRC1.east) edge[arrow] (9.9, 3.58);
  \path (DEP.east) edge[arrow,bend right=20] (9.95, 3.50);
}

\uncover<3->{

  \path (10, 3.58) edge[arrow] node[above] {\texttt{compile}} (11.5, 3.58);

  }
\end{tikzpicture}
\end{center}
\begin{center}{\Large \emph{header dependency as byproduct of compilation}}\end{center}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{New C++ Build Model}
\bigskip
\bigskip
\bigskip
\begin{center}
\begin{tikzpicture}[
  node distance=8mm,
  action/.style={rounded corners,
                 fill=blue!50!black!20,
                 minimum height=.8cm,
                 draw=blue!50!black},
  code/.style={fill=green!50!black!20,
               minimum width=2cm,
               minimum height=.8cm,
               draw=green!50!black},
  group/.style={fill=black!10,draw=none,rounded corners,inner sep=6pt},
  arrow/.style={->,shorten >=1pt,>=stealth',thick},
  rarrow/.style={<-,shorten <=1pt,>=stealth',thick}]

  \fontsize{8pt}{9pt}\selectfont

  \tikzstyle{every node}=
  [
    inner sep=3pt,
    thick,
    anchor=north west
  ]

  \coordinate (DUMMY1) at (0,0);
  \coordinate (DUMMY2) at (11,2);
  \path (DUMMY1) (DUMMY2);

  \node (SRC) at (0, 4) [action,minimum width=2cm] {\texttt{source file}};
  \node (PPP) at (4.5, 4) [action,minimum width=2cm] {\texttt{part preproc}};
  \path (SRC.east) edge[arrow] node[above] {\begin{minipage}{1.8cm}\center{\texttt{preprocess\\(partially)}}\end{minipage}} (PPP.west);

  \filldraw (3.25, 3.58) circle (3pt);

  \node (DEP) at (2.25, 2) [code,minimum width=2cm] {\texttt{header dep}};
  \path (3.25, 3.58) edge[arrow] (DEP.north);

\uncover<2->{
  \node (FPP) at (4.5, 7) [action,minimum width=2cm] {\texttt{full preproc}};
  \path (PPP.north) edge[arrow] node[left] {\begin{minipage}{1.8cm}\center{\texttt{preprocess\\(fully)}}\end{minipage}} (FPP.south);

  \node (MOD) at (9, 7) [code,minimum width=2cm] {\texttt{module dep}};
  \path (FPP.east) edge[arrow] node[above] {\begin{minipage}{2cm}\center{\texttt{shallow-parse}}\end{minipage}} (MOD.west);
}

\uncover<3->{
  \filldraw (7.75, 6.57) circle (3pt);

  \node (SUM) at (6.75, 5.5) [code,minimum width=2cm] {\texttt{checksum}};
  \path (7.75, 6.57) edge[arrow] (SUM.north);
}

\uncover<4->{
  \filldraw (7.5, 3.58) circle (3pt);
  \path (PPP.east) edge[arrow] (7.4, 3.58);

  \path (DEP.east) edge[arrow,bend right=25] (7.46, 3.49);
  \path (SUM.south) edge[arrow,bend left=10] (7.5, 3.67);
  \path (MOD.south) edge[arrow,bend left=30] (7.55, 3.66);
}

\uncover<5->{
  \node (OBJ) at (9, 4) [action,minimum width=2cm] {\texttt{object file}};
}

\uncover<5,7->{
  \path (7.5, 3.58) edge[arrow] node[below] {\texttt{compile}} (OBJ.west);
}

\uncover<6->{
  \node (DST) at (8.9, 2) [code,minimum width=2cm] {\begin{minipage}{2cm}\center{\texttt{distributed\\compilation}}\end{minipage}};
  \path (7.5, 3.58) edge[arrow,bend right=30] node[left] {\texttt{send}} (DST.west);
  \path (DST.north) edge[arrow] node[right] {\texttt{receive}} (OBJ.south);
}
\end{tikzpicture}
\end{center}
\end{frame}

%
%
\begin{frame}[fragile]
\frametitle{Next-Generation C++ Build System}
{\large
\begin{itemize}
  \itemsep0.7em
  \item Native
  \item Conceptual model of build
  \item Implemented/Extensible in C++
  \item Mostly declarative language
  \item Part of dependency management toolchain
\end{itemize}}
\end{frame}


%
%
\end{document}