Morello Software and Compilers
Explore Morello software and compilers, focusing on advanced techniques and innovations in programming language implementation for enhanced security and performance.
CHERI Static Analysis - POCL'24
Explore CHERI static analysis techniques for enhanced memory safety and security in software development.
Data Collection and IoT for Vehicles in Practice - Using OSGi and Realtime Java
Discover how OSGi technology and realtime Java VM create robust IoT data collection systems for vehicles, featuring proven architecture insights from 10+ million car implementations.
Lessons from the Buzz
Explore insights and key takeaways from the Buzz phenomenon, examining its impact and implications for technology and society.
Runtime Detection of Data Races in OCaml with ThreadSanitizer
Explore runtime detection of data races in OCaml using ThreadSanitizer. Learn core principles, challenges, adaptations, and practical application for reliable parallel code development.
A Grounded Conceptual Model for Ownership Types in Rust
Explore a systematic approach to teaching Rust's ownership types, featuring a new assessment tool, conceptual model, and visualizations to improve learner understanding of memory safety concepts.
Verus: Verifying Rust Programs Using Linear Ghost Types
Explore Verus, an SMT-based tool for formally verifying Rust programs. Learn how it leverages Rust's linear types and borrow checking to prove functional correctness in low-level, high-assurance systems.
Indexed Types for a Statically Safe WebAssembly - POPL 2024
Explore Wasm-prechk, a WebAssembly extension using indexed types for enhanced static safety. Learn about performance gains, type safety proofs, and implementation trade-offs in this innovative approach.
Flux: Liquid Types for Rust
Explore Flux, a refined type system for Rust that enhances verification of low-level pointer programs. Learn how it combines logical refinements with Rust's ownership mechanisms for efficient and ergonomic type-based verification.
RefinedRust: A Type System for High-Assurance Verification of Rust Programs
Explore RefinedRust, a novel type system for verifying both safe and unsafe Rust code. Learn about its implementation, evaluation, and potential impact on high-assurance software development.
Descend: A Safe GPU Systems Programming Language
Explore Descend, a safe GPU programming language enforcing memory management through type systems. Learn about its holistic model, extended Borrow checking, and competitive performance against CUDA.
Borrow Checking in Hylo - A High-Level Systems Programming Language
Explore Hylo's innovative approach to safe, efficient systems programming using mutable value semantics and abstract interpretation for lifetime verification.
Does Rust SPARK Joy? Safe Bindings from Rust to SPARK, Applied to the BBQueue Library
Explore safety guarantees in Rust-SPARK language bindings, focusing on the BBQueue circular buffer library. Learn about maintaining compile-time safety across language boundaries in embedded systems.
Leveraging Rust Types for Program Synthesis
Explore how Rust's type system enhances program synthesis, simplifying specifications and improving performance. Learn about Synthetic Ownership Logic and the RusSOL tool for automatic synthesis of correct Rust programs.
Enhancing Gen-AI with Rust - Scalable AI Systems
Explore Rust's potential in building scalable AI systems, focusing on its core features, advantages for AI applications, and future prospects in the field.
Substrate Engineering - Foundations for AI-Assisted Development
Explore the importance of substrate engineering in LLM-based tools, focusing on improving programming languages and frameworks for enhanced code reliability and safety.
Rust Operators for Kubernetes - Building Robust and Efficient Solutions
Explore Rust's benefits for building Kubernetes operators, including safety, performance, and reliability. Learn challenges, best practices, and how to create a simple operator using Rust.
Why Is Rust the Rising Star?
Explore Rust's benefits, memory safety, and performance advantages over C/C++. Learn why leading tech companies are adopting this rising programming language.
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.
Empirical Study of Rust-for-Linux: Success, Dissatisfaction, and Compromise
Empirical study on Rust-for-Linux project, analyzing its impact on kernel safety and performance. Explores successes, challenges, and compromises in integrating Rust into the Linux ecosystem.
Drop the ROP - Fine-Grained Control-Flow Integrity for the Linux Kernel
Explore fine-grained Control-Flow Integrity for Linux kernel security, addressing ROP attacks and dynamic kernel modules. Learn advanced mitigation techniques and implementation challenges.