Effective Ruby: 48 Specific Ways to Write Better Ruby, Rough Cuts

Description

• Copyright 2015
• Dimensions: 7" x 9-1/8"
• Pages: 240
• Edition: 1st

• Rough Cuts
• ISBN-10: 0-13-384705-5
• ISBN-13: 978-0-13-384705-5

This is the Rough Cut version of the printed book.

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



Sample Content

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



Updates

Submit Errata

