Refactoring in Ruby (Adobe Reader)
Description
The First Hands-On, Practical, All-Ruby Refactoring Workbook!
Refactoring-the art of improving the design of existing code-has taken the world by storm. So has Ruby. Now, for the first time, there's a refactoring workbook that's been designed from the ground up for the Ruby dynamic language-not adapted from compiled languages like Java or C++.
Refactoring in Ruby gives you all the realistic, hands-on practice you need to refactor Ruby code quickly and effectively. You'll discover how to recognize "code smells" that signal opportunities for improvement, and then improve your program's design one small, safe step at a time.
You'll learn when and how to refactor with both legacy code and during new test-driven development, and walk through a real-world refactoring in detail. The book concludes with several large programs designed to help you practice refactoring in several realistic domains, plus a handy code review checklist you'll use constantly. Along the way, you'll learn powerful lessons about designing higher-quality Ruby software: lessons that will help you experience the joy of writing great code-not just occasionally, but constantly.
Refactoring in Rubywill help you
- Identify signs of poor Ruby code design, and systematically improve existing software
- Understand the undesirable consequences of poor code design, and the tradeoffs associated with fixing it
- Recognize why poor code design occurs, so you can prevent it from occurring in your own code
- Master better design techniques that lead to more efficient, reliable, and maintainable software
- Practice analyzing code, so you can become more effective at it
- Fix code that's too long, large, or difficult to follow
- Ferret out duplication, and express each idea "once and only once"
- Use naming standards that provide a clear mental model for everyone who works with your code
- Improve and generalize conditional logic-and avoid using it as a "weak" substitute for object-oriented mechanisms
- Recognize missing or inadequately formed classes
- Simplify overly complex relationships between classes and their subclasses
- Achieve the right balance of responsibilities amongst objects
- Make your code easier to test and change
- Cope with incomplete library modules, and fix runaway dependencies
- Learn the next steps to take after you refactor
- Choose the right Ruby refactoring tools for your environment
More details
Other editions
Additional editions
Persons
William C. Wake is a senior consultant with Industrial Logic, Inc. From 2007 to early 2009, he managed development at Gene Codes Forensics, Inc., a producer of bioinformatics software. From 2001 through 2006, he was an independent consultant focused on agile software. He's the author of the Refactoring Workbook (Addison-Wesley, 2004) and coauthor of Design Patterns in Java (Addison-Wesley, 2006). His web site is www.xp123.com.
Kevin Rutherford, Ph.D., is an independent agile and TDD coach based in the United Kingdom. He has worked in software development for more than 25 years, and since 1997 has been coaching organizations to become highly responsive service providers. He founded the U.K.'s AgileNorth group and is regularly involved on the agile conference circuit. His working practices focus on use of the Theory of Constraints and code quality, and he is the author of the Reek tool for Ruby. His web site is www.kevinrutherford.co.uk.
Content
Foreword xvii
Preface xix
About the Authors xxiii
Part I: The Art of Refactoring 1
Chapter 1: A Refactoring Example 3
Sparkline Script 3
Consistency 6
Testability 8
Greedy Methods 8
Greedy Module 9
Comments 10
Whole Objects 11
Feature Envy 12
Uncommunicative Names 14
Derived Values 15
Wabi-Sabi 17
Summing Up 18
What's Next 18
Chapter 2: The Refactoring Cycle 19
What Is Refactoring? 19
Smells Are Problems 20
The Refactoring Cycle 21
When Are We Done? 21
Test-Driven/Behavior-Driven Development 22
Exercise 23
What's Next 23
Chapter 3: Refactoring Step by Step 25
The Refactoring Environment 25
Inside a Refactoring 26
The Generic Refactoring Micro-Process 30
Exercises 33
What's Next 33
Chapter 4: Refactoring Practice 35
Read Other Books 35
Practice Refactoring 35
Exercises to Try 36
Participate in the Community 37
Exercise 38
What's Next 38
Part II: Code Smells 39
Chapter 5: Measurable Smells 41
Comments 42
Long Method 44
Large Module 46
Long Parameter List 48
Exercises 49
Chapter 6: Names 57
Type Embedded in Name 59
Uncommunicative Name 60
Inconsistent Names 61
Exercises 62
Chapter 7: Unnecessary Complexity 65
Dead Code 66
Speculative Generality 68
Greedy Method 70
Procedural Code 72
Dynamic Code Creation 74
Exercises 76
Chapter 8: Duplication 79
Derived Value 80
Repeated Value 81
Duplicated Code 83
Alternative Modules with Different Interfaces 85
Exercises 86
Chapter 9: Conditional Logic 93
Nil Check 94
Special Case 96
Complicated Boolean Expression 98
Control Coupling 100
Simulated Polymorphism 101
Exercises 103
Chapter 10: Data 107
Open Secret 108
Data Class 110
Data Clump 112
Temporary Field 114
Exercises 115
Chapter 11: Inheritance 125
Implementation Inheritance 126
Refused Bequest 128
Inappropriate Intimacy (Subclass Form) 130
Lazy Class 131
Exercises 133
Chapter 12: Responsibility 135
Feature Envy 136
Utility Function 138
Global Variable 140
Inappropriate Intimacy (General Form) 141
Message Chain 143
Middle Man 145
Greedy Module 146
Exercises 148
Chapter 13: Accommodating Change 153
Divergent Change 154
Shotgun Surgery 156
Parallel Inheritance Hierarchies 158
Combinatorial Explosion 159
Exercises 160
Chapter 14: Libraries 163
Incomplete Library Module 164
Reinvented Wheel 166
Runaway Dependencies 167
Exercises 168
Part III: Programs to Refactor 171
Chapter 15: A Simple Game 173
Code 173
Refactoring 175
Development Episodes 180
Chapter 16: Time Recording 183
Preparing the Soil 187
Substitute Algorithm 191
Optional Extras 194
Chapter 17: Calculator 197
Code 198
Refactoring 209
Thank You 211
Part IV: Appendices 213
Appendix A: Answers to Selected Questions 215
The Refactoring Cycle 215
Refactoring Step by Step 216
Refactoring Practice 216
Measurable Smells 217
Names 220
Unnecessary Complexity 222
Duplication 225
Conditional Logic 230
Data 233
Inheritance 237
Responsibility 239
Accommodating Change 241
Libraries 244
A Simple Game 246
Time Recording 247
Appendix B: Ruby Refactoring Tools 251
Code Smell Detectors 251
Environments with Refactoring Support 252
Bibliography 253
Index 255
