Mr. Hoffman is a founder of Kitware and currently serves as Chairman of the Board, Vice President, and Chief Technical Officer (CTO). He is the original author and la ead architect of CMake, an open source, cross-platform build and configuration tool that is used by millions of developers around the world, and he is the co-author of the accompanying text, Mastering CMake. Using his 20+ years of experience with large software systems development, Mr. Hoffman is also a major technical contributor to Kitware’s Visualization Toolkit, Insight Toolkit, and ParaView projects.
As CTO, Mr. Hoffman’s emphasis is on software development methodologies and establishing best practices across the breadth of Kitware’s development efforts. As one of the visionaries leading the quality software process efforts at Kitware, Bill has been instrumental in adopting agile programming practices, fueling Kitware’s software development. He is a frequent speaker on these subjects at CppCon, C++Now, and other conferences.
Mr. Hoffman received a B.S. in Computer Science from the University of Central Florida and an M.S. in Computer Science from Rensselaer Polytechnic Institute (RPI). Prior to the formation of Kitware, he spent nine years at the General Electric Corporate Research and Development center, working in the Computer Vision Group. He has planned and taught several graduate-level courses at RPI as well as a course in object-oriented programming at New York University.
After more than 26 years, CMake continues to evolve alongside the C++ ecosystem. To remain effective, it has had to adapt to significant language changes, increasingly complex package management, and the sheer scale of modern codebases. This talk examines four major areas of recent development: C++ modules, the Common Package Specification (CPS), build instrumentation, and distributed execution. For each area, we will cover the challenges involved in implementing the feature, the solutions that have been developed, and how CMake helps you apply those solutions in real-world projects. C++ modules place new demands on build systems, requiring earlier and more accurate […]
C++20 modules represent a significant advancement in the language, promising to improve compile times, enhance code organization, and streamline dependency management. This talk is tailored for developers eager to harness the power of C++20 modules in their projects. We will explore the fundamentals of building both shared and static libraries using CMake, the de facto build system for C++. Attendees will gain practical insights into setting up build files and organizing source code with modules. We will dissect real-world open-source module projects, offering a concrete understanding of how modules are being used in the wild. A key focus will be […]
In 2023, Bret Brown and Bill Hoffman gave a talk at CppCon "Libraries: First Step Toward Standard C++ Dependency Management". This was an introduction to the Common Package Specification (CPS), a specification for the declaration of meta data that can accompany prebuilt libraries with full usage specifications. Prebuilt libraries have existed for decades… they predate C++ even. After all these years, techniques to use prebuilt libraries are still ad hoc and difficult to maintain. A root cause of this variety of techniques is the variety of things that are C++ libraries: header-only libraries, statically linked archives, dynamically linked binaries, and […]
In the C++ Developer Survey (2023), the top issues all revolve around build-related issues: managing dependencies, setting up CI/CD pipelines, dealing with CMake, setting up toolchains and IDEs, and improving build times. All of these issues can be mitigated with a better understanding of the "target model" and its wider application. Since 1983, developers have been creating libraries and programs with C++. Initially software was built with makefiles or shell scripts or direct invocation of the compiler. Over time, software complexity has increased leading to a significant rise in the need for reuse. This need led to the development of […]
Since February 2019 when modules were applied to the C++20 working draft in Kona, the CMake team has been working to support modules in CMake. The decade long experience with Fortran modules provided a roadmap for handling modules in the build system. The main issue is that binary module interface files (BMIs) must exist before they can be imported. Since a BMI is not created until a translation unit (TU) is compiled, this puts a restriction on the ordering of the compilation TUs. It requires the build system to have the ability to know for each TU which modules are […]