Hasty Briefsbeta

All tags

#c++

159 stories total

Bilingual

C and C++ prioritize performance over correctness (2023)
a year ago
- C and C++ prioritize performance over correctness, leading to undefined behaviors that can break programs unexpectedly.
- Examples include uninitialized variables, arithmetic overflow, infinite loops, and null pointer usage, where compilers optimize based on undefined behavior assumptions.
- The C++ standards committee has resisted defining behaviors like signed integer overflow to maintain optimization potential, despite correctness concerns.
- Undefined behaviors in C and C++ have shifted from being non-portability issues to optimization opportunities, impacting debuggability and correctness.
- The trade-off between performance and correctness in C and C++ is clear, with performance often prioritized even at the cost of program stability and security.
Growing Buffers to Avoid Copying Data
a year ago
- Johnny’s Software Lab LLC specializes in software performance optimization.
- Avoiding data copying is crucial for performance, especially in C++ and operating system contexts.
- C++ lacks a built-in realloc function, complicating buffer resizing without copying.
- A proposed resize_buffer function could help avoid unnecessary data copying in C++.
- Linux uses mmap and mremap for memory allocation and resizing, requiring careful address management.
- Windows lacks mremap but can use VirtualAlloc for similar purposes, though with more manual management.
- jemalloc offers xallocx for buffer resizing, a feature not present in standard C libraries.
- Experiments show significant performance gains when avoiding data copying during buffer resizing.
- Potential issues include system-specific behaviors, silent failures, and virtual memory fragmentation.
- Despite challenges, avoiding data copying is beneficial for performance in certain scenarios.
Show HN: Hexi – Modern header-only network binary serialisation for C++
a year ago
- Hexi is a lightweight, header-only C++23 library for safely handling binary data, primarily from network sources.
- It supports protocols like DNS, STUN, NAT Port Mapping Protocol, and others, with a focus on ease of use, safety, and minimal overhead.
- Hexi does not offer versioning, format conversion, or text-based format handling.
- Dual-licensed under MIT and Apache License 2.0, allowing flexible usage.
- Easy integration into projects by copying hexi.h or using CMake.
- Primary classes: buffer_adaptor (wraps containers) and binary_stream (handles reading/writing).
- Supports bounds checking and error handling via exceptions or no_throw for zero runtime overhead.
- Endianness handling with hexi::endian for portable data serialization.
- String handling with adaptors like null_terminated for safe serialization.
- Includes extras like file_buffer, static_buffer, and dynamic_buffer for various use cases.
- Features like write seeking, fine-grained control with put/get, and zero-copy views into buffer data.
Taming the UB Monsters in C++
a year ago
- C++ community is actively working on hardening and securing C++ software, focusing on undefined behavior (UB) to improve safety and security.
- Since C++11, constexpr compile-time code has been UB-free, ensuring safety during compile-time evaluation.
- C++26 introduces improvements like eliminating UB for uninitialized variables and bounds-hardened standard library operations, enhancing security.
- Efforts are underway to systematically catalog and address UB in C++, using tools like erroneous behavior, profiles, and contracts.
- A white paper is planned to document and mitigate C++ language UB, aiming for parity with other modern languages in security vulnerabilities.
- New proposals aim to eliminate UB exploited for remote code execution (RCE), significantly improving C++ software security.
- The approach maintains C++'s performance and control, allowing opt-outs for cases where full performance is needed.
- Adoption is designed to be easy, with many improvements requiring just a recompile, minimizing code changes.
- The C++ committee is focusing on security as a priority, responding to increased cyber threats and aiming for significant safety improvements.
Msgpack23 – A modern, header-only C++ library for MessagePack (de)serialization
a year ago
- msgpack23 is a modern, header-only C++ library for MessagePack serialization and deserialization.
- Targets C++20 and beyond, leveraging templates and type traits for flexibility.
- Header-only with no additional build steps or dependencies.
- Supports STL containers, maps, enums, time points, and user-defined types.
- Extensible via custom pack and unpack member functions.
- Endian-aware for portability using std::endian and std::byteswap.
- Includes support for various primitive types and std::chrono::time_point.
- Simple integration: clone the repository and include the header.
- Example provided for packing and unpacking std::map.
- Custom type serialization demonstrated with MyData struct.
- Performance-focused with minimal overhead and compile-time type deductions.
- Open for contributions under MIT License.
My Favorite C++ Pattern: X Macros (2023)
a year ago
- The article introduces the 'X Macros' pattern, a method for generating repetitive code in C++ to improve maintainability and reduce boilerplate.
- Application 1: String Interning - Demonstrates using X Macros to automate the declaration and initialization of over 100 unique strings in the Chapel compiler, enhancing efficiency and reducing manual errors.
- Application 2: AST Class Hierarchy - Shows how X Macros are used to manage the abstract syntax tree (AST) node hierarchy, including generating enum tags for dynamic casting and implementing the visitor pattern without double dispatch.
- Application 3: CPython Method Tables and Getters - Illustrates the use of X Macros to generate method tables and getters for Python bindings, streamlining the process of adding new methods and ensuring consistency.
- The article discusses the benefits of the X Macros pattern, such as declarative readability and reduced boilerplate, while acknowledging drawbacks like heavy macro usage and increased compilation dependencies.
Using Token Sequences to Iterate Ranges
a year ago
- The article discusses inefficiencies in C++ Ranges, particularly with views like filter and take_while, which perform redundant operations.
- It presents two solutions: Flux, a library offering internal iteration for better performance, and a theoretical approach using token sequences for code injection.
- Flux demonstrates how internal iteration can reduce overhead by avoiding redundant checks and optimizing space usage.
- The token sequences approach, still in design, allows for generating optimal loop structures dynamically, showcasing potential for zero-overhead abstractions.
- Examples highlight performance issues with common range operations and how alternative approaches can mitigate them.
- The article concludes by pondering future directions for C++ Ranges, including potential language and library enhancements for internal iteration.
Show HN: HNSW index for vector embeddings in approx 500 LOC
a year ago
- HNSW is a graph structure with levels that are sparsely populated at the top and densely populated at the bottom.
- Nodes in a layer connect to nearby nodes on the same level.
- Insertion involves picking a random level and inserting the node there and all levels below.
- Searches start at the top level, descend, and track the K nearest nodes.
- The implementation is a single-header, modern C++ library with about 500 lines of code.
- It uses Eigen for SIMD acceleration to speed up distance calculations.
- Example usage includes creating an index, adding vectors, and searching for nearest neighbors.
Boost 1.88.0
a year ago
- Boost 1.88.0 released on April 10th, 2025.
- New Libraries: None mentioned.
- Updated Libraries: Array, Asio, Assert, Beast, Conversion, DLL, Geometry, Graph, Iterator, Lockfree, Log, Mp11, MySQL, PolyCollection, SmartPtr, Stacktrace, TypeIndex, Unordered, Variant2.
- Key Improvements:
- - Array: Added `noexcept` and `constexpr`, deprecated obsolete functions, improved `array<T, 0>` behavior.
- - Asio: Fixed various issues, improved documentation, and added runtime configuration options.
- - DLL: Modernized code, reduced dependencies, and improved error handling.
- - Graph: Performance improvements, bug fixes, and modernization with C++14 features.
- - Iterator: Dropped C++03 support, added new traits, and optimized iterator sizes.
- - MySQL: Improved connection pool handling, added new features, and fixed race conditions.
- Compilers Tested: Extensive list including Clang, GCC, and Visual C++ across multiple C++ standards.
- Acknowledgements: Marshall Clow, Glen Fernandes, and Ion Gaztañaga managed the release.
C++: terser (shorter) lambda == SHORTY (ab-use?)
a year ago
- The library 'shorty' provides a terser syntax than C++ lambdas, not replacing C++ but offering a more concise way to write expressions.
- Examples include sorting with `$lhs > $rhs`, filtering even numbers with `($i % 2) == 0`, and zipping/transforming views.
- Supports calling external functions like `$<sqrt>($a * $a + $b * $b)` and casting with `$<int>($0)`.
- Special argument syntax includes `$lhs`, `$rhs`, `$it`, `$a` to `$f`, `$x`, `$y`, `$z`, `$i`, `$n`, `$k`, `$in`, `$argc`, and `$args`.
- Capture options: `$(v)` or `$ref(v)` for reference, `$value(v)` or `$copy(v)` for copy, and `$fixed<v>` or `$const<v>` for CNTTP.
- Supports calling callables or constructing new instances with `$<callable>(args...)` or `$call<CallableType>(args...)`.
- Arithmetic operations like `$a += 2` are supported, along with other compound assignments.
- Special thanks to an anonymous Argentinian for inspiring this project.
Show HN: Single-Header Profiler for C++17
a year ago
- utl::profiler is a single-include solution for localized profiling with simple macros.
- Features include measuring time for scopes, expressions, and code segments, with automatic call graph generation.
- Supports multi-threading, recursion, CPU-counter timestamps, and can export results at any program point.
- Profiling can be fully disabled via `UTL_PROFILER_DISABLE`.
- Includes style options for formatting results, such as indentation and color coding based on runtime percentages.
- Low overhead design with options to use CPU-counter intrinsics (`rdtsc`) for reduced profiling overhead.
- Memory overhead is minimized, with options to use smaller IDs (`UTL_PROFILER_USE_SMALL_IDS`) for further reduction.
- Thread-safe API with minimal locking required only during thread creation, joining, or manual result upload.
Modern CMake
a year ago
- Modern CMake (3.15+ or 4.0+) is a clean, powerful, and elegant solution to build system problems.
- A good build system like CMake is essential for avoiding hard-coded paths, supporting multiple OSs, compilers, and IDEs, and using libraries and tools.
- CMake is the preferred build system due to its widespread support across IDEs and libraries.
- Setting the minimum CMake version too low can cause warnings or errors; recommended minimum versions are provided.
- Modern CMake aims to address poor examples and best practices found online.
- Additional resources for learning Modern CMake include official documentation, presentations, and guides.
Raw Loops for Performance?
a year ago
- The author joined a new project and started making minor improvements, including replacing raw loops with C++20 ranges.
- A comparison was made between using raw loops with `push_back` and C++20 ranges (`std::ranges::transform`) for transforming data.
- Performance benchmarks showed that raw loops with `emplace_back` and `reserve` are faster than ranges, but ranges offer better readability.
- The author concludes that while ranges may be slightly slower, the difference is negligible in most real-world scenarios, and readability should be prioritized unless performance is critical.
C++ creator Bjarne Stroustrup reimagines how coding is taught
a year ago
- Bjarne Stroustrup, creator of C++, discussed the role of C++ and issues in programming education.
- C++ is the second most popular programming language globally, per the TIOBE Index.
- Stroustrup advocates for more variability in programming education, criticizing the 'one-size-fits-all' approach.
- He suggests reducing the number of computer science students to improve quality.
- Stroustrup proposes splitting courses into three tracks: nonprofessionals, scientists, and engineers/specialists.
- He criticizes current programming textbooks for overemphasizing syntax and lacking depth in concepts.
- Stroustrup believes C++ offers unique advantages in hardware access and performance optimization.
- Stanford professor Chris Gregg praised Stroustrup as a visionary in programming languages.
- Stroustrup created C++ to bridge high-level programming and hardware efficiency.
- He dislikes 'language wars' and emphasizes the importance of knowing multiple languages for professionalism.
Show HN: Less Slow C++
a year ago
- Benchmarks focus on performance-oriented software design in C++.
- Uses C++20 features and is optimized for GCC and Clang on Linux.
- Covers topics from micro-kernels to parallel algorithms and coroutines.
- Highlights include faster trigonometry, compiler optimizations, and matrix multiplication.
- Discusses GPU programming, CUDA, and differences between CPU and GPU code.
- Includes practical examples like JSON handling without memory allocations.
- Recommends Linux environment setup for best compatibility.
- Build process involves cloning the repo, installing dependencies, and compiling with CMake.
- Supports various third-party libraries for enhanced functionality.
- Provides flags to control benchmark output and filter specific tests.
- Encourages disabling SMT for stable benchmark results.
- Includes hand-written Assembly and PTX IR for hardware-specific optimizations.
- Condensed list of Google Benchmark features for writing benchmarks.
Pahole: Analysing Memory Layout of Complex Data Structures with Ease
a year ago
- The author reflects on their progress in maintaining a consistent writing routine and introduces the pahole tool for inspecting memory layouts in C/C++ data structures.
- Pahole is part of the dwarves suite and helps developers understand memory layout, alignment, and padding by analyzing DWARF debugging information.
- The tool is useful for optimizing cache efficiency, reducing false sharing, and improving performance by reorganizing data structures.
- Installation of pahole is straightforward via package managers or from source, with various CLI options for detailed analysis.
- Examples demonstrate how pahole reveals padding, holes, and cacheline usage in data structures, and how to reorganize them for better memory efficiency.
- The tool can also simulate memory layouts for different cacheline sizes and handle nested data structures effectively.
- The author credits Arnaldo Carvalho de Melo for developing pahole and shares their excitement about discovering such performance tools.
Show HN: Woeful – let web apps safely and securely connect to external resources
a year ago
- Wisp V1 Support
- Pcap network capture capability
- Blacklisting & Whitelisting ports and domains
- Faster performance compared to WispServerCpp
- Built with C++, with caution advised over Rust alternatives like Epoxy
- Acknowledgments to key projects: uWebSockets, Cli11, pugixml, tl::expected, PcapPlusPlus, BS_thread_pool
- Aimed at creating a high-performance Wisp server for varied traffic
- WispServerCpp described as unstable and buggy, this is an improved version
I started a devblog about mixing SwiftUI and C++ to make a Twitch app
a year ago
- Kulve is a SwiftUI application leveraging Swift/C++ interop introduced with Swift 5.9.
- The tech stack includes CMake, Xcode, VSCode, Swift/SwiftUI, and C++.
- CMake is used for independent C++ backend development, ensuring cross-platform compatibility.
- Xcode is utilized for SwiftUI editing and as a build system, despite preferring VSCode for raw editing.
- VSCode, with the clangd extension, is used for backend C++ development, offering superior linting and auto-complete.
- Swift is used exclusively for UI and scaffolding, while C++ handles general-purpose tasks like threading and networking.
- The application uses Swift/C++ interop for features like chat, with C++ managing memory and Swift handling UI updates.
- Memory management is handled in C++, with Swift wrapping raw pointers to ensure safety and efficiency.
- The design ensures Swift does not own memory, preventing leaks and maintaining performance.
- Kulve's approach allows embedding large data structures in UI elements efficiently via pointers.
- The post highlights unique solutions developed for Kulve, aiming to inform and assist others in native SwiftUI development.
New C++ features in GCC 15
a year ago
- GCC 15.1 is expected to be released in April or May 2025.
- GCC 15 is the system compiler in Fedora 42 and will be available in RHEL via the Red Hat GCC Toolset.
- The default dialect in GCC 15 remains -std=gnu++17, with options for C++23 and C++26 features.
- C++26 features in GCC 15 include pack indexing, attributes for structured bindings, and enhanced support for deleted functions.
- Pack indexing allows direct access to elements in a variadic template pack.
- Attributes can now be applied to structured bindings.
- Deleted functions can include a reason message with =delete("reason").
- Variadic friends allow using a friend declaration with a parameter pack.
- constexpr placement new is now supported in C++26.
- Structured bindings can now be used in conditions like if and while statements.
- Deleting a pointer to an incomplete type is now invalid in C++26.
- The Oxford variadic comma usage without a preceding comma is deprecated.
- Array comparison is now ill-formed in C++26.
- #embed directive for including binary data is introduced in C++26.
- Several defect reports have been resolved in GCC 15.
- Range-based for loops now correctly extend the lifetime of temporaries.
- Qualified lookup failures are diagnosed earlier during template parsing.
- Concepts TS support has been removed, requiring migration to C++20 Concepts.
- New compiler options like -fassume-sane-operators-new-delete and -Wheader-guard have been added.
- Improvements in compile-time speed for template-heavy code.
- New attributes like flag_enum and warnings like -Wself-move and -Wdefaulted-function-deleted have been introduced.
GCC 15 is now available, with support for more draft C++26 features
a year ago
- GCC 15 has been released with several new C++26 features implemented.
- Key C++26 features include P2558R2 (adding characters to basic set), P2552R3 (standard attributes), P2662R3 (pack indexing), and more.
- Improvements in C++ Modules and compilation time speed ups have been introduced.
- Other notable features include P1967R14 (#embed), P2865R5 (removing deprecated array comparisons), and P3247R2 (deprecating trivial types).
- For a complete list of changes, refer to the official release notes.

firstprev0next

About|Login

#c++

C and C++ prioritize performance over correctness (2023)

Growing Buffers to Avoid Copying Data

Show HN: Hexi – Modern header-only network binary serialisation for C++

Taming the UB Monsters in C++

Msgpack23 – A modern, header-only C++ library for MessagePack (de)serialization

My Favorite C++ Pattern: X Macros (2023)

Using Token Sequences to Iterate Ranges

Show HN: HNSW index for vector embeddings in approx 500 LOC

Boost 1.88.0

C++: terser (shorter) lambda == SHORTY (ab-use?)

Show HN: Single-Header Profiler for C++17

Modern CMake

Raw Loops for Performance?

C++ creator Bjarne Stroustrup reimagines how coding is taught

Show HN: Less Slow C++

Pahole: Analysing Memory Layout of Complex Data Structures with Ease

Show HN: Woeful – let web apps safely and securely connect to external resources

I started a devblog about mixing SwiftUI and C++ to make a Twitch app

New C++ features in GCC 15

GCC 15 is now available, with support for more draft C++26 features