New Rustacean

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 down. ### Corrigenda Sean noted he could be wrong about `IEnumerable` not having a `Sum` method in C♯, and post-show research indicated that he was (it's possible it was added after he had stopped doing .NET work, of course). See the [documentation][c1] for details on how `IEnumerable.Sum` it behaves in C♯ if you're curious. As a related note, I (Chris) have done a little bit of digging on C♯ in the interval and it's fair to say that while a lot of the "ceremony" involved in writing C♯ is annoying, it's much more than just a "slightly nicer Java", and indeed is a much nicer language than my previous, limited exposure had led me to believe. It's no Rust or F♯, but its type system is substantially more capable than Java's. [c1]: https://msdn.microsoft.com/library/bb919210(v=vs.90).aspx Links ----- - fmap + [Discussion of `fmap` with `Optional` in Swift][l1] + [In Haskell][l2] - Rust: + [Trait objects][l3] + [Specialization RFC][l4] * [Implementation][l5] - [Diesel][l6] [l1]: https://robots.thoughtbot.com/functional-swift-for-dealing-with-optional-values [l2]: http://learnyouahaskell.com/functors-applicative-functors-and-monoids [l3]: https://doc.rust-lang.org/book/trait-objects.html [l4]: https://github.com/rust-lang/rfcs/pull/1210 [l5]: https://github.com/rust-lang/rust/issues/31844 [l6]: https://github.com/sgrif/diesel Sponsors -------- - Aleksey Pirogov - Chris Palmer - [Derek Morr][s3] - Hamza Sheikh - Leif Arne Storset - Luca Schmid - Micael Bergeron - Ralph Giles ("rillian") - reddraggone9 - Ryan Ollos - [William Roe][s11] [s3]: https://twitter.com/derekmorr [s11]: http://willroe.me ### Become a sponsor - Patreon - [Venmo](https://venmo.com/chriskrycho) - [Dwolla](https://www.dwolla.com/hub/chriskrycho) - [Cash.me](https://cash.me/$chriskrycho) Follow ------ - New Rustacean: + Twitter: [@newrustacean](https://www.twitter.com/newrustacean) + Email: [[email protected]](mailto:[email protected]) - Chris Krycho + GitHub: [chriskrycho](https://github.com/chriskrycho) + Twitter: [@chriskrycho](https://www.twitter.com/chriskrycho)

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 - Aleksey Pirogov - Chris Palmer - Derek Morr - Hamza Sheikh - Leif Arne Storset - Luca Schmid - Micael Bergeron - Ralph Giles (“rillian”) - reddraggone9 - Ryan Ollos - William Roe Become a sponsor - Patreon - Venmo - Dwolla - Cash.me Follow - New Rustacean: - Twitter: @newrustacean - Email: [email protected] - Chris Krycho - GitHub: chriskrycho - Twitter: @chriskrycho

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 good community, how Rust's community has done well so far, and then how to keep building a good community and how to build good things *as* a community. Sponsors - Aleksey Pirogov - Chris Palmer - Derek Morr - Hamza Sheikh - Luca Schmid - Micael Bergeron - Ralph Giles (“rillian”) - reddraggone9 - William Roe Become a sponsor - Patreon.com/newrustacean - Venmo.com/chriskrycho - Dwolla.com/hub/chriskrycho - Cash.me/$chriskrycho Follow - New Rustacean: - Twitter: @newrustacean - App.net: @newrustacean - Email: [email protected] - Chris Krycho - Twitter: @chriskrycho - App.net: @chriskrycho

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 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. Sponsors - Aleksey Pirogov - Chris Palmer - Derek Morr - Hamza Sheikh - Luca Schmid - Micael Bergeron - Ralph Giles (“rillian”) - reddraggone9 - William Roe Become a sponsor - Patreon.com/newrustacean - Venmo.com/chriskrycho - Dwolla.com/hub/chriskrycho - Cash.me/$chriskrycho Follow - New Rustacean: - Twitter: @newrustacean - App.net: @newrustacean - Email: [email protected] - Chris Krycho - Twitter: @chriskrycho - App.net: @chriskrycho

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! Links - Nick Cameron: “Thoughts on Rust in 2016” - “Upcoming breakage starting in Rust 1.7, from RFCs 1214 and 136” - RFC 1214: Clarify (and improve) rules for projections and well-formedness - RFC 136: Ban private items in public APIs - The Rust Book: - Traits - Trait objects (dynamic dispatch) - The Rust reference: - std::iter and std::iter::Iterator - Add - Drop - PartialEq and Eq - PartialOrd and Ord - Special traits - Trait objects - RFC: impl specialization - Aaron Turon: “Specialize to reuse” Sponsors - Aleksey Pirogov - Chris Palmer - Derek Morr - Hamza Sheikh - Luca Schmid - Micael Bergeron - Ralph Giles (“rillian”) - reddraggone9 - William Roe Become a sponsor - Patreon.com/newrustacean - Venmo.com/chriskrycho - Dwolla.com/hub/chriskrycho - Cash.me/$chriskrycho Follow - New Rustacean: - Twitter: @newrustacean - App.net: @newrustacean - Email: [email protected] - Chris Krycho - Twitter: @chriskrycho - App.net: @chriskrycho

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 - Patreon/newrustacean - Venmo.com/chriskrycho - Dwolla.com/hub/chriskrycho - Cash.me/$chriskrycho Follow - New Rustacean: - Twitter: @newrustacean - App.net: @newrustacean - Email: [email protected] - Chris Krycho - Twitter: @chriskrycho - App.net: @chriskrycho

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 - Patreon.com/newrustacean - Venmo.com/chriskrycho - Dwolla.com/hub/chriskrycho - Cash.me/$chriskrycho Follow - New Rustacean: - Twitter: @newrustacean - App.net: @newrustacean - Email: [email protected] - Chris Krycho - Twitter: @chriskrycho - App.net: @chriskrycho

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 - Patreon.com/newrustacean - Venmo.com/chriskrycho - Dwolla.com/hub/chriskrycho - Cash.me/$chriskrycho FOLLOW - New Rustacean: - Twitter: @newrustacean - App.net: @newrustacean - Email: [email protected] - Chris Krycho - Twitter: @chriskrycho - App.net: @chriskrycho

Links

Sponsors

Become a sponsor

Follow

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 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 (Podcast.__init__) Become a sponsor - https://www.patreon.com/newrustacean - https://venmo.com/chriskrycho - dwolla.com/hub/chriskrycho - ttps://cash.me/$chriskrycho