With the Apple iPad launched and scores of other tablets and e-readers hitting the market, I think it’s important to step back and look at the larger trends. We’re in the middle of a major shift towards ubiquitous computing, cloud based personal storage, and tangible interaction. It’s a shift away from the generic computation typified by the “personal computer,” which never really achieved the individuality or specificity implied by the term “personal.” In short, we’re experiencing the emergence of The New Ecology of Things, where a network of heterogeneous, smart objects and spaces create opportunities for a more personal and meaningful landscape. This is what I’d like to explore:

• Where we’ve been and how the personal computer has made us soulless
• Where we’re about to be #1 with the emergence of digital slabs
• Where we’re about to be #2 with a new form of design that’s a hybrid of software and product
• Where we may be going and the future of the designer in an era of bespoke objects

The Past – The Personal Computer Has Made Us Soulless

There are many signs that all is not well with our day-to-day work life. John Hockenberry’s review of Michael Wolf’s The Transparent City contemplates the crushing homogeneity and conformity of modern work revealed through Wolf’s photographs of life seen through Chicago’s skyscrapers. Describing one photo, Hockenberry sees “12 random floors of eggshell white, computer screens on brown desks, and wall-hung bookshelves.” Sound familiar?

The article goes on to discuss how the environment for “knowledge work” is unlike factories where the space is specifically suited to the activity of making things. The knowledge working context has devolved to the point where “offices have become stacks of boxes for people who get paid to think out of them.” But I believe this is not only a problem of architecture and environmental design. Our daily activity has been squeezed into the narrow channel of interaction with the personal computer and its attendant posture, furniture, and detachment from the needs of the person. The digital tools we use have played a large role in creating this disembodied, deadening uniformity.

Similarly, Matthew B. Crawford has been driven out of the office and into his motorcycle repair shop as described in “Shop Class as Soulcraft: An Inquiry Into the Value of Work.” In the book, Crawford discusses how knowledge work has become vague and disconnected from the concrete, meaningful outcomes of manual labor. But again, perhaps it’s not only the type of work, but the manner in which the work is accomplished. The disconnection from the physical isn’t limited to paper-pushing knowledge workers, but architects, graphic designers, recording engineers and others whom we think of as having “satisfying” jobs where things are made. As creative workers, we’ve seen our day-to-day work compressed from a productive, bodily engaged studio environment down to the almost motionless “mouse-crouch” that plugs us into the virtual. Seduced by the power of the personal computer, we have morphed from active, engaged, social, interactive people to sedentary, soulless slugs perched in front of our glowing screens.

The personal computer has created a homogenous, static and context free environment for work and play that removes activity from the meaningful and productive character of acting and thinking in the embodied, physical environment. This needs to change.

The Emergent – Slabs: A Step Towards Re-Engagement

The iPhone, Android platform, Monome (its clones), Siftables, and now the iPad represent a new form of computing device that I call the slab. Slabs are hand-held, generic platforms with a range of sizes and capabilities (e.g, touch screen, GPS, accelerometer, gyro, WiFi, speaker, mic, etc.) that, in effect, turn into something new with each different application they run.

Slabs are different from personal computers. First, because they have a smaller, simpler form factor and a direct, touch based interaction. Second, because slabs do one thing at a time, in that the device effectively becomes the app once it’s launched, and the separation between software, hardware and interaction dissolves. When you switch apps on a slab, you get a whole new device that engages you as a unified, tangible object. This works because the app is the device (and all the discussions about slabs “multitasking” have new meaning in this context). Third, slabs will eventually be cheap enough that one can use multiple devices at a time, at a location and context appropriate to the physical space and task at hand.

Finally we can begin to disconnect from soulless trap of the (im)personal computer. By using slabs, we customize and re-engage with our environment and feel the consequences of our activity. Instead of being tied to a “workstation,” we can move around the work/play space, utilizing slabs and their spatial relations to one another. We use specialized tools and work practices as slabs morph to the needs of each activity (rather than the other way around). We touch things again. Instead of immersing ourselves in the virtual, we re-engage with people and things in the world. We work more easily with others, sharing and collaborating in physical space, where “here, look” and “take this and work on it” are literal statements that once again become the norm. We customize our tools and ultimately I hope, make or acquire our own specialized tools (see the bespoke objects discussion below).

In addition to their embodied and embedded character, slabs excel at leveraging the affordances of computation and networks. With configuration and data always backed up in the cloud, slabs can be easily reincarnated if scrambled, broken, or lost – and with this, interaction, meaning, and ideas become more important than the object. The cloud also enables different slabs to work across space and time while still being in the here and now. Our digital work is no longer tied to a single workstation, but can manifest in different forms, on different devices, with activity-specific functionality.

In short, there’s the potential to get the best of both worlds – the material and social character of the physical, along with the flexibility, power, and ubiquity of the computational. We gain a heterogeneous collection of devices, specifically suited to the activities at hand. For example, a graphic designer might have a large, work table slab for standing and working on layouts. Or a lap sized slab to sit with and edit an image in a concentrated mood. A narrow slab might sit on a table to keep track of a to-do list. And of course, the designer would use a few 8 1/2″ x 11″ slabs at a client meeting to pass around the table for discussion.

The Emergent – Sofducts: A Challenge for Designers

For the designer of these systems, the slab presents an interesting set of challenges. In particular, there’s a hybrid character to apps. Apps are software, yet as described above, the app becomes something more like a physical product once launched on a slab. This merging of app + slab leads to something I call the software/product or sofduct.

On one hand, the sofduct is distributed like software with almost no cost of goods. On the other hand, the user perceives the sofduct like a product because the interaction feels similar to that of  a manufactured object. You hold it, press buttons, shake it, etc. For example, GPS navigation systems used to be sold as a traditional product, in a box, physically shipped, with a warranty card and customer service phone number. Now, the sofduct version gives you the exact same functionality but is downloaded and runs on a slab as a piece of software. To the user, the end result looks and feels just like the traditional physical product. The sofduct is very disruptive in this way.

For one, whole business models are being destroyed by the sofduct. You can now buy the MotionX-GPS Drive app for $2.99, and get turn-by-turn navigation for $2.99 a month or $25/year (not to mention Google’s free turn-by-turn GPS on Android). In some cases, in-app purchasing of add-ons and features creates a modular “product” model, where the sofduct is actually a range of product possibilities that can be selected and customized by the user. Can traditional GPS units and other physical products survive this kind of competition?

But I’m especially interested in how sofducts disrupt the role of designers. Unlike software for a computer, a sofduct has to meet the expectations for a traditional product. The high-finish aesthetics, ergonomics, and conceptual integrity of physical product design will be assumed by users. Likewise, simplicity and clarity of interaction are critical. The perception of “product-ness” will also influence user expectations for reliability and customer service – we want products to simply work. Because of this, visual and interaction screen designers need to adopt the above considerations and aesthetics of product designers as they develop sofducts. Or better yet, collaborate with a product designer as a member of the design team.

On the other side, product designers entering the sofduct realm need to understand the traditions and expectations for software. Users want constant and rapid, usually free upgrades. Product design tries to get it perfect before launch, since there’s no turning back after you send the device to manufacturing. But with a sofduct, it may be better to put out a really good, but simpler version on the market quickly, and use a software model for product planning where upgrades are rolled out on a strategic schedule. Plus, customization and the integration of media are different from the fixed character of physical products, requiring a deep understanding of interaction, typography, and visual design that requires the experience of software and screen designers.

Sofducts are are new category for design, merging the focus, situated character, and physicality of an object with the malleability, customization, and media richness of software. This requires an integration of disciplines, including software development practices with product design, screen design with haptics, interactive/interaction design with materials sensibility, media production with physical interactions. Further, new business and design opportunities emerge, and require a complete rethinking of design and implementation for this new category.

The Future – Bespoke Objects

As slabs and sofducts create an emerging design landscape today, designers need to prepare for further disruptions and repositioning of their skills. Soon, trends in hardware and software will open up the possibility for low-cost, custom-built systems for individuals and specific applications. In the same way that one can have a bespoke suit tailored to a perfect fit and style, it may soon become possible to have a bespoke object with the hardware, software and design features tailored to the perfect fit and style for you and your intended use.

By this, I don’t mean the custom manufacturing typified by NIKEiD and others in recent years (though that will likely happen as well). What I do mean something literally like the local tailor, working out of a shop around the corner. The production of bespoke objects on the local level is becoming possible because of rapid advances in desktop 3D printing, system-on-a-board components, open-source software and hardware, and the DIY culture growing around these trends.

With cheap, off-the-shelf computational components and the ability to print 3D parts, the digital tailor will soon be able to hang their sign out and make individual or short-run custom objects full of ubicomp goodness. People will want these because a generic, mass-produced slab won’t always be suited to their particular circumstance or activity. Moreover, having a custom designed ensemble of complementary, networked objects, specifically crafted to your way of working will be the hallmark of the enthusiast and expert alike. We’ll want to assemble our own unique ecologies of things, from tiny watch sized objects, through tablets, to big activated interactive walls.

Assuming the bespoke object becomes a reality, what does this mean for the designer and design firms? Will it put designers out of business? I think that in the same way sofducts are disrupting design practices and business models, bespoke objects will create major disruptions for designers. If even a portion of product design and manufacturing moves to a decentralized, local model, many individual designers and design companies will have to adjust.

I see a few possibilities. First, those digital tailors are designers. Or at least the most successful ones will be. Just because some of the parts, software and 3D models will be off-the-shelf, bespoke objects will also have custom aspects and are systems that must be integrated for a specific person or task. That’s the job of a designer. Would it be so bad if designers are small business owners around the corner, selling locally in person and internationally online? Second, the off-the-shelf interactions, interfaces, systems-on-a-board, 3D models, etc. – i.e. the ecosystem around the bespoke object – all need design, and I’d expect a market to develop for small and large organizations to design and produce the necessary (virtual and physical) components that enable the digital tailor to operate.

The New Ecology of Things

Nearly 20 years ago, Mark Weiser published his seminal paper on ubiquitous computing in Scientific American, “The Computer for the 21st Century” (scan, reprint in PDF – you really should read it!). This remarkably prescient work predicts much of what’s becoming a reality today (and perhaps Apple’s iPad name is a tip-of-the-hat to Weiser’s taxonomy of tabs, pads, and boards). More recently, Microsoft showed their vision of 2019 video. It’s a great visualization of the potential fluidity of interaction, but the homogeneity and sense of virtuality (a window into something) does not capture the more tangible, gritty, idiosyncratic, embodied, embedded character I hope for in The New Ecology of Things.

Both visions emphasize the screen as the dominant system. Certainly the screen’s power to change dynamically; show combinations of text, image, animation, and video; and to support interaction through touch is remarkable. Yet I think one of the most interesting challenges for designers is to look beyond the screen slab, and imagine how other computationally enhanced objects with texture, kinetic motion, haptic feedback, sound, and light can be integrated into this new ecology of things. Let’s make sure we leverage the joy and power of all the human senses and abilities in our designs.

There’s also a new version of the Widgets on the download page with these new features:

• Arduino support now requires Firmata 2.1 which comes with the Arduino 18 software
• Insert widget now has data logging features
• Added IfThenElse widget

If you have been use the Arduino with a previous version of the widgets, you’ll need to update your Arduino with the newer Firmata released with Arduino 18.

Please send us your feedback on the new website on our contact page.

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 – perform an action when something happens
• Loops – do 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 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.
• Double 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)
• To copy a script block from one sprite to another sprite, drag the block of code onto the sprite in the Sprite List (lower right corner of Scratch).

---

Program sequence – Actions happen in a certain order

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, it’s important to set the particular instrument you want before you play a note. Otherwise, the program will play whatever the default instrument is.

Scratch Examples:

In Scratch, to visually see program sequence in action, click on the Edit button at the top of the screen, and select “Set Single Stepping…”, and then select “Flash Blocks (slow)”. 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.

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

Event Occurs -> Perform an Action

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 ever 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 (hint: put a script on the “stage” sprite to do this)
2. Make the sprites fall – i.e. animate from the top of the screen to the bottom of the screen.
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

Bonus Tasks:

1. When the falling sprites recycle to the top, make them start in a random position left to right (i.e. the x position should be reset to a random number). This will make the game less predicable and more fun.
2. Add a “good” sound for when the score is increased, and a “bad” sound for when the scored is decreased.

Hints:

1. Creating programs is a trial and error process – they never work right the first time. Expect this, and just keep improving and refining it as you go.
2. Get a single falling sprite working first, and then copy it to make additional falling sprites. This way, you’ll only make mistakes and changes to a single sprite, and won’t have to go back and change all the other sprites over and over again.
3. Consider where the code for each part should go. There is no right way to program, but often putting the code on the right sprite will make it easier because the sprite knows where it is.

• 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?