New Rustacean

New Rustacean
Let’s try some Rust, shall we?
Meta 2: Two milestones
Sep 25 • 12 min
CYSK: Rayon
Sep 16 • 14 min
Safe, threaded, parallel code in Rust!
News: Rust 1.20
Aug 31 • 13 min
Associated constants, conference season, meetups, and more!
Bonus 9: Open source is mostly just normal people
Aug 14
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 • 17 min
Using type aliases and creating custom type wrappers for more expressive and safer code.
News 3: Increasing Rust’s Reach
Jul 4 • 13 min
Growing Rust’s diversity to help Rust grow.
CYSK: Rocket
Jun 30 • 17 min
An accessible, well-designed web framework in Rust!
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.
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…