Understanding the Go Runtime
Explore the Go runtime's inner workings, from initialization to execution. Gain insights into garbage collection, scheduling, and core language features for optimized Go programming.
Going Down the Compilation Rabbit Hole - Understanding Go's Compiler
Explore the inner workings of Go's compiler, from parsing to assembly generation. Gain insights into how Go achieves simplicity and speed through compiler optimizations.
Micro-Optimizations for Android Development - Android Developers Backstage
Explorez les micro-optimisations Android avec Tor et Romain : allocations d'objets, inefficacités de code, compilateurs, outils personnalisés et bonnes pratiques pour améliorer les performances de vos applications.
Unwrapping Rust on Embedded Linux
Explore the transition from C to Rust in embedded systems, covering learning curves, migration strategies, compiler integration, cross-compilation, testing practices, and code size optimization.
Compilers Are Databases
Explore compiler design as database systems, examining challenges, data types, and innovative approaches for efficient language processing and development.
Analyzing Source Code Using Roslyn
Explore Roslyn's code analysis capabilities, including parsing, transforming, and pattern-checking C# code. Learn to create in-memory assemblies and run xUnit tests using Roslyn's powerful features.
Building and Scaling Developer Tools with Nx - Jeff Cross, CEO
Explore monorepo management, CI optimization, and developer tools with Nx. Learn about code consistency, deployment strategies, and business challenges in software development.
C++ Modules: Getting Started Today - Lecture
Explore C++20 modules: implementation, best practices, and CMake integration. Learn named modules, code structure, and interoperability with header-based code for practical application.
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.
Advancing cppfront with Modern C++ - Refining the Implementation of is, as, and UFCS
Explore Modern C++ and cppfront's implementation of 'is', 'as', and UFCS. Learn about challenges, achievements, and future directions in refining these key functionalities.
C++26 Preview - New Features and Enhancements
Explore cutting-edge C++26 features, from small tweaks to major additions. Learn about enhancements already in the working draft and compilers, customized based on audience interests.
A Tour Through Ferrocene Development
Explore Ferrocene, an open-source Rust compiler variant designed for safety-critical systems in automotive and aviation, focusing on its documentation, correctness principles, and implementation approach.
C++ Development Tools: Past, Present and Future
Explore the evolution of C++ development tools through time, examining their impact on software creation, current capabilities, and potential future innovations in this insightful keynote presentation.
How Linux ELF Symbols Work and How They Are Used in C++ and C Programming
Dive into the intricacies of Linux ELF symbols, exploring their role in C/C++ programming, from symbol tables and visibility to linking mechanisms and practical applications in library development.
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.
BLT (Build, Link, Test) Tutorial for HPC Software Development - 2024
Explore BLT, a CMake-based foundation for HPC applications. Learn to build, link, and test across various compilers, operating systems, and technologies for streamlined development.
Can I Cook a 5 o'clock Compiler Cake and Eat It at 2? - Optimizing Compilers for High-Performance Computing
Explore ML-enhanced compilers and domain-specific code generators in high-performance computing. Examine the programmability/performance dilemma and potential solutions for future compiler development.
Performance Aware Program Synthesis for Scientific Computing - Enabling Effective Lazy Programmers
Explore performance-aware program synthesis techniques for scientific computing, focusing on efficient code generation and optimization strategies for computational research.
Angular's DNA: Stability and Evolution
Delve into Angular's core architecture and discover how foundational principles like view-based templating and dependency injection continue driving its evolution while maintaining stability.
Crafting Domain Specific Languages - A Practical Guide - OCX 2024
Discover practical insights into creating and implementing Domain-Specific Languages (DSLs), from abstraction levels to IDE integration, based on real industrial applications and modern web technologies.
Behind the Scenes: Debugging Kotlin/WASM
Dive into the internals of Kotlin/Wasm debugging, exploring tooling capabilities and implementation details for efficient WebAssembly development and troubleshooting.