This book may not be the ultimate reference for vualizing data, but it does give the reader a complete set of tools to start with; the theory on how to get the data in the first place, information on how graphs are built and read, and a programming tool to actually create the graphs with.

It does contain many sourcecodes which may seem pointless as you can just pcik them off the web, but being able to read the code while reading on the train is quite nice :-)

it could do with more different graphs, but then again I'd rather get a complete explenation about a few graphs so I understand them completely, than a quick runthrough of many graphs and ending up not knowing much about any of them.

Your milage may vary depending on your level of experience, but I'd recommend this book to relatively experienced programmers who need to get started with graphing data.

I bought this book hoping to learn something about data visualisation techniques - things like which kind of presentation use for which purpose, how to design understandable and readable graphs etc.

Instead, I found just an introduction to some Java toolkit. As an introduction to this toolkit the book is not bad - it is well written and have interesting examples and readable code snippets - but it just fails to provide the information the title promises.

I'm short of superlatives for this book or more generally for the work of Ben Fry.

In my line of work, how people think of graphs is very much influenced by what is possible to do in Excel without changing the default settings too much.
Enter Processing, a data visualization-oriented language, which makes it easy to create custom visualizations, tailored for the problem you want to address. There is a growing community around Processing and a number of truly incredible graphs that have been created with just a few lines of code. Ben Fry's own work, which ranges from simplistic to very sophisticated, is nothing short of mind-blowing. Yet this book demystifies this and make it all look accessible.

It opens great perspectives for anyone interested in expressing their data graphically. Still, the title is misleading.

This is not a book about, say, editorial rules by which one should construct a visualization. It is not an abstract book that offers generic advice that can be used in whatever environment. For that kind of book, pick Show Me the Numbers: Designing Tables and Graphs to Enlighten or The Visual Display of Quantitative Information, 2nd edition - books which are consistent with Fry's approach, by the way. "Visualizing Data" is really a practical cookbook that will introduce you to Processing. It offers methodological insights, but which are mostly relevant in the Processing environment.

That being said, I highly recommend this book and keeping a close tab on [..]

This book was exactly what I was looking for--chapter eight alone was worth the cost of the book. A word to the wise: rather than assuming its contents from the title alone, read chapter one thoroughly to ensure that this book is right for you.

'Visualizing Data' is a book that is supposed to discuss how data is presented, sorted, stored and examined. Instead what we get is a 350+ page book that is jumbled with lots of code samples (why) and a small subset of data that is actually visualized. This is a really niche topic that I thought would be interesting to examine as I opened the book cover but thumbing through I saw few pictures (although there are a few in here that are good) and lots of java code. While it's interesting to see how data is outputted code-wise, from the book title I felt this would be more of a design discussion for the reader.

I can't recommend this book. There is too much code, too much content, and the code that is contained within is all Java. I didn't get much out of it and I feel that if less code and more pictures were added the end result would have been much more solid.

** NOT RECOMMENDED

Ben Fry hits the mark!

The author jumps right into describing the process in Chapter 1, "The Seven Stages of Visualizing Data."
He elaborates each of the stages with illustrations and examples.

In chapter 2, "Getting Started with Processing," Ben introduces a software tool (named Processing) that's available for download: www.processing.org/download.

From the site: "Processing is an open project initiated by Ben Fry and Casey Reas. It evolved from ideas explored in the Aesthetics and Computation Group at the MIT Media Lab."

And the remainder of the title details the various stages of visualizing data with sample code you can use to develop your own visualizations!

Based on the title and publisher's writeup I was expecting the book to provide in-depth coverage of various visual metaphors for understanding and manipulating data, such as "Designing Interfaces" by Tidwell, another O'Reilly book that I am very pleased with.

Unfortunately it would be more appropriate if the title (Visualizing Dta) and sub-title (Exploring and Explaining Data with the Processing Environment) were switched. This book is primarily a tutorial on using the Processing Environment (http://processing.org), showing you how to create various interactive charts and composed primarily of code examples.

In addition, the visualizations presented in the book are far from aesthetically pleasing. The Processing Environment has the capability to create visualizations that are not only functional, but beautiful as well. You can find a collection of visualizations at http://www.visualcomplexity.com, many of which were created with the Processing Environment.

In summary I am granting a 2-star rating because the book does not deliver the expected coverage of data visualization design and even in its explanation of the Processing Environment does not provide exemplary visualizations.

Processing looks like a very powerful tool and this book serves as a good introduction to both programming and computer visuals. It's nicely paced but if you are a professional software engineer looking to harness processing you will find yourself skimming the whole book in search for advanced material.

In particular the use of java for a whole lot of tasks including text parsing and data mining leads to very tedious and verbose code where a few lines of perl or awk would have done the job.

Overall this is a good book if you are somewhat new to programming. Else this will make for too short a read.

This book allowed me to quickly create some simple applications using the processing API. So, in that respect, the book was successful. However, the book falls short in three respects.

1) One would expect a book with the title "Visualizing Data" to be crammed with pictures showing many different data visualizations. However, this book has relatively few. Every colleague of mine who passed by my desk and picked up the book had the exact same reaction.

2) The processing language is touted as a means for people unfamiliar with programming to get up to speed with visualization. However, I would be very surprised if anyone with little programming experience would get much out of this book.

3) Don't expect to use this book as a reference for the processing language. It is basically just a collection of half explained examples. Consider for example the function smooth(). This function appears in almost every example but forget about trying to find an explanation of what the function does in the book.

The book is probably worth buying to get up to speed quickly but plan on spending a significant amount of time sifting through the processing.org website and other online resources before being able to get anything non-trivial done. And if you don't already know Java then don't expect to accomplish anything even modestly complex without a lot of outside help.

This is an exceptionally good book on a specialist topic by one of my design heroes. Where most data visualization books present either pages of (often quite ugly) charts and diagrams, but with no tools to create them, Fry manages here to combine both programming skills and a real understanding of design. It's the rare book that manages to do two disciplines really well. Though it's full of code, Visualizing Data is so much more than a technical manual.

This is definitely a programming book; I agree with another reviewer here that if you're already comfortable with Java you'll find this much easier going. But Fry builds his code examples up sensibly, and explains what's going on. A smart Flash developer or Processing dabbler (like me) really won't have any trouble following along. The examples move from simple plotting of points, to time-based animation, to complex correlation, and into more complex visualizations. And it's not just drawing pixels: there are long and useful sections on data acquisition techniques, approaches to parsing and formatting data. Luckily, Fry's a really good writer, and is able to keep these topics from getting dull.

But the great thing about Visualizing Data is that it's also a *design* book--a real one--with thoughtful considerations about use of color, typography, and the "feel" of interaction. Fry's data visualizations are worthy of being in any of Edward Tufte's books. I nearly stood up and cheered when Fry took a few paragraphs in the middle of a code explanation to talk about why the em-dash character and non-lining numerals made the typography of a particular example better. That level of detail is, I think, totally absent from any other book like this.

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