Cantitate/Preț
Produs
Total produse
Vezi coșul
Implementation Patterns de Kent Beck

Implementation Patterns: Addison-Wesley Signature Series (Beck)

Autor Kent Beck
en Limba Engleză Paperback – 30 sep 2007
Programmers make hundreds of decisions a day. Occasionally they make large-scale decisions like those covered by Design Patterns. Far more frequently they make small-scale decisions--choosing names, organizing code logically, dividing programs into coherent parts. The cumulative effect of these hour-by-hour, minute-by-minute decisions is as significant as the effect of the design decisions in making code clear, flexible, and robust. This book is a catalog of the frequent decisions programmers make and the approaches to these decisions that result in code that communicates clearly. Programmers applying Implementation Patterns achieve code that is consistent, easy to read, and easy to modify. It sets out the "bag of tricks" common to excellent programmers in Java and similar languages. Implementation Patterns will appeal to programmers wishing to improve their individual practice, teams finding a common style, and language designers looking for abstractions to add to the next generation of programming languages. The days development teams are bigger, more spread out, and frequently forced to work with legacy applications. Now more than ever clear, communicative code is essential.
Citește tot Restrânge

Preț: 26969 lei

Preț vechi: 33711 lei
-20% Nou

Puncte Express: 405
Preț estimativ în valută:
5161€ • 5347$ • 4307£

Carte tipărită la comandă

Livrare economică 22 martie-05 aprilie

 Adaugă în coș

Wish list
Gift list
Am citit!
Adaugă în listă
Preluare comenzi: 021 569.72.76

Specificații

ISBN-13: 9780321413093
ISBN-10: 0321413091
Pagini: 157
Ilustrații: Illustrations (some col.)
Dimensiuni: 180 x 234 x 12 mm
Greutate: 0.35 kg
Ediția:1
Editura: Addison-Wesley Professional
Seria Addison-Wesley Signature Series (Beck)

Locul publicării:Boston, United States

Descriere

“Kent is a master at creating code that communicates well, is easy to understand, and is a pleasure to read. Every chapter of this book contains excellent explanations and insights into the smaller but important decisions we continuously have to make when creating quality code and classes.”
–Erich Gamma, IBM Distinguished Engineer
 
“Many teams have a master developer who makes a rapid stream of good decisions all day long. Their code is easy to understand, quick to modify, and feels safe and comfortable to work with. If you ask how they thought to write something the way they did, they always have a good reason. This book will help you become the master developer on your team. The breadth and depth of topics will engage veteran programmers, who will pick up new tricks and improve on old habits, while the clarity makes it accessible to even novice developers.”
–Russ Rufer, Silicon Valley Patterns Group
 
“Many people don’t realize how readable code can be and how valuable that readability is. Kent has taught me so much, I’m glad this book gives everyone the chance to learn from him.”
–Martin Fowler, chief scientist, ThoughtWorks
 
“Code should be worth reading, not just by the compiler, but by humans. Kent Beck distilled his experience into a cohesive collection of implementation patterns. These nuggets of advice will make your code truly worth reading.”
–Gregor Hohpe, author of Enterprise Integration Patterns
 
“In this book Kent Beck shows how writing clear and readable code follows from the application of simple principles. Implementation Patterns will help developers write intention revealing code that is both easy to understand and flexible towards future extensions. A must read for developers who are serious about their code.”
–Sven Gorts
 
“Implementation Patterns bridges the gap between design and coding. Beck introduces a new way of thinking about programming by basing his discussion on values and principles.”
–Diomidis Spinellis, author of Code Reading and Code Quality
 
Software Expert Kent Beck Presents a Catalog of Patterns Infinitely Useful for Everyday Programming
 
Great code doesn’t just function: it clearly and consistently communicates your intentions, allowing other programmers to understand your code, rely on it, and modify it with confidence. But great code doesn’t just happen. It is the outcome of hundreds of small but critical decisions programmers make every single day. Now, legendary software innovator Kent Beck–known worldwide for creating Extreme Programming and pioneering software patterns and test-driven development–focuses on these critical decisions, unearthing powerful “implementation patterns” for writing programs that are simpler, clearer, better organized, and more cost effective.
 
Beck collects 77 patterns for handling everyday programming tasks and writing more readable code. This new collection of patterns addresses many aspects of development, including class, state, behavior, method, collections, frameworks, and more. He uses diagrams, stories, examples, and essays to engage the reader as he illuminates the patterns. You’ll find proven solutions for handling everything from naming variables to checking exceptions.
 
This book covers
  • The value of communicating through code and the philosophy behind patterns
  • How and when to create classes, and how classes encode logic
  • Best practices for storing and retrieving state
  • Behavior: patterns for representing logic, including alternative paths
  • Writing, naming, and decomposing methods
  • Choosing and using collections
  • Implementation pattern variations for use in building frameworks
Implementation Patterns will help programmers at all experience levels, especially those who have benefited from software patterns or agile methods. It will also be an indispensable resource for development teams seeking to work together more efficiently and build more maintainable software. No other programming book will touch your day-to-day work more often.

Cuprins

Preface  xv
Chapter 1: Introduction  1
Tour Guide  3
And Now...  4
Chapter 2: Patterns  5
Chapter 3: A Theory of Programming  9
Values  10
Principles  13
Conclusion  18
Chapter 4: Motivation  19
Chapter 5: Class  21
Class  22
Simple Superclass Name  23
Qualified Subclass Name  24
Abstract Interface   24
Interface  26
Abstract Class  26
Versioned Interface  27
Value Object  28
Specialization  31
Subclass  32
Implementor  34
Inner Class  34
Instance-Specific Behavior  36
Conditional  36
Delegation  38
Pluggable Selector  40
Anonymous Inner Class  41
Library Class  41
Conclusion  42
Chapter 6: State  43
State  44
Access  45
Direct Access  46
Indirect Access  47
Common State  47
Variable State  48
Extrinsic State  50
Variable  50
Local Variable  51
Field  52
Parameter  53
Collecting Parameter  55
Optional Parameter  56
Var Args  56
Parameter Object  57
Constant  58
Role-Suggesting Name  58
Declared Type  60
Initialization  61
Eager Initialization  61
Lazy Initialization  62
Conclusion  62
Chapter 7: Behavior  63
Control Flow  64
Main Flow  64
Message  65
Choosing Message  65
Double Dispatch  66
Decomposing (Sequencing) Message  67
Reversing Message  67
Inviting Message  68
Explaining Message  69
Exceptional Flow  70
Guard Clause  70
Exception  72
Checked Exceptions  72
Exception Propagation  73
Conclusion  73
Chapter 8: Methods  75
Composed Method  77
Intention-Revealing Name  79
Method Visibility  80
Method Object  82
Overridden Method  83
Overloaded Method  83
Method Return Type  84
Method Comment  85
Helper Method  85
Debug Print Method  86
Conversion  87
Conversion Method  87
Conversion Constructor  88
Creation  88
Complete Constructor  89
Factory Method  90
Internal Factory  91
Collection Accessor Method  91
Boolean Setting Method  93
Query Method  93
Equality Method  94
Getting Method  95
Setting Method  96
Safe Copy  97
Conclusion  98
Chapter 9: Collections  99
Metaphors  100
Issues  101
Interfaces  103
Implementations  107
Collections  110
Extending Collections  114
Conclusion  115
Chapter 10: Evolving Frameworks  117
Changing Frameworks without Changing Applications  117
Incompatible Upgrades  118
Encouraging Compatible Change  120
Conclusion  129
Appendix A: Performance Measurement  131
Example  131
API  132
Implementation  133
MethodTimer  134
Canceling Overhead  136
Tests  136
Conclusion  142
Bibliography  145
General Programming  145
Philosophy  147
Java  148
Index  149

Notă biografică

Kent Beck, one of the software industry’s most creative and acclaimed leaders, consistently challenges software engineering dogma and promotes ideas like patterns, test-driven development, and Extreme Programming. Currently affiliated with Three Rivers Institute and Agitar Software, he is the author of many Addison-Wesley titles, including Test-Driven Development (2003) and, with Cynthia Andres, Extreme Programming Explained, Second Edition (2005).

Textul de pe ultima copertă

"Kent is a master at creating code that communicates well, is easy to understand, and is a pleasure to read. Every chapter of this book contains excellent explanations and insights into the smaller but important decisions we continuously have to make when creating quality code and classes." -"Erich Gamma, IBM Distinguished Engineer" " " "Many teams have a master developer who makes a rapid stream of good decisions all day long. Their code is easy to understand, quick to modify, and feels safe and comfortable to work with. If you ask how they thought to write something the way they did, they always have a good reason. This book will help you become the master developer on your team. The breadth and depth of topics will engage veteran programmers, who will pick up new tricks and improve on old habits, while the clarity makes it accessible to even novice developers." -"Russ Rufer, Silicon Valley Patterns Group" " " "Many people don't realize how readable code can be and how valuable that readability is. Kent has taught me so much, I'm glad this book gives everyone the chance to learn from him." -"Martin Fowler, chief scientist, ThoughtWorks" " " "Code should be worth reading, not just by the compiler, but by humans. Kent Beck distilled his experience into a cohesive collection of implementation patterns. These nuggets of advice will make your code truly worth reading." -"Gregor Hohpe, author of "Enterprise Integration Patterns "In this book Kent Beck shows how writing clear and readable code follows from the application of simple principles. "Implementation Patterns "will help developers write intention revealing code that is both easy to understand and flexible towards future extensions. A must read for developers who are serious about their code." -"Sven Gorts" " " ""Implementation Patterns "bridges the gap between design and coding. Beck introduces a new way of thinking about programming by basing his discussion on values and principles." -"Diomidis Spinellis, author of "Code Reading "and "Code Quality Software Expert Kent Beck Presents a Catalog of Patterns Infinitely Useful for Everyday Programming Great code doesn't just function: it clearly and consistently communicates your intentions, allowing other programmers to understand your code, rely on it, and modify it with confidence. But great code doesn't just happen. It is the outcome of hundreds of small but critical decisions programmers make every single day. Now, legendary software innovator Kent Beck-known worldwide for creating Extreme Programming and pioneering software patterns and test-driven development-focuses on these critical decisions, unearthing powerful "implementation patterns" for writing programs that are simpler, clearer, better organized, and more cost effective. Beck collects 77 patterns for handling everyday programming tasks and writing more readable code. This new collection of patterns addresses many aspects of development, including class, state, behavior, method, collections, frameworks, and more. He uses diagrams, stories, examples, and essays to engage the reader as he illuminates the patterns. You'll find proven solutions for handling everything from naming variables to checking exceptions. This book covers
  • The value of communicating through code and the philosophy behind patterns
  • How and when to create classes, and how classes encode logic
  • Best practices for storing and retrieving state
  • Behavior: patterns for representing logic, including alternative paths
  • Writing, naming, and decomposing methods
  • Choosing and using collections
  • Implementation pattern variations for use in building frameworks
"Implementation Patterns" will help programmers at all experience levels, especially those who have benefited from software patterns or agile methods. It will also be an indispensable resource for development teams seeking to work together more efficiently and build more maintainable software. No other programming book will touch your day-to-day work more often.