Spotlight customer reviews:
|
Customer Rating:  
Summary: Good introduction if you don't know how to code
Comment: 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.
Customer Rating:
Summary: Mixed feelings
Comment: 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.
Customer Rating:
Summary: Outstanding
Comment: 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.
Customer Rating:
Summary: Information Visualization using the Processing language
Comment: 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
|
|
|
