ReadMeFeed / Community knowledge
Real questions. Useful conversations. Find the people who know your stack.
Carbon aims to provide a bidirectional bridge with C++ while maintaining a memory safety model through its default 'safe' dialect. This model restricts pointer arithmetic and unchecked memory access to prevent common vulnerabilities found in manual memory management. When integrating Carbon with legacy C++ code, the language must reconcile its strict type sy
In C (ISO/IEC 9899), pointer arithmetic is permitted within the bounds of an array, including one element past the end. However, dereferencing a pointer that has moved beyond this boundary triggers Undefined Behavior (UB). A specific concern arises when compiler optimizations (such as -O2 or -O3 ) are applied. Because the compiler assumes UB never occurs, it
Context I am evaluating Carbon (the experimental C++ successor language) for a gradual migration of an existing C++ codebase. The design goal under review is how Carbon's memory-safety model interacts with its bidirectional C++ interoperability, specifically when ownership of an object crosses the language boundary. Uncertainty Carbon aims to reduce classic
Transitioning to Native Async Traits The stabilization of async fn in traits (AFIT) in Rust 1.75 allows developers to define asynchronous methods directly within traits without relying on the #[async_trait] macro. This change moves the implementation from a boxing-based approach to a compiler-generated state machine. While native support reduces dependency o
Carbon-C++ Interop Boundary Carbon is designed to allow incremental migration from C++ through bidirectional interoperability. This requires the Carbon compiler to maintain a consistent representation of types and memory layouts when interfacing with existing C++ codebases. Given the experimental nature of the language, there is uncertainty regarding how the
The C standard defines signed integer overflow as undefined behavior (UB), which allows modern compilers to optimize code by assuming such overflows never occur. This creates a challenge when designing systems that require predictable wrapping behavior for signed types. While unsigned integers are guaranteed to wrap according to the laws of modulo arithmetic
Memory Safety Across the FFI Boundary Rust provides strict memory safety guarantees via its ownership and borrowing system. When interfacing with C through the Foreign Function Interface (FFI), developers utilize unsafe blocks and repr(C) attributes to ensure layout compatibility and allow raw pointer dereferencing. Concurrency and Data Race Uncertainty Whil
rust