v3 flag enabled
Log In
Log In

Posts

Stay up to date with Boost and the C++ ecosystem with the latest news, videos, resources, and user-created content.

Filter

All

Latest Posts

  • Local Regression Tests
    The steps for running Boost regression tests locally are described, focusing on a Python command‑line utility. Required software includes Python 2.3‑2.9, a recent Git client, and at least 5 GB free per compiler. A new directory is created, the run.py script is downloaded via the raw view, and it is executed with three mandatory options: runner ID, toolset list, and repository tag. The script fetches the latest regression scripts, Boost source code, and build tools, builds b2 and process_jam_log if needed, and then runs the selected tests. Test outcomes are processed, aggregated, and uploaded to a shared FTP server where a continuous merger publishes public reports. Optional parameters allow proxy configuration, incremental builds that preserve existing binaries, and custom comment files describing the testing environment.
    Blogpost #blogpost
  • Library Metadata
    The Boost super‑project requires each sub‑module to contain a meta/libraries.json file describing the libraries it provides. For a single library the file holds one JSON object, while modules with multiple libraries must list several objects in an array. Every entry must include the fields key, name, description, authors, maintainers and category; additional optional fields such as boost‑version, status, std, documentation and cxxstd may also be supplied. The key uniquely identifies the library relative to the libs directory, and the status field can mark a library as deprecated or hidden. Authors and maintainers are recorded as strings, and the category field lists one or more predefined categories that classify the library’s domain. The cxxstd field indicates the minimum C++ standard required for the majority of the library’s functionality, with values ranging from 98 to 23.
    News #news
  • Development Best Practices
    Guidance is provided for reducing development time while maintaining quality and maintainability of new libraries. Beneficial Boost dependencies such as Config, Core, Assert, ThrowException and Mp11 are listed for developers to evaluate for relevance. Robust GitHub practices are recommended, including submitting changes via pull requests, rebasing instead of merging, using fast‑forward‑only merges, squashing commits and enforcing meaningful commit discipline to preserve a linear history. Clear commenting is encouraged through Doxygen‑style API documentation, explanatory comments for complex logic, and concise inline comments that describe purpose rather than repeat code. Error messages are advised to include the library name, input and expected values, context, standard error codes and actionable advice, avoiding low‑level noise.
    Blogpost #blogpost
  • Best Practices
    The metadata for each Boost library is stored in a submodule’s meta/libraries.json file. For a submodule containing a single library, the file contains one JSON object with fields such as key, name, authors, maintainers, description, std, category, and cxxstd. When multiple libraries are present, an array of such objects is required. Mandatory fields are key, name, description, authors, maintainers, and category, while boost-version, status, documentation, and cxxstd are optional. The status field may be set to deprecated or hidden to indicate libraries that are outdated or intended only as internal components. The cxxstd field specifies the minimum C++ standard needed for the majority of the library’s functionality, with values ranging from 98 to 23. Category values correspond to a predefined list that maps to website categories, allowing case‑insensitive matching.
    News #news
  • Fuzzy testing
    Fuzz testing injects random data into software functions to expose crashes and vulnerabilities, enhancing security. A fuzzing engine repeatedly runs instrumented code with varied inputs and uses coverage feedback to guide sample generation. Detected errors include crashes, memory leaks, and undefined behavior, making the technique especially useful for libraries processing untrusted input. Fuzzing is presented as a complement to unit tests rather than a replacement, with unit tests verifying expected outputs. LibFuzzer is recommended for integration, requiring specific compiler and linker sanitization flags and an LLVMFuzzerTestOneInput entry point. The entry point is invoked repeatedly, while a user‑defined main function must be omitted. Providing a seed corpus of valid and invalid samples, often derived from unit tests, is advised to improve coverage.
    Blogpost #blogpost
  • Sanitize your code
    Sanitizers are recommended for detecting common bugs and inefficiencies in libraries. Several tools are listed, including AddressSanitizer, Valgrind, and related components such as LeakSanitizer, UndefinedBehaviorSanitizer, MemorySanitizer, and ThreadSanitizer. AddressSanitizer is described as a fast memory‑error detector available on major platforms and can be enabled with compiler flags or B2 settings; it also incorporates LeakSanitizer. UndefinedBehaviorSanitizer, MemorySanitizer, and ThreadSanitizer are explained with their respective detection capabilities and activation options. Valgrind is presented as an open‑source suite for Linux that checks memory leaks, uninitialized memory, and threading issues, with installation commands for various distributions. Guidance is given for running programs under Valgrind and for integrating it into continuous‑integration pipelines.
    Blogpost #blogpost
  • Local Regression Test
    How to run Boost regression tests on a local machine using the Python run.py tool is outlined. Invocation of the b2 utility for single or all libraries and execution of Boost.Build tests via a Python script is described. Python 2.3‑2.9, a recent Git version and several gigabytes of disk space are prerequisites; then run.py is downloaded and executed with required options. The required options --runner (run label), --toolsets (compilers) and --tag (branch) are specified; optional proxy, FTP and email settings are also supported. Commands such as cleanup, get-source, patch, regression and upload-logs, together with many options, are provided to give fine‑grained control. Scripts and Boost sources are downloaded, b2 and helper tools are built, tests are run, logs are processed and results are uploaded to a shared FTP server.
    Blogpost #blogpost
  • C++ 26
    C++26 – Detailed Description

    C++26 is the latest revision of the C++ programming language standard and represents one of the most significant updates since C++11. The standard was finalized by the ISO C++ committee in March 2026 and focuses on four major themes: reflection, safety, contracts, and modern asynchronous programming, while maintaining C++'s traditional strengths of performance, portability, and low-level control.

    The headline feature of C++26 is compile-time reflection, which allows programs to inspect their own structure and generate code during compilation. Developers can now access information about types, functions, members, and enumerations directly within the language, significantly reducing boilerplate code and enabling powerful metaprogramming techniques without relying on macros or external code generators. Many experts consider reflection to be the most transformative addition to C++ in over a decade.

    Another major addition is Contracts, a language-level
    Blogpost #blogpost
  • Tablet
    News #news

Create an account

Advance your career, learn from experts, and help shape the future of Boost and C++.

Create Post