Synopses & Reviews
If you’re an experienced Ruby programmer, Effective Ruby will help you harness Ruby’s full power to write more robust, efficient, maintainable, and well-performing code. Drawing on nearly a decade of Ruby experience, Peter J. Jones brings together 48 Ruby best practices, expert tips, and shortcuts—all supported by realistic code examples.
Jones offers practical advice for each major area of Ruby development, from modules to memory to metaprogramming. Throughout, he uncovers little-known idioms, quirks, pitfalls, and intricacies that powerfully impact code behavior and performance.
Each item contains specific, actionable, clearly organized guidelines; careful advice; detailed technical arguments; and illuminating code examples. When multiple options exist, Jones shows you how to choose the one that will work best in your situation.
Effective Ruby will help you systematically improve your code—not by blindly following rules, but by thoroughly understanding Ruby programming techniques.
Key features of this concise guide include
- How to avoid pitfalls associated with Ruby’s sometimes surprising idiosyncrasies
- What you should know about inheritance hierarchies to successfully use Rails (and other large frameworks)
- How to use misunderstood methods to do amazingly useful things with collections
- Better ways to use exceptions to improve code reliability
- Powerful metaprogramming approaches (and techniques to avoid)
- Practical, efficient testing solutions, including MiniTest Unit and Spec Testing
- How to reliably manage RubyGem dependencies
- How to make the most of Ruby’s memory management and profiling tools
- How to improve code efficiency by understanding the Ruby interpreter’s internals
Review
“This book is quite unlike any other Ruby book, and in a couple hundred pages, I imagine anyone who reads this—novice or expert—will emerge a better Ruby programmer.”
—From the Foreword by Mitchell Hashimoto, founder and CEO of HashiCorp, creator of Vagrant
Synopsis
Effective Ruby will help experienced Ruby programmers harness all of Ruby's power to write more robust, efficient, maintainable, and well-performing code. Utilizing the concise, scenario-driven style pioneered in Scott Meyers's best-selling Effective C++, Peter Jones brings together 50 Ruby best practices, tips, shortcuts, and realistic code examples from expert programmers.
Through realistic examples, Jones uncovers little-known Ruby quirks, pitfalls, and intricacies that powerfully impact code behavior and performance. You'll learn how to choose the most efficient and effective way to accomplish key tasks when multiple options exist, and how to write code that's easier to understand, maintain, and improve. Drawing on his deep understanding of Ruby's capabilities, Jones offers practical advice for each major area of Ruby development, including:
- Modules, classes, and objects
- Collections
- Exceptions
- Metaprogramming
- Testing
- Memory and object management
Each section contains specific, actionable guidelines organized into items, each with carefully worded advice supported by detailed technical arguments and illuminating examples. Using Effective Ruby, developers can systematically improve their code: not by blindly following rules, but by gaining a deep understanding of the technical reasons why those rules of thumb make sense.
About the Author
Peter J. Jones has been working professionally with Ruby since 2005. He began programming before he learned how to use a keyboard properly after stumbling upon a Commodore 64, a few code listings, and some cassette tapes. Peter is a freelance software engineer and a senior instructor for programming related workshops taught by Devalot.com.
Table of Contents
Foreword xi
Preface xiii
Acknowledgments xvii
About the Author xix
Chapter 1: Accustoming Yourself to Ruby 1
Item 1: Understand What Ruby Considers to Be True 1
Item 2: Treat All Objects as If They Could Be nil 3
Item 3: Avoid Ruby’s Cryptic Perlisms 6
Item 4: Be Aware That Constants Are Mutable 9
Item 5: Pay Attention to Run-Time Warnings 12
Chapter 2: Classes, Objects, and Modules 17
Item 6: Know How Ruby Builds Inheritance Hierarchies 17
Item 7: Be Aware of the Different Behaviors of super 24
Item 8: Invoke super When Initializing Subclasses 28
Item 9: Be Alert for Ruby’s Most Vexing Parse 31
Item 10: Prefer Struct to Hash for Structured Data 35
Item 11: Create Namespaces by Nesting Code in Modules 38
Item 12: Understand the Different Flavors of Equality 43
Item 13: Implement Comparison via “<=>” and the Comparable Module 49
Item 14: Share Private State through Protected Methods 53
Item 15: Prefer Class Instance Variables to Class Variables 55
Chapter 3: Collections 59
Item 16: Duplicate Collections Passed as Arguments before Mutating Them 59
Item 17: Use the Array Method to Convert nil and Scalar Objects into Arrays 63
Item 18: Consider Set for Efficient Element Inclusion Checking 66
Item 19: Know How to Fold Collections with reduce 70
Item 20: Consider Using a Default Hash Value 74
Item 21: Prefer Delegation to Inheriting from Collection Classes 79
Chapter 4: Exceptions 85
Item 22: Prefer Custom Exceptions to Raising Strings 85
Item 23: Rescue the Most Specific Exception Possible 90
Item 24: Manage Resources with Blocks and ensure 94
Item 25: Exit ensure Clauses by Flowing Off the End 97
Item 26: Bound retry Attempts, Vary Their Frequency, and Keep an Audit Trail 100
Item 27: Prefer throw to raise for Jumping Out of Scope 104
Chapter 5: Metaprogramming 107
Item 28: Familiarize Yourself with Module and Class Hooks 107
Item 29: Invoke super from within Class Hooks 114
Item 30: Prefer define_method to method_missing 115
Item 31: Know the Difference between the Variants of eval 122
Item 32: Consider Alternatives to Monkey Patching 127
Item 33: Invoke Modified Methods with Alias Chaining 133
Item 34: Consider Supporting Differences in Proc Arity 136
Item 35: Think Carefully Before Using Module Prepending 141
Chapter 6: Testing 145
Item 36: Familiarize Yourself with MiniTest Unit Testing 145
Item 37: Familiarize Yourself with MiniTest Spec Testing 149
Item 38: Simulate Determinism with Mock Objects 152
Item 39: Strive for Effectively Tested Code 156
Chapter 7: Tools and Libraries 163
Item 40: Know How to Work with Ruby Documentation 163
Item 41: Be Aware of IRB’s Advanced Features 166
Item 42: Manage Gem Dependencies with Bundler 170
Item 43: Specify an Upper Bound for Gem Dependencies 175
Chapter 8: Memory Management and Performance 179
Item 44: Familiarize Yourself with Ruby’s Garbage Collector 179
Item 45: Create Resource Safety Nets with Finalizers 185
Item 46: Be Aware of Ruby Profiling Tools 189
Item 47: Avoid Object Literals in Loops 195
Item 48: Consider Memoizing Expensive Computations 197
Epilogue 201
Index 203