Eternal Sunshine of the Spotless Programming Language

What if one concept could define everything from error handling to async/await? Learn how Rust’s design avoids the complexity of older languages.

#1about 2 minutes

Understanding the original design goals and evolution of C++

C++ was created to improve upon C with better static type checking and support for large-scale programming through user-defined types.

#2about 4 minutes

How Java and Go emerged to address C++ limitations

Successor languages like Java and Go were created to solve specific C++ frustrations like manual memory management and slow build times.

#3about 8 minutes

Modern C++ evolution and the burden of backward compatibility

While modern C++ has adopted features similar to Rust, its commitment to backward compatibility creates significant technical debt that prevents removing outdated features.

#4about 4 minutes

Defining shared behavior across types with Rust traits

Rust traits provide a powerful way to define shared behavior, similar to interfaces, but can also be implemented for types you don't own.

#5about 6 minutes

Extending core language syntax and features with traits

Traits are the mechanism for implementing core language features like operator overloading, allowing custom types to integrate seamlessly with Rust's syntax.

#6about 6 minutes

Achieving composition over inheritance with the newtype pattern

By wrapping an existing type in a new struct (the newtype pattern), you can implement custom trait behavior to favor composition over complex inheritance hierarchies.

#7about 5 minutes

Simplifying error handling with custom error types and traits

Creating custom error enums and implementing conversion traits like `From` allows for clean, centralized error handling using the question mark operator.

#8about 9 minutes

A practical example of refactoring code using custom types

A web handler is refactored by creating custom response types and implementing conversion traits, making the code more readable, reusable, and type-safe.

#9about 1 minute

How the Future trait enables a flexible async ecosystem

Rust's `async/await` syntax is built upon the `Future` trait, which allows different third-party runtimes to provide the execution logic.

#10about 15 minutes

The power and limitations of using traits for language design

Traits are the central construct for evolving Rust by adding new features without introducing breaking changes, though they can lead to complex error messages.

From learning to earning

Jobs that call for the skills explored in this talk.