Nanopass Attribute Grammars - Managing Complexity in Compiler Design
Explore nanopass attribute grammars for managing compiler complexity, enabling type-safe language versioning and transformation composition in feature-rich language implementations.
CodeProber: Live Compiler Exploration - LIVE23
Explore interactive compiler debugging with CodeProber. Learn to identify and fix bugs in language tooling using source code-based exploration of AST properties.
Binding Syntax for Dependently-Typed Programs - WITS'24
Explore innovative binding syntax for dependently-typed programs, enhancing ergonomics while maintaining fixed grammar for improved error messaging.
Probabilistic Programming with Stochastic Probabilities
Explore a novel approach to probabilistic programming languages using stochastic probability estimation, enabling unrestricted stochastic control flow and programmable inference with custom proposals.
Compilation of Qubit Circuits to Optimized Qutrit Circuits
Explore an optimizing compiler for qutrit circuits that improves quantum computations, offering depth reduction and higher fidelity compared to manual implementations and qubit circuits.
Misconceptions About Loops in C - Challenges in Loop Analysis for Static Analysis Tools
Explore rare edge cases and challenges in loop analysis for C programming, enhancing understanding of static analysis tools and improving software verification techniques.
A Journey of Journey Programming Language - Developing a Tester-Friendly Language
Explore the development of Journey Programming Language, from concept to implementation in Rust. Gain insights into language design, project planning, and Rust's advantages.
Let's Code in Our Mother Tongue - Designing an African Native Language-Based Programming Language
Explore the creation of an African native language-based programming language, bridging cultural gaps in coding and expanding linguistic diversity in tech.
Automatic Promotion of Helper Functions to TCG Using LLVM
Explore automatic translation of C helper functions to optimized Tiny Code Generators for QEMU using LLVM. Learn about performance improvements and see an interactive demo of C to TCG mappings.
Syntax Directed Definition (SDD) - Types of Attributes and SDDs in Compiler Design
Explore syntax directed definitions, attribute types, and SDD variations in compiler design. Master key concepts for effective language processing and translation.
Compiler Options Hardening for C and C++
Explore compiler options to enhance C/C++ program security. Learn about memory-safety issues, mitigation techniques, and the OpenSSF Compiler Options Hardening Guide for informed decision-making.
Building a JIT Compiler for CPython
Explore CPython's JIT compiler development using "copy-and-patch" technique, addressing challenges and tradeoffs in performance optimization for diverse platforms and user bases.
Ladder: Enabling Efficient Low-Precision Deep Learning Computing through Hardware-aware Tensor Transformation
Innovative compiler for optimizing low-precision deep learning computations, bridging custom data types with hardware limitations to enhance performance without hardware modifications.
Recognition of Tokens in Compiler Design - Transition Tables and Diagrams
Explore token recognition in compiler design, including transition tables and diagrams. Learn key concepts for understanding lexical analysis and automata theory in compilation processes.
LEX: Language Specifying Lexical Analyzer - Compiler Design
Explore LEX, a powerful tool for creating lexical analyzers in compiler design. Learn its functionality, usage, and implementation in language processing.
Bootstrapping Process in Compiler Design - Self-Hosting and Cross Compilers
Explore compiler bootstrapping, self-hosting, and cross-compilation techniques. Learn key concepts and processes in compiler design for efficient language implementation.
Elimination of Left Recursion in Compiler Design - Examples and Explanation
Explore left recursion in compiler design, its impact on parsing, and techniques for elimination. Learn to identify and resolve left-recursive grammars for efficient parsing.
Left Factoring in Compiler Design - Elimination of Left Factored Grammar
Explore left factoring in compiler design, including left factored grammar and elimination techniques. Learn to optimize grammar for efficient parsing and reduce ambiguity in language processing.
Shift-Reduce Parser in Compiler Design - Bottom-Up Parsing Example
Comprehensive explanation of shift-reduce parsing in compiler design, including bottom-up parsing techniques and practical examples for effective implementation.
Specification of Tokens in Compiler Design - Regular Expressions, Languages, and Alphabets
Explore token specification in compiler design, covering regular expressions, languages, strings, and alphabets. Learn key concepts for effective lexical analysis and token recognition.
Parse Tree and Derivation Trees in Compiler Design
Explore parse trees, left-most and right-most derivations, and derivation trees in compiler design. Learn key concepts for understanding language parsing and syntax analysis.