Steve Klabnik



Average rating: 4.31 · 413 ratings · 55 reviews · 5 distinct worksSimilar authors
The Rust Programming Language

4.36 avg rating — 358 ratings9 editions
Rate this book
Clear rating
Designing Hypermedia APIs

3.10 avg rating — 10 ratings
Rate this book
Clear rating
Rust for Rubyists

2.71 avg rating — 7 ratings
Rate this book
Clear rating
CLOSURE

by
4.45 avg rating — 31 ratings — published 2013
Rate this book
Clear rating
Rails 4 in Action: Revised ...

by
really liked it 4.00 avg rating — 33 ratings — published 2013 — 2 editions
Rate this book
Clear rating
More books by Steve Klabnik…

Upcoming Events

No scheduled events. Add an event.

“Inheritance has recently fallen out of favor as a programming design solution in many programming languages because it’s often at risk of sharing more code than necessary. Subclasses shouldn’t always share all characteristics of their parent class but will do so with inheritance. This can make a program’s design less flexible. It also introduces the possibility of calling methods on subclasses that don’t make sense or that cause errors because the methods don’t apply to the subclass. In addition, some languages will only allow a subclass to inherit from one class, further restricting the flexibility of a program’s design.

For these reasons, Rust takes a different approach, using trait objects instead of inheritance.”
Steve Klabnik, The Rust Programming Language

“Rust’s central feature is ownership. Although the feature is straightforward to explain, it has deep implications for the rest of the language.

All programs have to manage the way they use a computer’s memory while running. Some languages have garbage collection that constantly looks for no longer used memory as the program runs; in other languages, the programmer must explicitly allocate and free the memory. Rust uses a third approach: memory is managed through a system of ownership with a set of rules that the compiler checks at compile time. None of the ownership features slow down your program while it’s running.”
Steve Klabnik, The Rust Programming Language

“In languages with a garbage collector (GC), the GC keeps track and cleans up memory that isn’t being used anymore, and we don’t need to think about it. Without a GC, it’s our responsibility to identify when memory is no longer being used and call code to explicitly return it, just as we did to request it. Doing this correctly has historically been a difficult programming problem. If we forget, we’ll waste memory. If we do it too early, we’ll have an invalid variable. If we do it twice, that’s a bug too. We need to pair exactly one allocate with exactly one free.

Rust takes a different path: the memory is automatically returned once the variable that owns it goes out of scope.”
Steve Klabnik, The Rust Programming Language



Is this you? Let us know. If not, help out and invite Steve to Goodreads.