Reflecting on Active Record Associations
Explore Active Record associations by building custom macros, understanding dynamic method definition, and optimizing query performance in Ruby on Rails.
Declare Victory with Class Macros in Ruby
Explore metaprogramming in Ruby, from attr_reader to custom class macros, for cleaner, more declarative code and easier-to-understand classes.
Scala Macros: Unleashing the Power of Compile-Time Metaprogramming
Explore compile-time metaprogramming with Scala macros to simplify and enhance development in complex codebases.
Metaprogramming Techniques in Scala
Explore metaprogramming in Scala: learn to manipulate programs, modify behavior, and leverage functional programming concepts for advanced code manipulation.
Unleashing the Power of Type-Level Programming in Scala
Dive deep into advanced Scala techniques, exploring type-level programming for powerful compile-time computations and fine-grained type control.
A New Way to __init_subclass__ for Python Automation
Explore metaprogramming techniques to automate Python class initialization, reducing manual intervention and enhancing code flexibility for diverse data handling scenarios.
What's New in C++23
Explore C++23's new features with Sy Brand, enhancing code simplicity, expressiveness, and power. Learn how upcoming changes benefit your programming and prepare for future upgrades.
High Speed Query Execution with Accelerators and C++ - Lecture
Explore advanced techniques for accelerating big data analytics using C++ and custom hardware, combining metaprogramming and novel processor architectures for optimized query execution.
C++ in the World of Embedded Systems
Explore C++ applications in embedded systems, covering concepts, architectures, and modern features. Learn to leverage C++ for efficient embedded software development with practical examples.
Binary Object Serialization with Data Structure Traversal and Reconstruction in C++ - Lecture
Explore advanced C++ serialization techniques for complex data structures, including binary object serialization, data traversal, and dynamic reconstruction using template argument deduction and reflection-like mechanisms.
Expressive Compile-time Parsers in C++ - CppCon 2023
Explore compile-time parsers in C++ for expressive APIs and DSLs. Learn techniques, compare libraries, and discover applications in regular expressions, parser generators, and reflection features.
AI-Driven Performance Metaprogramming - Embedding Spaces for Program Analysis and Optimization
Explore AI-driven performance metaprogramming using embedding spaces for programs. Learn to assess, analyze, and improve program performance through advanced AI methods.
C++ as a Metacompiler - Exploring Compile-Time Language Processing
Explore metacompilation in C++17+: leveraging grammatical tools to create domain-specific languages, translate to meta assembly, and generate constexpr functions for compile/runtime use.
Lean4Lean - Formalizing the Type Theory of Lean
Explore the formalization of Lean's type theory with Mario Carneiro, delving into advanced concepts and techniques for theorem proving and mathematical reasoning.
SPy: Static Python Language - Fast as C, Pythonic as Python
SPy: A statically typed Python variant aiming for C-like performance while preserving Pythonic feel. Leverages modern Python practices and typing for compile-time optimizations without sacrificing dynamic features.
Mixing Paradigms Using the Latest C# Language Features
Explore advanced C# features like records, tuples, and LINQ, integrating functional and object-oriented paradigms to solve practical problems effectively.
Let's Code an Incremental Source Generator with Roslyn
Explore Roslyn-based metaprogramming through live coding of an incremental source generator, unveiling its intricacies, benefits, and quality assessment techniques.
Let's Code an Incremental Source Generator with Roslyn
Explore incremental source generation with Roslyn in this live coding session. Learn to implement, test, and optimize generators for improved compile-time efficiency and runtime performance.
Reflection in C++ - Past, Present, and Hopeful Future
Explore C++ reflection's evolution, potential applications, and future prospects. Gain insights into advanced programming concepts and language design for enhanced code flexibility and reuse.
Symbolic Calculus for High-performance Computing From Scratch Using C++23
Explore symbolic calculus implementation in C++23 for high-performance computing. Learn techniques for compile-time derivatives, integrals, and optimized linear algebra computations.
Reintroduction to Generic Programming for C++ Engineers - C++Now 2024
Explore generic programming in C++20 with concepts, simplifying complex ideas for all engineers to create robust, maintainable software. Fresh perspective on fundamental principles.