New Rustacean
Deep dive teaching episodes, news updates, and interviews with people around the Rust community.
- Update frequency
- every 12 days
- Average duration
- 16 minutes
- Episodes
- 103
- Years Active
- 2015 - 2019
News 1: One year and counting
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 B…
00:26:16 |
Tue 31 May 2016
Bonus 5: Better than open-source contributions
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 softwar…
00:11:07 |
Tue 10 May 2016
e014: Stringing things along
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 …
00:18:58 |
Tue 26 Apr 2016
Bonus 4: We can have nice things
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…
00:10:17 |
Tue 19 Apr 2016
e013: Staying alive
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 do…
00:17:40 |
Mon 04 Apr 2016
e012: I'm not familiar with that expression
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 i…
00:16:41 |
Mon 21 Mar 2016
e011: Once Upon a Type
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 exam…
00:17:51 |
Tue 08 Mar 2016
Interview 1::Part 2 – Sean Griffin
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 sy…
00:22:14 |
Thu 25 Feb 2016
Interview 1::Part 1 – Sean Griffin
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 o…
00:24:50 |
Mon 15 Feb 2016
Bonus 3: Building as a community
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,…
00:12:03 |
Mon 01 Feb 2016
e010: Macros rule!
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 t…
00:16:32 |
Mon 18 Jan 2016
e009: Composing a Rustic tune
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 compos…
00:17:23 |
Sat 09 Jan 2016
e008: Just like something else
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 …
00:17:37 |
Sun 27 Dec 2015
e007: Testify
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 t…
00:18:46 |
Sun 13 Dec 2015
Bonus 2: Legacy Code
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 yo…
00:09:41 |
Sun 06 Dec 2015
Bonus 1: Polyglot Programming Promises and Perils
Polyglot Programming Promises and Perils
Sometimes, you’re doing a technical interview, and you just cannot figure out why your JavaScript function isn’t behaving like it should… and then, prompted b…
00:08:28 |
Wed 25 Nov 2015
e006: Modularize this!
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 fe…
00:18:22 |
Mon 16 Nov 2015
e005: Allocate it where?
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 dis…
00:18:30 |
Sun 08 Nov 2015
e004: Functionalized
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 …
00:17:07 |
Fri 30 Oct 2015
e003: No. more. nulls.
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 e…
00:16:51 |
Wed 21 Oct 2015
Disclaimer: The podcast and artwork embedded on this page are the property of Chris Krycho. This content is not affiliated with or endorsed by eachpod.com.