This workshop is a quick introduction to working with digital audio. It uses the free, open-source Audacity software. Digital audio software like Audacity shows sound as a waveform, which is a visual representation of the audio over time. Sound can be edited in much the same way that words are edited in a word processing program – i.e. by copying, cutting, and pasting, as well as modifying the sound (e.g. EQ or changing volume) which is similar to styling text.

Getting Started:

• Download Audacity 1.3.11
• Install the MP3 library so you can export in MP3 format
• Optionally, install a set of LADSPA plug-ins for making sound effects (under optional downloads)
• Launch Audacity
• Download sounds for intro to sound

For this workshop, set the recording settings: AUDACITY>PREFERENCES>DEVICES>RECORDING>

• DEVICE: Built-in Microphone
• CHANNELS: 1 (Mono)

Make use of the Audacity help system

• HELP>QUICK HELP
• HELP>MANUAL

Topics

Recording & Playback

Record a short sequence of you saying “One, Two, Three… One, Two, Three…”

To play back audio, use the green play button, or hit the spacebar. Hold the shift key down when pressing the green button to play back in a continuous loop.

• Basic recording info
• Full recording tutorial
• Playing back audio

Waveform Editing

A waveform is a visual representation of sound, where time moves from left to right, and loudness (amplitude) is represented as height.

You can cut, copy, and paste the waveform just as you would in a word-processing application.

• What is sound
• Basic editing
• Edit menu
• Selecting parts of a waveform

Do the following kinds of edits

• Cut to trim the start and end of an audio clip, then use the Trim tool to do the same
• Copy and paste
• Add silence
• Normalize audio level
• Fade-in / Fade-out from the effect menu EFFECT>Fade In EFFECT>Fade Out

Controlling level with the Envelope Tool

You can change the loudness of the sound as time progress by using the envelope tool. Use it to change the volume of the entire track, or set different points in time, and use the tool to change the volume up or down over time.

• Envelope Tool

Working with Multiple Tracks

To create a mix of several different sounds, you can create multiple tracks in Audacity. Each track will contain a different sound, and you can control where in time each sound plays, and what the volume relationships are between the multiple tracks.

• Use TRACKS>ADD NEW>AUDIO TRACK to create a new, empty track OR Record a new track
• The TRACK MENU
• Use the Time Shift Tool to move audio left and right in time to match up with another track
• Mixing
• Use mute and solo
• Use track volume and pan
• Auto Duck

Effects

• EQ – Change the tone of the sound – e.g. bass, mid, treble
• Pitch change – Change the pitch of a selection without changing the length of the sound
• Tempo change – Change the length of a selection without changing the pitch of the sound
• Reverb – Add the on the characteristics of a room to your sound
• Etc.

Outputing final audio

• Sample Rate & Sample Format (Bit Depth)
• Stereo/Mono and file size
• Using left and right channel panning creatively
• Audio formats: .wav, .aiff, .mp3

And the doubters are right, for those of us who want a cool, small, OS X laptop thing, the iPad does not hit the mark (of course, as the iPad matures it will get many of these things – the inevitable 4.0 release of the iPhone OS will likely address the multitasking and app organization issues. And maybe Adobe and Apple will finally make nice for the Flash plug-in. And the 2011 version will have a camera etc.).

But people who want a better laptop aren’t the target audience for the iPad. Just like people who wanted a better Blackberry weren’t the target audience for the original iPhone. And people who wanted a green-washed sports-car were not the target audience for the Prius. Guess what? These products were a success anyway, because they met a new need and found a new audience.

So what is the iPad? Well, that remains to be seen. It will evolve in the next year as developers turn the iPad into a range of completely new things that, once they exist, will be essential for many people. To start all this off, Apple gives us the basic foundation and a decent value proposition:

• Read rich media books/magazines/newspapers
• Comfortably browse the web
• Use interactive textbooks and other learning material
• Work with personal media (photos, music, video)
• Play games
• Shift low-intensity computer stuff off the computer (email, todo lists, calendars, presentations, note taking, etc.)
• And as an add-on value, provide an admittedly compromised level of computer substitution for word processing, spreadsheets, etc. so we don’t always have to drag around a laptop.

That alone is a pretty good deal for $500. But what will come, and will likely make the iPad a major success, is a range of new apps that turn the iPad into an incredible device for doing more specific kinds of activities. For example, recording a song – it can be a complete recording system and tangible interface with faders, knobs, transport controls, etc. Or as remote control for your house and entertainment system. Or as a painting canvas. Or as a device that sits next to, and is an adjunct to your computer - wacom tablet, todo list, email, application switcher, etc. Or to organize your genealogy. Or to do scrapbooking (really, this could sell a millions units alone). Or plan a trip. Or evaluate X-Rays at your patient’s bedside… You get the idea.

I call these devices Slabs. The iPad, iPhone, Andriod, etc. are generic platforms that, via an app, turn into a product. And a 10″ Slab with multi-touch surface can be a lot of different products.

More to come in the following days on my thoughts about SLABS, SOFTDUCTS, and BESPOKE OBJECTS.

You should go through all the Scratch examples first to understand the concepts. Then go back and apply the concepts in Flash ActionScript 3.

Introduction

We’ll first cover the basic concepts of programming using Scratch, a visual programming language. Scratch allows you to create programs without writing any code. Instead, you snap together programming blocks (kind of like Lego) to accomplish the task you want. Learning concepts this way allows you to concentrate on the actual concepts rather than getting bogged down with the spelling and syntax of traditional programming languages.

• Download Scratch 1.4
• Getting Started with Scratch v1.4 (PDF)
• Scratch Concepts (PDF)
• Scratch Reference Guide v1.4 (PDF)
• Video introduction (starting @ 1minute:34seconds into the movie)

Once you’ve gotten a feel for the programming concepts using Scratch, we’ll switch to Flash ActionScript and apply these same concepts to a traditional programming language. ActionScript is similar to JavaScript and uses the same syntax. For this workshop, we’ll be using ActionScript version 3.

We’ll cover the following concepts, first in Scratch, then in Flash ActionScript:

• Program sequence – actions happen in a particular order
• Event handling – do something when something else happens
• Loops – doing something over and over again
• Conditional statements (if and if-else) – decision making & logic
• Variables – remember things over time

In the future, I may do another workshop on the following topics

• Arrays – lists of things
• Randomness
• Communication between objects

Before we start, watch the video introduction from the Scratch site – apologies for the “kid” tone of the video.

Also note the following features of Scratch and the diagram below:

• there are three major parts of the Scratch environment: the Blocks Palette, the Script Area, and the Stage
• when creating a program, you are applying that program to the currently selected sprite (graphic on the stage) – so double click on a sprite and then drag programming blocks from the Blocks Palette to the Script area to apply a script to that sprite.
• to create a sequence of blocks – i.e. a script – snap together blocks in the script area by dragging one block onto another block
• right click on any object for options, including help for any programming block.
• click on a set of blocks in the scripts area to run it
• to delete a programming block from the Script Area, drag it back to the Blocks Palette (or right click and select delete)

---

Program sequence – Actions happen in a certain order

Concept in Scratch
Programs are composed of a series of actions arranged in a particular order. The order of actions is very important, because one action may depend on another action occuring first. For example in Scratch, if you want to play a sound note, it is important to set the particular instrument you want before you play a note. Otherwise, the program will play whatever the default instrument is. To visually see the progress through the sequence of program blocks, click on the Edit button at the top of the screen, and select “Set Single Stepping…”, and then select “Flash Blocks”. This will execute each step of the program at a slow speed so you can see what’s happening.

Once you’ve watched it “step” through the code a few times, re-order the code (e.g. put the “say hello” first) and then step through the code again and see what happens.

Scratch Examples:

ActionScript 3 Examples:

Example 1

trace("step 1");
trace("step 2");
trace("step 3");
trace("step 4");

Example 2 – requires a movieclip on stage with an instance name of myMovieClip

myMovieClip.x += 20;
myMovieClip.rotation += 15;
trace("Hello");

---

Event Handling – Performing an action when something happens

When programming for interaction, the most basic programming approach is to respond to the user’s interactions – i.e. a mouse click, pressing a button, walking in front of a screen. In programming terms, these interactions are thought of as events. Flash ActionScript and similar languages provide a standard way to perform an action when an event happens. In Scratch, you can use the “When Sprite Clicked” control block to handle the event where the user clicks on a graphic.

Scratch Examples:

ActionScript 3 Examples:

In ActionScript 3, responding to events seems complicated (especially when compared to ActionScript 2), but actually just requires more typing. The concept is that once you have given an object an instance name, it can be told to listen for events using the addEventListener() function. This function needs the name of the event you want to listen to, and the name of the function that should be executed when the event occurs. You then create a function with that name that contains the code you want run when the event occurs.

Note: If you are using a movieClip instead of a button, you will need to set the movieClip.buttonMode property to true so the cursor changes to a hand on rollover.

Example 1 – requires a button symbol on stage with an instance name of myMovieClip

myMovieClip.addEventListener(MouseEvent.CLICK,onClick);
// myMovieClip.buttonMode = true; // you only need this if using a movieClip rather than a button

function onClick(event) {
	myMovieClip.x += 20;
	myMovieClip.rotation += 15;
	trace("Hello");
}

Example 2

stage.addEventListener(KeyboardEvent.KEY_DOWN, onKey);

function onKey(event) {
	if (event.keyCode == Keyboard.SPACE) {
		myMovieClip.x += 20;
		myMovieClip.rotation += 15;
		trace("Hello");
	}
}

(see this adobe docs page for a complete list of the keyCodes)

Example 3 – requires that there be two button symbols on the stage with instance names of leftArrow and rightArrow respectively. In addition, there should be a keyframe at frame 1 named “page1″, and a keyframe at frame 5 (or where-ever) named “page2″.

Example 3 completed Flash file: events.fla

leftArrow.addEventListener(MouseEvent.CLICK,goPage1);

function goPage1(event) {
	gotoAndStop("page1");
}

rightArrow.addEventListener(MouseEvent.CLICK,goPage2);

function goPage2(event) {
	gotoAndStop("page2");
}

---

Loops – Perform an action over and over again

Many programming tasks require doing something over and over again. Looping structures enclose a series of actions and repeat them. For example, if you want to animate a graphic (sprite) across the screen, you would use a loop to do this – moving the sprite say 10 pixels each time through the loop. Looping also means that the program runs on its own for a while, without user interaction.

Scratch Examples:

ActionScript 3 Examples:

Example 1

myMovieClip.addEventListener(MouseEvent.ROLL_OVER,onOver);

function onOver(event) {
	for (var i=0;i<10;i++) {
		myMovieClip.x += 10;
	}
}

Example 2

myMovieClip.addEventListener(Event.ENTER_FRAME,onEnter);

function onEnter(event) {
	myMovieClip.x += 10;
}

---

Conditionals – Making decisions and controlling the flow of the program sequence

As the complexity of the program behavior increases, the software will need the ability to make decisions and perform different actions based on those decisions. For example, if you want a graphic to reverse direction when it hits the edge of the screen, your code will need to check the current position and decide if it is beyond the edge. If it is, it will need to reverse direction. To see these if statements in action, turn on the “single step” mode to watch as the code makes a decision and follows a different sequence of actions as it reaches the edge of the screen.

Scratch Examples:

ActionScript 3 Examples:

myMovieClip.addEventListener(Event.ENTER_FRAME,onEnter);

function onEnter(event) {
	if (myMovieClip.x < 500) {
		myMovieClip.x += 10;
	}
}

Example 2

myMovieClip.addEventListener(Event.ENTER_FRAME,onEnter);

function onEnter(event) {
	var clip = event.currentTarget

	// check to see if we are at the right or left edge
	if (clip.x > 500) { // right edge
		clip.rotation = 180;
	} else if (clip.x < 0) { // left edge
		clip.rotation = 0;
	}

	// go in the direction we are pointing
	if (clip.rotation == 0) { // pointing to the right
		clip.x += 10;
	} else { // pointing to the left
		clip.x -= 10;
	}
}

---

Variables – Storing information over time

In most projects, it’s important to store information such as numbers or some text. Variables provide the mechanism to not only store, but to change information as the program progresses through time. For example, in a game, the score starts out at zero, and each time the user does the right thing, the score is increased. A variable will hold the initial value (or be initialized to it), and then that value will be increased (or decreased) as an effect of a user action. Variables are how a program keeps track of the current score or other information that it needs to reference.

Scratch Examples:

Create two sprites on the stage, called Sprite1 and Sprite2. Then go to the Variables panel, and “Make a variable” called “counter”. Then double click on each sprite and add the following programs to the appropriate sprite, where Sprite1 adds 1 to counter, and Sprite2 subtracts one from counter.

ActionScript 3 Examples:

Example 1 – These two examples require that there be two buttons or movieclips with instance names of “sprite1″ and “sprite2″ respectively.

var counter = 0;

sprite1.addEventListener(MouseEvent.CLICK,addOne);
sprite2.addEventListener(MouseEvent.CLICK,subtractOne);

function addOne(event) {
	counter++;
	trace(counter);
}

function subtractOne(event) {
	counter--;
	trace(counter);
}

Example 2 – This example requires that a dynamic text field be on the stage with the instance name of “showCounter”

var counter = 0;
showCounter.text = counter;

sprite1.addEventListener(MouseEvent.CLICK,addOne);
sprite2.addEventListener(MouseEvent.CLICK,subtractOne);

function addOne(event) {
	counter++;
	showCounter.text = counter;
}

function subtractOne(event) {
	counter--;
	showCounter.text = counter;
}

Example 3 – This example uses only one function to accomplish both addition and subtraction by giving the sprite objects a score value in a variable called changeByScore, and using that to change the score. The technique of giving an object new variables only works with movieClips, not buttons. So if you used buttons in the previous example, open the property inspector and change the sprite symbols to “Movie Clip”  instead of “Button”.

var counter = 0;
showCounter.text = String(counter);

sprite1.addEventListener(MouseEvent.CLICK,changeScore);
sprite1.changeScoreBy = 1

sprite2.addEventListener(MouseEvent.CLICK,changeScore);
sprite2.changeScoreBy = -1

function changeScore(event) {

	// get the object that called this function
	var clip = event.currentTarget

	// change the counter by the amount stored in that object's changeByScore variable
	counter += clip.changeScoreBy;

	// display the current value of the counter variable
	showCounter.text = counter;
}

showStatus.text = "";

sprite1.addEventListener(MouseEvent.MOUSE_DOWN, dragIt);
sprite1.addEventListener(MouseEvent.MOUSE_UP, dropIt);
sprite1.addEventListener(Event.ENTER_FRAME,showCollision);

function dragIt(event) {
	// get the object that called this function
	var clip = event.currentTarget

	// Enable the moveClip to be dragged
	clip.startDrag(true);
}

function dropIt(event) {
	// get the object that called this function
	var clip = event.currentTarget

	// Disable dragging
	clip.stopDrag();
}

function showCollision(event) {
	// get the object that called this function
	var clip = event.currentTarget

	// check to see if the dragged sprite is touching the fixed sprite
	if (clip.hitTestObject(sprite2)) {
		showStatus.text = "Touching...";
	} else {
		showStatus.text = "Not Touching...";
	}
}

Programming tasks

1. Initialize the score to 0 when the game starts
2. Make the sprites fall
3. Make the sprites cycle back to the top of the screen when they reach they bottom of the screen
4. Make the bar move back and forth when the left and right arrow keys are pressed
5. Make the sprites check to see if they have collided with the bar
   1. if they have, add or subtract from the score
   2. move the sprite back to the top of the screen
6. Display the current score

• Conference organizer and ThingM partner Mike Kuniavsky’s talk “Read Write Material Culture” proposed that only the 20th century was mostly Read-only, where before that and emerging in the 21st century, production can be local and accessible to many makers. The economics of industrial production pushed individuals away from making, but the emergence of new technologies and tools (e.g. web-based distribution, 3D printing, open-source hardware and software toolkits) make it once again possible for individuals to produce things and make a living at it.
• Ed Baafi of Learn 2 Teach, Teach 2 Learn and the Boston FabLab demoed a web-based visual programming system for putting code on the Arduino. Using the same approach as Scratch, users can drag-and-drop programming structures and watch them run while the hardware responds. Once the code is finished, the system will download compiled code to the Arduino so it can run un-tethered. He hopes to release a beta version soon.
• Along these same lines, David Zicarelli founder of MAX/MSP maker Cycling74 demoed a project where users can create a patch in MAX, and it will run on the Arduino, either tethered or downloaded and un-tethered.
• André Knörig demoed Frizting, a web-based system for visualizing hardware prototypes with the Arduino and other microcontrollers. Once diagramed, the circuit can be shared, and most importantly, Frizting will generate the layout for a printed circuit board (PCB), so you can turn your idea into a more formal project that can be manufactured.
• Jan Borchers of The Media Computing Group at RWTH Aachen University showed his Luminet project, which is a system of intelligent nodes that talk to each other, and are programmed by infecting the network of Luminet nodes, where the code jumps from one node to the next.

Slides for many of the presentations are here.

Each of these play a role in people’s lives with broad effects in terms of activities, emotions, thinking, tactility, social interactions, creativity, work, play, and more. Even the “functional” hammer does more than solve the problem of putting nails into wood – it feels right in the hand, it gains a patina over time that makes it personal, in a pinch it will open a beer bottle, and you can use it to repair a church after Katrina.

In particular, if we think about Interactive Design, the highest goal should be to empower people to create their own meaning spaces, not solve pre-determined problems or even make great experiences. As I’ve discussed in my Productive Interaction paper and in The New Ecology of Things, design plays a greater role than serving tasks and solving problems. The things in our lives communicate, create social exchanges, and enable us to manipulate both the tangible and the idea. They afford creative abuse and invention. Forget solving problems, design things to be productive, embodied, mythological, meaningful.

In other words, by tracking what you and others do and create (emails, blog entries, tweets, browsing activity, shopping, etc.), and by scouring the web and analyzing its content, these systems make sense of the web in a much more sophisticated way than the brute force kind of searching that Google does. So it could find correlations, generate connections, optimize searches, make you aware of implicit networks of interest, and generally act on your behalf to both filter the incoming avalanche of data, and provide better/faster means to get to interesting information that you might not otherwise find.

While this idea is related to the kinds of recommendations that Amazon and other sites do, it is stronger because it aggregates a lot more activity and content beyond the silo of a single site. Plus, the ultimate expression of the implicit web (I hope) is that the user will have more control, and can “dial-in” the criteria of a search or automated task to their specific interests at that moment, rather than being stuck with some company’s idea of your interests. This idea relates to my essay on Productive Interaction, where the design of these systems is not about creating enveloping, persuasive experiences (as experience design dictates), but designing contexts where users are empowered to create their own meaning spaces.

Related LINKS below

Some posts by an investor in implicit web companies:
http://www.feld.com/wp/archives/2009/04/the-maturing-of-the-implicit-web.html
http://www.foundrygroup.com/blog/archives/2008/03/theme-implicit-web.php

ReadWriteWeb’s take on it:
http://www.readwriteweb.com/archives/the_implicit_web_lastfm_amazon_google.php

More sophisticated, semantic based tagging

http://www.readwriteweb.com/archives/common_tag_brings_standards_to_metadata.php

Some companies doing it:
http://getglue.com/brief.php
http://www.oneriot.com/
http://www.lijit.com/
http://www.orch8.net/

From the Feld.com post:

We think of the technologies that fall under the implicit web theme as a next-generation set of applications, tools and infrastructure that stitch together a long list of interrelated and overlapping ideas: the academic and theoretical ideas behind the Semantic Web, the utility of social networks and social media, crowd sourcing/wisdom-of-crowds, folksonomy, user attention data, advanced search and content analysis tools, lifestream analysis and numerous others. 

When combined, these technologies offer the promise of a more unified computing environment that spans the applications where a user consumes and creates information (email clients, web browsers, RSS readers, etc) and is aware of the user’s preferences, interests and interpersonal relationships without requiring a ton of heavy lifting on the user’s part to get useful work done.

All projects are working interactive demos that use the Make Controller in combination with our NET Lab Toolkit (Pen & Book didn’t use the Make).

Net Desk - Chris Becker & Ryan D’orazi 
Focuses on the affordances of paper comps of magazine and other printed material. Each piece of paper is tagged, and acts as a vector into all of its versions, related documents, and relationships with the people and files that created the content of the page. By swiping the paper over different areas of the desk, the user instantly sees these different aspects of the page on a large screen. Reflects the activities of real-world magazine production. Paper, custom built table, Barcode reader, Wii controller, 50″ display, light sensors.

Whisper Stones - Kylan Coats
Plays with the idea mythical character of the stone by allowing people to lean down, pick up a one of several stones, and anonymously leave or hear and audio message. Small and large stones, $10 radio shack solid state recorders, switches.

Pen and Book - Chris Lauritzen & Hunter Sebresos 
Explores and embraces the affordances of pen and paper by imagining simple, non-precious, mass produced and cheap digital pens and e-books. Enables the user to write on standard paper, yet instantly email the new document. Also, mark up a book and access the notes with any reader, anywhere. Paper, modified ball-point pen, Wacom tablets, projector, Flash, AppleScript.

Memory Apparatus – Hyun Yang
Inverts the “problem” of ubiquitous surveillance video, and demonstrates how people can access the histories of their own lives through the near future of continuous video capture of everything, everywhere. By rotating the two axis of the Astrolabe like object, one can dial in moments and locations of your life, seeing yourself from the perspective of a surveillance camera. Knob, Wii controller, video.

Postgeheimnis (The mail project) – Christiane Holzheid & Julia Tsao
A series of speculations (some mocked up in video scenarios, others prototypes) that explores ideas for applying some of the beneficial affordances of traditional mail and packages to electronic forms of mail. For example, in one of the working prototypes, an authorized friend is able to leave a video message for you and assign it to an object (e.g. a lamp) in your home. The lamp blinks when a message is waiting, and you simply touch the lamp see the video message played back in place of the light cast by the lamp. Micro projector, speaker, pressure sensors, two computers, Flash media server.

Shop Conscious – Nicole Chan & Haelim Paek
A system that enables the shopper to rate and find more information as they shop. They can create different rating profiles for themselves, weighting sustainability, product quality, and social network criteria. It includes a portable and dressing room media component. iPhone with LiveView app streaming flash from laptop, proximity sensors, light sensor.

Brainstorming Egg – Haemi Yoon
This project imagines a quarter sized projector that can be stuck to any surface (like your pant-leg) and turns it into a brainstorming area. Using a egg shaped object as the interface, the user can gesture to create a topic, manipulate media (e.g. scrub video), and make connections between ideas. Accelerometer, XBee wireless module, Wii controller in combination with Jonny Lee’s whiteboard software.

NetCreator – Austin Lee & Yoo Kyoung Noh
By imagining a future startup company, this project uses a series of video simulations and working prototypes to explore how everyday objects can mediate communications and create new meanings in their surroundings. For example, the working prototype demonstrated how a user could read information on their coffee cup, transfer that article to another person’s cup, send secret messages, or seamlessly transition from the short version on the cup to a full version displayed on an e-paper table. iPod Touch with LiveView app streaming flash from laptop, pressure sensor, projector, knob.

Update: Behind the scenes of the making of the video

Microsoft Office Lab’s Vision 2019 video

MDP Alumni Sebastian Bettencourt’s Beyond The Fold Newspaper Project

Here are links to several of my students’ past projects:

• 2004 – wall – scott nazarian, nikolai cornell
• 2005,2006 – mirror – in search of identity, infiniti interactive - nikolai cornell, phil van allen, others
• 2006 – interactive table – acura oracle – nikolai cornell, jonathan jarvis, phil van allen, others
• 2006 – handheld augmented reality – telepath – matt mcbride
• 2007 – e-paper newspaper – beyond the fold - sebastian bettencourt

In my current New Ecology of Things class, and in my upcoming research, we are working on an in-depth exploration of how people can work, play, and be entertained using digital affordances, yet moving away from the “mouse crouch” of sitting at a computer. One difference I have from the Microsoft vision is this: I believe each different activity can have its own set of affordances rather than the seeming standard ones envisioned in the Microsoft video. For example, writing an essay should be quite different from say, designing a website. I call this approach “anti-homogenous.” What we don’t need is a new ubiquitous interface and set of gestures. What we do need is gaining back some of the benefits of work and play spaces that are suited to the activity at hand.

This line of thinking was inspired by an article in Metropolis Magazine by John Hokenberry on an excellent new photography book by Michael Wolf called The Transparent City. The photos are studies of high-rises in Chicago, and show the uniformity of our current workplaces. An excerpt from the article:

The steel mill can’t be confused with the meatpacking plant or the typewriter-assembly factory. But here one has no idea of what goods or (more likely) services emerge from these cubicles and boardrooms.

Microsoft is proposing a new way of working, but in many ways, it is reproducing the idea of one-size-fits-all that’s embodied by operating systems like Windows. I’m not saying that Microsoft got it all wrong, they did a very good job up to a point. But perhaps we need to think beyond the homogenous approach. Instead, people need to be able to create their own work/play spaces that afford the kind of activities they are doing at the moment.  What would that heterogenous approach look like?

View Video (95meg)

I’m very interested in how tangible objects can be used in interesting ways to interact with information on screens. This video collects together a series of experiments on the use of a range of object prototypes. In making these, I imagined a screen in front of me (in some cases a standard size screen, in other cases a wall sized screen), and manipulated the various objects as if I was controlling and interacting with content on the screen. It was more an experiment in the affordance of the objects in relation to screens than thinking of specific applications.

This project was aided by the help of my graduate students Jonathan Jarvis, and Parker Kuncl.

NET Lab Widgets

There’s a new version of the NET Lab Toolkit. This release adds a new skin, single keystroke to make widgets invisible, play/pause function for VideoControl and several bug fixes. This is in addition to support for Xbee wireless sensors, the Wii Remote, and DMX lighting control that came with the ALPHA version released in July ‘08.