Salt Lake City, UT 84105 (during COVID-19)
San Francisco, CA 94131
I love to build software, in all its forms. My interest is in tackling new, hard problems and searching for elegant and efficient solutions. I've worked at many levels of the software stack, from writing compilers and assemblers, to debugging the kernel on embedded hardware, to writing new web applications to support performance analysis, to working on large UI driven graphics applications. The common thread among all of my work is a drive for delivering quality products and a knack for finding creative or novel solutions.
FIXME: Fill in roles.
- '17-'20: Undisclosed (Software Engineering Manager)
- ??-??: Build System (ICT5/Staff Software Engineer)
- ??-??: Build System (ICT4/Senior Software Engineer)
- ??-??: Clang Compiler Team (ICT4/Senior Software Engineer)
- '08-??: Clang Compiler Team (ICT3/Software Engineer)
- '08: Compiler Team (ICT2/Software Engineering Intern)
- '??: Psychology Dept
- '00: NaN
- '00: Contracting
- '99: Sabbatical
- '98: NaN
Some of the major past projects I have driven or worked on are included below.
FIXME: Fill in description.
New Xcode Build System (Apple)
I designed and implemented a brand new build system for Xcode which was a drop-in replacement for the legacy system, but with a brand new architecture on top of llbuild (see below).
This was a very large engineering effort to implement this system without requiring changes to user's projects, and required significant reverse engineering as well as design in order to implement a high performance, clean architecture for the legacy semantics.
Swift Package Manager (Apple)
I was one of the lead designers and engineers on the Swift Package Manager. I helped drive the initial creation of the project and have overseen much of the design and engineering.
I built a new build system framework used for developing high-performance, incremental, and parallel solutions for large, computationally intensive problems.
LLVM/Clang Compiler (Apple)
Over the past 4 years, Apple has completely transitioned from using the GCC compiler as the basis for its OS X and iOS platforms to using the new LLVM/Clang compiler. I was instrumental in this transition.
When I joined the compiler team the Clang project was just beginning and my mandate was to transition Clang from being a C/Objective-C parser into a full-blown compiler. My responsibilities included:
Implementing the mid-level code generation from the source representation to the compiler backend representation for C and Objective-C.
Implementing a GCC compatible compiler driver replacement for Clang.
Implementing the Intel and ARM ABI support.
Bug fixes across all parts of the compiler.
Lead the effort to migrate the code bases for both OS X and iOS to using the new compiler, including debugging miscompilations, diagnosing undefined behavior in external source code, coordinating with other teams to fix or update their source code or projects.
LLVM Integrated Assembler, OS X System Assembler (Apple)
Designed and implemented the "machine code" subsystems for the LLVM project. These subsystems include support for parsing Intel and ARM assembler source code and a complete retargetable assembler.
These new subsystems allowed us to implement an integrated assembler in the compiler in which we completely bypass converting the internal machine code representation into assembly output, and can instead write object files directly (while still supporting inline assembly). This is a performance win for compile time.
This work eventually went on to form the basis for the assembler used on all of Apple's platforms.
Performance Monitoring System (Apple)
As part of my work on the LLVM/Clang compiler, we had a serious need for a performance monitoring system to track both the compile-time performance and the execution-time performance across many benchmarks, machines, and test configurations.
I designed and implemented a new open-source performance monitoring system that supports all of our performance monitoring efforts. The system includes both a server component for receiving data, generating notifications, and a web-based frontend for visualizing and comparing results, as well as client-side utilities for generating and submitting performance data.
Multi-project and Multi-branch Source Integration System (Apple)
Python, WSGI, SQL, Flask, git
The LLVM/Clang compiler at Apple is built from several different repositories, each of which contains multiple branches for distinct internal projects. In addition, we have a DAG among the branches for how commits should be forwarded amongst projects.
To support continuous integration style testing of our compiler, I implemented a novel source integration system which tracks all of the incoming sources and branches, and automates the branch forwarding and collation process to produce a serialized linear stream of commits that can be tested by an off-the-shelf continuous integration system.
Symbolic Execution for Automatic Bug Finding (Stanford Ph.D. Program)
Designed and implemented a new scalable symbolic execution system for attempting to explore large numbers of possible paths through programs. The system implemented a symbolic virtual machine that was capable of executing hundreds of thousands of "symbolic threads" (separate execution paths) of an input program.
We used this system to find several crashing bugs in Unix tools like cat and to generate test cases that achieved good program coverage. Our paper describing this system won the best paper award at OSDI'08, and subsequently was inducted into the SIGOPS Hall of Fame in 2018.
Our implementation, KLEE, was open sourced and has continued to be used as a foundation for a significant amount of research in the symbolic execution community for over a decade after its release.
Poisson-Disk Point Distributions (University of Virginia)
C, Python, OpenGL
Independently developed a new exact algorithm for generating poisson-disk distributions in O(N log N) time; the previous best algorithm did not actually have a termination criteria. In conjunction, developed a new approximate algorithm that generated high-quality distributions in linear time.
This work was published in SIGGRAPH'06, the world's leading computer graphics conference. I am proud to be one of the few undergraduate students ever to have been first-author on a paper for this conference.
Fast Catmull-Clark Subdivision Surfaces (NaN Technologies)
Implemented a novel algorithm for computing Catmull-Clark subdivision surfaces (as made popular in the Pixar short film "Geri's Game"). This algorithm avoids the naive recursive implementation of most subdivision surface algorithms in order to be able to work on dense memory-efficient 2D grids. In addition, the algorithm supports incremental updates to the computed subdivision surface for fast, real-time editing of surfaces at high subdivision levels.
This algorithm continues to form the basis of the subdivision surface support in the Blender 3D application, and I believe continues to be the fastest implementation of Catmull-Clark subdivision surfaces in a professional application.
Software Porting Efforts (NaN Technologies, WAXTRAPP)
C, C++, UNIX, POSIX, X11, OpenGL, GLUT, Carbon
I have been responsible for many porting efforts of various software systems. The major ports I have been responsible for are:
Ported Blender to the iPAQ mobile device, including development of a complete fixed-point OpenGL library, for use as a proof of concept.
As a contractor, ported WAXTRAPP's content management system from UNIX to Windows (including platform appropriate installer package and service registration mechanisms).
Ported the Blender 3D application to Mac OS X, including a rewrite of large parts of the internal event handling (Blender includes its own GUI/windowing system).
Ported the Blender 3D application from UNIX to Windows.
Much of my technical work has been done as part of an open source community, and my contributions are accurately summarized via Ohloh.
A New Architecture for Building Software LLVM Developer Meeting 2016. An introduction to
llbuildand proposal for how to dramatically accelerate software builds by developing a new architecture which allows eliminating the redundant work done by traditional C++ compilers. These techniques are now increasingly recognized to be required to develop performant implementations of modern languages like Swift (see Request Evaluator), Rust (see Salsa), and Scala (see Zinc).
What's New in Xcode 6 Apple WWDC 2014. Presented demo segment introducing how to integrate Swift into an Xcode application, as part of Apple's initial Swift release.
Building From the Command Line with Xcode Apple WWDC 2012. Presented with Anders Bertelrud on how to best take advantage of Xcode from the command line, including integrations with CI systems like Jenkins.
The LLVM Assembler & Machine Code Infrastructure LLVM Developer Meeting 2010. An overview of LLVM's at that time new assembler and machine code architecture, of which I was a key contributor.
SIGOPS Hall of Fame 2018, for work on KLEE.
KLEE: Unassisted and Automatic Generation of High-Coverage Tests for Complex Systems Programs
Cristian Cadar, Daniel Dunbar, Dawson Engler
Proceedings of USENIX Symposium on Operating Systems Design and Implementation (OSDI 2008)
Winner of OSDI 2008 Best Paper
A Spatial Data Structure for Fast Poisson-Disk Sample Generation
Daniel Dunbar and Greg Humphreys
Proceedings of SIGGRAPH 2006
Dot-sampled structured grids: From geometry to perceptual organization
Daniel Dunbar, Lars Strother, and Michael Kubovy
Perception (ECVP), 2004, Supplement (abstract 0211)
(Incomplete) Ph.D. Candidate in Computer Science
2006 - 2008 (left to join Apple Inc)
University of Virginia
2003 - 2006
- Graduated Summa Cum Laude
- Member: Phi Beta Kappa
- Member & President: Cooperative Housing of UVA