Programming Languages - The Fundamental Tools of the Computer Age
Explore the role of programming language research in developing reliable software, focusing on program validation, verification, and analysis techniques.
Postcards from the Peak of Complexity - Insights on Java Platform Evolution
Explore Java's evolution through insights and war stories from Language Architect Brian Goetz, covering major features like generics, lambdas, and virtual threads.
This is C++ - Uncompromised Performance, Undefined Behavior, and Move Semantics
Dive into C++'s superpower for uncompromised performance. Explore undefined behavior and move semantics to write better code and understand C++'s evolution, including current controversial issues.
Flex - Lexical Analysis
Learn to use flex for lexical analysis in compiler construction, covering setup, syntax, and practical examples for tokenizing source code.
The Role of Computer Science in Computer Science Education
Exploring computer science's role in CS education, addressing challenges and opportunities in curriculum design, language development, and accessibility for diverse learners.
Move Deliberately and Don't Break Anything: Lessons from Java Evolution
Explore Java's evolution, challenges in language design, and future directions with insights on maintaining compatibility while adding new capabilities for millions of developers.
Rust: A Language for the Next 40 Years
Explore Rust's unique features, memory safety guarantees, and evolution through Editions. Discover its growing adoption in critical systems and its potential for the future of programming.
Trait Evaluation Caching in Rust - PR #85186
Explore trait evaluation caching in Rust with Niko and Jack Huey as they explain PR #85186, diving into the intricacies of this performance optimization technique.
Async Rust: Past, Present, and Future
Explore async Rust's evolution, current state, and future developments. Understand design decisions, trade-offs, and ongoing improvements by the Async Working Group for better async programming.
Imagining Introductory Rust - Considerations and Opportunities
Explore the potential of Rust as a first programming language, discussing motivations, course structure, and challenges in teaching Rust to beginners.
Teaching Rust and Code Recommendations for Beginners - RustEdu Workshop 2022
Explore teaching Rust, student outcomes, and an AI-powered tool for suggesting code improvements to beginners learning the language.
Words from the Rust Core Team - Updates from the Rust Community
Insights into Rust's community updates, development progress, and future plans from a core team member at RustCon Asia 2019.
Making Rust Delightful - Ergonomics in Language Design
Explore Rust's design philosophy, ergonomics, and decision-making process. Learn how language features balance ease of use with safety and performance, using real-world examples from Rust's development.
How the Chalk-Engine Crate Works in Rust
Explore the inner workings and functionality of the chalk-engine crate in Rust programming, gaining insights into its design and implementation.
Rust Region Inferencer Discussion - Async-Await Working Group
Rust developers discuss region inferencer changes to address limitations, uncovering unexpected issues while exploring multiple unrelated lifetimes in existential types.
Unsafe Code Guidelines in Rust - Lang Team Sync
Explore Rust's Unsafe Code Guidelines progress, plans, and discussions on PR #58739. Gain insights into the language team's approach to managing unsafe code.
Implementing RFC #2229: Disjoint Field Capture Plan - Rust Strategy and Roadmap
Explore the implementation strategy for RFC #2229 in Rust, covering refactorings, independent tasks, and a roadmap for disjoint field capture.
The Symbiotic Relationship of C++ and Rust - RustConf 2019
Explore the intertwined evolution of Rust and C++, their shared future, and the mutual influence on language design and community responsibility.
The Rust 2018 Module System - Simplifying Crates and Modules
Comprehensive overview of Rust 2018's new module system, exploring its motivations, practical impacts, and future enhancements for both novice and experienced Rust developers.
Rust Shared State Code Review - Analyzing Initial Audit Results
Explore initial findings from Aaron Turon's shared state audit, categorizing state elements to determine necessary steps for improving confidence in Rust's codebase.
Polonius Working Group: The Role of Subset Relations in Rust
Explore subset relations in Polonius's design and a proposal for equality-only propagation, enhancing understanding of Rust's borrow checker implementation.