TY  - BOOK
AU  - Kanat-Alexander,Max
TI  - Understanding Software: Software Legend Max Kanat-Alexander Shows You How to Succeed As a Developer by Embracing Simplicity, with Forty-Three Essays That Will Help You Really Understand the Software You Work With
SN  - 9781788628341
AV  - QA76.754.K363 2017 
U1  - 5.3 
PY  - 2017///
CY  - Birmingham
PB  - Packt Publishing, Limited
KW  - Computer software
KW  - Electronic books
N1  - Cover -- Copyright -- Credits -- About the Author -- www.PacktPub.com -- Customer Feedback -- Table of Contents -- Foreword -- Part One: Principles for Programmers -- Chapter 1: Before You Begin… -- If You're Going To Do It Then Do it Well -- Chapter 2: The Engineer Attitude -- Chapter 3: The Singular Secret of the Rockstar Programmer -- Chapter 4: Software Design, in Two Sentences -- Part Two: Software Complexity and its Causes -- Chapter 5: Clues to Complexity -- Chapter 6: Ways To Create Complexity: Break Your API -- Chapter 7: When Is Backwards-Compatibility Not Worth It? -- Chapter 8: Complexity is a Prison -- Part Three: Simplicity and Software Design -- Chapter 9: Design from the Start -- Starting the Right Way -- Chapter 10: The Accuracy of Future Predictions -- Chapter 11: Simplicity and Strictness -- Chapter 12: Two is Too Many -- Refactoring -- Chapter 13: Sane Software Design -- The Wrong Way -- The Right Way -- We followed all the Laws Of  Software Design -- Part Four: Debugging -- Chapter 14: What is a Bug? -- Hardware -- Chapter 15: The Source  of Bugs -- Compounding Complexity -- Chapter 16: Make It Never Come Back -- Make it Never Come Back - An Example -- Down the Rabbit Hole -- Chapter 17: The Fundamental Philosophy of Debugging -- Clarify the Bug -- Look at the System -- Find the Real Cause -- Four Steps -- Part Five: Engineering in Teams -- Chapter 18: Effective Engineering Productivity -- The Solution -- Chapter 19: Measuring Developer Productivity -- Chapter 20: How to Handle Code Complexity in a Software Company -- Step 1 - Problem Lists -- Step 2 - Meeting -- Step 3 - Bug Reports -- Step 4 - Prioritization -- Step 5 - Assignment -- Step 6 - Planning -- Chapter 21: Refactoring is about Features -- Being Effective -- Refactoring Doesn't Waste Time, It Saves It -- Refactoring To Clarity -- Summary; Chapter 22: Kindness  and Code -- Software is about People -- Chapter 23: Open Source Community, Simplified -- Retaining Contributors -- Removing the Barriers -- Getting People Interested -- Summary -- Part Six: Understanding Software -- Chapter 24: What is a Computer? -- Chapter 25: The Components of Software: Structure, Action, and Results -- Chapter 26: Software Revisited: (I)SAR Clarified -- Structure -- Action -- Results -- ISAR in a Single Line of Code -- Wrapping SAR Up -- Chapter 27: Software as Knowledge -- Chapter 28: The Purpose of Technology -- Are there Counter-Examples to this Rule? -- Is the Advance of Technology "Good"? -- Chapter 29: Privacy, Simplified -- Privacy of Space -- Privacy of Information -- A Summary of Privacy -- Chapter 30: Simplicity and Security -- Chapter 31: Test-Driven Development and the Cycle of Observation -- Examples of ODA -- Development Processes and Productivity -- Chapter 32: The Philosophy of Testing -- Test Value -- Test Assertions -- Test Boundaries -- Test Assumptions -- Test Design -- End to End Testing -- Integration Testing -- Unit Testing -- Reality -- Fakes -- Determinism -- Speed -- Coverage -- Conclusion - The Overall Goal of Testing -- Part Seven: Suck Less -- Chapter 33: The Secret  of Success:  Suck Less -- Why is it that this worked? -- Chapter 34: How We Figured Out What Sucked -- Chapter 35: The Power  of No -- Recognizing Bad Ideas -- Having No Better Idea -- Clarification: Acceptance and Politeness -- Chapter 36: Why Programmers Suck -- What to Study -- Chapter 37: The Secret of Fast Programming: Stop Thinking -- Understanding -- Drawing -- Starting -- Skipping a Step -- Physical Problems -- Distractions -- Self-Doubt -- False Ideas -- Caveat -- Chapter 38: Developer Hubris -- Chapter 39: "Consistency" Does Not Mean "Uniformity -- Chapter 40: Users Have Problems, Developers Have Solutions; Trust and Information -- Problems Come from Users -- Chapter 41: Instant Gratification = Instant Failure -- Solving for the long term -- How to Ruin Your Software Company -- Chapter 42: Success Comes from Execution, Not Innovation -- Chapter 43: Excellent Software -- 1.   Does exactly what the user told it to do -- 2.    Behaves exactly like the user expects it to behave -- 3.    Does not block the user from communicating their intention -- Excellence is senior to (but is not in conflict with) code simplicity -- Index
UR  - https://ebookcentral.proquest.com/lib/orpp/detail.action?docID=5087520
ER  -