Type-safe Nanopasses: How to Write a Safe and Modern Compiler Front-end - INFER 2024
Explore a novel approach to strongly typing compiler passes, combining nanopasses and recursion schemes for efficient, type-safe compiler front-end development in Ada.
Functional Parsing for Novel Markup Languages - Lambda Days 2022
Explore functional parsing for novel markup languages, focusing on fault-tolerant parsers with real-time error messages. Learn design principles and implementation techniques through case studies of MiniLaTeX and L1.
Using Smoke and Mirrors to Compile a Functional Programming Language to Efficient GPU Code
Explore techniques for compiling functional languages to efficient GPU code, overcoming hardware restrictions through strategic language design and aggressive compiler optimizations.
Build Your Own Svelte Compiler - From Scratch to Optimized JavaScript
Develop a Svelte compiler from scratch, exploring compiler design principles and optimizing JavaScript code generation.
Mgmt Config Lambdas: Real-Time Automation with Functional Iteration
Explore functional iteration with lambda functions in Mgmt, a real-time automation tool. Learn about implementation challenges, plumbing changes, and see live demos of practical applications.
Julia Compiler Secrets - Static Analysis - JuliaCon 2024
Explore advanced static analysis capabilities in Julia's compiler, including type inference, effect system, and escape analysis, to optimize code performance and enhance correctness.
C++ Overload Inspector - A Tool for Analyzing and Profiling Overloaded Function Calls
Explore a tool for analyzing and profiling overloaded function calls in C++. Learn about fundamental overloading rules, tricky examples, and how to optimize compilation time using the open-source inspector.
BinaryBuilder 2: Return of the Compilers - JuliaCon 2024
Explore BinaryBuilder 2's redesign, addressing pain points and unlocking new capabilities for complex software projects, multiple compilers, and platforms in Julia package development.
LLVM in HPC: Enabling Performance Portability, Interoperability, and Novel Features - Part 2
Explore recent LLVM efforts for HPC: portable CUDA, debugging at scale, GPU execution of legacy codes, automatic differentiation, ML in compilers, and static information impact.
Bridging Domain Science and HPC with Julia
Explore Julia's potential in HPC, combining scientific ecosystem with high performance. Gain insights on its strengths, limitations, and notable international projects from an experienced user.
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.
LLVM Optimization Remarks - Helping the Compiler Generate Better Code
Explore LLVM optimization remarks to enhance code performance. Learn to decipher compiler logs, identify missed optimizations, and leverage tools like opt-viewer for actionable insights.
A Long Journey of Changing std::sort Implementation at Scale
Explore Google's journey in replacing std::sort in LLVM libc++, addressing challenges, improving debugging and benchmarking, and lessons learned in optimizing sorting algorithms.
Enhancing Rust with BTF Debug Format Support
Explore recent advancements in BTF debug format support for Aya and bpf-linker. Learn about BTF generation, LLVM's role, and implementing BTF information for Rust programs in eBPF technology.
Safe by Construction - Writing Secure Code Without Thinking About Security
Learn robust coding techniques to create secure software without actively focusing on security. Explore key concepts, address complexity, and discover real-world applications for writing safer code.
RADSan: A Realtime-Safety Sanitizer - Lecture
Explore RADSan, a realtime-safety sanitizer for LLVM. Learn about sanitizers, realtime-safety testing, RADSan's components, and how to implement it in your projects. Discuss community sharing strategies.
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.
My Plan B: Exploring Alternative Strategies in Computer Science Research
Explore innovative approaches to software testing and verification with Professor Alastair Donaldson in his Imperial Inaugural lecture.
Dude, Where's My Code? - Improving Julia's Debugging and Code Update Capabilities
Exploring Julia's usability challenges in debugging and live updates, with focus on improving code provenance tracking and enhancing macro expansion for better developer experience.
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.
Predictive Parser in Compiler Design - LL(1) Parser and Top Down Parsing
Explore predictive parsing in compiler design, focusing on LL(1) parsers and top-down parsing techniques. Learn key concepts for efficient syntax analysis.