Muutke küpsiste eelistusi

E-raamat: Refactoring: Ruby Edition

4.24/5 (8778 hinnangut Goodreads-ist)
  • Formaat - EPUB+DRM
  • Hind: 18,52 €*
  • * hind on lõplik, st. muud allahindlused enam ei rakendu
  • Lisa ostukorvi
  • Lisa soovinimekirja
  • See e-raamat on mõeldud ainult isiklikuks kasutamiseks. E-raamatuid ei saa tagastada.

DRM piirangud

  • Kopeerimine (copy/paste):

    ei ole lubatud

  • Printimine:

    ei ole lubatud

  • Kasutamine:

    Digitaalõiguste kaitse (DRM)
    Kirjastus on väljastanud selle e-raamatu krüpteeritud kujul, mis tähendab, et selle lugemiseks peate installeerima spetsiaalse tarkvara. Samuti peate looma endale  Adobe ID Rohkem infot siin. E-raamatut saab lugeda 1 kasutaja ning alla laadida kuni 6'de seadmesse (kõik autoriseeritud sama Adobe ID-ga).

    Vajalik tarkvara
    Mobiilsetes seadmetes (telefon või tahvelarvuti) lugemiseks peate installeerima selle tasuta rakenduse: PocketBook Reader (iOS / Android)

    PC või Mac seadmes lugemiseks peate installima Adobe Digital Editionsi (Seeon tasuta rakendus spetsiaalselt e-raamatute lugemiseks. Seda ei tohi segamini ajada Adober Reader'iga, mis tõenäoliselt on juba teie arvutisse installeeritud )

    Seda e-raamatut ei saa lugeda Amazon Kindle's. 

The Definitive Refactoring Guide, Fully Revamped for Ruby

 

With refactoring, programmers can transform even the most chaotic software into well-designed systems that are far easier to evolve and maintain. What’s more, they can do it one step at a time, through a series of simple, proven steps. Now, there’s an authoritative and extensively updated version of Martin Fowler’s classic refactoring book that utilizes Ruby examples and idioms throughout–not code adapted from Java or any other environment.

 

The authors introduce a detailed catalog of more than 70 proven Ruby refactorings, with specific guidance on when to apply each of them, step-by-step instructions for using them, and example code illustrating how they work. Many of the authors’ refactorings use powerful Ruby-specific features, and all code samples are available for download.

 

Leveraging Fowler’s original concepts, the authors show how to perform refactoring in a controlled, efficient, incremental manner, so you methodically improve your code’s structure without introducing new bugs. Whatever your role in writing or maintaining Ruby code, this book will be an indispensable resource.

 

This book will help you

•    Understand the core principles of refactoring and the reasons for doing it

•    Recognize “bad smells” in your Ruby code

•    Rework bad designs into well-designed code, one step at a time

•    Build tests to make sure your refactorings work properly

•    Understand the challenges of refactoring and how they can be overcome

•    Compose methods to package code properly

•    Move features between objects to place responsibilities where they fit best

•    Organize data to make it easier to work with

•    Simplify conditional expressions and make more effective use of polymorphism

•    Create interfaces that are easier to understand and use

•    Generalize more effectively

•    Perform larger refactorings that transform entire software systems and may take months or years

•    Successfully refactor Ruby on Rails code

Foreword xiii
Preface xv
Acknowledgments xx
About the Authors xxii
Chapter 1 Refactoring, a First Example
1(50)
The Starting Point
2(4)
The First Step in Refactoring
6(1)
Decomposing and Redistributing the Statement Method
7(25)
Replacing the Conditional Logic on Price Code with Polymorphism
32(18)
Final Thoughts
50(1)
Chapter 2 Principles in Refactoring
51(22)
Where Did Refactoring Come From?
51(1)
Defining Refactoring
52(2)
Why Should You Refactor?
54(3)
When Should You Refactor?
57(3)
Why Refactoring Works
60(1)
What Do I Tell My Manager?
61(1)
Indirection and Refactoring
61(2)
Problems with Refactoring
63(4)
Refactoring and Design
67(2)
It Takes A While to Create Nothing
69(1)
Refactoring and Performance
70(1)
Optimizing a Payroll System
71(2)
Chapter 3 Bad Smells in Code
73(14)
Duplicated Code
74(1)
Long Method
74(2)
Large Class
76(1)
Long Parameter List
76(1)
Divergent Change
77(1)
Shotgun Surgery
78(1)
Feature Envy
78(1)
Data Clumps
79(1)
Primitive Obsession
79(1)
Case Statements
80(1)
Parallel Inheritance Hierarchies
81(1)
Lazy Class
81(1)
Speculative Generality
81(1)
Temporary Field
82(1)
Message Chains
82(1)
Middle Man
83(1)
Inappropriate Intimacy
83(1)
Alternative Classes with Different Interfaces
83(1)
Incomplete Library Class
84(1)
Data Class
84(1)
Refused Bequest
84(1)
Comments
85(1)
Metaprogramming Madness
86(1)
Disjointed API
86(1)
Repetitive Boilerplate
86(1)
Chapter 4 Building Tests
87(10)
The Value of Self-Testing Code
87(1)
The Test::Unit Testing Framework
88(3)
Developer and Quality Assurance Tests
91(1)
Adding More Tests
92(5)
Chapter 5 Toward a Catalog of Refactorings
97(4)
Format of the Refactorings
97(2)
Finding References
99(2)
Chapter 6 Composing Methods
101(66)
Extract Method
102(6)
Inline Method
108(2)
Inline Temp
110(1)
Replace Temp with Query
111(3)
Replace Temp with Chain
114(3)
Introduce Explaining Variable
117(4)
Split Temporary Variable
121(3)
Remove Assignments to Parameters
124(3)
Replace Method with Method Object
127(4)
Substitute Algorithm
131(2)
Replace Loop with Collection Closure Method
133(2)
Extract Surrounding Method
135(4)
Introduce Class Annotation
139(3)
Introduce Named Parameter
142(5)
Remove Named Parameter
147(3)
Remove Unused Default Parameter
150(2)
Dynamic Method Definition
152(6)
Replace Dynamic Receptor with Dynamic Method Definition
158(2)
Isolate Dynamic Receptor
160(5)
Move Eval from Runtime to Parse Time
165(2)
Chapter 7 Moving Features Between Objects
167(20)
Move Method
167(5)
Move Field
172(3)
Extract Class
175(4)
Inline Class
179(2)
Hide Delegate
181(4)
Remove Middle Man
185(2)
Chapter 8 Organizing Data
187(74)
Self Encapsulate Field
188(3)
Replace Data Value with Object
191(3)
Change Value to Reference
194(4)
Change Reference to Value
198(3)
Replace Array with Object
201(5)
Replace Hash with Object
206(4)
Change Unidirectional Association to Bidirectional
210(3)
Change Bidirectional Association to Unidirectional
213(4)
Replace Magic Number with Symbolic Constant
217(2)
Encapsulate Collection
219(5)
Replace Record with Data Class
224(1)
Replace Type Code with Polymorphism
225(7)
Replace Type Code with Module Extension
232(7)
Replace Type Code with State/Strategy
239(12)
Replace Subclass with Fields
251(4)
Lazily Initialized Attribute
255(2)
Eagerly Initialized Attribute
257(4)
Chapter 9 Simplifying Conditional Expressions
261(36)
Decompose Conditional
261(3)
Recompose Conditional
264(1)
Consolidate Conditional Expression
265(3)
Consolidate Duplicate Conditional Fragments
268(1)
Remove Control Flag
269(5)
Replace Nested Conditional with Guard Clauses
274(5)
Replace Conditional with Polymorphism
279(5)
Introduce Null Object
284(8)
Introduce Assertion
292(5)
Chapter 10 Making Method Calls Simpler
297(56)
Rename Method
298(2)
Add Parameter
300(2)
Remove Parameter
302(1)
Separate Query from Modifier
303(4)
Parameterize Method
307(3)
Replace Parameter with Explicit Methods
310(3)
Preserve Whole Object
313(4)
Replace Parameter with Method
317(3)
Introduce Parameter Object
320(4)
Remove Setting Method
324(3)
Hide Method
327(1)
Replace Constructor with Factory Method
328(4)
Replace Error Code with Exception
332(5)
Replace Exception with Test
337(4)
Introduce Gateway
341(5)
Introduce Expression Builder
346(7)
Chapter 11 Dealing with Generalization
353(44)
Pull Up Method
353(3)
Push Down Method
356(1)
Extract Module
357(5)
Inline Module
362(1)
Extract Subclass
363(5)
Introduce Inheritance
368(3)
Collapse Heirarchy
371(1)
Form Template Method
372(14)
Replace Inheritance with Delegation
386(3)
Replace Delegation with Hierarchy
389(3)
Replace Abstract Superclass with Module
392(5)
Chapter 12 Big Refactorings
397(20)
The Nature of the Game
397(1)
Why Big Refactorings Are Important
398(1)
Four Big Refactorings
398(1)
Tease Apart Inheritance
399(6)
Convert Procedural Design to Objects
405(1)
Separate Domain from Presentation
406(6)
Extract Hierarchy
412(5)
Chapter 13 Putting It All Together
417(4)
References 421(2)
Index 423
Jay Fields is a software developer for DRW Trading and a frequent conference presenter. Jay has a passion for discovering and maturing innovative solutions. Jays website is available at www.jayfields.com.

 

Shane Harvie has delivered software in Agile environments in the United States, India, and Australia. He works for DRW Trading in Chicago and blogs at www.shaneharvie.com.

 

Martin Fowler is Chief Scientist at ThoughtWorks and one of the worlds leading experts in the effective design of enterprise software. He has pioneered object-oriented development, patterns, agile methodologies, domain modeling, UML, and Extreme Programming. His books include Refactoring, Analysis Patterns, and UML Distilled. His book, Patterns of Enterprise Application Architecture, won Software Developments Jolt Productivity Award and Javaworld.coms best Java book award.