000 06003nam a22004333i 4500
001 EBC5087520
003 MiAaPQ
005 20240729131514.0
006 m o d |
007 cr cnu||||||||
008 240724s2017 xx o ||||0 eng d
020 _a9781788628341
_q(electronic bk.)
035 _a(MiAaPQ)EBC5087520
035 _a(Au-PeEL)EBL5087520
035 _a(CaPaEBR)ebr11449432
035 _a(OCoLC)1005542231
040 _aMiAaPQ
_beng
_erda
_epn
_cMiAaPQ
_dMiAaPQ
050 4 _aQA76.754.K363 2017
082 0 _a5.3
100 1 _aKanat-Alexander, Max.
245 1 0 _aUnderstanding Software :
_bSoftware 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.
250 _a1st ed.
264 1 _aBirmingham :
_bPackt Publishing, Limited,
_c2017.
264 4 _c©2017.
300 _a1 online resource (278 pages)
336 _atext
_btxt
_2rdacontent
337 _acomputer
_bc
_2rdamedia
338 _aonline resource
_bcr
_2rdacarrier
505 0 _aCover -- 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.
505 8 _aChapter 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.
505 8 _aTrust 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.
588 _aDescription based on publisher supplied metadata and other sources.
590 _aElectronic reproduction. Ann Arbor, Michigan : ProQuest Ebook Central, 2024. Available via World Wide Web. Access may be limited to ProQuest Ebook Central affiliated libraries.
650 0 _aComputer software.
655 4 _aElectronic books.
776 0 8 _iPrint version:
_aKanat-Alexander, Max
_tUnderstanding Software
_dBirmingham : Packt Publishing, Limited,c2017
797 2 _aProQuest (Firm)
856 4 0 _uhttps://ebookcentral.proquest.com/lib/orpp/detail.action?docID=5087520
_zClick to View
999 _c131179
_d131179