NULL Pointers in C Language - Tutorial 53
Comprehensive explanation of NULL pointers in C programming, covering their definition, usage, and potential pitfalls, with practical examples to enhance understanding.
What If We Pretended Unsafe Code Was Nice, and Then It Was? - RustConf 2022
Explore Rust's Strict Provenance APIs for safer and more efficient unsafe code. Learn how pretending unsafe code is nice can lead to better documentation, libraries, and tools.
Unsafe Code Guidelines in Rust - Lang Team Sync
Explore Rust's Unsafe Code Guidelines progress, plans, and discussions on PR #58739. Gain insights into the language team's approach to managing unsafe code.
Enhancing Safety in C++ Code With Modern C++ Quantities and Units Library - ACCU 2024
Explore how modern C++ quantities and units library enhances code safety, addressing engineering mishaps and improving project robustness through practical examples and potential language extensions.
The Rust Borrow Checker - A Deep Dive
Explore Rust's borrow checker: from basics to advanced concepts. Learn to leverage its guidance for writing safer, more powerful code, understanding its critical role in Rust's functionality and philosophy.
How to Avoid Safety Hazards When Using Closures in Scala
Explore safety hazards in Scala closures, learn to identify unsafe code, write safer closure-using code, and utilize new library components for increased flexibility and safety in parallel and distributed programming.
Safer C++ with MISRA-C++ 2023
Explore MISRA-C++ 2023 guidelines for safer C++ programming in critical systems. Learn key rules, modern C++ design compliance, and strategies for improved code quality and reduced risks.
Using Units, Quantities, and Dimensions in C++14
Explore C++14's zero-cost abstraction for safer physical property computations, incorporating dimensions into the type system. Learn to use units libraries for improved code clarity and accuracy.
Removing Needless Undefined Behavior for a Safer C++
Explore strategies to eliminate undefined behavior in C++, enhancing safety and security. Learn about potential fixes, well-defined behavior, and the role of contracts in mitigating risks.
Beware of C++
Explore potential pitfalls and complexities in C++ programming with expert insights on language features, best practices, and common misconceptions to enhance code quality and efficiency.
IIFE in C++ for Performance and Safety
Explore C++ IIFE technique for cleaner, safer, and more performant code in object initialization, enhancing scope management and reducing global pollution.
Simplest Safe Integers
Explore pitfalls of C++ built-in types and learn about a simple integer library for MISRA-C++ compliance. Discover safe integer types that prevent promotion and maintain signedness, enhancing code safety and reliability.
Coding for Safety, Security, and Sustainability in C++ - Panel Discussion
Expert panel explores C++'s future, addressing safety, security, and sustainability challenges. Discusses language evolution, competition, and community needs for improved software development.
Integer Type Selection in C++ - Safe, Secure and Correct Code
Explore integer type selection in C++ for safe and secure coding. Learn about signed vs. unsigned, exact width integers, and best practices to avoid common pitfalls and vulnerabilities.
Boundaries in Practice
Exploring "Functional Core, Imperative Shell" in Swift: practical examples for writing safer, more maintainable code through effective boundaries in iOS development.
In Defense of Ruby Metaprogramming
Explore Ruby's metaprogramming: when to use it, which features to leverage, and how to implement it safely. Learn to harness Ruby's flexibility for powerful and enjoyable coding.
JavaScript Tools at Scale Using Type Information
Explore advanced JavaScript tools leveraging type information for enhanced static analysis, refactoring, and code safety in large-scale projects.
The C++ Type System is Your Friend
Explore how C++'s type system and templates can create efficient, safe, and reusable code through lightweight abstractions, type-rich APIs, and zero-overhead template techniques.
Using C#'s Type System Effectively
Practical tactics to leverage C#'s type system for improved compiler feedback, safer code optimization, and enhanced programming philosophy. Explore simple to advanced techniques.
C++ - No More Nulls! - Fixing the Billion Dollar Mistake
Explore techniques to eliminate null in C++, enhancing code safety and clarity. Learn to use non-nullable types, std::optional, and gsl::not_null for improved software design.
Sane and Safe C++ Class Types
Explore safe C++ class design, focusing on best practices, rules, and guidelines for creating robust and maintainable code while navigating complex language features and potential pitfalls.