Visualizing Data: Exploring and Explaining Data with the Processing Environment by Ben Fry
|
Book Summary Author: Ben Fry Edition: Paperback Audio: English (Original Language); English (Unknown); English (Published) Format: Illustrated Published: 2008-01-11 ISBN: 0596514557 Number of pages: 382 Publisher: O'Reilly Media, Inc. |
| Used | aurigadistributionservices | Used, verygood Mint interiors, no highlighting or markings, cover may have a taped tear or cut Usually ships in 1-2 business days | $19.99 | |
| Used | srjbooks2 | Used, verygood Usually ships in 1-2 business days | $20.14 | |
| New | dutchgreek | New Usually ships in 1-2 business days | $20.24 | |
| New | new_books_today | New All orders ship same business day via standard shipping (USPS Media Mail) if received by 1 PM CST. Usually ships in 1-2 business days | $22.57 | |
| New | firsttrust_books | New Usually ships in 1-2 business days | $22.85 | |
| New | a1books | New Brand new item. Over 4 million customers served. Order now. Selling online since 1995. Few left in stock - order soon. Code: I20081115031746S Usually ships in 1-2 business days | $22.89 | |
| New | a1books | New Brand new item. Over 3.5 million customers served. Order now. Selling online since 1995. Order with confidence. Code: B20081116115540T Usually ships in 1-2 business days | $23.82 | |
| New | pbshopus | New New American book. Shipped within the US in 4-7 days (expedited) or about 10-14 days (standard). Standard can occasionally be slower so we advise using expedited if quicker delivery is important! Usually ships in 1-2 business days | $24.07 | |
| New | pbshop | New Brand new book! Delivered direct from our US warehouse by Expedited (4-7 days) or Standard (usually 10-14 days but can be longer). Expedited shipping recommended for speedier delivery. Over 1 million satisfied customers Usually ships in 1-2 business days | $24.07 | |
| New | photo9x5 | New Brand new book. Fast shipping, 100% satisfaction guarantee. Usually ships in 1-2 business days | $24.49 |
Your purchase is protected by the A-to-z Safe Buying Guarantee. Amazon.com automatically transfers your payment to the merchant so you'll never need to pay a merchant directly. Amazon.com A-to-z Safe Buying Guarantee covers both the delivery of your item and its condition upon receipt.
Book Reviews of the Visualizing Data: Exploring and Explaining Data with the Processing Environment
Customer Review: Information Visualization using the Processing language
Summary: 5 Stars
This book was written by the author as a way of translating his Ph.D. dissertation on information visualization into something that would be accessible to most computer professionals. Most of the examples in this book are written from scratch by using some math, some lines and rectangles, and bits of text. This is done by using the Processing programming environment and API that the author helped develop. Processing makes it easy to quickly "sketch" code that produces images. Once you outgrow the environment, it's possible to use Java to write Processing code since the API is based on Java.
This book is aimed at readers who want to explore and communicate to others various facets of a data set. You don't need to have a computer science background, but I think it would help make some parts of the book plainer than they already are. Thus you'll be most successful with this book if you have some familiarity with writing code in a high-level object-oriented language. This is not an advanced text by any means, but a little background in writing code will go a long way toward understanding the concepts. The following is an overview of the chapters:
Chapter 1. The Seven Stages of Visualizing Data - the process for developing a useful visualization, from acquiring data to interacting with it.
Section 1.1. Why Data Display Requires Planning
Section 1.2. An Example
Section 1.3. Iteration and Combination
Section 1.4. Principles
Section 1.5. Onward
Chapter 2. Getting Started with Processing - basic introduction to the Processing environment and syntax. It provides a bit of background on the structure of the API and the philosophy behind the project's development.
Section 2.1. Sketching with Processing
Section 2.2. Exporting and Distributing Your Work
Section 2.3. Examples and Reference
Section 2.4. Functions
Section 2.5. Sketching and Scripting
Section 2.6. Ready?
Chapter 3. Mapping - plots data points on a map, our first introduction to reading data from the disk and representing it on the screen. From this chapter through chapter 8 the book covers example projects that progressively get more difficult.
Section 3.1. Drawing a Map
Section 3.2. Locations on a Map
Section 3.3. Data on a Map
Section 3.4. Using Your Own Data
Section 3.5. Next Steps
Chapter 4. Time Series - covers several methods of plotting charts that represent how data changes over time.
Section 4.1. Milk, Tea, and Coffee (Acquire and Parse)
Section 4.2. Cleaning the Table (Filter and Mine)
Section 4.3. A Simple Plot (Represent and Refine)
Section 4.4. Labeling the Current Data Set (Refine and Interact)
Section 4.5. Drawing Axis Labels (Refine)
Section 4.6. Choosing a Proper Representation (Represent and Refine)
Section 4.7. Using Rollovers to Highlight Points (Interact)
Section 4.8. Ways to Connect Points (Refine)
Section 4.9. Text Labels As Tabbed Panes (Interact)
Section 4.10. Interpolation Between Data Sets (Interact)
Section 4.11. End of the Series
Chapter 5. Connections and Correlations - the first chapter that really delves into how to acquire and parse a data set.
Section 5.1. Changing Data Sources
Section 5.2. Problem Statement
Section 5.3. Preprocessing
Section 5.4. Using the Preprocessed Data (Acquire, Parse, Filter, Mine)
Section 5.5. Displaying the Results (Represent)
Section 5.6. Returning to the Question (Refine)
Section 5.7. Sophisticated Sorting: Using Salary As a Tiebreaker (Mine)
Section 5.8. Moving to Multiple Days (Interact)
Section 5.9. Smoothing Out the Interaction (Refine)
Section 5.10. Deployment Considerations (Acquire, Parse, Filter)
Chapter 6. Scatterplot Maps - develops a project that allows users to progressively refine a U.S. map as they type a zip code.
Section 6.1. Preprocessing
Section 6.2. Loading the Data (Acquire and Parse)
Section 6.3. Drawing a Scatterplot of Zip Codes (Mine and Represent)
Section 6.4. Highlighting Points While Typing (Refine and Interact)
Section 6.5. Show the Currently Selected Point (Refine)
Section 6.6. Progressively Dimming and Brightening Points (Refine)
Section 6.7. Zooming In (Interact)
Section 6.8. Changing How Points Are Drawn When Zooming (Refine)
Section 6.9. Deployment Issues (Acquire and Refine)
Section 6.10. Next Steps
Chapter 7. Trees, Hierarchies, and Recursion - Recursion, an important topic when dealing with tree structures, and treemaps, is a useful representation for certain kinds of tree data.
Section 7.1. Using Recursion to Build a Directory Tree
Section 7.2. Using a Queue to Load Asynchronously (Interact)
Section 7.3. An Introduction to Treemaps
Section 7.4. Which Files Are Using the Most Space?
Section 7.5. Viewing Folder Contents (Interact)
Section 7.6. Improving the Treemap Display (Refine)
Section 7.7. Flying Through Files (Interact)
Section 7.8. Next Steps
Chapter 8. Networks and Graphs - The first half discusses how to produce a representation of connections between many nodes in a network, and the second half shows an example of doing the same with web site traffic data to see how a site is used over time. The latter project also covers how to integrate Processing with Eclipse, a Java IDE.
Section 8.1. Simple Graph Demo
Section 8.2. A More Complicated Graph
Section 8.3. Approaching Network Problems
Section 8.4. Advanced Graph Example
Section 8.5. Mining Additional Information
Chapter 9. Acquiring Data - cookbook that covers all sorts of practical techniques, from reading data from files, to spoofing a web browser, to storing data in databases.
Section 9.1. Where to Find Data
Section 9.2. Tools for Acquiring Data from the Internet
Section 9.3. Locating Files for Use with Processing
Section 9.4. Loading Text Data
Section 9.5. Dealing with Files and Folders
Section 9.6. Listing Files in a Folder
Section 9.7. Asynchronous Image Downloads
Section 9.8. Using openStream( ) As a Bridge to Java
Section 9.9. Dealing with Byte Arrays
Section 9.10. Advanced Web Techniques
Section 9.11. Using a Database
Section 9.12. Dealing with a Large Number of Files
Chapter 10. Parsing Data - Examples include parsing HTML tables, XML, compressed data, and SVG shapes. It even includes a basic example of watching a network connection to understand how an undocumented data protocol works.
Section 10.1. Levels of Effort
Section 10.2. Tools for Gathering Clues
Section 10.3. Text Is Best
Section 10.4. Text Markup Languages
Section 10.5. Regular Expressions (regexps)
Section 10.6. Grammars and BNF Notation
Section 10.7. Compressed Data
Section 10.8. Vectors and Geometry
Section 10.9. Binary Data Formats
Section 10.10. Advanced Detective Work
Chapter 11. Integrating Processing with Java - covers the specifics of how the Processing API integrates with Java. It's more of an appendix aimed at advanced Java programmers who want to use the API with their own projects.
Section 11.1. Programming Modes
Section 11.2. Additional Source Files (Tabs)
Section 11.3. The Preprocessor
Section 11.4. API Structure
Section 11.5. Embedding PApplet into Java Applications
Section 11.6. Using Java Code in a Processing Sketch
Section 11.7. Using Libraries
Section 11.8. Building with the Source for processing.core