Haarcascades training (haartraining) is seemed an quick tool to achieve accurate hand gesture detection and recognition. The face and body detection examples included in openCV’s installation example folders (\opencv\data\haarcascades\) demonstrate how fast the haarcascades files help to do the job. More information about how to train the haarcascades files can go to sonots.com.

Many face-image databases have been provided for haarcascades training, e.g. http://www.face-rec.org/databases/. But hand images are less contributed for haarcascades training. At least, these are more difficult than face images to find in the internet. I was also asked by many blog readers for the haarcascades training file to support their hand detection or recognition related projects.

So I post an example of using haarcascades training file 1256617233-1-haarcascade_hand.xml for hand gesture detection.

The source codes can be downloaded from (or go to the download page):

http://download.andol.info/1256617233-1-haarcascade_hand.xml
http://download.andol.info/1256617233-2-haarcascade-hand.xml
http://download.andol.info/haarcascades-based%20hand%20detection.cpp

1. Multitouch and gestures defined

The term multitouch refers to the ability not only to detect physical touches and movements on a screen, but to detect and track multiple touches and movements simultaneously. Touch events are similar to mouse events, except that you can receive and track more than one of them at once, and touch events do not support mouse-specific concepts such as hovering.

Gestures are the synthesis of multiple touch events into a single event. Examples of gestures include “pinching” an image to scale it, or “swiping” to delete something from a list. Some platforms explicitly support the concept of gestures, reducing the amount of work that a developer needs to do in order to detect and react to them, and some platforms require developers to capture multiple touch events and synthesize them into gestures themselves. The Flash Platform automatically synthesizes the most common gestures across different platforms, but also provides developers with the APIs necessary to synthesize their own.

Although multitouch technology has been around for many years, it was the popularity of the Apple iPhone that really introduced the concept to the mainstream. The advantages of interacting with devices directly, rather than through buttons or using a stylus, has become so apparent that the behavior is making its way into desktop computing, as well. Windows 7 supports multitouch right out of the box, HP has been selling touch-enabled TouchSmart computers since 2007, and Microsoft launched the gesture- and touch-centric Microsoft Surface in 2008. Additionally, Apple introduced their multitouch trackpad with the MacBook Air, and has since incorporated the technology into their entire laptop line. Apple’s newest mouse—the Magic Mouse—even has limited gesture support. Touch, multitouch, gesture, and haptic-based computing is becoming so prominent that almost all new high-end, hand-held devices support one or more of these interaction models.

…

For full information please refer this original article http://www.adobe.com/devnet/flash/articles/multitouch_gestures.html

First we gather a data set of all the hand-shapes we wish to recognise. A naive approach to recognizing a new image D would be to simply compare it with all the images stored in the data set and find the target image T with the closest match. But because there are so many images in the data set this will take far too long. We can reduce the time by using a multi-scale approach. We divide up the data set into groups of images, which are similar to one another by blurring the images at different levels so that small differences between similar images will be eroded.

More information please refer here http://www.ercim.eu/publication/Ercim_News/enw46/shamaie.html

A full paper about this can be found here titled as ‘tracking a hand manipulating objects‘

As described by the authors, a method of individual local tracker is used to achieve extractions. To achieve the goal as the left picture shows, it is required to build a 3-dimensional frame to skip the covering of objects and overlapped parts of hands. Seems the authors do not narrowly focus on color image segmentation which has been commonly adopted by computer vision researchers, but they integrate an estimation of features as well as 2.5-dimensional maps. That means probably extra dimension may required. In previous posts, we have successfully located contours of hands yet the shape recognition is still under investigation. And this new method may inspire us something further in hands tracking and recognition.

Linking DLLs:

• To permanantly include necessary dll files, add “C:\Program Files\OpenCV\bin” to PATH by visiting Advanced tab in System of Windows (the locate of directory might be different).
• One can just copy necessary dll files into project directory with source files.
• It might be required to restart Visual C++ when execution of instance failes after successful build.

Customize Global Options:

• Open the Visual C++ .Net Application. In the menu bar, select Tools->Options
• In the listing, choose Projects->VC++ Directories.
• First, select Library files from the “Show Directories for” List Box.
• Click the Insert New icon, and locate the folder where you have installed opencv.
• Consider that it is installed in “C:/Program Files/OpenCV”.
• In the Library files list, locate and add:

“C:\Program Files\OpenCV\lib”

• Now choose Include files in the list box, and locate and add the following directories:

“C:\Program Files\OpenCV\cv\include”
“C:\Program Files\OpenCV\cxcore\include”
“C:\Program Files\OpenCV\otherlibs\highgui”
“C:\Program Files\OpenCV\cvaux\include”
“C:\Program Files\OpenCV\otherlibs\_graphics\include”

• Next, choose source files in the list box, and locate and add the following directories:

“C:\Program Files\OpenCV\cv\src”
“C:\Program Files\OpenCV\cxcore\src”
“C:\Program Files\OpenCV\cvaux\src”
“C:\Program Files\OpenCV\otherlibs\highgui”
“C:\Program Files\OpenCV\otherlibs\_graphics\src”

• Now click OK in the Options dialog.
• You have successfully configured the global settings.

Create New Project:

• Within Developer Studio create new application:
• Select from menu “File”->”New…”->”Projects” tab.
• Choose “Win32 Application” or “Win32 console application” – the latter is the easier variant and both the sample projects have this type.

• Type the project name and choose location
• Click Ok.. In the Application Wizard, Just click Finish.

• After the above steps done Developer Studio will create the project folder (by default it has the same name as the project), <project name>.vcproj file, Solution <project name>.sln and, Three Source files: <project name>.cpp, stdafx.cpp and stdafx.h. StdAfx files are precompiled header files, which can be very useful if you want to reduce the compilation time.
• For example, consider that we have created a new “Hello” Project. Open the Hello.cpp file, and include the OpenCV-related #include directives:

#include <cv.h>
#include <cxcore.h>
#include <highgui.h>

• Note that these should be included after stdafx.h or you may get build errors.
• Now Type some OpenCV code, and Build the Solution by pressing the F7 Key. There should be linker errors.
• Add dependency projects into workspace
• Choose from menu: “Project” -> “Properties”.
• Choose “Linker” tab -> “Input” category -> “Additional Dependencies:”. Add the paths to all necessary import libraries (cxcore[d].lib cv[d].lib highgui[d].lib cvaux[d].lib cvcam[d].lib)
  • Note: The debug versions are available only when you Build the Visual C++ .NET solution provided with the OpenCV installation.

• If the build process complains about a missing ‘windows.h’ header file, then you’ll need to install the latest version of the Microsoft Windows SDK.
• . That’s it!.. Now Build and Run the application using F5 key and enjoy OpenCV!

.

Post quoted from: openCV Wiki, all copyrights reserved by original authors.

I’m using OpenCV for some tests, and for some reasons (freelance gigs and Symbian SDK) using MS Visual Studio. As new and shiny OpenCV 2.0 is out I decided to switch to it. As it happen, one absolutely have to read buried in the download section readme, before doing anything.
The thing is, OpenCV 2.0 doesn’t include lib files for VS. They have to be built by user.
So here is step by step retelling of readme:
1. Rename your old OpenCV installation to save it, just in case
2. Download and install OpenCV 2.0a
3. Download and install CMake
4. Reboot (or CMake wouldn’t work)
5. Go to C:\Program Files\CMake 2.6\bin and run cmake-gui.exe
6. In the “Where is the source code” field choose your new OpenCV directory (C:\OpenCV)
In “Where to build the binaries” choose directory for VS compiled OpneCV (C:\OpenCV\VS2005)
7. press Configure button and choose VS2005 (or whatever) as building enviroment
8. Press Generate and VS project will be generated in the C:\OpenCV\VS2005
9. Launch solution and build it. For debug build some projects require debug python libraries. As riseriyo pointed in comments if you have Python installed other than 2.6 that can cause problem.
10. Copy *.lib from C:\OpenCV\vs2005\lib\release (or debug) to C:\OpenCV\lib
Copy *.dll from C:\OpenCV\vs2005\bin\release to C:\OpenCV\bin
11. Now, reconfigure your application project. Include directories now “C:\OpenCV\include\opencv” instead of “C:\OpenCV\include
12. All libraries renamed from *.lib to *200.lib (cv.lib to cv200.lib) or *200d.lib for debug. Rename them, or change project settings.

The post was posted originally in ‘Mirror Image‘, all copyrights reserved by original authors.

Recently, it is being applied to consumer electronic products because companies consider it an important key to their success.

However, there is a difference in the concept of usability between the two applications. Unlike the software user interfaces, the image/impression felt by the users are as important as the performance for a consumer electronic product to be successful. ”

Morning by Krzysztof Browko

Goðafoss by Ragnheidur Arngrimsdottir

Morning impression by Przemyslaw Wielicki

Central Balkan by Vladimir666

Flowing Water & Ice Formations by Doug Roane

Morning Sun by Norbert Maier

Planet Earth by steler

A Reflective Morning by John Parminter

Gold Fields by Janusz Wanczyk

Sea by jtangen

Morning line by Janusz Wanczyk

Mountain Waves by Alan Czekierda

Dream about a green valley by Janusz Wanczyk

Two valley view by Bergljot

Autumn curve by Janusz Wanczyk

Lovely Old Lane by Northman

Morning valley by Janusz Wanczyk

Elf’s Land by Alexander Maslarski

Thin Ice by Doug Roane

In the mist’s sea by Janusz Wanczyk

The Sky Goes All the Way Home by Mark Broughton

Strolling on the Dolomites by Robert Strahinjic

Glacier Formation by Axel Gimenez

Sea by Boots

Pangong Tso by Prateek Dubey

The Other Side by Stefan Bingham

Seljalandsfoss by Henrik Spranz

[From smashingapps.com, all rights reserved by original authors]

This showcase will focus mostly on the layout and organization schemes. Below are about 40 different typographic layouts used in different fields of print such as brochure design, editorial design, and poster design.

Effektive CV/Poster Mailer

Spit Kingdom

Sheridan & Co.

Avant Garde Gothic Typeface Booklet

Akimoto Typeface

NTU Art & Design Prospectus

BABE

Rizzo + Gobart

Mise au point

UsineSonore

Bionic Systems

National Geographic

Colorcubic

Kiosk 37

ALPHA_TXT

Posters by Official Classic

Poster

Stel Christian Cambas Poster

Typography Poster

Beck 8-Bit Variations

Children of the idiom

Commune

Aesthetic Mathematics

What’s the World…

Oscar_Wilde_Retrospective

Play With Colors

Posters by Pablo Alfieri

More Posters by Pablo Alfieri

99 Dingbats

No Lemon Daydream Magazine

Lazydog

Real Dutch Design Books

Macro Micro

Marius Martinussen

DADA Design

Berlin Cafe Posters

[From smashingmagazine.com, all rights reserved by original authors.]

I have a similar problem. On page.php, after the loop I’m using get_posts to grab and display some Posts that are related to the current Page.

Everything is fine except that I’m getting full content without the more link. Does the more quicktag not work with get_posts on page.php?

Here is the solution: 

the “more…” does NOT work on Pages by default – a Page displays just one single entry, so no need for it: there is no “multi-Page” view in WP.

According to some older posts in this forum that you could find by searching – this should address the issue:
<?php $more = 0; ?> if placed before the query.

After much experimentation, here is what I’ve learned:

The more quicktag does not seem to work with get_posts() outside the loop even when using $more = 0; or a custom template instead of page.php.

The more quicktag will work with query_posts() outside the loop if you set $more = 0; even if you use page.php.

A note for people switching functions. Use category= with get_posts(). Use cat= with query_posts().

Next challenge: get tags working on my related posts displayed below a page’s content.

Here’s my query for posterity:

<?php if (isset ($relatedcat)) {
// related cat set in custom field
 $query= 'numberposts=99&cat='.
$relatedcat.'&orderby=date&order=ASC';
 query_posts($query); // run the query
 global $more; $more = 0; // allow more quicktag
 while (have_posts()) : the_post(); // the loop
 setup_postdata($post);
?>
<div class="post" >

It can be a daunting task to hunt exactly where memory needs to be released. So I’ve compiled this short list of places where you should look out for memory leaks.

Create it, then Release it

If you create something, make sure you release it before “returning”. This is probably the very first thing you should check when fixing memory leak problems with OpenCV. For example, if you do a cvCreateImage, make sure you do a cvReleaseImage. There are many things you can create. Here are some functions that “create” and their corresponding “release” functions

One warning though: If you create something and want to return it, don’t release it. Lets say a function that creates a checkerboard image and returns it. If you release the image before returning it, you’re freeing all memory that stores the image data. And when you try accessing memory that isn’t yours, you get a crash.

Release returned structures

This is the second thing you should check for. Often, once you return a structure (say, an image).. you forget about it.

Multiple Memory Allocations

This is the third thing you should check for: Allocating memory, and then changing the pointer itself. Here’s some example code:

IplImage* image = cvCreateImage(whatever);
image = CreateCheckerBoard(whatever);
…
cvReleaseImage(&image);

This function creates a memory leak. First, you allocate some memory for image. Then, you call the function CreateCheckerBoard. This function itself creates new memory. And image now points to this new memory. The memory created in the first step is lost forever. No variable points to it. A memory leak. To fix this, you need to modify the code like this:

IplImage* image = NULL;
image = CreateCheckerBoard(whatever);
…
cvReleaseImage(&image);

If you return a sequence, release its storage

There are many instances where you use the CvSeq data structure. And often you might want to return this structure for further use. If you release its storage (a CvMemStorage structure) within the function itself, you’d free the memory where the sequence is stored. And then you’d try and access it in the calling function. Again, crash.

A temporary fix would be to just erasing the cvReleaseMemStorage statement… but that would mean lots of memory.
To fix this, you don’t release the memory in the function itself. You release it in the calling function like this:

cvReleaseMemStorage(&thesequence->storage);

storage is a member of the CvMemStorage structure that always points to the memory where its stored.

Again, this is just an example. There are more structures where a similar situation could arise.

Dependence on other structures

I quite recently discovered this memory leak. To explain this, I’ll use an example: Lets say you find out the contours of an image. OpenCV would return a “linked list” type structure calledCvSeq. You decide to access the third element of this linked list. OpenCV returns a pointer to the third element. All going great till this moment.

Now you decide to save all the points of this contour (the third element) in a data structure of your own. Since this is an array of points, you do something like:

mystructure->points = thirdcontour->points;

You set the pointer to equal to the thirdcontour. This is the bug. If you release the storage of the sequence (which you should), mystructure has a bad pointer. To fix this, allocate new memory to mystructure->points and then copy contents ofthirdcontour->points… something like this:

mystructure->points = (CvPoint*)malloc(sizeof(CvPoint) * thirdcontour->total);
memcpy(mystructure->points,thirdcontour->points,sizeof(CvPoint)*thirdcontour->total);

This creates new memory for your structure and then copies each element there. Once you’ve done this, you can release the storage of the sequence without fear.

Six feet by Lev Tsimring

envy by Fulvio Pellegrini

Please wait a little by Marc Siewior

Turtle and apple by Vedran Vidak

Collaboration by ryandws

Kung Fu Master by Lina Gunawan

Softdrink Addict by Andrei

About a dream by Jurga

Sunshine in a cup by She Hates Monday

Tired by Bill Mangold

Teaser by Johan Lind

So Hungry by Heath Carney

Say, Harold, haven’t we seen her before? by Ursula I Abresch

I’ll never talk to you again by Adrifil

Passionate by Ursula I Abresch

You are my best Friend by Jani

Ohhh Nooooo!!! by Mark B Bartosik

Anatomy Lessons by Paul van Geldrop

No Birds by Sameli

Bicho by Barbara C.

The Dancing Nebula

Infinity

Experiment Wall

Age Is Beauty

Loose Leaf

Motion Senses

A E R O S T R E A M

HD walls for windows

Experiment Wall

Explo Wall

Rainbow

Reflux

Horsehead Nebula

Ever Wondered?

Confused Trajects

Dusk

ONyx

Horizon

Zebra stripes

Blue Interlaced

Explode texture

Apple color shades

Epic

Leopard Aurora

Hologram Reflector

Used Crayons

Ultimate Vista

Last Stripes

Magma texture

Life Magic

Vortex Apple

Bunch of light vectors

Blue Apple logo

Abstract waves

Not thinking straight

Spirit Lanterns

According to the algrithms of  HOUGH, that is more accurate to line detection rather than circle detection, although some times it looks not so much different in theory. Actually, if detecting circles in a black-white picture, it will be obviously not so accurate as detection for lines. Detected circles are always flashing in different possible positions.

To solve this problem and low the mistake detection, the target picture should do some filter: SMOOTH.

cvSmooth( gray, gray, CV_GAUSSIAN, 11, 11 );
cvCanny(gray, edge, (float)edge_thresh, (float)edge_thresh*3, 5); //get the circle edges
CvSeq* circles =  cvHoughCircles( gray, cstorage, CV_HOUGH_GRADIENT, 2, gray->height/50, 5, 35 );
cout << circles->total <<endl; //check how many circles detected
int i;
for( i = 0; circles->total>=2?i<2:i < circles->total; i++ ){
float* p = (float*)cvGetSeqElem( circles, i );
cvCircle( src, cvPoint(cvRound(p[0]),cvRound(p[1])), 3, CV_RGB(255,0,0), -1, 8, 0 );
cvCircle( src, cvPoint(cvRound(p[0]),cvRound(p[1])), cvRound(p[2]), CV_RGB(200,0,0), 1, 8, 0);
}

After finished basic shapes recognition using openCV, we would step new progress — hand recognition. I saw some researchers said computer vision as key part of artificial intellegence due to its hardness. That probably is right, because when i started the hand detection ( before recognition ), i was blocked by the algrithms to accuratly detect the hand shape. Nothing simple algrithm will be applied directly here due to the variation of hand gestures.

When i googled how to detect hand gestures, i found  HandVu .

HandVu is a library of hand gesture recognition based on c++/c and openCV. According to the demoes published in web, this library looks powerful, although still is getting mature. When i tried to download the source files, i found the version hasnt been updated for years until 2006 and the downloaded binary didnt work right with alerts of *.dll files getting lost , that was probably caused by the openCV version.

Whatever, at least the HandVu library offered guidline of hand recognition.

In this post, i will present you the new progress of object recognition using openCV—angle recognition.

Actually, this is just a small step further than the last one which is rectangles’ recognition. From the four outlines of rectangle as well as the four corner points, we can get two relative points to calculat the angle between them. As inllustrated below, i chosed two points which are most left and right. Once the position of these two points are captured, the SINE value of the angle can be calculated like this

SIN (angle) = abs(p1.y-p2.y)/sqrt(
(p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y))

So, that’s it.

April 26th, 2007

Multitouch Audio Exploration

---

Jens Wunderling has been working on an interesting project for over a year now, he started with a single touch ELO display and now he has implemented it with multitouch.

loopArena is an AMAZING interactive audio tool, similar to a sequencer, however much more dynamic. Jen’s calls it an “agent based generative music interface”, which allows for multiple users to generate live music.  No typography, rasters and tools are needed because interaction is limited to dragging objects with the fingertips. I would imagine that this gives the artists a lot more freedom and allows one’s creativity to flourish.

He has been working with Ulrich v. Zadow of the MTC team. And as you can see from the video above the results are stunning. As for the technical details, the User Interface, Timing and MIDI Out are all made in Processing, Touch data is received from the libavg framework via OSC, and Processing sends Out MIDI data to Propellerheads Reason. You can read about how it all started as his Intermediate Diploma project.

There was a problem often happened in the prototype demonstration. When turned off the demonstrating computer and camera and then turned it on, there popped a interesting problem that was the camera was reset and the preset zoom area disappeared.

So, the best idea is to design a lable to tell prototype which part is target work place and which parts are not. After one day’s researching, finally, the solution is presented here (the picture above)— two circle dots are used to specify the invisible border of work place, out part of these two dots’ rectangle, there would not be work place any more, vice versa.

Do you like the new Google Chrome? Just admitted, almost all people like it after using it, it is smart, responsing quick and simply and easy-so many merits that hardly can not we dislike it.

However, there is a problem while i was surfing the web today, i cited the reason here:

[From 'http://searchlightdigital.com', all rights reserved by original author]

For those of you who enjoy living under rocks, Chrome is the new browser created by Google. It is open source and currently only available for Windows, although I have found a site that says how to build it from source for the Mac. However, despite the hype, I have decided that I will not be using it. In fact, I’m not even going to download it.

Is it because they don’t have a Mac version? Well, whilst it’s annoying that we Mac users have to wait, I’m not so aloof as to hold that against them, and let’s be honest, there’s a whole lot more Windows computers out there than OSX. Also, I could just compile it myself.

No, the reason I won’t be getting it is their terms of service, the fine print of the program. So, what do they say that I am not happy about?

Section 11.1
You retain copyright and any other rights you already hold in Content which you submit, post or display on or through, the Services. By submitting, posting or displaying the content you give Google a perpetual, irrevocable, worldwide, royalty-free, and non-exclusive license to reproduce, adapt, modify, translate, publish, publicly perform, publicly display and distribute any Content which you submit, post or display on or through, the Services. This license is for the sole purpose of enabling Google to display, distribute and promote the Services and may be revoked for certain Services as defined in the Additional Terms of those Services.

Converted to English this means that anything I send via Chrome is usable by Google, they don’t own it but they can republish it and use it. Imagine that you are using it to post to a forum or blog, Google gets a copy that they can use. Lets suppose you use it to send a message about a really good idea you’ve just had, Google got a copy too.

It may be a really good browser that’s several times as fast as Safari but in all honesty, I don’t think that I can use it knowing that everything I post Google gets a copy of. I run an online game that is free at the moment but what if I want to moneytise it? Google probably doesn’t want to compete with me on it, but imagine if they did? The irony is that I used to use a Gmail account and still use it for some things and I never thought to read the ToC on that.

If you want more stuff about Chrome, PCWorld have a good article that lists 7 pros and cons of Chrome.

These beautiful shelves from the Tank Collection are designed by Peter Petersen.

Introduction

In this tutorial I will show you how to build a simple 3D photo album in AS3. We will build an application similar to this one.

I will use two AS3 libraries: FIVe3D and TweenLite, both open source. Five3D is a lightweight 3D library written by Mathieu Badimon. TweenLite is one of the many libraries available for script based animation in AS3. It was created by Jack Doyle from Greensock. It’s principal characteristic is that it’s small (hence it’s name) and simple to use. FIVe3D and TweenLite work very well together!

Please visit the homepages of both these libraries - FIve3D, TweenLite - to learn more. You do not have to download them however – they are already included in the tutorial files. I used FIVe3D v2.1 and TweenLite v6.31 (both latest ones at the time I was writing this).

The pictures of Stockholm used in this tutorial are from my private collection.

 

1. Setting up the workspace

Start by downloading the tutorial files - here. Unpack the ZIP file into a folder on your disk. Inside the package you will find a folder called ‘work’. This folder contains a FLA file and all the classes you need to build the album. Open the ‘album.fla’ file you will find in there.

You do not have to modify anything in the ‘album.fla’, but let’s just take a look what’s in there. The document class should be set to ‘Main’, the AS3 classpath in the ‘Publish settings’ – to ‘./src’. Finally, the export path in the should point to ‘../album.swf’.

Now open the ’src/Main.as’ with your favourite AS3 editor. This is our document class. It doesn’t do anything for the moment, but you can notice that is extends the ‘Sprite’ class, sets the scaling and alignment properties of the ’stage’ object and traces a short message. Test ‘album.fla’ using Ctrl+Enter in the Flash IDE. You should see a black screen and a message in the output window saying ‘Ready to go!’. If you see this message, then in fact we ARE ready to go!

Quick note: The folder ‘full’ contains complete source files of the finished application. Use it for reference, if you have problems or bugs. The folder ‘pictures’ contains the pictures used in this example.

2. Loading pictures

Now that you have both files open – all the work will consist of editing the ‘Main.as’ file and testing it by exporting the ‘album.fla’ file.

The first step is to load all the pictures we will be using in our album. They are located in the ‘photos’ folder, and since the ’swf’ file is exported to the root folder, the path to the pictures in our application will look like this: ‘photos/photoName.jpg’.

Let’s start by adding some import statements that we will need at this stage:

import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Loader;
import flash.events.Event;
import flash.net.URLRequest;
import flash.text.TextField;
import flash.text.TextFormat;
import flash.text.TextFieldAutoSize;

Now, let’s declare some objects we will be using. Variables should always be declared just below the class declaration line, and in that case it should look like that:

public class Main extends Sprite {

 private var numPicture:int = 9;
 private var picturePath:String = "photos/photo0";
 private var pictureExtensiton:String = ".jpg";
 private var loadingIndex:int = 1;
 private var loadingInfo:TextField;
 private var pictures:Array;
 private var pictureLoader:Loader;

The variable ‘numPictures’ holds the total number of pictures, and ‘picturePath’ and ‘pictureExtensiton’ will be used to construct a correct path to each picture.

In a real world solution you would probably load an XML file containing all the paths to all the pictures, the total number and maybe even a title and a description for each one. Loading and parsing XML files goes beyond the scope of this tutorial however, so for the sake of simplicity all those values are hard coded. If you want, after you complete the tutorial, you can modify the code so that it uses an XML file. This would be a great exercise!

The ‘loadingIndex’ property will helps us keep track of how many pictures are already loaded. We will display this information to the user – this is what the ‘loadingInfo’ text field is for. All the loaded pictures will be put into the ‘pictures’ array. Finally, to load the pictures, we will use a Loader object, that I called the ‘pictureLoader’ (obvious name, isn’t it?).

At this moment, we can add some actual code. In the constructor function you can remove the line with the ‘trace’ command and replace it with this:

loadingInfo = new TextField();
loadingInfo.defaultTextFormat = new TextFormat("Verdana", 10, 0xffffff);
loadingInfo.autoSize = TextFieldAutoSize.LEFT;
loadingInfo.text = "Loading picture " + loadingIndex + " of " + numPicture;
loadingInfo.x = stage.stageWidth/2 - loadingInfo.textWidth/2;
loadingInfo.y = stage.stageHeight/2 - loadingInfo.textHeight/2;
addChild(loadingInfo);
pictures = new Array();
loadPicture();

The first 7 (out of 9!) lines are needed to create and position a text field that we will use to display a preloading information. I heard people complaining that in AS3 you have to write lots of code to do a simple thing. Sometimes it’s true 

Apart from adding the text field, we also initialize the ‘pictures’ array and we call the ‘loadPicture’ function. If you try to export your fla at this point, you will get an error, since this function is not yet there. Let’s add it after right after the constructor:

private function loadPicture() {
  pictureLoader = new Loader();
  pictureLoader.contentLoaderInfo.addEventListener(Event.COMPLETE, onPicture);
  pictureLoader.load(new URLRequest(picturePath + loadingIndex + pictureExtensiton));
  loadingIndex++;
}

private function onPicture(e:Event):void {
  var picture:BitmapData = (e.target.content as Bitmap).bitmapData;
  pictures.push(picture);
  if (loadingIndex <= numPicture) {
    loadingInfo.text = "Loading picture " + loadingIndex + " of " + numPicture;
    loadPicture();
  } else {
    removeChild(loadingInfo);
    buildAlbum();
  }
}

private function buildAlbum():void {
  trace("Pictures loaded!");
}

I know, it is 3 function instead of just one! They are all needed for to complete the loading operation, that’s why they are here.

The function ‘loadPicture’ load a single picture and increments the ‘loadingIndex’ variable by 1.

Since I add an event listener to the loader, when the picture is loaded the ‘onPicture’ function is invoked. At this point I check if the ‘loadingIndex’ is still less then the total number of pictures. If this is true – I call loadPicture again to load the next one. If not, it means that all the pictures are there. In that case I can remove the loading information text field and call a function to build the album. Export your fla and you should see the text ‘Pictures loaded!’ in the output window after a short while.

Take a look a the first line of code in the ‘onPicture’ method. When external images are loaded, whether it is a jpg, gif or a png, Flash will wrap it into a object of type ‘Bitmap’. A Bitmap is a DisplayObject, so it can be added to the display list and thus be display on the screen. However, in our case we do not want to display the pictures directly. We will use them as 3D textures instead, so we do not need the Bitmap object, but a BitmapData objects instead. Fortunately they are easily accessible from Bitmap.bitmapData, and this is what the first line in that function does. In the next line I store the BitmapData in the ‘pictures’ array for later use.

3. Building 3D album

If you tested the application so far, you should get the ‘Pictures loaded!’ message in the output window. Now let’s display them!

First, we will need to import some more classes. Add this in the import section at the top of the class:

import five3D.display.Scene3D;
import five3D.display.Bitmap3D;
import five3D.display.Sprite3D;
import flash.geom.ColorTransform;

These are the all the 3D classes from the FIVe3D library we will be need (yes, only 3!). The ColorTransform class will be used for rollover/rollout effects.

Next, we need to declare some more variables. Right after the previous declarations, enter the following code lines:

private var scene:Scene3D;
private var album:Sprite3D;
private var padding:Number = 60;
private var fullViewZ:Number = 2400;
private var darker:ColorTransform = new ColorTransform(.8, .8, .8, 1, 0, 0, 0, 0);
private var lighter:ColorTransform = new ColorTransform(1, 1, 1, 1, 0, 0, 0, 0);

All 3D content in FIVe3Dmust be put inside a Scene3D. We’ll use the scene variable to store a reference to this object. Our album will be a Sprite3D, and this is what we declare next. The ‘padding’ is the distance between pictures in the album, so that they do not stick one to another. The ‘fullViewZ’ property is the z-distance of the album from the screen. The bigger the z value the further in depth the object appears. 2400 is a value big enough to allow us to see all the pictures in the same time, not cropped.

The ‘darker’ an ‘lighter’ ColorTransform object will be used for rollover effects. When applied to a Sprite, the ‘darker’ makes it slightly… darker. The ‘lighter’ restores the sprites original colors. One of the coolest things in FIVe3D is that a Sprite3D actually extends a regular Sprite and most of the operations that can be done on a Sprite can also be done on a Sprite3D. That includes the changing transform.colorTransform property that we are going to use here.

The real fun begins now! We will start to build a 3D view of the album. Replace the trace command in the ‘buildAlbum’ function with this:

scene = new Scene3D();
scene.x = Math.round(stage.stageWidth/2);
scene.y = Math.round(stage.stageHeight / 2);
addChild(scene);

This code will create the indispensable Scene3D, position it in the middle of the screen and add it to the display list. And that’s it, the 3D stage is ready! Now, we can create the album. Continue by adding this:

album = new Sprite3D();

for (var i:int = 0;  i < pictures.length; i++) {
  var bitmap3d:Bitmap3D = new Bitmap3D(pictures[i] as BitmapData);
  var picture3d:Sprite3D = new Sprite3D();

  bitmap3d.x = bitmap3d.bitmapData.width / -2;
  bitmap3d.y = bitmap3d.bitmapData.height / -2;
  picture3d.addChild(bitmap3d);

  var row:Number = Math.floor(i / 3) - 1;
  var col:Number = i % 3 - 1;
  var pw:Number = bitmap3d.bitmapData.width + padding;
  var ph:Number = bitmap3d.bitmapData.height + padding;
  picture3d.x = row * pw;
  picture3d.y = col * ph;

  picture3d.transform.colorTransform = darker;
  picture3d.buttonMode = true;
  album.addChild(picture3d);
}

album.z = fullViewZ;
scene.addChild(album);

This code is a bit more complicated, but still very simple to understand. First, we create the album Sprite3D. This one will be a holder for all the pictures.

Next, in a for loop, we traverse the pictures array (remember that one?) It holds a collection of objects of type BitmapData, each one representing a picture. To display the picture in 3D we must wrap it into a Bitmap3D object, and this is what we do first.

Each picture must be clickable. Unfortunately a Bitmap3D does not extend Sprite3D so it doesn’t support interactivity – this is the same situation as with Sprite vs. Bitmap in regular AS3. To make the pictures interactive we need to wrap each Bitmap3D into a Sprite3D.

When a child is added its top-left corner is always positioned a 0,0 coordinates of its parent. It works so in AS3, and FIVe3D correctly follows this behavior. What we need here is to position the Bitmap3D inside the Sprite3D in a way that its center is at 0,0 coordinates not its top-left corner. That is why offset the x and y coordinates of the bitma3d by half its width and half its height respectively.

Next, using some simple math we distribute the Sprite3Ds in a 3×3 pattern.

Finally we apply a dark color transform to each Sprite3D, we set their ‘buttonMode’ property to true and we add it as a child to the ‘album’ Sprite3D. The final code after the loop positions the album on a correct z distance (while x and y are set 0 by default). And, once the album is ready, we add it to the scene object as a child.

You can test the application now. You should see all 9 pictures as small thumbnails laid out in a 3×3 pattern in the middle of the screen. Not very interesting, huh? Yep! And it won’t get any better until we add some interactivity!

4. Adding interactivity

Interactivity in the album will consist of handling some mouse events and using TweenLite to animate objects. Before we move on let’s add a final set of imports:

import gs.TweenLite;
import fl.motion.easing.Sine;
import flash.events.MouseEvent;

TweenLite is just one class. To define the easing of animations is uses the classes from the standard fl.motion.easing package – we will use the Sine. At the end, we need the MouseEvent to handle mouse interaction of course.

We also need to declare two more variables:

private var zoomMode:Boolean = false;
private var zoomedPicture:Sprite3D;

The boolean value ‘zoomMode’ will inform us whether the album is in full view or if one of the pictures is zoomed. ‘zoomedPicture’ will be use to hold a reference to the currently zoomed picture. This behavior will be added in the last step of the tutorial, but we need these variable already now.

Now let’s get back to the ‘buildAlbum’. Right after the last line, where the album is added to the scene, let’s enter some listeners:

album.addEventListener(MouseEvent.ROLL_OVER, onOver, true);
album.addEventListener(MouseEvent.ROLL_OUT, onOut, true);
stage.addEventListener(Event.RESIZE, onResize);
stage.addEventListener(MouseEvent.MOUSE_MOVE, moveAlbum);

The first two lines need special attention. What I do here is add a rollover and a rollout listeners to the container that holds the pictures. Now, of course, I do not want to listen to the rollover/out event on the container, but I’d rather do that on each picture. That is what the third argument does. This argument is called ‘useCapture’ and if it is set to ‘true’ it will notify the parent display object – the album in this case – of any event of that type dispatched by any of is children (or any of its descendants to be exact). So whenever a Sprite3D containing a single picture is rolled over or out, the album, its parent, is notified. It is a very powerful technique of the AS3 event system!

Now we can add the functions to handle the rollover/rollout events. Notice how I get a reference to the object that dispatched the event using the ‘target’ property of the event object:

private function onOver(me:MouseEvent):void {
  if (me.target is Sprite3D && !zoomMode) {
    (me.target as Sprite3D).transform.colorTransform = lighter;
  }
}

private function onOut(me:MouseEvent):void {
  if (me.target is Sprite3D && !zoomMode) {
    (me.target as Sprite3D).transform.colorTransform = darker;
  }
}

The next listener will be called whenever the stage is resized. That happens, for example, when the user resizes his browser window. If that happens we will center the Scene3D on the screen. Such feature is always nice to have, and the code is simple:

private function onResize(e:Event):void {
  scene.x = Math.round(stage.stageWidth/2);
  scene.y = Math.round(stage.stageHeight / 2);
}

Of course, I left the best for the end. Here’s the function that handles the 3D movement of the album based on the mouse pointer position:

private function moveAlbum(me:MouseEvent):void {
  if (zoomMode) return; 

  var mouseXPos:Number = (me.stageX - stage.stageWidth/2) / (stage.stageWidth / 2);
  var mouseYPos:Number = (me.stageY - stage.stageHeight/2) / (stage.stageHeight / 2);

  TweenLite.killTweensOf(album);
  var props:Object = new Object();
  props.rotationY = 45 * mouseXPos;
  props.rotationX = -15 * mouseYPos;
  props.x = 400 * mouseXPos;
  props.y = 300 * mouseYPos;
  props.ease = Sine.easeOut;
  TweenLite.to(album, .3, props);
}

I introduced the zoomMode flag here, because all the mouse interaction, as well as rollover/out interaction will be disabled when one picture is zoomed. We will add this functionality in the next part of the tutorial.

After this basic check, I divide the mouse position by the stage width in a way to get a value between -1 and 1, where -1 means the mouse is on the left edge of the screen, and 1 means it is on the right.

Next, I call the ‘killTweensOf’ method to make sure any animation that might be going on now will be terminated. Now I can setup and start a new animation.

I assemble the properties of the new animation in the props object. They are all based on the mouse position and have some maximal values. For example, rotationY can have a minimum value of -45 and a maximum value of 45 degrees. Once the animation properties are ready, I must add a last one, called ‘ease’ which specifies the type of movement and easing to use. In the last line I call TweenLite and pass the object to be animated – the album, a time for the animation expressed in seconds – 0.3 seconds in this case, and the target properties for the animation.

Try the application now. The 3×3 album should be responding to the mouse movement by rotating and moving sideways. Each picture should become slightly lighter on rollover and darker again on rollout. Finally, if you resize the window, the album will always be centered vertically and horizontally.

You’d better start enjoying 3D flash applications by now. Because you’re in one!

5. Zooming pictures

Before we finish we need to add one more important feature: the ability to zoom pictures. We do not need any new import statements, nor do we need to declare any more variables. What we need to do is to add another listener. In ‘buildAlbum’ function add a last line:

stage.addEventListener(MouseEvent.CLICK, onClick);

And here is the ‘onClick’ function.

private function onClick(me:MouseEvent):void {
  var props:Object;

  if (me.target is Sprite3D && !zoomMode) {
    TweenLite.killTweensOf(album);
    props = new Object();
    props.z = 0;
    props.rotationX = 0;
    props.rotationY = 0;
    props.x = 0 - me.target.x;
    props.y = 0 - me.target.y;
    props.ease = Sine.easeInOut;
    TweenLite.to(album, .6, props);

    zoomedPicture = me.target as Sprite3D;
    zoomMode = true;
  } else if (zoomMode) {
    zoomedPicture.transform.colorTransform = darker;

    TweenLite.killTweensOf(album);
    props = new Object();
    props.z = fullViewZ;
    props.x = 0;
    props.y = 0;
    props.ease = Sine.easeOut;
    props.onComplete = onBackToFull;
    TweenLite.to(album, .3, props);
  }
}

In that case we are listening to a mouse click event on the stage object. That means that any click anywhere on the stage will result in calling this function. That is why what we need to know what was clicked and what is the state of the application, before we can take any action. We will use the ‘target’ property of the event object and the ‘zoomMode’ flag to figure this out.

First possibility: a picture was clicked. That means the target is a Sprite3D and the zoomMode is off. This is the situation handled by the first part of the ‘if’ statement. In that case we start a tween with all the rotation properties set to 0 – we want the picture to face the screen. For the x and y, we also set them to 0 and we subtract the position of the picture inside the album – this way the zoomed picture will always be positioned in the middle of the screen.

The z property for the album is also set to 0, but in that case 0 has a special meaning. In FIVe3D, if you keep the default settings for the Scene3D object (as I do here) and set an objects ‘z’ property to 0 it will be scaled 1:1 to it’s original size. This way we make sure the pictures will have the best possible quality when zoomed in.

Finally we keep a reference to the clicked picture in the ‘zoomedPicture’ variable and set the ‘zoomMode’ flag to true.

The next possibility is that a click event occurred when ‘zoomMode’ in on. In this situation we ‘un-zoom’ the album no matter what was clicked.

The second part of the ‘if’ statement does pretty much the opposite of the first one as long as the animation is concerned. What is worth noting is that the ‘zoomMode’ is not being reset. Instead I create a new property for the TweenLite called ‘onComplete’. It takes a function as argument. That function will be called when the animation is over. Here’s the code:

private function onBackToFull():void {
  zoomMode = false;
}

I reset the ‘zoomMode’ property after the animation is over, because if it was reset before, the animation caused by the movement of the mouse pointer could interfere with the zoom out, possibly causing an unpredictable behavior.

Conclusion

If you take a look at the swf you will notice that it is around 16KB in total. The Main class consists of less then 200 lines of code. It means that you just made yourself a 3D photo album application that loads in less then a second and with virtually no coding at all (200 lines, come on!). Isn’t it awesome?

Now it is your turn to take this application to the next level:

• Load the album information from an XML file
• Add a title and a description for each picture
• Use 3D to dislpay them – FIVe3D is particularly good at handling 3D text
• Make it work with any number of pictures of different size and aspect ratios
• Load the pictures from your flickr account using the Flickr API
• A nice tweak would be to add reflections for the pictures in the bottom row
• In the zoom mode, the other pictures could be accessible without having to zoom out first
• or… anything else you want 

Hope you enjoyed the tutorial. Have fun!

Beached from Keith Loutit on Vimeo.

Tilt-shift photography is really different from other nornal camera photographies, look the camera angle of this video, amazing.

More videoes and pictures

Bathtub III from Keith Loutit on Vimeo.

Bathtub II from Keith Loutit on Vimeo.

Tilt-shift effect (test 2) from Julien Vignali on Vimeo.

[From smashingmagzine.com, All rights reserved by the original author.]

A significant evolutionary shift has occurred in human-computer interaction design. Prior to this shift, computer software designers tended toward a computer-centered design approach that at best assumed and at worst ignored the needs and preferences of end users.

This approach prioritized the attributes of the technology itself and often resulted in design solutings that were in search of problems. Its limitaions gave rise to a human-centered design in which users articulated their needs and developers observed or listened to users and then addressed various needs in their designs.

Ulike the technology push of computer-centered design, human-centered design emphasizes human needs and objectives and the technology that serves these purposes.

[From 'activity-centered design']

In this section, we would like to point out three interesting parallels where concepts and developments from other disciplines offer relevant insights into the nature of our own work in interaction design.

Eye of a Tokay Gecko
“A close-up shot of a Tokay Gecko. Their eyes remind me of old-fashioned keyholes. Thanks for looking!” The photo is taken by Alan M.

La force et la passion
“She felt her strength and passion back by 1 small drop of water.”. The photo is taken by Leon Baas.

High-Tech Jumper
“Jumping spider on a DVD reading my data! Shot with a Canon 20D with a Canon MP-E macro lens.” The photo is taken by Coder.

Bubble Magic
“Close-up of a wet leaf … taken with a Canon Powershot A610 ” The photo is taken by Sophie.

Lasius Vlavius
“This yellow meadow ant is trying to find a way to dry ground after the rain”. The photo is taken by Leon Baas.

Flower Detail
Close-up of a very colorful flower.

Frog’s eye
Photos are taken by Justin Dotson.

Dewdrop Refraction
Taken by Brian Valentine.

Water lily
The photo is taken by Chun-Chih Fan (ddsnet).

A flower
The photo is taken by Indah Susanti.

Another vision
The photo is taken by Kristina Buceatchi.

A Flower
The photo is taken by Cyril Cattin.

Igor Siwanowicz

Under a microscope

Crane Fly
This insect looks like something out of a Sci-fi movie.

A flower
The photo is taken by Chan Chen.

Spider
Stunning detail of a spider.

8.365 I saw the sea
The photo is taken by Lux Tenebra.

Water & Rose
Beautiful colors.

European hover fly in profile

Refracted Daisy
You can see the refracted daisy in the blurred background.

White Spider

Flower in water
Amazing picture of a flower sitting in water. The reflection almost looks surreal.

House fly
Simply wonderful photo.

Red Veined Darter
Truly stunning macro of this insect covered in morning dew. Wow!.

Whether you upload, embed, or invite user contributions, Magnify.net’s platform can power your site’s video experience. The magnifyfree product allows you to gather videos from across the web and build your own video channel for free!

Complete control of your site name, url, page design and CSS, as well as 50% of the advertising impressions delivered to an ad network of your choice.

Features

• Free webpage builder
• Webcam capture
• Video discovery from the most popular video sharing site
• Ten 50mb uploads per week
• “Friending” based social network
• 50/50 ad inventory share

You are welcome to share if you know more amazing firefox add-ons that will save time which our readers/viewers may like.
Read It Later

It lets you save articles and webpages so you can read them later, even when you’re offline. Now the internet is your bitch. Firefox add-on
Chunkit

This add-on is so badass, that if search engines made a superhero movie, this would be the Batman. Basically, you get to search any website with sonar vision and see through all the links at once. Firefox add-on
Remove Cookie(s) From Site

So, you visited a website you’re not too proud of, but you don’t want to delete your cookies or you will lose your progress on Defend Your Castle. Well now you can have your cookie and eat it too. Firefox add-on

YourWebsiteValue

This is your childhood cardboard fort of Firefox add-ons. Absolutely useless, but very… very cool. Basically this shows you the estimated worth of most websites. Who knows how accurate and useful it really is, but hey, did you really think your cool fort could actually keep the girls out? Firefox add-on
TryAgain

This is the Drunk Uncle at the bar that won’t stop hitting on the ladies of Firefox add-ons. TryAgain will keep trying to load a webpage when the server is not found, and it won’t stop till it gets what it wants. Firefox add-on
IMDb Preview

IMDb suffers from Wikipedia syndrome. How many times have you started on Pee-wee’s Big Adventure and ended up on The Shining? Too many damn times. However, with this add-on you get to preview links on IMDb and see snip-bits of information without leaving the page. Wait, why doesn’t Wiki have this?
Aging Tabs

What’s your record? 20 tabs open at once? Well Aging tabs will help you realize your laziness by making unused tabs fade and change colors with age. Although, it would be cooler if they made the tabs blow up in a fiery explosion instead.
Tab Mix Plus

This is the ultimate tab collection, greatest hits volume, 0.3.6. It has such classics as duplicating tabs, controlling tab focus, tab clicking options, and many of your other favorite hits. And if you download in the next 15 minutes we will throw in “undo closed tabs and windows!” Firefox add-on
CoolPreviews

Preview how a webpage page looks like before you actually click on the link. So now you can see how unorganized, useless, and ugly the website is before you commit your precious time to it. Dating really needs a tool like this. Firefox add-on
You can also take a look at 5 must have firefox add-ons for social media addicts I found interesting on the other website.

We asked Mike Shaver, who is now Mozilla’s VP of engineering, to comment on how he views the Gecko/WebKit dichotomy today and why he believes Gecko is still important.

“I have a lot of respect for the WebKit guys, and for the work they’ve done,” he told us in an e-mail. “The web is better because they’re around and pushing hard, and Mozilla itself is better from the competitive push as well as cooperation ranging from new web standards to plugin interfaces to the nerdiest of implementation discussions.”

Although he respects the technical achievements of WebKit, he believes that the WebKit development model and fragmentation in the WebKit ecosystem would create serious challenges that make it unsuitable for Firefox.

“We’re getting a ton of value out of a unified engine for all our projects, from desktop to device and xulrunner to Thunderbird. If you look at the WebKit landscape right now, you see a lot of different projects there and it’s not clear how or if they’ll converge,” he wrote. “We’d obviously need to hack WebKit pretty hard to adapt it to our needs, and it’s not likely that adding another fast-moving variant to that mix would be helpful to anyone, least of all WebKit! We learned about fork maintenance and integration the hard way (and had to learn it a couple of times, to be honest), so that’s not trouble that we want to borrow.”

The WebKit governance model and Apple’s general lack of transparency are also issues that would negatively impact Mozilla if Firefox adopted WebKit.

“I think we would have a hard time maintaining our momentum and depth of community empowerment in the WebKit setting. The level of visibility around patches and review is a lot higher in our world, as one example, and we don’t have bugs disappearing into an Apple-only bug system,” he told us. “For us to come into WebKit’s world and insist on that additional transparency would be unfair and counterproductive, but to live without it wouldn’t be an option for Mozilla. Our system works for us, and their system works for them (and is in many ways less noisy), but I don’t think that any one system could work very well for both of us.”

Conclusion

My hope is that this detailed examination of Gecko’s strengths, and the effort that Mozilla has invested in overcoming its weaknesses, will help illuminate the continuing relevance of Gecko in the Mozilla ecosystem and finally put to rest dubious speculation about the possibility of WebKit adoption for Firefox.

The technical advantages of Gecko are evident when viewed objectively, and the amount of effort that would be required to make WebKit fit into the Firefox stack would far outweigh the technical benefits. As we have noted in the past, there are also reasons why the choice and diversity inherent in having multiple competing implementations is valuable, too.

There are many things the Gecko and WebKit developer communities can learn from each other, but replacing Gecko would not serve any justifiable purpose. In closing, I’ll leave you with one more thought from Mike Shaver:

“We follow WebKit as closely as anyone in the world, and we cast as critical an eye towards our technology stack as anyone in the world,” he told us. “But a brain transplant is neither practical nor likely to be useful.”

[This topic is from http://arstechnica.com, all rights reserved by original author.]

[More photography click here]

i’d like to tell some of my sentiment of work for the last two months’ intern. There are three problems i found, the first is CORE STRATOGY. Dim stratogy is dangerous. The second is team cooperation flow. Working flow is fatal to the team working, one this part, the other one another part and suck like this. The third is speed. I think the internet application development should be develped rapidly and evoluted quickly as the users’ feedback comes back.

Although there are many problems and some difficulties else existed, i beleive this project’s future is everbright, of course the condition is to integerate all the available resources and clear the employees’ responsibilities and work flow.

Last weekend i went to Ningbo University in suburbs of ningbo with two of lovely lovely girls who are in the same major and supervisor with me but juniorer. The distination was Ningbo University, unfortunately, the day we set up rained, so i had to handle the umbrella and another hand hold the camera.

We went to the power station by taxi, while passing the west lake in rain, we appreciated the dim rain west lake in legend. Then we directoryly went to ningbo by rail, two hours and half more, we arrived at ningbo power station and by bus to ningbo university.

After all the transporation, we meet our friend my classmate Nan Wang-a tall handsome boy who has just been a hight school teacher for months. The supper was servered by Mr. Wang’s parents with most chinese traditional food-chinese dumplin. I liked it very much and of course all of us eached as much as we could as well as the fresh fruid apple. So thanks for Mr. Wang’s and his parents’ warm hospitality, really thanks.

[Album: 20080907_Ningbo Uni. click here]

ps: All the photoes are private protected and copyright reserved.

If you want to maximize the revenue of your service you need to maximize completion rates of your web forms. Unless you have some revolutionary ideas to impress your visitors at first glance, it is not enough to simply enable users to sign up on your site. To make it possible for the service to reach a maximal exposure we, designers, need to provide users with a good user experience. We need to invite them, describe to them how the service works, explain to them why they should fill in the form and suggests the benefits they’ll get in return. And, of course, we should also make it extremely easy for them to participate.

However, designing effective web forms isn’t easy. And it has one simple reason: nobody likes to fill in forms — neither offline nor online. Therefore, as designers, we need to figure out sound design decisions to make the form completion easy, intuitive and painless.

But how exactly can we figure out these decisions? Where should the link to the form be placed in the layout? How should we design it? How should we highlight the labels and how should we align them? How do web form design patterns look like in modern web-sites? These were exactly the questions we’ve asked ourselves. And to get the answers we’ve conducted a survey.

Below we present findings of our survey of current web form design patterns — the results of an analysis of 100 popular web-sites where web-forms (should) matter. We have decided to start with sign-up forms first. We present the first part of our findings below; the second part of the survey results will be published next week.

Sign-Up Form Design Survey

The main objective of the survey was to provide designers and developers with some intuition of how effective web forms are designed in practice; we also wanted to present some guidelines of how a user-friendly web form can be achieved.

We have selected 100 large sites where web-forms (should) matter. To select these sites we have considered Technorati, Alexa as well as popularity in search engines and various rankings. We used this popularity as an indicator for sites where web forms really matter as they directly affect business goals and therefore should have been given a high priority during the design process. In particular, registration forms are crucial for social applications which explains why many of the reviewed forms are from social networking sites.

We have focused on sign-up forms as we wanted to consider further crucial forms (e.g. checkout forms) separately. Aftewards we’ve gone through each and every one sign-up form of the selected sites and analyzed the design approaches implemented in these forms.

We have filled in each of these forms using a special e-mail account and a special user name. To make the survey as comprehensive as possible we have identified 29 different design problems and questionswhich may arise when designing web forms.

We have grouped them in categories and attempted to find similarities in design decisions and design ideas. Trying to approach the problem from the usability point of view we have also kept notice of both positive and negative examples to showcase them in this article among our findings.

Please notice that this post is not about checkout forms — that’s a topic for another discussion, we may consider them separately in one of the upcoming posts. We would like to thank Wufoo for providing us with a framework to conduct our survey.

1. Placement of the forms

1.1. How is the link to the sign-up form titled?

Users know that they are supposed to sign-up, register, join, become a member or create an account which is why they are looking for exactly these phrases when they want to participate. Obviously, users expect that a link with one of these links leads to a sign-up form. Unfortunately, that’s not always the case.

The most popular title was “Sign up” (40%), followed by “Join” (18%), “Register” (18%) and “Create account” (17%). We have observed less large, loud and shiny “start here”-buttons as we’ve seen them over the last years. Apparently, designers try to communicate information rathen than design and emphasize the functionality of the service.

1.2. Where is the link to the sign-up form placed?

When users are visiting a site for the first time, they try to figure out what single layout blocks stand for. The eye movements are jumping “all over the place” and users try to understand which areas are more important and where the content he or she is looking for is probably placed. To meet users’ expectations designers need to help users to intuitively anticipate what is required to start using the service.

If the user can’t find the link which leads to a sign-up form, he also won’t be able to sign up for your service. Therefore it is crucial to make the link as visible and as obvious as possible. Where should a designer place the “sign-up”-link to make it more approachable?

According to our survey, the sign-up link

• is placed in the header on 59% of the sites (76% of them have a “sign-up”-link placed at the right upper corner),
• has a prominent position on the homepage on 21% of the sites (link or the form itself is placed on the homepage)
• is hidden behind the “Login”-link in the header in 9% of the cases (e.g. Craigslist).

Not that surprising is the fact that the sign-up link was rarely placed in the sidebar (7% - Propeller, Xing). However, 4% of the sites first offered users to directly use the service and required a registration only when it was required to store the settings.

2. Design of the forms

2.1. Is the sign-up form layout simplified?

Since the user has clicked on the sign-up-link he is likely to have decided to sign up for the service you are offering. More importantly, he has not clicked on the link to explore further navigation options or attractive blinking advertisements.

Consequently, designers tend to remove all unnecessary details and distractions which don’t help the user to complete the form. Often only a logo and the form itself are presented, without any navigation options or additional information. Idea: the user must be able to focus on the task he has to accomplish. Any distractions stand in user’s way and therefore have to be removed.

Since users want what lies on the other side of a form the process of completing forms should be as obvious and as simple as possible. Hence designers often use “minimized” layouts for sign-up forms. According to our survey, 61% of web forms are simplified compared to the general page layout (e.g. MovableType,Livejournal, Amazon, Yandex.ru).

Consider the sign-up form on Yahoo. The visitors are provided only with the form which is required to set up an account. There is nothing else; consequently, there are no distractions as well. Notice that the tone and the language are conversational and appealing. That’s simple, easy and user-friendly.

Flixster is probably our favorite example of an overcrowded form which doesn’t really respect its visitors. The registration page offers every possible navigation option at once. And the login page has outstanding advertisements right next to the login form. That’s not user-friendly. The second busiest web form we’ve seen would be Photobucket.

2.2. Is any additional information provided?

Many designers try to encourage visitors to actually fill in the form by presenting additional information such as help, required information or even copyright disclaimer. It differs from sites to sites; however, in most cases benefits of registration are presented next to the form.

• 41% of the forms provide benefits of the registration
  (MySpace, Del.icio.us, Last.fm, LinkedIn, Digg, Mister Wong, Break.com)
• 28% don’t provide any additional information at all and offer a pure sign-up form
  (Pownce, DeviantArt, Dailymotion)
• 11% inform the visitors how much time investment is required
  (Threadless, Newsvine, WordPress)

Only few sites mention up front what information is needed during the registration (6%), which steps to follow (8%) or provide some warnings, hints etc. (6%, e.g. 37signals, Bloglines).

2.3. One-page-form vs. multi-page form

93% of the forms of the survey turned out to be one-page-forms. Apparently, designers try help users to get the signing procedure as quickly and painlessly as possible. Few sites using multi-page forms often try to combine signing-up with exploring users’ preferences.

For instance, Meebo combines a sign-up form with a complete registration and offers users a sign-up wizard in a pop-up window. The form consists of 6 pages where users are lead from setting their account to providing additional details about their preferences.

2.4. How are titles of the input fields highlighted?

62% of the sign-up forms used bold to highlight the title of the input field. It’s remarkable that not a single site used italics to achieve the same effect. To make the labels more visible 20% of sign-up forms used color and 18% used plain text.

Large version

2.5. Label alignment

To be honest, we have expected a stronger trend toward one of the possible alignments. However, in our opinion no strong trend in the label alignment can be identified.

• right-aligned labels are used on 41% of the reviewed sites
  (YouTube, Facebook, Metacafe)
• 30% of sign-up forms use top-aligned labels
  (Behance.net, Wufoo, Tickspot, DZone)
• 29% use left-aligned labels
  (Digg, Ning, Wykop.pl, 43things, StudiVZ).

According to Matteo Penzo’s label placement research (1996) and Luke Wroblewski’s findings(pdf), top-aligned labels can dramatically reduce completion times since they require less eye fixations. If you want to achieve the same aim but have a vertical screen real estate constraints, right-aligned labels work better. And in case your form requires people to scan labels to learn what’s required (unfamiliar or advanced data), left-aligned labels work best.

2.6. How many mandatory fields?

When conducting a survey we’ve observed a strong trend toward forms with very few mandatory fields. Few years ago designers asked visitors to type in their personal information such as first name, last name, address, country and personal interests. Now login, password and password confirmation suffice.

We found out that 54% of the forms required the user to fill at most 5 input fields (in 6% of the cases registration wasn’t required at all to start using the service). 34% of the forms use 6-8 input fields, while 12% risk user’s patience with over 9 mandatory input fields.

2.7. How many optional fields?

Similarly to above findings one can observe that most sites avoid optional fields and ask users to provide the optional information after the registration process is already done. 62% of the forms had no optional fields at all, and 98% of the forms had less than 5 optional fields.

2.8. Vertically or horizontally arranged fields?

In this aspect sign-up forms show a strong trend toward vertical arrangement of fields with a clear vertical path to completion. 86% of web-sites have input fields arranged vertically. Apart from that, 15% emphasize a beautiful and engaging visual design which is supposed to attract visitors and make them feel more comfortable when filling in the form.

Box.net offers a simple sign-up form with vertically arranged input fields. When the visitors type in the data their eyes are fixed across the vertical axis at the left to the input field.

Mint has a sign-up form with horizontally arranged input fields. When the visitors type in the data they eye needs to jump from one field to the other.

Further findings

• 18% have a sign-in form or a link to the sign-in form placed next to it (e.g. YouTube, Reddit, Digg, Lulu, Metacafe);
• 78% do not use asterisks to highlight required input fields; in most cases neither asterisks nor any other form of highlighting is used.
• 9% use a progress indicator to show to the users where they currently are and which steps are required to get the registration done.
• 85% of the sites don’t use legend and fieldset preferring a simple web-form with as few input fields as possible.
• fields are usually grouped and divided by whitespace (69%), borders are also used (22%), different background colors are used in 9% of the cases.

Bottom line

Let’s conclude the first part of the survey results with a brief overview of the main findings of our survey of current web form design patterns. Please keep in mind that we have considered only sign-up forms.

• the registration link is titled “sign up” (40%) and placed in the right upper corner,
• sign-up forms have a simplified layout to avoid distractions for users (61%),
• sign-up forms are one-page-forms (93%),
• sign up forms attract visitors by explaining the benefits of registration (41%),
• titles of the input fields are highlighted bold (62%)
• no trend in the label alignment can be identified,
• designers tend to use few mandatory fields,
• designers tend to use few optional fields,
• vertically arranged fields are preferred to horizontally arranged fields (86%).

Please stay tuned, we’ll present the second part of our findings next week.

 

June 25th, 2008

Bill Gates’ web experience: Byzantine, idiotic logic

Posted by Michael Krigsman @ 7:03 am

 

Analyzing IT program management failures with the perfect vision of hindsight often leads the observer through a senseless and convoluted maze of past decisions. Studying the Byzantine and idiotic logic behind many IT failures, one wonders, “How did we get here from there?”

Bill Gates experienced this Tower of Babel when he tried to download two Microsoft consumer products (MovieMaker and Digital Plus Pack).

The seattlepi.com released an internal Microsoft email where Bill described his experience. The email begins with Bill’s summary, emphasizing how program management, the coordinating entity, has failed:

I am quite disappointed at how Windows Usability has been going backwards and the program management groups don’t drive usability issues.

Bill then details the complexities that prevented him from downloading the software:

I decided to download (Moviemaker) and buy the Digital Plus pack … so I went to Microsoft.com. They have a download place so I went there.

…

 

 

Resumes play an important role when applying for a job.
Unfortunately, many applicants focus only on the content of the resume and not
the physical appearance. The typeface chosen to display the resume not only
influences the physical appearance, but also influences how an employer may
view the applicant. In this study, resumes displayed in a high appropriate
typeface (Corbel), resulted in the applicant being perceived as more
knowledgeable, mature, experienced, professional, believable, and trustworthy
than when displayed in a neutral typeface (Tempus Sans) or low appropriate
typeface (Vivaldi). Moreover, the applicant was more likely to be called for an
interview when their resume was displayed in a high appropriate typeface than
a neutral or low appropriate typeface.

[Inspiration from A. Dawn Shaikh & Doug Fox, thanks ]

“Dave, stop. Stop, will you? Stop, Dave. Will you stop, Dave?” So the supercomputer HAL pleads with the implacable astronaut Dave Bowman in a famous and weirdly poignant scene toward the end of Stanley Kubrick’s 2001: A Space Odyssey. Bowman, having nearly been sent to a deep-space death by the malfunctioning machine, is calmly, coldly disconnecting the memory circuits that control its artificial »

brain. “Dave, my mind is going,” HAL says, forlornly. “I can feel it. I can feel it.”

I can feel it, too. Over the past few years I’ve had an uncomfortable sense that someone, or something, has been tinkering with my brain, remapping the neural circuitry, reprogramming the memory. My mind isn’t going—so far as I can tell—but it’s changing. I’m not thinking the way I used to think. I can feel it most strongly when I’m reading. Immersing myself in a book or a lengthy article used to be easy. My mind would get caught up in the narrative or the turns of the argument, and I’d spend hours strolling through long stretches of prose. That’s rarely the case anymore. Now my concentration often starts to drift after two or three pages. I get fidgety, lose the thread, begin looking for something else to do. I feel as if I’m always dragging my wayward brain back to the text. The deep reading that used to come naturally has become a struggle.

I think I know what’s going on. For more than a decade now, I’ve been spending a lot of time online, searching and surfing and sometimes adding to the great databases of the Internet. The Web has been a godsend to me as a writer. Research that once required days in the stacks or periodical rooms of libraries can now be done in minutes. A few Google searches, some quick clicks on hyperlinks, and I’ve got the telltale fact or pithy quote I was after. Even when I’m not working, I’m as likely as not to be foraging in the Web’s info-thickets—reading and writing e-mails, scanning headlines and blog posts, watching videos and listening to podcasts, or just tripping from link to link to link. (Unlike footnotes, to which they’re sometimes likened, hyperlinks don’t merely point to related works; they propel you toward them.)

For me, as for others, the Net is becoming a universal medium, the conduit for most of the information that flows through my eyes and ears and into my mind. The advantages of having immediate access to such an incredibly rich store of information are many, and they’ve been widely described and duly applauded. “The perfect recall of silicon memory,” Wired’s Clive Thompson has written, “can be an enormous boon to thinking.” But that boon comes at a price. As the media theorist Marshall McLuhan pointed out in the 1960s, media are not just passive channels of information. They supply the stuff of thought, but they also shape the process of thought. And what the Net seems to be doing is chipping away my capacity for concentration and contemplation. My mind now expects to take in information the way the Net distributes it: in a swiftly moving stream of particles. Once I was a scuba diver in the sea of words. Now I zip along the surface like a guy on a Jet Ski.

I’m not the only one. When I mention my troubles with reading to friends and acquaintances—literary types, most of them—many say they’re having similar experiences. The more they use the Web, the more they have to fight to stay focused on long pieces of writing. Some of the bloggers I follow have also begun mentioning the phenomenon. Scott Karp, who writes a blog about online media, recently confessed that he has stopped reading books altogether. “I was a lit major in college, and used to be [a] voracious book reader,” he wrote. “What happened?” He speculates on the answer: “What if I do all my reading on the web not so much because the way I read has changed, i.e. I’m just seeking convenience, but because the way I THINK has changed?”

Bruce Friedman, who blogs regularly about the use of computers in medicine, also has described how the Internet has altered his mental habits. “I now have almost totally lost the ability to read and absorb a longish article on the web or in print,” he wrote earlier this year. A pathologist who has long been on the faculty of the University of Michigan Medical School, Friedman elaborated on his comment in a telephone conversation with me. His thinking, he said, has taken on a “staccato” quality, reflecting the way he quickly scans short passages of text from many sources online. “I can’t read War and Peace anymore,” he admitted. “I’ve lost the ability to do that. Even a blog post of more than three or four paragraphs is too much to absorb. I skim it.”

Anecdotes alone don’t prove much. And we still await the long-term neurological and psychological experiments that will provide a definitive picture of how Internet use affects cognition. But a recently published study of online research habits, conducted by scholars from University College London, suggests that we may well be in the midst of a sea change in the way we read and think. As part of the five-year research program, the scholars examined computer logs documenting the behavior of visitors to two popular research sites, one operated by the British Library and one by a U.K. educational consortium, that provide access to journal articles, e-books, and other sources of written information. They found that people using the sites exhibited “a form of skimming activity,” hopping from one source to another and rarely returning to any source they’d already visited. They typically read no more than one or two pages of an article or book before they would “bounce” out to another site. Sometimes they’d save a long article, but there’s no evidence that they ever went back and actually read it. The authors of the study report:

It is clear that users are not reading online in the traditional sense; indeed there are signs that new forms of “reading” are emerging as users “power browse” horizontally through titles, contents pages and abstracts going for quick wins. It almost seems that they go online to avoid reading in the traditional sense.
Thanks to the ubiquity of text on the Internet, not to mention the popularity of text-messaging on cell phones, we may well be reading more today than we did in the 1970s or 1980s, when television was our medium of choice. But it’s a different kind of reading, and behind it lies a different kind of thinking—perhaps even a new sense of the self. “We are not only what we read,” says Maryanne Wolf, a developmental psychologist at Tufts University and the author of Proust and the Squid: The Story and Science of the Reading Brain. “We are how we read.” Wolf worries that the style of reading promoted by the Net, a style that puts “efficiency” and “immediacy” above all else, may be weakening our capacity for the kind of deep reading that emerged when an earlier technology, the printing press, made long and complex works of prose commonplace. When we read online, she says, we tend to become “mere decoders of information.” Our ability to interpret text, to make the rich mental connections that form when we read deeply and without distraction, remains largely disengaged.

Reading, explains Wolf, is not an instinctive skill for human beings. It’s not etched into our genes the way speech is. We have to teach our minds how to translate the symbolic characters we see into the language we understand. And the media or other technologies we use in learning and practicing the craft of reading play an important part in shaping the neural circuits inside our brains. Experiments demonstrate that readers of ideograms, such as the Chinese, develop a mental circuitry for reading that is very different from the circuitry found in those of us whose written language employs an alphabet. The variations extend across many regions of the brain, including those that govern such essential cognitive functions as memory and the interpretation of visual and auditory stimuli. We can expect as well that the circuits woven by our use of the Net will be different from those woven by our reading of books and other printed works.

Sometime in 1882, Friedrich Nietzsche bought a typewriter—a Malling-Hansen Writing Ball, to be precise. His vision was failing, and keeping his eyes focused on a page had become exhausting and painful, often bringing on crushing headaches. He had been forced to curtail his writing, and he feared that he would soon have to give it up. The typewriter rescued him, at least for a time. Once he had mastered touch-typing, he was able to write with his eyes closed, using only the tips of his fingers. Words could once again flow from his mind to the page.

But the machine had a subtler effect on his work. One of Nietzsche’s friends, a composer, noticed a change in the style of his writing. His already terse prose had become even tighter, more telegraphic. “Perhaps you will through this instrument even take to a new idiom,” the friend wrote in a letter, noting that, in his own work, his “‘thoughts’ in music and language often depend on the quality of pen and paper.”

Also see:

LIVING WITH A COMPUTER
(July 1982)
“The process works this way. When I sit down to write a letter or start the first draft of an article, I simply type on the keyboard and the words appear on the screen…” By James Fallows

“You are right,” Nietzsche replied, “our writing equipment takes part in the forming of our thoughts.” Under the sway of the machine, writes the German media scholar Friedrich A. Kittler, Nietzsche’s prose “changed from arguments to aphorisms, from thoughts to puns, from rhetoric to telegram style.”

The human brain is almost infinitely malleable. People used to think that our mental meshwork, the dense connections formed among the 100 billion or so neurons inside our skulls, was largely fixed by the time we reached adulthood. But brain researchers have discovered that that’s not the case. James Olds, a professor of neuroscience who directs the Krasnow Institute for Advanced Study at George Mason University, says that even the adult mind “is very plastic.” Nerve cells routinely break old connections and form new ones. “The brain,” according to Olds, “has the ability to reprogram itself on the fly, altering the way it functions.”

As we use what the sociologist Daniel Bell has called our “intellectual technologies”—the tools that extend our mental rather than our physical capacities—we inevitably begin to take on the qualities of those technologies. The mechanical clock, which came into common use in the 14th century, provides a compelling example. In Technics and Civilization, the historian and cultural critic Lewis Mumford described how the clock “disassociated time from human events and helped create the belief in an independent world of mathematically measurable sequences.” The “abstract framework of divided time” became “the point of reference for both action and thought.”

The clock’s methodical ticking helped bring into being the scientific mind and the scientific man. But it also took something away. As the late MIT computer scientist Joseph Weizenbaum observed in his 1976 book, Computer Power and Human Reason: From Judgment to Calculation, the conception of the world that emerged from the widespread use of timekeeping instruments “remains an impoverished version of the older one, for it rests on a rejection of those direct experiences that formed the basis for, and indeed constituted, the old reality.” In deciding when to eat, to work, to sleep, to rise, we stopped listening to our senses and started obeying the clock.

The process of adapting to new intellectual technologies is reflected in the changing metaphors we use to explain ourselves to ourselves. When the mechanical clock arrived, people began thinking of their brains as operating “like clockwork.” Today, in the age of software, we have come to think of them as operating “like computers.” But the changes, neuroscience tells us, go much deeper than metaphor. Thanks to our brain’s plasticity, the adaptation occurs also at a biological level.

The Internet promises to have particularly far-reaching effects on cognition. In a paper published in 1936, the British mathematician Alan Turing proved that a digital computer, which at the time existed only as a theoretical machine, could be programmed to perform the function of any other information-processing device. And that’s what we’re seeing today. The Internet, an immeasurably powerful computing system, is subsuming most of our other intellectual technologies. It’s becoming our map and our clock, our printing press and our typewriter, our calculator and our telephone, and our radio and TV.

When the Net absorbs a medium, that medium is re-created in the Net’s image. It injects the medium’s content with hyperlinks, blinking ads, and other digital gewgaws, and it surrounds the content with the content of all the other media it has absorbed. A new e-mail message, for instance, may announce its arrival as we’re glancing over the latest headlines at a newspaper’s site. The result is to scatter our attention and diffuse our concentration.

The Net’s influence doesn’t end at the edges of a computer screen, either. As people’s minds become attuned to the crazy quilt of Internet media, traditional media have to adapt to the audience’s new expectations. Television programs add text crawls and pop-up ads, and magazines and newspapers shorten their articles, introduce capsule summaries, and crowd their pages with easy-to-browse info-snippets. When, in March of this year, TheNew York Times decided to devote the second and third pages of every edition to article abstracts, its design director, Tom Bodkin, explained that the “shortcuts” would give harried readers a quick “taste” of the day’s news, sparing them the “less efficient” method of actually turning the pages and reading the articles. Old media have little choice but to play by the new-media rules.

Never has a communications system played so many roles in our lives—or exerted such broad influence over our thoughts—as the Internet does today. Yet, for all that’s been written about the Net, there’s been little consideration of how, exactly, it’s reprogramming us. The Net’s intellectual ethic remains obscure.

About the same time that Nietzsche started using his typewriter, an earnest young man named Frederick Winslow Taylor carried a stopwatch into the Midvale Steel plant in Philadelphia and began a historic series of experiments aimed at improving the efficiency of the plant’s machinists. With the approval of Midvale’s owners, he recruited a group of factory hands, set them to work on various metalworking machines, and recorded and timed their every movement as well as the operations of the machines. By breaking down every job into a sequence of small, discrete steps and then testing different ways of performing each one, Taylor created a set of precise instructions—an “algorithm,” we might say today—for how each worker should work. Midvale’s employees grumbled about the strict new regime, claiming that it turned them into little more than automatons, but the factory’s productivity soared.

More than a hundred years after the invention of the steam engine, the Industrial Revolution had at last found its philosophy and its philosopher. Taylor’s tight industrial choreography—his “system,” as he liked to call it—was embraced by manufacturers throughout the country and, in time, around the world. Seeking maximum speed, maximum efficiency, and maximum output, factory owners used time-and-motion studies to organize their work and configure the jobs of their workers. The goal, as Taylor defined it in his celebrated 1911 treatise, The Principles of Scientific Management, was to identify and adopt, for every job, the “one best method” of work and thereby to effect “the gradual substitution of science for rule of thumb throughout the mechanic arts.” Once his system was applied to all acts of manual labor, Taylor assured his followers, it would bring about a restructuring not only of industry but of society, creating a utopia of perfect efficiency. “In the past the man has been first,” he declared; “in the future the system must be first.”

Taylor’s system is still very much with us; it remains the ethic of industrial manufacturing. And now, thanks to the growing power that computer engineers and software coders wield over our intellectual lives, Taylor’s ethic is beginning to govern the realm of the mind as well. The Internet is a machine designed for the efficient and automated collection, transmission, and manipulation of information, and its legions of programmers are intent on finding the “one best method”—the perfect algorithm—to carry out every mental movement of what we’ve come to describe as “knowledge work.”

Google’s headquarters, in Mountain View, California—the Googleplex—is the Internet’s high church, and the religion practiced inside its walls is Taylorism. Google, says its chief executive, Eric Schmidt, is “a company that’s founded around the science of measurement,” and it is striving to “systematize everything” it does. Drawing on the terabytes of behavioral data it collects through its search engine and other sites, it carries out thousands of experiments a day, according to the Harvard Business Review, and it uses the results to refine the algorithms that increasingly control how people find information and extract meaning from it. What Taylor did for the work of the hand, Google is doing for the work of the mind.

The company has declared that its mission is “to organize the world’s information and make it universally accessible and useful.” It seeks to develop “the perfect search engine,” which it defines as something that “understands exactly what you mean and gives you back exactly what you want.” In Google’s view, information is a kind of commodity, a utilitarian resource that can be mined and processed with industrial efficiency. The more pieces of information we can “access” and the faster we can extract their gist, the more productive we become as thinkers.

Where does it end? Sergey Brin and Larry Page, the gifted young men who founded Google while pursuing doctoral degrees in computer science at Stanford, speak frequently of their desire to turn their search engine into an artificial intelligence, a HAL-like machine that might be connected directly to our brains. “The ultimate search engine is something as smart as people—or smarter,” Page said in a speech a few years back. “For us, working on search is a way to work on artificial intelligence.” In a 2004 interview with Newsweek, Brin said, “Certainly if you had all the world’s information directly attached to your brain, or an artificial brain that was smarter than your brain, you’d be better off.” Last year, Page told a convention of scientists that Google is “really trying to build artificial intelligence and to do it on a large scale.”

Such an ambition is a natural one, even an admirable one, for a pair of math whizzes with vast quantities of cash at their disposal and a small army of computer scientists in their employ. A fundamentally scientific enterprise, Google is motivated by a desire to use technology, in Eric Schmidt’s words, “to solve problems that have never been solved before,” and artificial intelligence is the hardest problem out there. Why wouldn’t Brin and Page want to be the ones to crack it?

Still, their easy assumption that we’d all “be better off” if our brains were supplemented, or even replaced, by an artificial intelligence is unsettling. It suggests a belief that intelligence is the output of a mechanical process, a series of discrete steps that can be isolated, measured, and optimized. In Google’s world, the world we enter when we go online, there’s little place for the fuzziness of contemplation. Ambiguity is not an opening for insight but a bug to be fixed. The human brain is just an outdated computer that needs a faster processor and a bigger hard drive.

The idea that our minds should operate as high-speed data-processing machines is not only built into the workings of the Internet, it is the network’s reigning business model as well. The faster we surf across the Web—the more links we click and pages we view—the more opportunities Google and other companies gain to collect information about us and to feed us advertisements. Most of the proprietors of the commercial Internet have a financial stake in collecting the crumbs of data we leave behind as we flit from link to link—the more crumbs, the better. The last thing these companies want is to encourage leisurely reading or slow, concentrated thought. It’s in their economic interest to drive us to distraction.

Maybe I’m just a worrywart. Just as there’s a tendency to glorify technological progress, there’s a countertendency to expect the worst of every new tool or machine. In Plato’s Phaedrus, Socrates bemoaned the development of writing. He feared that, as people came to rely on the written word as a substitute for the knowledge they used to carry inside their heads, they would, in the words of one of the dialogue’s characters, “cease to exercise their memory and become forgetful.” And because they would be able to “receive a quantity of information without proper instruction,” they would “be thought very knowledgeable when they are for the most part quite ignorant.” They would be “filled with the conceit of wisdom instead of real wisdom.” Socrates wasn’t wrong—the new technology did often have the effects he feared—but he was shortsighted. He couldn’t foresee the many ways that writing and reading would serve to spread information, spur fresh ideas, and expand human knowledge (if not wisdom).

The arrival of Gutenberg’s printing press, in the 15th century, set off another round of teeth gnashing. The Italian humanist Hieronimo Squarciafico worried that the easy availability of books would lead to intellectual laziness, making men “less studious” and weakening their minds. Others argued that cheaply printed books and broadsheets would undermine religious authority, demean the work of scholars and scribes, and spread sedition and debauchery. As New York University professor Clay Shirky notes, “Most of the arguments made against the printing press were correct, even prescient.” But, again, the doomsayers were unable to imagine the myriad blessings that the printed word would deliver.

So, yes, you should be skeptical of my skepticism. Perhaps those who dismiss critics of the Internet as Luddites or nostalgists will be proved correct, and from our hyperactive, data-stoked minds will spring a golden age of intellectual discovery and universal wisdom. Then again, the Net isn’t the alphabet, and although it may replace the printing press, it produces something altogether different. The kind of deep reading that a sequence of printed pages promotes is valuable not just for the knowledge we acquire from the author’s words but for the intellectual vibrations those words set off within our own minds. In the quiet spaces opened up by the sustained, undistracted reading of a book, or by any other act of contemplation, for that matter, we make our own associations, draw our own inferences and analogies, foster our own ideas. Deep reading, as Maryanne Wolf argues, is indistinguishable from deep thinking.

If we lose those quiet spaces, or fill them up with “content,” we will sacrifice something important not only in our selves but in our culture. In a recent essay, the playwright Richard Foreman eloquently described what’s at stake:

I come from a tradition of Western culture, in which the ideal (my ideal) was the complex, dense and “cathedral-like” structure of the highly educated and articulate personality—a man or woman who carried inside themselves a personally constructed and unique version of the entire heritage of the West. [But now] I see within us all (myself included) the replacement of complex inner density with a new kind of self—evolving under the pressure of information overload and the technology of the “instantly available.”
As we are drained of our “inner repertory of dense cultural inheritance,” Foreman concluded, we risk turning into “‘pancake people’—spread wide and thin as we connect with that vast network of information accessed by the mere touch of a button.”

I’m haunted by that scene in 2001. What makes it so poignant, and so weird, is the computer’s emotional response to the disassembly of its mind: its despair as one circuit after another goes dark, its childlike pleading with the astronaut—“I can feel it. I can feel it. I’m afraid”—and its final reversion to what can only be called a state of innocence. HAL’s outpouring of feeling contrasts with the emotionlessness that characterizes the human figures in the film, who go about their business with an almost robotic efficiency. Their thoughts and actions feel scripted, as if they’re following the steps of an algorithm. In the world of 2001, people have become so machinelike that the most human character turns out to be a machine. That’s the essence of Kubrick’s dark prophecy: as we come to rely on computers to mediate our understanding of the world, it is our own intelligence that flattens into artificial intelligence.