 |
Beautiful Code: Leading Programmers Explain How They Think View Larger Image | Andy Oram, Greg Wilson
O'Reilly Media, Paperback, Published June 2007, 600 pages, ISBN 0596510047 | List Price: $44.99
Our Price: $36.95
You Save: $8.04 (18% Off)
| | | Availability: In-Stock |
Be the First to Write a Review and tell the world about this title!People who purchase this book frequently purchase: - Pro C# 2008 and the .NET 3.5 Platform 4th Edition; Andrew Troelsen, $36.95, 38% Off!
- Code Complete, 2nd Edition; Steve McConnell, $31.50, 37% Off!
- The Art of Agile Development; James Shore, et al, $32.95, 18% Off!
- Programming Collective Intelligence: Building Smart Web 2.0 Applications; Toby Segaran, $24.95, 38% Off!
Books on similar topics, in best-seller order:Books from the same publisher, in best-seller order:
How do the experts solve difficult problems in software development? In this
unique and insightful book, leading computer scientists offer case studies that
reveal how they found unusual, carefully designed solutions to high-profile
projects. You will be able to look over the shoulder of major coding and design
experts to see problems through their eyes.
This is not simply another design patterns book, or another software engineering
treatise on the right and wrong way to do things. The authors think aloud as
they work through their project's architecture, the tradeoffs made in its construction,
and when it was important to break rules. Beautiful Code is an opportunity
for master coders to tell their story. All author royalties will be donated
to Amnesty International.
The book includes:
Chapter 1, A Regular Expression Matcher, by Brian Kernighan, shows
how deep insight into a language and a problem can lead to a concise and elegant
solution.
Chapter 2, Subversion's Delta Editor: Interface as Ontology, by Karl
Fogel, starts with a well-chosen abstraction and demonstrates its unifying effects
on the system's further development.
Chapter 3, The Most Beautiful Code I Never Wrote, by Jon Bentley,
suggests how to measure a procedure without actually executing it.
Chapter 4, Finding Things, by Tim Bray, draws together many strands
in Computer Science in an exploration of a problem that is fundamental to many
computing tasks.
Chapter 5, Correct, Beautiful, Fast (In That Order): Lessons From Designing
XML Verifiers, by Elliotte Rusty Harold, reconciles the often conflicting
goals of thoroughness and good performance.
Chapter 6, Framework for Integrated Test: Beauty through Fragility,
by Michael Feathers, presents an example that breaks the rules and achieves
its own elegant solution.
Chapter 7, Beautiful Tests, by Alberto Savoia, shows how a broad,
creative approach to testing can not only eliminate bugs but turn you into a
better programmer.
Chapter 8, On-the-Fly Code Generation for Image Processing, by Charles
Petzold, drops down a level to improve performance while maintaining portability.
Chapter 9, Top-Down Operator Precedence, by Douglas Crockford, revives
an almost forgotten parsing technique and shows its new relevance to the popular
JavaScript language.
Chapter 10, The Quest for an Accelerated Population Count, by Henry
Warren, reveals the impact that some clever algorithms can have on even a seemingly
simple problem.
Chapter 11, Secure Communication: The Technology of Freedom, by Ashish
Gulhati, discusses the directed evolution of a secure messaging application
that was designed to make sophisticated but often confusing cryptographic technology
intuitively accessible to users.
Chapter 12, Growing Beautiful Code in BioPerl, by Lincoln Stein, shows
how the combination of a flexible language and a custom-designed module can
make it easy for people with modest programming skills to create powerful visualizations
for their data.
Chapter 13, The Design of the Gene Sorter, by Jim Kent, combines simple
building blocks to produce a robust and valuable tool for gene researchers.
Chapter 14, How Elegant Code Evolves With Hardware: The Case Of Gaussian
Elimination, by Jack Dongarra and Piotr Luszczek, surveys the history of
LINPACK and related major software packages, to show how assumptions must constantly
be re-evaluated in the face of new computing architectures.
Chapter 15, The Long-Term Benefits of Beautiful Design, by Adam Kolawa,
explains how attention to good design principles many decades ago helped CERN's
widely used mathematical library (the predecessor of LINPACK) stand the test
of time.
Chapter 16, The Linux Kernel Driver Model: The Benefits of Working Together,
by Greg Kroah-Hartman, explains how many efforts by different collaborators
to solve different problems led to the successful evolution of a complex, multithreaded
system.
Chapter 17, Another Level of Indirection, by Diomidis Spinellis, shows
how the flexibility and maintainability of the FreeBSD kernel is promoted by
abstracting operations done in common by many drivers and filesystem modules.
Chapter 18, Python's Dictionary Implementation: Being All Things to All
People, by Andrew Kuchling, explains how a careful design combined with
accommodations for a few special cases allows a language feature to support
many different uses.
Chapter 19, Multi-Dimensional Iterators in NumPy, by Travis E. Oliphant,
takes you through the design steps that succeed in hiding complexity under a
simple interface.
Chapter 20, A Highly Reliable Enterprise System for NASA's Mars Rover Mission,
by Ronald Mak, uses industry standards, best practices, and Java technologies
to meet the requirements of a NASA expedition where reliability cannot be in
doubt.
Chapter 21, ERP5: Designing for Maximum Adaptability, by Rog rio Atem
de Carvalho and Rafael Monnerat, shows how a powerful ERP system can be developed
with free software tools and a flexible architecture.
Chapter 22, A Spoonful of Sewage, by Bryan Cantrill, lets the reader
accompany the author through a hair-raising bug scare and a clever solution
that violated expectations.
Chapter 23, Distributed Programming with MapReduce, by Jeff Dean and
Sanjay Ghemawat, describes a system that provides an easy-to-use programming
abstraction for large-scale distributed data processing at Google that automatically
handles many difficult aspects of distributed computation, including automatic
parallelization, load balancing, and failure handling.
Chapter 24, Beautiful Concurrency, by Simon Peyton Jones, removes
much of the difficulty of parallel program through Software Transactional Memory,
demonstrated here using Haskell.
Chapter 25, Syntactic Abstraction: The syntax-case Expander, by Kent
Dybvig, shows how macros-a key feature of many languages and systems-can be
protected in Scheme from producing erroneous output.
Chapter 26, Labor-Saving Architecture: An Object-Oriented Framework for
Networked Software, by William Otte and Douglas C. Schmidt, applies a range
of standard object-oriented design techniques, such as patterns and frameworks,
to distributed logging to keep the system flexible and modular.
Chapter 27, Integrating Business Partners the RESTful Way, by Andrew
Patzer, demonstrates a designer's respect for his programmers by matching the
design of a B2B web service to its requirements.
Chapter 28, Beautiful Debugging, by Andreas Zeller, shows how a disciplined
approach to validating code can reduce the time it takes to track down errors.
Chapter 29, Treating Code as an Essay, by Yukihiro Matsumoto, lays
out some challenging principles that drove his design of the Ruby programming
language, and that, by extension, will help produce better software in general.
Chapter 30, When a Button Is All That Connects You to the World, by
Arun Mehta, takes you on a tour through the astounding interface design choices
involved in a text editing system that allow people with severe motor disabilities,
like Professor Stephen Hawking, to communicate via a computer.
Chapter 31, Emacspeak: The Complete Audio Desktop, by TV Raman, shows
how Lisp's advice facility can be used with Emacs to address a general need-generating
rich spoken output-that cuts across all aspects of the Emacs environment, without
modifying the underlying source code of a large software system.
Chapter 32, Code in Motion, by Laura Wingerd and Christopher Seiwald,
lists some simple rules that have unexpectedly strong impacts on programming
accuracy.
Chapter 33, Writing Programs for "The Book", by Brian Hayes, explores
the frustrations of solving a seemingly simple problem in computational geometry,
and its surprising resolution.
About the Authors
Andy Oram is an editor at O'Reilly Media, a highly respected book publisher
and technology information provider. An employee of the company since 1992,
Andy currently specializes in free software and open source technologies. His
work for O'Reilly includes the first books ever published commercially in the
United States on Linux, and the 2001 title Peer-to-Peer. His modest programming
and system administration skills are mostly self-taught.
Andy is also a member of Computer Professionals for Social Responsibility and
writes often for the O'Reilly Network and other publications. Topics include
policy issues related to the Internet and trends affecting technical innovation
and its effects on society. His web site is www.praxagora.com/andyo.
Andy works at the O'Reilly office in Cambridge, Massachusetts and lives nearby
with his wife, two children, and a six-foot grand piano that can often be heard
late at night.
Greg Wilson holds a Ph.D. in Computer Science from the University of Edinburgh,
and has worked on high-performance scientific computing, data visualization,
and computer security. He is the author of Data Crunching and Practical Parallel
Programming (MIT Press, 1995), and is a contributing editor at Doctor Dobb's
Journal, and an adjunct professor in Computer Science at the University of Toronto.
|
|
