Enhanced descriptions from Syndetics:

Enormous quantities of data go unused or underused today, simply because people can't visualize the quantities and relationships in it. Using a downloadable programming environment developed by the author, Visualizing Data demonstrates methods for representing data accurately on the Web and elsewhere, complete with user interaction, animation, and more.



How do the 3.1 billion A, C, G and T letters of the human genome compare to those of a chimp or a mouse? What do the paths that millions of visitors take through a web site look like? With Visualizing Data, you learn how to answer complex questions like these with thoroughly interactive displays. We're not talking about cookie-cutter charts and graphs. This book teaches you how to design entire interfaces around large, complex data sets with the help of a powerful new design and prototyping tool called "Processing".



Used by many researchers and companies to convey specific data in a clear and understandable manner, the Processing beta is available free. With this tool and Visualizing Data as a guide, you'll learn basic visualization principles, how to choose the right kind of display for your purposes, and how to provide interactive features that will bring users to your site over and over. This book teaches you:

The seven stages of visualizing data -- acquire, parse, filter, mine, represent, refine, and interact How all data problems begin with a question and end with a narrative construct that provides a clear answer without extraneous details Several example projects with the code to make them work Positive and negative points of each representation discussed. The focus is on customization so that each one best suits what you want to convey about your data set The book does not provide ready-made "visualizations" that can be plugged into any data set. Instead, with chapters divided by types of data rather than types of display, you'll learn how each visualization conveys the unique properties of the data it represents -- why the data was collected, what's interesting about it, and what stories it can tell. Visualizing Data teaches you how to answer questions, not simply display information.

Table of contents provided by Syndetics

• Preface (p. vii)
• 1 The Seven Stages of Visualizing Data (p. 1)
• Why Data Display Requires Planning (p. 2)
• An Example (p. 6)
• Iteration and Combination (p. 14)
• Principles (p. 15)
• Onward (p. 18)
• 2 Getting Started with Processing (p. 19)
• Sketching with Processing (p. 20)
• Exporting and Distributing Your Work (p. 23)
• Examples and Reference (p. 24)
• Functions (p. 27)
• Sketching and Scripting (p. 28)
• Ready? (p. 30)
• 3 Mapping (p. 31)
• Drawing a Map (p. 31)
• Locations on a Map (p. 32)
• Data on a Map (p. 34)
• Using Your Own Data (p. 51)
• Next Steps (p. 53)
• 4 Time Series (p. 54)
• Milk, Tea, and Coffee (Acquire and Parse) (p. 55)
• Cleaning the Table (Filter and Mine) (p. 55)
• A Simple Plot (Represent and Refine) (p. 57)
• Labeling the Current Data Set (Refine and Interact) (p. 59)
• Drawing Axis Labels (Refine) (p. 62)
• Choosing a Proper Representation (Represent and Refine) (p. 73)
• Using Rollovers to Highlight Points (Interact) (p. 76)
• Ways to Connect Points (Refine) (p. 77)
• Text Labels As Tabbed Panes (Interact) (p. 83)
• Interpolation Between Data Sets (Interact) (p. 87)
• End of the Series (p. 92)
• 5 Connections and Correlations (p. 94)
• Changing Data Sources (p. 94)
• Problem Statement (p. 95)
• Preprocessing (p. 96)
• Using the Preprocessed Data (Acquire, Parse, Filter, Mine) (p. 111)
• Displaying the Results (Represent) (p. 118)
• Returning to the Question (Refine) (p. 121)
• Sophisticated Sorting: Using Salary As a Tiebreaker (Mine) (p. 126)
• Moving to Multiple Days (Interact) (p. 127)
• Smoothing Out the Interaction (Refine) (p. 132)
• Deployment Considerations (Acquire, Parse, Filter) (p. 133)
• 6 Scatterplot Maps (p. 145)
• Preprocessing (p. 145)
• Loading the Data (Acquire and Parse) (p. 155)
• Drawing a Scatterplot of Zip Codes (Mine and Represent) (p. 157)
• Highlighting Points While Typing (Refine and Interact) (p. 158)
• Show the Currently Selected Point (Refine) (p. 162)
• Progressively Dimming and Brightening Points (Refine) (p. 165)
• Zooming In (Interact) (p. 167)
• Changing How Points Are Drawn When Zooming (Refine) (p. 177)
• Deployment Issues (Acquire and Refine) (p. 178)
• Next Steps (p. 180)
• 7 Trees, Hierarchies, and Recursion (p. 182)
• Using Recursion to Build a Directory Tree (p. 182)
• Using a Queue to Load Asynchronously (Interact) (p. 186)
• An Introduction to Treemaps (p. 189)
• Which Files Are Using the Most Space? (p. 194)
• Viewing Folder Contents (Interact) (p. 199)
• Improving the Treemap Display (Refine) (p. 201)
• Flying Through Files (Interact) (p. 208)
• Next Steps (p. 219)
• 8 Networks and Graphs (p. 220)
• Simple Graph Demo (p. 220)
• A More Complicated Graph (p. 229)
• Approaching Network Problems (p. 240)
• Advanced Graph Example (p. 242)
• Mining Additional Information (p. 262)
• 9 Acquiring Data (p. 264)
• Where to Find Data (p. 265)
• Tools for Acquiring Data from the Internet (p. 266)
• Locating Files for Use with Processing (p. 268)
• Loading Text Data (p. 270)
• Dealing with Files and Folders (p. 276)
• Listing Files in a Folder (p. 277)
• Asynchronous Image Downloads (p. 281)
• Using openStream() As a Bridge to Java (p. 284)
• Dealing with Byte Arrays (p. 284)
• Advanced Web Techniques (p. 284)
• Using a Database (p. 288)
• Dealing with a Large Number of Files (p. 295)
• 10 Parsing Data (p. 296)
• Levels of Effort (p. 296)
• Tools for Gathering Clues (p. 298)
• Text Is Best (p. 299)
• Text Markup Languages (p. 303)
• Regular Expressions (regexps) (p. 316)
• Grammars and BNF Notation (p. 316)
• Compressed Data (p. 317)
• Vectors and Geometry (p. 320)
• Binary Data Formats (p. 325)
• Advanced Detective Work (p. 328)
• 11 Integrating Processing with Java (p. 331)
• Programming Modes (p. 331)
• Additional Source Files (Tabs) (p. 334)
• The Preprocessor (p. 335)
• API Structure (p. 336)
• Embedding PApplet into Java Applications (p. 338)
• Using Java Code in a Processing Sketch (p. 342)
• Using Libraries (p. 343)
• Building with the Source for processing.core (p. 343)
• Bibliography (p. 345)
• Index (p. 349)

Author notes provided by Syndetics

Ben Fry received his doctorate from the Aesthetics + Computation Group at the MIT Media Laboratory and was the 2006-2007 Nierenberg Chair of Design for the Carnegie Mellon School of Design. He worked with Casey Reas to develop Processing, which won a Golden Nica from the Prix Ars Electronica in 2005. Ben's work has received a New Media Fellowship from the Rockefeller Foundation, and been shown at the Museum of Modern Art, Ars Electronica, the 2002 Whitney Biennial and the 2003 Cooper Hewitt Design Triennial.