New Rustacean

New Rustacean

Meta 3: Happy Coding

May 27 • 16 min

A story and a dream (and the promise of Rust): the final episode of New Rustacean!

News: Rust 1.35

May 23 • 18 min

WASI, `Option::copied`, and the future of async/await syntax!

CYSK: bindgen and cbindgen

May 17 • 18 min

Automatic generation of FFI types between Rust and C APIs.

e031: FFI Deep Dive

May 13 • 25 min

Exposing Rust types and functions to C API consumers.

e030: Can You See Me Now?

Apr 27 • 18 min

Item visibility and `pub()` as API design tools.

News: Rust 1.33 and 1.34

Apr 20 • 18 min

Moar `const fn`, some `Pin`, and alternative Cargo registries!

e029: I’m Out to C

Apr 4 • 23 min

Using Rust’s Foreign Function Interface (FFI) with C!

Bonus 14: How the Sausage Gets Made

Mar 23 • 19 min

How I make the show, and why you won’t find it on Google Play, Spotify, or Stitcher.

Bonus 13: I Still Make Silly Mistakes

Feb 28 • 12 min

A story about parsing command-line arguments manually and some thoughts on “rookie mistakes.”

e028: Meet My Associates

Feb 21 • 23 min

Associated items: functions and methods, constants, types, and (very briefly!) GATs.

News: Rust 1.32

Jan 22 • 18 min

`dbg!`, unified paths, more places you can use `Self`, and a *bunch* of `const fn` stabilizations—plus some neat community highlights!

News: Rust 1.31 and the 2018 Edition, Part II

Jan 14 • 22 min

Stabilizing rustfmt, clippy, tool lints, and `const fn` (all in both editions!), and the 2018 Edition-specific features: syntax changes and non-lexical lifetimes!

News: Rust 1.31 and the 2018 Edition, Part I

Jan 7 • 20 min

An overview of the edition, and some of the improvements that are available in both the 2015 and 2018 editions: better lifetime elision, some Cargo features, and some library stabilizations.

Interview: Integer32

Dec 31, 2018 • 41 min

Talking with Carol and Jake about _The Rust Programming Language_, _Rust in Motion_, and Rust Belt Rust. With a bonus discussion about the value of focusing on our kids over just building big businesses.

e027: Trust Me; I Promise!

Nov 30, 2018 • 21 min

An intro to `unsafe` Rust and Rust’s idea of safety.

News: Rust 1.29 and 1.30

Nov 16, 2018 • 17 min

Procedural macros, better paths, and the Rust 2018 beta!

Bonus 12: Translating Between Languages

Oct 23, 2018 • 15 min

Musings inspired by a project translating TypeScript to Rust

Bonus 11: Burnout

Sep 22, 2018 • 27 min

What burnout is, the many ways it can happen to us, and what we can do about it.

News: Rust 1.28

Aug 16, 2018

Stable `#[global_allocator]`, more Rust 2018 Edition schedule news, video learning resources, and a static site genrator!

e026: Functional Programming Ideas

Jul 24, 2018 • 18 min

How Rust both borrows from FP languages and charts its own, very different course.

e025: Traits Deep Dive, Part III

Jul 4, 2018 • 20 min

Closure traits, `impl trait`, `dyn trait`, and object safety!

News: Rust 1.27

Jun 30, 2018 • 15 min

Stable SIMD, `dyn trait`, `rustfix` and the alpha release of the Rust 2018 Edition Preview!

e024: Traits Deep Dive, Part II

Jun 19, 2018 • 20 min

Operators as sugar for traits, traits as generic constraints, monomorphization, and universal and existential types.

CYSK: The wasm tools

May 31, 2018 • 15 min

wasm intro, `wasm-bindgen`, and `wasm-pack`

News: Rust 1.26

May 14, 2018 • 17 min

`impl trait`, `match` on references, `Result`s from `main`, and more. A good way to mark three years since Rust 1.0!

e023: Traits Deep Dive, Part I

Apr 28, 2018 • 20 min

Defining and using your own traits, using other crates’ traits, and the orphan rule.

News: Rust 1.25

Mar 31, 2018 • 14 min

Paths and matches and SIMD, cargo new changes, and tons of community-driven learning materials!

Bonus 10: “Becoming a Contributor”

Mar 17, 2018 • 31 min

My Rust Belt Rust 2017 talk!

News: Rust 1.24

Mar 1, 2018 • 18 min

Performance wins, incremental compilation, and the Rust 2018 Roadmap and Epoch.

CYSK: Serde

Feb 10, 2018 • 12 min

The library for serialization and deserialization in Rust.

e023: Send and Sync

Jan 31, 2018 • 20 min

The “marker traits” that Rust uses for safe concurrency.

Interview – Diesel 1.0, with Sean Griffin – Part 2

Jan 21, 2018 • 31 min

Getting Diesel to 1.0, writing docs and exposing problems with the API, improving Diesel in the future, and thinking about API design for open source libraries in general.

Interview – Diesel 1.0, with Sean Griffin – Part 1

Jan 13, 2018 • 31 min

Growing Diesel’s community, self-imposed technical challenges, and some of the ways Diesel has contributed to the Rust ecosystem.

News: Rust 1.23

Jan 5, 2018 • 16 min

Rustdoc changes, the first `impl` period, Firefox Quantum, and more wasm!

Increasing Rust’s Reach: Matt Gathu

Dec 30, 2017 • 21 min

Matt’s experience porting wget to Rust.

Increasing Rust’s Reach: Lee Baillie

Dec 26, 2017 • 24 min

Lee’s experience designing a new website for Rust.

Increasing Rust’s Reach: Anna Liao

Dec 21, 2017 • 29 min

Anna’s experience learning Rust while porting a Raspberry Pi Python project as part of the Increasing Rust’s Reach 2017 program.

RBR 2017: Katie Nolan

Dec 15, 2017 • 5 min

A micro-interview recorded at Rust Belt Rust 2017, in Columbus, Ohio, October 27–28.

RBR 2017: Ben Beckwith

Dec 14, 2017 • 5 min

A micro-interview recorded at Rust Belt Rust 2017, in Columbus, Ohio, October 27–28.

RBR 2017: Andrew Hobden

Dec 13, 2017 • 6 min

A micro-interview recorded at Rust Belt Rust 2017, in Columbus, Ohio, October 27–28.

RBR 2017: Parry Wilcox

Dec 12, 2017 • 6 min

A micro-interview recorded at Rust Belt Rust 2017, in Columbus, Ohio, October 27–28.

RBR 2017: Matthias Endler

Dec 11, 2017 • 6 min

A micro-interview recorded at Rust Belt Rust 2017, in Columbus, Ohio, October 27–28.

RBR 2017: Ben Striegel

Dec 10, 2017 • 6 min

A micro-interview recorded at Rust Belt Rust 2017, in Columbus, Ohio, October 27–28.

RBR 2017: Holden Marcsisin

Dec 9, 2017 • 7 min

A micro-interview recorded at Rust Belt Rust 2017, in Columbus, Ohio, October 27–28.

RBR 2017: Esty Thomas

Dec 7, 2017 • 6 min

A micro-interview recorded at Rust Belt Rust 2017, in Columbus, Ohio, October 27–28.

RBR 2017: Thomas Gideon

Dec 6, 2017 • 5 min

A micro-interview recorded at Rust Belt Rust 2017, in Columbus, Ohio, October 27–28.

RBR 2017: Tom Kriezkowski

Nov 26, 2017 • 5 min

A micro-interview recorded at Rust Belt Rust 2017, in Columbus, Ohio, October 27–28.

News: Rust 1.21 and 1.22

Nov 24, 2017 • 15 min

Quality of life improvements, Failure, wasm, and rustdoc fun.

RBR 2017: Jess Saxeter

Nov 19, 2017 • 5 min

A micro-interview recorded at Rust Belt Rust 2017, in Columbus, Ohio, October 27–28.

RBR 2017: Pete Lyons

Nov 18, 2017 • 4 min

A micro-interview recorded at Rust Belt Rust 2017, in Columbus, Ohio, October 27–28.

RBR 2017: Arun Kulsheshthra

Nov 14, 2017 • 5 min

A micro-interview recorded at Rust Belt Rust 2017, in Columbus, Ohio, October 27–28.

RBR 2017: Anthony Deschamps

Nov 13, 2017 • 5 min

A micro-interview recorded at Rust Belt Rust 2017, in Columbus, Ohio, October 27–28.

RBR 2017: Colin Dean

Nov 11, 2017 • 7 min

A micro-interview recorded at Rust Belt Rust 2017, in Columbus, Ohio, October 27–28.

Meta 2: Two milestones

Sep 25, 2017 • 12 min

CYSK: Rayon

Sep 16, 2017 • 14 min

Safe, threaded, parallel code in Rust!

News: Rust 1.20

Aug 31, 2017 • 13 min

Associated constants, conference season, meetups, and more!

Bonus 9: Open source is mostly just normal people

Aug 14, 2017

My experience with ember-cli-typescript as an example: we’re all just people muddling along and doing our best.

e021: Keeping your types under cover

Jul 17, 2017 • 17 min

Using type aliases and creating custom type wrappers for more expressive and safer code.

News 3: Increasing Rust’s Reach

Jul 4, 2017 • 13 min

Growing Rust’s diversity to help Rust grow.

CYSK: Rocket

Jun 30, 2017 • 17 min

An accessible, well-designed web framework in Rust!

Interview 4 – Jonathan Turner: Part 3

Jun 17, 2017 • 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, 2017 • 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, 2017 • 22 min

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

CYSK: RLS

Apr 18, 2017 • 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, 2017 • 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, 2017 • 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, 2017 • 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, 2017 • 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, 2017 • 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, 2017 • 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…