Clean Code - Info and Reading Options

"Clean Code" Table Of Contents:

• 1- Foreword
• 2- Introduction
• 3- On the Cover
• 4- Clean Code
• 5- There Will Be Code
• 6- Bad Code
• 7- The Total Cost of Owning a Mess
• 8- The Grand Redesign in the Sky
• 9- Attitude
• 10- The Primal Conundrum
• 11- The Art of Clean Code?
• 12- What Is Clean Code?
• 13- Schools of Thought
• 14- We Are Authors
• 15- The Boy Scout Rule
• 16- Prequel and Principles
• 17- Conclusion
• 18- Bibliography
• 19- Meaningful Names
• 20- A Introduction
• 21- Use Intention-Revealing Names
• 22- Avoid Disinformation
• 23- Make Meaningful Distinctions
• 24- Use Pronounceable Names
• 25- Use Searchable Names
• 26- Avoid Encodings
• 27- Hungarian Notation
• 28- Member Prefixes
• 29- Interfaces and Implementations
• 30- Avoid Mental Mapping
• 31- Class Names
• 32- Method Names
• 33- Don't Be Cute
• 34- Pick One Word per Concept
• 35- Don't Pun
• 36- Use Solution Domain Names
• 37- Use Problem Domain Names
• 38- Add Meaningful Context
• 39- Don't Add Gratuitous Context
• 40- Final Words
• 41- Functions
• 42- Small!
• 43- Blocks and Indenting
• 44- Do One Thing
• 45- Sections within Functions
• 46- One Level of Abstraction per Function
• 47- Reading Code from Top to Bottom: The Stepdown Rule
• 48- Switch Statements
• 49- Use Descriptive Names
• 50- Function Arguments
• 51- Common Monadic Forms
• 52- Flag Arguments
• 53- Dyadic Functions
• 54- Triads
• 55- Argument Objects
• 56- Argument Lists
• 57- Verbs and Keywords
• 58- Have No Side Effects
• 59- Output Arguments
• 60- Command Query Separation
• 61- Prefer Exceptions to Returning Error Codes
• 62- Extract Try/Catch Blocks
• 63- Error Handling Is One Thing
• 64- The Error.java Dependency Magnet
• 65- Don't Repeat Yourself
• 66- Structured Programming
• 67- How Do You Write Functions Like This?
• 68- Conclusion
• 69- SetupTeardownIncluder
• 70- Bibliography
• 71- Comments
• 72- Comments Do Not Make Up for Bad Code
• 73- Explain Yourself in Code
• 74- Good Comments
• 75- Legal Comments
• 76- Informative Comments
• 77- Explanation of Intent
• 78- Clarification
• 79- Warning of Consequences
• 80- TODO Comments
• 81- Amplification
• 82- Javadocs in Public APIs
• 83- Bad Comments
• 84- Mumbling
• 85- Redundant Comments
• 86- Misleading Comments
• 87- Mandated Comments
• 88- Journal Comments
• 89- Noise Comments
• 90- Scary Noise
• 91- Don't Use a Comment When You Can Use a Function or a Variable
• 92- Position Markers
• 93- Closing Brace Comments
• 94- Attributions and Bylines
• 95- Commented-Out Code
• 96- HTML Comments
• 97- Nonlocal Information
• 98- Too Much Information
• 99- Inobvious Connection
• 100- Function Headers
• 101- Javadocs in Nonpublic Code
• 102- Example
• 103- Bibliography
• 104- Formatting
• 105- The Purpose of Formatting
• 106- Vertical Formatting
• 107- The Newspaper Metaphor
• 108- Vertical Openness Between Concepts
• 109- Vertical Density
• 110- Vertical Distance
• 111- Vertical Ordering
• 112- Horizontal Formatting
• 113- Horizontal Openness and Density
• 114- Horizontal Alignment
• 115- Indentation
• 116- Dummy Scopes
• 117- Team Rules
• 118- Uncle Bob's Formatting Rules
• 119- Objects and Data Structures
• 120- Data Abstraction
• 121- Data/Object Anti-Symmetry
• 122- The Law of Demeter
• 123- Train Wrecks
• 124- Hybrids
• 125- Hiding Structure
• 126- Data Transfer Objects
• 127- Active Record
• 128- Conclusion
• 129- Bibliography
• 130- Error Handling
• 131- Use Exceptions Rather Than Return Codes
• 132- Write Your Try-Catch-Finally Statement First
• 133- Use Unchecked Exceptions
• 134- Provide Context with Exceptions
• 135- Define Exception Classes in Terms of a Caller's Needs
• 136- Define the Normal Flow
• 137- Don't Return Null
• 138- Don't Pass Null
• 139- Conclusion
• 140- Bibliography
• 141- Boundaries
• 142- Using Third-Party Code
• 143- Exploring and Learning Boundaries
• 144- Learning log4j
• 145- Learning Tests Are Better Than Free
• 146- Using Code That Does Not Yet Exist
• 147- Clean Boundaries
• 148- Bibliography
• 149- Unit Tests
• 150- The Three Laws of TDD
• 151- Keeping Tests Clean
• 152- Tests Enable the -ilities
• 153- Clean Tests
• 154- Domain-Specific Testing Language
• 155- A Dual Standard
• 156- One Assert per Test
• 157- Single Concept per Test
• 158- F.I.R.S.T.
• 159- Conclusion
• 160- Bibliography
• 161- Classes
• 162- Class Organization
• 163- Encapsulation
• 164- Classes Should Be Small!
• 165- The Single Responsibility Principle
• 166- Cohesion
• 167- Maintaining Cohesion Results in Many Small Classes
• 168- Organizing for Change
• 169- Isolating from Change
• 170- Bibliography
• 171- Systems
• 172- How Would You Build a City?
• 173- Separate Constructing a System from Using It
• 174- Separation of Main
• 175- Factories
• 176- Dependency Injection
• 177- Scaling Up
• 178- Cross-Cutting Concerns
• 179- Java Proxies
• 180- Pure Java AOP Frameworks
• 181- AspectJ Aspects
• 182- Test Drive the System Architecture
• 183- Optimize Decision Making
• 184- Use Standards Wisely, When They Add Demonstrable Value
• 185- Systems Need Domain-Specific Languages
• 186- Conclusion
• 187- Bibliography
• 188- Emergence
• 189- Getting Clean via Emergent Design
• 190- Simple Design Rule 1: Runs All the Tests
• 191- Simple Design Rules 2-4: Refactoring
• 192- No Duplication
• 193- Expressive
• 194- Minimal Classes and Methods
• 195- Conclusion
• 196- Bibliography
• 197- Concurrency
• 198- Why Concurrency?
• 199- Myths and Misconceptions
• 200- Challenges
• 201- Concurrency Defense Principles
• 202- Single Responsibility Principle
• 203- Corollary: Limit the Scope of Data
• 204- Corollary: Use Copies of Data
• 205- Corollary: Threads Should Be as Independent as Possible
• 206- Know Your Library
• 207- Thread-Safe Collections
• 208- Know Your Execution Models
• 209- Producer-Consumer
• 210- Readers-Writers
• 211- Dining Philosophers
• 212- Beware Dependencies Between Synchronized Methods
• 213- Keep Synchronized Sections Small
• 214- Writing Correct Shut-Down Code Is Hard
• 215- Testing Threaded Code
• 216- Treat Spurious Failures as Candidate Threading Issues
• 217- Get Your Nonthreaded Code Working First
• 218- Make Your Threaded Code Pluggable
• 219- Make Your Threaded Code Tunable
• 220- Run with More Threads Than Processors
• 221- Run on Different Platforms
• 222- Instrument Your Code to Try and Force Failures
• 223- Hand-Coded
• 224- Automated
• 225- Conclusion
• 226- Bibliography
• 227- Successive Refinement
• 228- Args Implementation
• 229- How Did I Do This?
• 230- Args: The Rough Draft
• 231- So I Stopped
• 232- On Incrementalism
• 233- String Arguments
• 234- Conclusion
• 235- JUnit Internals
• 236- The JUnit Framework
• 237- Conclusion
• 238- Refactoring SerialDate
• 239- First, Make It Work
• 240- Then Make It Right
• 241- Conclusion
• 242- Bibliography
• 243- Smells and Heuristics
• 244- Comments
• 245- Inappropriate Information
• 246- Obsolete Comment
• 247- Redundant Comment
• 248- Poorly Written Comment
• 249- Commented-Out Code
• 250- Environment
• 251- Build Requires More Than One Step
• 252- Tests Require More Than One Step
• 253- Functions
• 254- Too Many Arguments
• 255- Output Arguments
• 256- Flag Arguments
• 257- Dead Function
• 258- General
• 259- Multiple Languages in One Source File
• 260- Obvious Behavior Is Unimplemented
• 261- Incorrect Behavior at the Boundaries
• 262- Overridden Safeties
• 263- Duplication
• 264- Code at Wrong Level of Abstraction
• 265- Base Classes Depending on Their Derivatives
• 266- Too Much Information
• 267- Dead Code
• 268- Vertical Separation
• 269- Inconsistency
• 270- Clutter
• 271- Artificial Coupling
• 272- Feature Envy
• 273- Selector Arguments
• 274- Obscured Intent
• 275- Misplaced Responsibility
• 276- Inappropriate Static
• 277- Use Explanatory Variables
• 278- Function Names Should Say What They Do
• 279- Understand the Algorithm
• 280- Make Logical Dependencies Physical
• 281- Prefer Polymorphism to If/Else or Switch/Case
• 282- Follow Standard Conventions
• 283- Replace Magic Numbers with Named Constants
• 284- Be Precise
• 285- Structure over Convention
• 286- Encapsulate Conditionals
• 287- Avoid Negative Conditionals
• 288- Functions Should Do One Thing
• 289- Hidden Temporal Couplings
• 290- Don't Be Arbitrary
• 291- Encapsulate Boundary Conditions
• 292- Functions Should Descend Only One Level of Abstraction
• 293- Keep Configurable Data at High Levels
• 294- Avoid Transitive Navigation
• 295- Java
• 296- Avoid Long Import Lists by Using Wildcards
• 297- Don't Inherit Constants
• 298- Constants versus Enums
• 299- Names
• 300- Choose Descriptive Names
• 301- Choose Names at the Appropriate Level of Abstraction
• 302- Use Standard Nomenclature Where Possible
• 303- Unambiguous Names
• 304- Use Long Names for Long Scopes
• 305- Avoid Encodings
• 306- Names Should Describe Side-Effects
• 307- Tests
• 308- Insufficient Tests
• 309- Use a Coverage Tool!
• 310- Don't Skip Trivial Tests
• 311- An Ignored Test Is a Question About an Ambiguity
• 312- Test Boundary Conditions
• 313- Exhaustively Test Near Bugs
• 314- Patterns of Failure Are Revealing
• 315- Test Coverage Patterns Can Be Revealing
• 316- Tests Should Be Fast
• 317- Conclusion
• 318- Bibliography
• 319- Concurrency
• 320- Client/Server Example
• 321- The Server
• 322- Adding Threading
• 323- Server Observations
• 324- Conclusion
• 325- Possible Paths of Execution
• 326- Number of Paths
• 327- Digging Deeper
• 328- Conclusion
• 329- Knowing Your Library
• 330- Executor Framework
• 331- Nonblocking Solutions
• 332- Nonthread-Safe Classes
• 333- Dependencies Between Methods Can Break Concurrent Code
• 334- Tolerate the Failure
• 335- Client-Based Locking
• 336- Server-Based Locking
• 337- Increasing Throughput
• 338- Single-Thread Calculation of Throughput
• 339- Multithread Calculation of Throughput
• 340- Deadlock
• 341- Mutual Exclusion
• 342- Lock & Wait
• 343- No Preemption
• 344- Circular Wait
• 345- Breaking Mutual Exclusion
• 346- Breaking Lock & Wait
• 347- Breaking Preemption
• 348- Breaking Circular Wait
• 349- Testing Multithreaded Code
• 350- Tool Support for Testing Thread-Based Code
• 351- Conclusion
• 352- Tutorial: Full Code Examples
• 353- Client/Server Nonthreaded
• 354- Client/Server Using Threads
• 355- org.jfree.date.SerialDate
• 356- Cross References of Heuristics
• 357- Epilogue
• 358- Index

Read “Clean Code”:

Read “Clean Code” by choosing from the options below.