beautiful code chm

Beautiful Code
Dedication
Foreword
Preface
Chapter 1. A Regular Expression Matcher
Section 1.1. The Practice of Programming
Section 1.2. Implementation
Section 1.3. Discussion
Section 1.4. Alternatives
Section 1.5. Building on It
Section 1.6. Conclusion
Chapter 2. Subversion's Delta Editor: Interface As Ontology
Section 2.1. Version Control and Tree Transformation
Section 2.2. Expressing Tree Differences
Section 2.3. The Delta Editor Interface
Section 2.4. But Is It Art?
Section 2.5. Abstraction As a Spectator Sport
Section 2.6. Conclusions
Chapter 3. The Most Beautiful Code I Never Wrote
Section 3.1. The Most Beautiful Code I Ever Wrote
Section 3.2. More and More with Less and Less
Section 3.3. Perspective
Section 3.4. What Is Writing?
Section 3.5. Conclusion
Section 3.6. Acknowledgments
Chapter 4. Finding Things
Section 4.1. On Time
Section 4.2. Problem: Weblog Data
Section 4.3. Problem: Who Fetched What, When?
Section 4.4. Search in the Large
Section 4.5. Conclusion
Chapter 5. Correct, Beautiful, Fast (in That Order): Lessons from Designing XML Verifiers
Section 5.1. The Role of XML Validation
Section 5.2. The Problem
Section 5.3. Version 1: The Na?ve Implementation
Section 5.4. Version 2: Imitating the BNF Grammar O(N)
Section 5.5. Version 3: First Optimization O(log N)
Section 5.6. Version 4: Second Optimization: Don't Check Twice
Section 5.7. Version 5: Third Optimization O(1)
Section 5.8. Version 6: Fourth Optimization: Caching
Section 5.9. The Moral of the Story
Chapter 6. Framework for Integrated Test: Beauty Through Fragility
Section 6.1. An Acceptance Testing Framework in Three Classes
Section 6.2. The Challenge of Framework Design
Section 6.3. An Open Framework
Section 6.4. How Simple Can an HTML Parser Be?
Section 6.5. Conclusion
Chapter 7. Beautiful Tests
Section 7.1. That Pesky Binary Search
Section 7.2. Introducing JUnit
Section 7.3. Nailing Binary Search
Section 7.4. Conclusion
Chapter 8. On-the-Fly Code Generation for Image Processing
Chapter 9. Top Down Operator Precedence
Section 9.1. JavaScript
Section 9.2. Symbol Table
Section 9.3. Tokens
Section 9.4. Precedence
Section 9.5. Expressions
Section 9.6. Infix Operators
Section 9.7. Prefix Operators
Section 9.8. Assignment Operators
Section 9.9. Constants
Section 9.10. Scope
Section 9.11. Statements
Section 9.12. Functions
Section 9.13. Array and Object Literals
Section 9.14. Things to Do and Think About
Chapter 10. The Quest for an Accelerated Population Count
Section 10.1. Basic Methods
Section 10.2. Divide and Conquer
Section 10.3. Other Methods
Section 10.4. Sum and Difference of Population Counts of Two Words
Section 10.5. Comparing the Population Counts of Two Words
Section 10.6. Counting the 1-Bits in an Array
Section 10.7. Applications
Chapter 11. Secure Communication: The Technology Of Freedom
Section 11.1. The Heart of the Start
Section 11.2. Untangling the Complexity of Secure Messaging
Section 11.3. Usability Is the Key
Section 11.4. The Foundation
Section 11.5. The Test Suite
Section 11.6. The Functioning Prototype
Section 11.7. Clean Up, Plug In, Rock On…
Section 11.8. Hacking in the Himalayas
Section 11.9. The Invisible Hand Moves
Section 11.10. Speed Does Matter
Section 11.11. Communications Privacy for Individual Rights
Section 11.12. Hacking the Civilization
Chapter 12. Growing Beautiful Code in BioPerl
Section 12.1. BioPerl and the Bi:Graphics Module
Section 12.2. The Bi:Graphics Design Process
Section 12.3. Extending Bi:Graphics
Section 12.4. Conclusions and Lessons Learned
Chapter 13. The Design of the Gene Sorte
Section 13.1. The User Interface of the Gene Sorter
Section 13.2. Maintaining a Dialog with the User over the Web
Section 13.3. A Little Polymorphism Can Go a Long Way
Section 13.4. Filtering Down to Just the Relevant Genes
Section 13.5. Theory of Beautiful Code in the Large
Section 13.6. Conclusion
Chapter 14. How Elegant Code Evolves with Hardware The Case of Gaussian Elimination
Section 14.1. The Effects of Computer Architectures on Matrix Algorithms
Section 14.2. A Decompositional Approach
Section 14.3. A Simple Version
Section 14.4. LINPACK's DGEFA Subroutine
Section 14.5. LAPACK DGETRF
Section 14.6. Recursive LU
Section 14.7. ScaLAPACK PDGETRF
Section 14.8. Multithreading for Multi-Core Systems
Section 14.9. A Word About the Error Analysis and Operation Count
Section 14.10. Future Directions for Research
Section 14.11. Further Reading
Chapter 15. The Long-Term Benefits of Beautiful Design
Section 15.1. My Idea of Beautiful Code
Section 15.2. Introducing the CERN Library
Section 15.3. Outer Beauty
Section 15.4. Inner Beauty
Section 15.5. Conclusion
Chapter 16. The Linux Kernel Driver Model: The Benefits of Working Together
Section 16.1. Humble Beginnings
Section 16.2. Reduced to Even Smaller Bits
Section 16.3. Scaling Up to Thousands of Devices
Section 16.4. Small Objects Loosely Joined
Chapter 17. Another Level of Indirection
Section 17.1. From Code to Pointers
Section 17.2. From Function Arguments to Argument Pointers
Section 17.3. From Filesystems to Filesystem Layers
Section 17.4. From Code to a Domain-Specific Language
Section 17.5. Multiplexing and Demultiplexing
Section 17.6. Layers Forever?
Chapter 18. Python's Dictionary Implementation: Being All Things to All People
Section 18.1. Inside the Dictionary
Section 18.2. Special Accommodations
Section 18.3. Collisions
Section 18.4. Resizing
Section 18.5. Iterations and Dynamic Changes
Section 18.6. Conclusion
Section 18.7. Acknowledgments
Chapter 19. Multidimensional Iterators in NumPy
Section 19.1. Key Challenges in N-Dimensional Array Operations
Section 19.2. Memory Models for an N-Dimensional Array
Section 19.3. NumPy Iterator Origins
Section 19.4. Iterator Design
Section 19.5. Iterator Interface
Section 19.6. Iterator Use
Section 19.7. Conclusion
Chapter 20. A Highly Reliable Enterprise System for NASA's Mars Rover Mission
Section 20.1. The Mission and the Collaborative Information Portal
Section 20.2. Mission Needs
Section 20.3. System Architecture
Section 20.4. Case Study: The Streamer Service
Section 20.5. Reliability
Section 20.6. Robustness
Section 20.7. Conclusion
Chapter 21. ERP5: Designing for Maximum Adaptability
Section 21.1. General Goals of ERP
Section 21.2. ERP5
Section 21.3. The Underlying Zope Platform
Section 21.4. ERP5 Project Concepts
Section 21.5. Coding the ERP5 Project
Section 21.6. Conclusion
Chapter 22. A Spoonful of Sewage
Chapter 23. Distributed Programming with MapReduce
Section 23.1. A Motivating Example
Section 23.2. The MapReduce Programming Model
Section 23.3. Other MapReduce Examples
Section 23.4. A Distributed MapReduce Implementation
Section 23.5. Extensions to the Model
Section 23.6. Conclusion
Section 23.7. Further Reading
Section 23.8. Acknowledgments
Section 23.9. Appendix: Word Count Solution
Chapter 24. Beautiful Concurrency
Section 24.1. A Simple Example: Bank Accounts
Section 24.2. Software Transactional Memory
Section 24.3. The Santa Claus Problem
Section 24.4. Reflections on Haskell
Section 24.5. Conclusion
Section 24.6. Acknowledgments
Chapter 25. Syntactic Abstraction: The syntax-case Expander
Section 25.1. Brief Introduction to syntax-case
Section 25.2. Expansion Algorithm
Section 25.3. Example
Section 25.4. Conclusion
Chapter 26. Labor-Saving Architecture: An Object-Oriented Framework for Networked Software
Section 26.1. Sample Application: Logging Service
Section 26.2. Object-Oriented Design of the Logging Server Framework
Section 26.3. Implementing Sequential Logging Servers
Section 26.4. Implementing Concurrent Logging Servers
Section 26.5. Conclusion
Chapter 27. Integrating Business Partners the RESTful Way
Section 27.1. Project Background
Section 27.2. Exposing Services to External Clients
Section 27.3. Routing the Service Using the Factory Pattern
Section 27.4. Exchanging Data Using E-Business Protocols
Section 27.5. Conclusion
Chapter 28. Beautiful Debugging
Section 28.1. Debugging a Debugger
Section 28.2. A Systematic Process
Section 28.3. A Search Problem
Section 28.4. Finding the Failure Cause Automatically
Section 28.5. Delta Debugging
Section 28.6. Minimizing Input
Section 28.7. Hunting the Defect
Section 28.8. A Prototype Problem
Section 28.9. Conclusion
Section 28.10. Acknowledgments
Section 28.11. Further Reading
Chapter 29. Treating Code As an Essay
Chapter 30. When a Button Is All That Connects You to the World
Section 30.1. Basic Design Model
Section 30.2. Input Interface
Section 30.3. Efficiency of the User Interface
Section 30.4. Download
Section 30.5. Future Directions
Chapter 31. Emacspeak: The Complete Audio Desktop
Section 31.1. Producing Spoken Output
Section 31.2. Speech-Enabling Emacs
Section 31.3. Painless Access to Online Information
Section 31.4. Summary
Section 31.5. Acknowledgments
Chapter 32. Code in Motion
Section 32.1. On Being "Bookish"
Section 32.2. Alike Looking Alike
Section 32.3. The Perils of Indentation
Section 32.4. Navigating Code
Section 32.5. The Tools We Use
Section 32.6. DiffMerge's Checkered Past
Section 32.7. Conclusion
Section 32.8. Acknowledgments
Section 32.9. Further Reading
Chapter 33. Writing Programs for "The Book"
Section 33.1. The Nonroyal Road
Section 33.2. Warning to Parenthophobes
Section 33.3. Three in a Row
Section 33.4. The Slippery Slope
Section 33.5. The Triangle Inequality
Section 33.6. Meandering On
Section 33.7. "Duh!"—I Mean "Aha!"
Section 33.8. Conclusion
Section 33.9. Further Reading