News
**New Rustacean**

A show about the Rust programming language and the people who use it.

Latest Episodes:

e010: Macros rule! Jan 18, 2016

Show notes

Macros rule!

Notes

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 show_notes crate documentation, rather than within the documentation for this module. (See the Rust Book discussion of documenting macros for details.) Even so, the source is still in this module; see the implementations for details.

Become a sponsor

Follow

New Rustacean:
- Twitter: @newrustacean
- App.net: @newrustacean
- Email: hello@newrustacean.com
Chris Krycho
- Twitter: @chriskrycho
- App.net: @chriskrycho

e009: Composing a Rustic tune Jan 09, 2016

Show notes

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 multiple traits on a single type.

We also talk about the syntax for traits, the use of marker traits, some of the things you can’t presently do with traits, and even just a smidge about the future of traits in Rust. All that in less than 20 minutes!

You’ll find today’s source example fairly interesting, I think: it’s just one type, but it uses almost every concept discussed on the show today!

Become a sponsor

Follow

New Rustacean:
- Twitter: @newrustacean
- App.net: @newrustacean
- Email: hello@newrustacean.com
Chris Krycho
- Twitter: @chriskrycho
- App.net: @chriskrycho

e008: Just like something else Dec 27, 2015

Show notes

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 to specify behavior which can be implemented for more than one type. The combination gives us powerful tools for higher-level programming constructs in Rust.

Comments on source code

Now that we have a handle on how tests work, we’ll use them to validate the behavior of our code going forward. This is great: we can show that the tests do what we think.

To today’s point, though: we actually know even apart from whether the tests run successfully that these generic functions and the associated traits are behaving as we want. Failure with generics is a compile-time error, not a runtime error.

Sponsors

Chris Palmer
Derek Morr
Luca Schmid
Micael Bergeron
Ralph Giles (“rillian”)
reddraggone9
William Roe

Become a sponsor

Follow

New Rustacean:
- Twitter: @newrustacean
- App.net: @newrustacean
- Email: hello@newrustacean.com
Chris Krycho
- Twitter: @chriskrycho
- App.net: @chriskrycho

e007: Testify Dec 13, 2015

Show notes

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 benchmarks in Rust.

The detailed code samples for this episode are heavy on showing; because of the nature of test functions, you will be best off just reading the source rather than leaning heavily on the descriptions generated by rustdoc. (The descriptions are still there, but they’re much less useful than they have been in previous episodes.) In particular, the test module here is excluded because of the use of the #[cfg(test)] attribute marker on it.

Because we are using the feature-gated benchmarking functionality, the show notes “library” can now only be compiled with the Rust nightly (as of 1.5, the version current as this episode is produced).

One thing that isn’t necessarily obvious from reading the test documentation in the Rust book and Rust reference: the extern crate test statement needs to be not in this module, but at the module (lib.rs) which defines the library/crate; in this case, show_notes/lib.rs.

Sponsors

Chris Palmer
Derek Morr
Luca Schmid
Micael Bergeron
Ralph Giles (“rillian”)
reddraggone9
William Roe

Become a sponsor

Follow

New Rustacean:
- Twitter: @newrustacean
- App.net: @newrustacean
- Email: hello@newrustacean.com
Chris Krycho
- Twitter: @chriskrycho
- App.net: @chriskrycho

Bonus 2: Legacy Code Dec 06, 2015

Show notes

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 you opt for smaller clean-up jobs because, however ugly, what is already present works?

Sponsors

Chris Palmer
Derek Morr
Luca Schmid
Micael Bergeron
Ralph Giles (“rillian”)
reddraggone9
William Roe

Become a sponsor

Follow

New Rustacean:
- Twitter: @newrustacean
- App.net: @newrustacean
- Email: hello@newrustacean.com
Chris Krycho
- Twitter: @chriskrycho
- App.net: @chriskrycho

Bonus 1: Polyglot Programming Promises and Perils Nov 25, 2015

Show notes

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 by the interviewer, you realize that you’re not returning anything. Polyglot programming is beautiful, and wonderful, and sometimes it bites you when you aren’t looking.

Sponsors

reddraggone9
Chris Patti

Become a sponsor

Follow

New Rustacean:
- Twitter: @newrustacean
- App.net: @newrustacean
- Email: hello@newrustacean.com
Chris Krycho
- Twitter: @chriskrycho
- App.net: @chriskrycho

e006: Modularize this! Nov 16, 2015

Show notes

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 and Modules will be very helpful.

Corrigenda

I accidentally called this episode 5, instead of episode 6. Whoops.

Just before the 15:00 mark, while discussing libraries, I referred to “e006.md” when I meant to say “e006.rs”. Slips of the tongue inspired by the fact that Rust (delightfully) uses Markdown for its documentation.

Sponsors

reddraggone9
Chris Patti

Become a sponsor

Follow

New Rustacean:
- Twitter: @newrustacean
- App.net: @newrustacean
- Email: hello@newrustacean.com
Chris Krycho
- Twitter: @chriskrycho
- App.net: @chriskrycho

e005: Allocate it where? Nov 08, 2015

Show notes

Allocate it where?

Subject: Returning functions from other functions, and thinking about the stack, the heap, and reference types.

MP3

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 need to care about them for returning functions.

The functions themselves are not especially interesting; they just show you the basic form you use to return functions from other functions, and how to then use them in another function. You’ll want to take a detailed look instead at the documentation for each (or just read the source!), because that’s where the meat of the discussion in this week’s code is.

Sponsors

reddraggone9
Chris Patti

Become a sponsor

Follow

New Rustacean:
- Twitter: @newrustacean
- App.net: @newrustacean
- Email: hello@newrustacean.com
Chris Krycho
- Twitter: @chriskrycho
- App.net: @chriskrycho

e004: Functionalized Oct 29, 2015

Show notes

Date: October 29, 2015

Subject: 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
“What is a closure?” (Progammers Stack Exchange) – the first answer is the best, but the second answer may be a helpful stepping stone for people just getting their heads around this and coming from OOP languages like C++ or Java (even though I disagree with the explanation in some ways).
“What is a closure?” (Stack Overflow) – careful, thorough answer using JavaScript as an example.

Follow/Support

New Rustacean:
- Twitter: @newrustacean
- App.net: @newrustacean
- Patreon
- Dwolla
- Email: hello@newrustacean.com
Chris Krycho
- Twitter: @chriskrycho
- App.net: @chriskrycho

e003: No. more. nulls. Oct 21, 2015

Show notes

No More Nulls

Subject: Enumerated (enum) types, pattern matching, and meaningful return types.

Notes

Today’s episode discusses, in order:

Enumerated types, with an eye to the difference between structs and enums, and to the differences between enums in C and in Rust.
Pattern matching, with a focus on using them with enumerated types and some discussion about how they differ from switch blocks in C-like languages.
Using the Option and Result enumerated types with pattern matching to provide meaningful returns from functions safely.

Order

There is a specific order to the examples below, and it is not the automatically-alphabetized order rendered by rustdoc. Instead, you should work through in the sequence they appear in the source:

Follow/Support

New Rustacean:
- Twitter: @newrustacean
- App.net: @newrustacean
- Patreon
- Email: hello at newrustacean dot com
Chris Krycho
- Twitter: @chriskrycho
- App.net: @chriskrycho

Our TOPPODCAST Picks

Follow Us

Stay Connected

New Rustacean

Notes

Links

Sponsors

Become a sponsor

Follow

Notes

Links

Sponsors

Become a sponsor

Follow

Notes

Comments on source code

Links

Sponsors

Become a sponsor

Follow

Notes

Links

Sponsors

Become a sponsor

Follow

Sponsors

Become a sponsor

Follow

Links

Sponsors

Become a sponsor

Follow

Notes

Corrigenda

Links

Sponsors

Become a sponsor

Follow

Notes

Links

Sponsors

Become a sponsor

Follow

Notes

Closures

Links

Follow/Support

Notes

Order

Links

Follow/Support

Related Podcasts

1

2

3

4

5

6