GitHub Advanced Security: Securing the World's Software - Lecture
Explore GitHub Advanced Security's approach to empowering developers in securing software through code scanning, secret scanning, and supply chain security, with insights on AI integration.
Domo Arigato, Mr. Roboto - Security Robots a la Unit-Testing
Explore security unit testing for custom code, focusing on inoculating applications, identifying endpoints, and addressing common vulnerabilities through automated testing frameworks.
Maximizing Success with TypeScript and ESLint - Josh Goldberg
Explore TypeScript and ESLint best practices, advanced features, and performance optimization with insights on open-source maintenance, book writing, and the future of these technologies.
C/C++ Compiler Options Best Practices
Discover best practices for C/C++ compiler options to enhance code security and performance. Gain insights into optimizing your compilation process.
Lifetime Safety in C++ - Past, Present and Future
Explore C++ memory safety advancements, current mitigations, and future directions. Learn to enhance code safety without sacrificing performance or flexibility.
How to Build Your First C++ Automated Refactoring Tool - Lecture
Learn to create C++ automated refactoring tools using Clang, scaling expert knowledge and ensuring best practices across large codebases. Discover practical applications for improving code quality efficiently.
Ruff: An Extremely Fast Python Linter and Code Formatter Written in Rust
Explore Ruff, a high-speed Python linter and formatter in Rust. Learn its functionality, performance optimizations, and design choices that make it significantly faster than alternatives.
Ruff: An Extremely Fast Python Linter and Code Formatter Written in Rust
Explore Ruff, a high-speed Python linter and formatter in Rust. Learn its functionality, performance optimizations, and design choices that make it significantly faster than alternatives.
The C++ Vector Challenge - Exploring Object Interfaces and Formal Specifications
Delve into the complexities of C++ vector implementation, exploring formal interfaces, static checking mechanisms, and the challenges of specifying object interfaces through a deep technical analysis.
Inside the Scala Capture Checker
Explore Scala's capture checker, its algorithms, architecture, and integration into the compiler for ensuring resource and effect safety in programs.
A Tour Through the Meeting C++ Community Survey - 2023
Explore insights from the Meeting C++ community survey, covering trends, tools, and practices in C++ development since 2020.
Dealing with Static Analysis Findings: MISRA - Lecture
Learn to handle static analysis findings, focusing on MISRA C++ violations. Explore strategies for addressing feedback, documenting deviations, and improving code quality in safety-critical systems.
Purging Undefined Behavior and Intel Assumptions in Legacy C++ Codebases - Lecture
Eliminate undefined behavior in legacy C++ codebases to reduce maintenance costs and support new platforms. Learn tools and strategies for identifying and addressing issues.
Memory-Safe C++ - Addressing Common Vulnerabilities
Explore memory-safe C++ with a new compiler and runtime that detects vulnerabilities without source code changes. Learn static analysis techniques and runtime checks for enhanced software security.
Pets, Cattle and Automatic Clang Operations with C++ Code
Discover how to leverage Clang tools for automated C++ code refactoring, config generation, and semantic code search, enhancing development workflow and efficiency.
Customising Clang-Tidy to Modernize Legacy C++ Code - From Printf to Std::Print
Discover how to automate C++ code modernization using clang-tidy, focusing on upgrading legacy printf-style logging to modern formatting approaches like fmt::print and std::print.
Static Analysis of APL in APL - Development Tools and Verification
Explore static analysis techniques for APL programming, focusing on code verification, bug detection, and security enforcement through practical implementation strategies and architectural considerations.
Co-dfns Compiler Roadmap and Updates - Implementation and Integration Features
Discover the latest developments in Co-dfns compiler for APL, exploring GPU integration, scalar optimization, static analysis, and traditional APL support through practical use cases and performance insights.
Liquid Type Systems - Understanding Type Theory and SMT Solvers
Explore the innovative Liquid Types system, combining traditional type theory with SMT solvers to enhance type system expressivity while maintaining practical usability in programming languages.
Compile-Time Validation in C++ Programming
Master advanced compile-time validation techniques in C++ to enhance code safety and reliability through functional programming approaches, unit testing, and upcoming C++26 reflection features.
Practical Vulnerability Analysis for Development Teams
Discover effective vulnerability analysis techniques and best practices for development teams, focusing on identifying and mitigating security risks in software development.