New Rustacean — Overcast

Interview 4 – Jonathan Turner: Part 3

Jun 17 • 22 min

Smoothing the Rust dev story: future work on the RLS, in Rust itself, and in Servo.

Interview 4 – Jonathan Turner: Part 2

May 30 • 25 min

Making Rust Better: Rust as the fusion of systems and high-level programming languages, and the RLS.

Interview 4 – Jonathan Turner: Part 1

Apr 30 • 22 min

Background, TypeScript, coming to Rust, and how helpful the Rust community can be.

CYSK: RLS

Apr 18 • 11 min

Where the RLS came from, what it can do, and how you can start using it today!

e020: Putting code in its place

Apr 1 • 20 min

How do we organize code in Rust? Where do we break it apart into modules or crates, and why? Structuring code in a language like Rust can seem a bit more ambiguous than doing the same in a language with classes to attach all our functionality to, but in…

Bonus 8: Giving back (by teaching)

Mar 19 • 13 min

On the responsibilities and opportunities we have to help others with our knowledge and abilities. Many of us have been very blessed with opportunities and support as we learn software. We should go out of our way to share with others in kind. Today, my…

e019: Let’s `Clone` a `Cow`

Feb 28 • 18 min

The final pieces of the story for (single-threaded) memory management in Rust. Notes ——- Sometimes, we actually do need to copy types. Wouldn’t it be nice if Rust gave us a convenient way to do that when it’s convenient, or when the cost is low enough…

CYSK: clap

Feb 14 • 10 min

A Command-Line Argument Parser. Sponsors ———— - Aleksey Pirogov - Andreas Fischer - Andrew Thompson - Austin LeSure - Ben Whitley - Charlie Egan - Chris Palmer - Christopher Giffard - Daniel Collin - Derek Morr - Jakub “Limeth” Hlusička - Jordan Henderson…

e018: `Borrow`, `AsRef`, `Deref`: my head hurts now

Jan 31 • 17 min

Three traits which are essential for designing good, Rustic APIs. Notes Borrow, AsRef, and Deref are a little complicated, but they’re well-worth understanding. Together, they give you tools for dealing with everything from HashMap and friends to…

CYSK: quick-xml

Jan 9 • 8 min

A pull-parser for reading and writing XML. Sponsors * Aleksey Pirogov * Andreas Fischer * Ben Whitley * Cameron Mochrie * Chris Palmer * Christopher Giffard * Daniel Collin * Derek Morr * Jakub “Limeth” Hlusička * Jupp Müller * Keith Gray * Lachlan…

News 2: Let’s talk roadmap!

Dec 29, 2016 • 21 min

Rust’s achievements in 2016 and goals for 2017 Sponsors * Aleksey Pirogov * Andreas Fischer * Ben Whitley * Cameron Mochrie * Chris Palmer * Daniel Collin * Derek Morr * Jakub “Limeth” Hlusička * Jupp Müller * Keith Gray * Lachlan Collins * Luca Schmid *…

Meta 1 – Slowing Down

Nov 12, 2016 • 7 min

Avoiding burnout by taking it a little easier. Sometimes, the way a podcast stays in existence is by coming out less often. That’s what’s happening here. # Links - [lightning-rs] - [Pelican] - [Hugo] - [Jekyll] - [Static Site Generators]\: The definitive…

Interview 3 – Carol (Nichols || Goulding)

Sep 30, 2016 • 47 min

Carol (Nichols || Goulding) on learning Rust, teaching Rust, and building community Chris talks with Carol (Nichols || Goulding), a Rust community team member, co-author of the first major revision of The Rust Programming Language, and co-founder of the…

Bonus 7: Katas—or: learning by doing

Sep 10, 2016 • 10 min

Katas—or: learning by doing One of the best ways to learn is to pick a small problem you have already internalized, and to do it again but in a new language or in a new way in a language you already know. Sponsors * Aleksey Pirogov * Cameron Mochrie *…

Bonus 6: It doesn‘t have to be sexy

Aug 20, 2016 • 11 min

Building (and celebrating) all the little, not-so-glorious pieces of the Rust ecosystem. Notes We love the Rust compiler team. But there’s more to the Rust community, and more required for Rust to be as great as it can be, than just the language itself.…

e017: Point me where I need to go

Aug 8, 2016 • 17 min

A deep dive on references and pointers in Rust. Notes By listener request, today we look at the syntax and semantics of referencing and dereferencing and the corresponding `&` and `*` operators. As was the case with e016, the code samples have little to…

e016: RefCells and code smells

Jul 23, 2016 • 18 min

Digging deeper on smart pointers and mutability with `Cell` and `RefCell`. Notes What are the Cell and RefCell types, and when should we use them? Today, we follow up both the detailed discussion of smart pointers in e015 and the closely related…

Interview 2::Part 2 – Raph Levien

Jul 4, 2016 • 19 min

Raph Levien on Rust’s current strengths and places it can improve Notes Chris chats with Raph Levien about what inspired him to build a text editor, as well as about where the rough edges in the Rust development story are today, and how we might improve…

Interview 2::Part 1 – Raph Levien

Jun 24, 2016 • 28 min

Raph Levien on using Rust to build the Xi editor Notes Chris chats with Raph Levien about his background in software development, what attracted him to Rust, and how he’s using Rust to build the Xi Editor, a project which aims to be the fastest text…

e015: Not dumb pointers

Jun 17, 2016 • 20 min

Box, String, Vec, Rc, and Arc have this in common: they’re not dumb. This episode, we take a close look at smart pointer types—from a few we’ve already talked about, like Box, Vec, and String, to some new ones, like Rc and Arc. - What smart pointers are,…

News 1: One year and counting

May 31, 2016 • 26 min

A year in, Rust is changing fast but still stable. Sponsors * Aleksey Pirogue * Chris Palmer * Daniel Collin * Derek Morr * Hamza Sheikh * Lachlan Collins * Leif Arne Storset * Luca Schmid * Micael Bergeron * Pascal Hertleif * Ralph Giles (“gillian”) *…

Bonus 5: Better than open-source contributions

May 9, 2016 • 11 min

Some things matter more than contributing to open-source software in your free time. A lot more. It’s trendy to ask for open-source work as evidence of your interest in tech and commitment to software development. Trendy and completely wrong. Companies…

e014: Stringing things along

Apr 25, 2016 • 18 min

Strings &strs and Vecs and slices (and Unicode) – oh, my! Notes This episode, I take a deep dive on strings in Rust, looking at the differences between String and &str, discussing Unicode a bit, and then expanding the discussion to think about how these…

Bonus 4: We can have nice things

Apr 19, 2016 • 10 min

Just how good Rust is, and how you can learn it even if you’re busy. Notes Sometimes life goes crazy and I don’t have time to do all the technical writing required for a full episode, but I can’t get Rust off my mind, so I record an episode like this one.…

e013: Staying alive

Apr 4, 2016 • 17 min

Reasoning about and using lifetimes in Rust (and why we need them) Notes Lifetimes are our way of reasoning about how long a given piece of data is available and safe to use in Rust. The reason we don’t have the dangling pointer problem is that we do have…

e012: I’m not familiar with that expression

Mar 21, 2016 • 16 min

What it means to be an expression-oriented language, and how that works out in Rust. Notes Rust is an expression-oriented language. What does that mean, and how does it play out in Rust? We look at if and match blocks, discuss looping constructs, and…

e011: Once Upon a Type

Mar 8, 2016 • 17 min

Type systems: strong vs. weak, dynamic vs. static, and degrees of expressivity. Notes Talking about type systems! A broad and wide-ranging discussion about type systems in general, with specific examples from languages like PHP, JavaScript, Python, C,…

Interview 1::Part 2 – Sean Griffin

Feb 25, 2016 • 22 min

Sean Griffin on type systems and hopes for Rust’s future Notes ——- Chris chats with Sean Griffin about the tradeoffs between mental overhead and type safety, the expressiveness of different type systems, and some of the places where Rust currently falls…

Interview 1::Part 1 – Sean Griffin

Feb 15, 2016 • 24 min

Sean Griffin on Rust, Diesel, and ORMs Notes Chris chats with Sean Griffin about his programming background and initial experience with Rust, Rust’s appeal, and what he’s doing with Diesel and some of his plans for a new web framework in Rust. Sponsors -…

Bonus 3: Building as a community

Jan 31, 2016 • 12 min

The value of a good community, and how you can help Rust today. Community is one of the most important parts of a programming language community, or indeed *any* technical community. In this episode, I talk a bit about what happens when you don’t have a…

e010: Macros rule!

Jan 18, 2016 • 16 min

Using Rust’s macro system, its limitations, and its future. Because of the way macros are exported—before name resolution on crates occurs—the documentation for the macros defined in the source for this episode occurs in the MACROS section of the…

e009: Composing a Rustic tune

Jan 9, 2016 • 17 min

Notes Last time, we looked at generics and traits at a high level. This time, we dig deeper on traits, looking specifically at std::iter::Iterator as an example of a powerful trait that can be composed across types, and then at how we might compose…

e008: Just like something else

Dec 27, 2015 • 17 min

Notes In this episode we cover—at a _very_ high level—two more fundamental concepts in Rust programming: generics and traits. Generics gives us the abilitty to write types and functions which can be used with more than one type. Traits give us the ability…

e007: Testify

Dec 13, 2015 • 18 min

Notes All about testing in Rust! In order, we take a look at: - Why you need tests. - Unit tests in other (dynamically-typed) languages vs. in Rust. - How to write unit tests in Rust. - How and why to write integration tests in Rust. - How and why to use…

Bonus 2: Legacy Code

Dec 6, 2015 • 9 min

Software developers spend a large part of our careers dealing with legacy code. But what is the _best_ way to deal with legacy code? When should you rip out the old and rewrite it, and when should you opt for smaller clean-up jobs because, however ugly,…

Bonus 1: Polyglot Programming Promises and Perils

Nov 25, 2015 • 8 min

The delights and challenges of knowing (or even just learning) lots of languages.

e006: Modularize this!

Nov 16, 2015 • 18 min

Designing APIs, and using packages (“crates”) and modules Notes Today, we are talking about modules, packages, and APIs in Rust. Taking a bit of a breather after some pretty hard material the last few weeks. For reference, the Rust book section on Crates…

e005: Allocate it where?

Nov 8, 2015 • 18 min

Returning functions from other functions, and thinking about the stack, the heap, and reference types. NOTES This episode, we look at returning functions from other functions, and as part of that discuss some basics about the stack and the heap—and why we…

e004: Functionalized

Oct 29, 2015 • 17 min

Functions, methods, closures, and function as arguments! NOTES This week’s episode covers the basics of all sorts of functions: normal functions, methods, and closures. Closures - An explanation (in Ruby) by Martin Fowler - Rust book - Rust by Example -…

e003: No. more. nulls.

Oct 21, 2015 • 16 min

No More Nulls - Date: October 21, 2015 - Subject: Enumerated (`enum`) types, pattern matching, and meaningful return values. # Notes Today’s episode discusses, in order: - Enumerated types, with an eye to the difference between structs and enums, and to…

e002: Something borrowed, something… moved?

Oct 11, 2015 • 17 min

Something borrowed, something… moved? * Date: October 12, 2015 * Subject: The struct data type constructor, and the basics of Rust’s “ownership” concept and “borrowing” and “moving”. * Audio: * M4A * MP3 * Ogg Follow/Support * New Rustacean: * Twitter:…

e001: Document All the Things

Oct 3, 2015 • 17 min

Documentation in general, and rustdoc and cargo doc in particular. Document all the things! * Date: October 3, 2015 * Subject: Documentation in general, and rustic and cargo doc in particular. * Audio: * M4A * MP3 Follow/Support * New Rustacean: *…

e000: Hello, world!

Sep 24, 2015 • 17 min

Hello, world! * Date: September 24, 2015 * Subject: The host, the language, and the show! * Audio: * M4A * MP3 Today’s show is pretty meta. You can skip it if you just want to start with something more technical, but I thought listeners might want to know…