Interference Inc. is looking for new hires that are involved in the interactive technology domain. I’ve been working with Interference for more than a year now and it’s been great. This may be the job for you! You can find the information below.

Company: Interference Inc.
Positions: We are looking for a PROGRAMMER and an INTERACTIVE ENGINEER
Position Type: Full-Time

Experience:
Candidates who have worked/have familiarity with multi-touch platforms previously and are eager to explore and learn more in a fast paced marketing/technology environment creating installations for major
global brands.

The position for the first 3 months is a probation period where the person is hired as an independent contractor and paid 1099. Depending on review and evaluation, the candidate is then hired full-time with
benefits: full medical, 401K, and 2 weeks of vacation.

Location: New York, NY
Start Date: ASAP

THE COMPANY
Interference Inc. is a world-renowned experiential marketing agency specializing in integrated, guerrilla and buzz marketing. Out of Interference, The SuperTouch Group was born in 2009, bringing creative technology offerings to the same impressive roster of clients. The SuperTouch mission is to generate wonder through simple, fun, entertaining and educational uses of interactive technology. We create innovative products for people to interact with technology in unique and compelling ways, and ideally away from the platforms that they are used to. SuperTouch develops Interactive Mirrors, touch surfaces, live gaming and creative custom technology builds as well as the back-end programming.

JOB SUMMARY
The Programmer and Interactive Engineer will report directly to the project’s Lead Engineer and to the Head of Production/Account. Qualified candidates should possess a couple of key skills itemized in the lists below.

PROGRAMMING SKILLS (Please specify where you are proficient)

• Proficiency with Flash/Flex/Actionscript 3, .NET/C#/WPF, Python, Java, C++ (or others, please specify)
• Knowledge of Computer Vision (OpenCV, Augmented Reality Frameworks)
• Knowledge of microcontrollers (arduino or similar) and working with sensors
• Proficiency with openFrameworks, processing, max/msp, or pd
• Knowledge of Adobe Creative Suite including, InDesign, Photoshop, Illustrator and After Effects
• Knowledge of computer networking

ENGINEERING SKILLS (Please specify where you are proficient)

• Experience in architecture, hardware design, and/or fabrication
• Ability to source, test and assess hardware for fabrication and to assemble working prototypes
• Experience in soldering, electronics, and lab testing
• Experience in interactive or touch technology with an emphasis in multi-touch computing

REQUIREMENTS

• Extremely organized individual who is a self-starter and able to learn quickly in a fast-paced environment
• Ability to think creatively, multi-task, and go beyond off-the-shelf solutions
• Strong logistical, time management and planning skills when implementing creative solutions for client deadlines
• The individual must be polished and professional and be prepared to interact with high level clientele onsite

Please note, the Interactive Engineer position may require travel to install, maintain, and breakdown
technologies across the U.S. as well as internationally. Candidates applying for the position must be able to
travel with the necessary documentation, willing to travel 1-2 times per month, and maintain a valid driver’s
license.

IF INTERESTED, PLEASE SUBMIT RESUMES TO: Christine Lane, Christine@interferenceinc.com

You can download and save the job description below:

Interferece Job Description 10_07_13 Supertouch Tech Description.doc

Date:	January 1, 1970
MD5 Hash:	a32db82cb70c1bd7f509df0562a9c45e

32.0 KiB 52 Downloads Details...

Wall Pong is an interactive multi-player multitouch pong type game I wrote in AS3 a couple years ago. The aim is to get the ball into the opposing goal. You can see Wong within my Audiotouch OS software. I’ve been meaning to release the source code and game for quite some time and finally I had the chance to clean up the code (it still could use WAY more cleaning and probably re-factoring), but it’s in good enough shape for others to use.

I’m hoping to convert this version to use the new native touch api in flash CS5.

You can download the application on techsparked here!!

If you’re using Drupal, you’re probably using views. If you’re using views, than you’ve probably wanted to build a view that involved combining content and found out it was hard or almost impossible through the views UI.

For example, if you’ve ever tried to build a single view of all content (posts, comments, flags, relationships, etc) into a single list, you’ve probably found that you can’t. However, you can easily build independent post views, comment views, flag views, and relationship views.  Since that’s the case, why can’t we merge all these views into a single view through the views UI? Well you can, and this article hopefully will give the basic information needed to start merging your views into more complex results.

In this article, we’ll be building a basic activity stream to demonstrate the ability to

1. create custom queries for views,
2. merge our results,
3. create our custom query module, and
4. finally output through the views UI.

After some themeing, our results will look something like the following which is a combination of comments, flags (sparks), and posts (various content types):

Live DEMO:

You can see a live example on the bottom of http://techsparked.com/

DOWNLOAD EXAMPLE MODULE:

custom_views module custom_views.zip

Date:	January 1, 1970
MD5 Hash:	580adbe74f69b884e3b6eda6c547db83

1.5 KiB 24 Downloads Details...

Introduction:

Before we begin, we have to know what we’re making. We’re going to be creating a list view (you can choose another type if you please) of posts and comments from our site ordered by date. Later, you can choose to add more activity into your view like flags (likes), relationships (who’s following whom), etc. but for now we’ll keep it simple since the same principle for 2 types of information also applies to 5 types.

Step 1: Making the query

To create our activity stream view, we’re essentially going to combine two individual views into a single query. We’re going to take advantage of the views UI preview in order to get our query (in case we don’t know too much about SQL queries).

1. Create a new temporary view (we’re not actually going to save it) called recent_posts (or similar).
2. Add fields for: user name, user picture, node title, node post date, and node type.
3. Add a sort criteria for Node: poste date.
4. Add a filter for Node: published.



Your view should look like the above

5. In the views ‘live preview’, click the preview button.
6. Scroll down to where the ‘query’ is shown and copy and paste this to a temporary text file on your desktop. We’re going to need this query code in a bit.



7. Create a new temporary view (we’re not actually going to save it) called recent_comments (or similar).
8. Add relationship for: Comment: node and Comment: User.
9. Add fields for: user name, user picture, node title,  comment title, and comment post date (all fields related to their relationships).
10. Add a sort criteria for Comment: poste date.
11. Add a filter for Node: published.



12. Scroll down to where the ‘query’ is shown and copy and paste this to the same file you created in step 6. We’re going to need this query code in a bit.

Step 2: Combine and merge the queries using UNION

We should now have 2 views queries copied to a text file that look something like:

//posts view
SELECT node.nid AS nid,
users.picture AS users_picture,
users.uid AS users_uid,
users.name AS users_name,
users.mail AS users_mail,
node.type AS node_type,
node.title AS node_title,
node.created AS node_created,
history_user.timestamp AS history_user_timestamp,
node.changed AS node_changed,
node_comment_statistics.last_comment_timestamp AS node_comment_statistics_last_comment_timestamp
FROM node node
INNER JOIN users users ON node.uid = users.uid
LEFT JOIN history history_user ON node.nid = history_user.nid AND history_user.uid = ***CURRENT_USER***
INNER JOIN node_comment_statistics node_comment_statistics ON node.nid = node_comment_statistics.nid
WHERE (node.status <> 0)
ORDER BY node_created DESC

//comments view
SELECT comments.cid AS cid,
users_comments.picture AS users_comments_picture,
users_comments.uid AS users_comments_uid,
users_comments.name AS users_comments_name,
users_comments.mail AS users_comments_mail,
comments.subject AS comments_subject,
comments.nid AS comments_nid,
node_comments.title AS node_comments_title,
node_comments.nid AS node_comments_nid,
comments.timestamp AS comments_timestamp
FROM comments comments
LEFT JOIN node node_comments ON comments.nid = node_comments.nid
LEFT JOIN users users_comments ON comments.uid = users_comments.uid
WHERE (node_comments.status <> 0)
ORDER BY comments_timestamp DESC

1. Views adds a few things that we really won’t need. So we can remove all the bold parts above to clean up our queries. The results should look like:

//posts view
SELECT node.nid AS nid, //node id
users.picture AS users_picture, //picture
users.uid AS users_uid, //user id
users.name AS users_name, //user name
node.type AS node_type, // node type
node.title AS node_title, // node title
node.created AS node_created //post date
FROM node node
INNER JOIN users users ON node.uid = users.uid
WHERE (node.status <> 0)
ORDER BY node_created DESC

//comments view
SELECT comments.cid AS cid, //comment id
users_comments.picture AS users_comments_picture, // picture
users_comments.uid AS users_comments_uid, //user id
users_comments.name AS users_comments_name, //user name
node_comments.type AS node_type, //node type
comments.subject AS comments_subject, // comment title
comments.timestamp AS comments_timestamp //post date
FROM comments comments
LEFT JOIN node node_comments ON comments.nid = node_comments.nid
LEFT JOIN users users_comments ON comments.uid = users_comments.uid
WHERE (node_comments.status <> 0)
ORDER BY comments_timestamp DESC

2. The result above are much cleaner. We’re going to merge these two queries by using UNION. UNION combines the results of multiple SELECTs. If you’re not familiar with UNION, i’d recommend reading this. In order to to create a union you have to have the same amount of SELECT fields. Luckily, when we cleaned up our view we were left with 7 SELECT fields (id, picture, user name, node type, title, post date). If you don’t have the same amount of fields in each query, you’ll need to create the same amount by modifying your queries or adding a ‘NULL’ select in the query that has less fields. To make a UNION query of the above is simple. Copy and cut the ORDER BY node_created DESC from the end of the first query and replace the ORDER BY comments_timestamp DESC from the end of the second query with it.  Then, add ‘UNION‘ bewteen the two queries and you’re done! Results below:

//posts view
SELECT node.nid AS nid, //node id
users.picture AS users_picture, //picture
users.uid AS users_uid, //user id
users.name AS users_name, //user name
node.type AS node_type, // node type
node.title AS node_title, // node title
node.created AS node_created //post date
FROM node node
INNER JOIN users users ON node.uid = users.uid
WHERE (node.status <> 0)

UNION

//comments view
SELECT comments.cid AS cid, //comment id
users_comments.picture AS users_comments_picture, // picture
users_comments.uid AS users_comments_uid, //user id
users_comments.name AS users_comments_name, //user name
node_comments.type AS node_type, //node type
comments.subject AS comments_subject, // comment title
comments.timestamp AS comments_timestamp //post date
FROM comments comments
LEFT JOIN node node_comments ON comments.nid = node_comments.nid
LEFT JOIN users users_comments ON comments.uid = users_comments.uid
WHERE (node_comments.status <> 0)
ORDER BY node_created DESC

3. This is going to merge our two views (posts and comments) and sort them by post date. Meaning, intstead of having 2 seperate views (one after the other), we now have a single view query that sorts both views (together) by node_created/comments_timestamp.  We just created our custom query! Now it’s time to prepare it to be fed into views

Step 3: Creating the custom query module

Now that we have our custom query ready to feed into views, we have to create a module to feed it into the views UI.  Sound scary? It’s not – I’ll be giving you all the pieces below.

1. Create a folder on your desktop called custom_views
2. Create a text file on your desktop called custom_views.info
3. Inside the file, paste:

; $Id$
name = Custom Views
description = Custom views query for this site.
core = 6.x

4. Save this file.
5. Create a text file on your desktop called custom_views.install
6. Inside this file, paste:

<?php // $Id: custom_views.install

/**
* Implementation of hook_install()
*/
function custom_views_install() {
// Set the module weight so it can override other modules.
db_query(“UPDATE {system} SET weight = 99 WHERE name = ‘custom_views’”);
}

/**
* Implementation of hook_uninstall()
*/
function custom_views_uninstall() {
// Remove the module from the system table
db_query(“DELETE FROM {system} WHERE name = ‘custom_views’”);
}

7. Save this file.
8. Create a text file on your desktop called custom_views.module
9. Inside this file, paste:

<?php // $Id: custom_views.module,v 1.272.2.1 20010/05/07 12:25:24 goba Exp $

function custom_views_views_pre_execute(&$view) {

if($view->name==”SiteActivity”) {//if we don’t do this it’ll alter ALL our view queries with this one!

$view->build_info['query']=”//custom query goes here“;

$view->build_info['count_query']=$view->build_info['query'];  // count_query determines the pager.  Do this so the right item count is returned.

}

}

/**
* This module is Views 2.0 enabled.
* Implementation of hook_views_api().
*/
function custom_views_views_api() {
return array(‘api’ => 2.0);
}

10. Inside the custom_views_views_pre_execute function where it says ‘custom query goes here‘, paste the custom query we made in step 2 . Result below:

<?php // $Id: custom_views.module,v 1.272.2.1 20010/05/07 12:25:24 goba Exp $

function custom_views_views_pre_execute(&$view) {

if($view->name==”SiteActivity”) //if we don’t do this it’ll alter ALL our site’s view queries with this one!
{
$view->build_info['query']=
”
SELECT node.nid AS nid, //node id
users.picture AS users_picture, //picture
users.uid AS users_uid, //user id
users.name AS users_name, //user name
node.type AS node_type, // node type
node.title AS node_title, // node title
node.created AS node_created //post date
FROM node node
INNER JOIN users users ON node.uid = users.uid
WHERE (node.status <> 0)

UNION

SELECT comments.cid AS cid, //comment id
users_comments.picture AS users_comments_picture, // picture
users_comments.uid AS users_comments_uid, //user id
users_comments.name AS users_comments_name, //user name
node_comments.type AS node_type, //node type
comments.subject AS comments_subject, // comment title
comments.timestamp AS comments_timestamp //post date
FROM comments comments
LEFT JOIN node node_comments ON comments.nid = node_comments.nid
LEFT JOIN users users_comments ON comments.uid = users_comments.uid
WHERE (node_comments.status <> 0)
ORDER BY node_created DESC”;

$view->build_info['count_query']=$view->build_info['query'];  // count_query determines the pager.  Do this so the right item count is returned.}
}

/**
* This module is Views 2.0 enabled.
* Implementation of hook_views_api().
*/
function custom_views_views_api() {
return array(‘api’ => 2.0);
}

11. Save this file. We just created our custom views module.
12. Now upload your custom_views module to your website and enable it like normal.

Step 4: Output our activity stream through the views UI

Now that we have our new module, with our custom query added to our site, it’s time to create our final view.

1. Create a new node view and call it ‘SiteActivity‘. We’re picking this name because that’s what we put in our module “if($view->name==”SiteActivity“)”. If you want to call it something else, you’ll need to change the name in the custom_views module too.
2. Since the query we made had user picture, user name, node type, title, and post date, we’ll add fields for all of those.



3. You can arrange these how you want. Preview your new view and see what it looks like! Hopefully it should be a combination of other views you created before, but now they’re combined into a single list!
4. The original example in the beginning of this post goes a bit further (probably covered later in a part 2 of this tutorial). It uses views custom fields in order to take all the results and images based upon the content type and activity type (project, flag, comment). With a little creativity you can do the same.

Final Thoughts:

Most of the themeing parts of this tutorial will be saved for another time (part 2) since they deserve a separate part. In this example we covered how to combine multiple views queries and sorting based on a common part (post date). The method of creating a custom query and module to input in views should work with any custom query and not just UNIONs. So there is a lot of room for creativity. I hope you enjoyed this tutorial. I don’t claim to be an expert by any means and so please let me know if there are problems or insights that could improve upon this process. If there are any steps missing or clarification needed – let me know so I can make the necessary changes/additions.

DOWNLOAD EXAMPLE MODULE:

custom_views module custom_views.zip

Date:	January 1, 1970
MD5 Hash:	580adbe74f69b884e3b6eda6c547db83

1.5 KiB 24 Downloads Details...

Help by digging this story!!!

After lots of hard work, I am proud to announce the open beta launch of a new social platform I’ve been developing for creative and emergent interactive technology called techsparked. If you like my blog, the MTmini, Audiotouch or any of my work – you’re going to love techsparked!

CALL FOR PARTICIPATION

5th Annual ACM Conference on Interactive Tabletops and Surfaces 2010

The Interactive Tabletops and Surfaces 2010 Conference (ITS) is a
premiere venue for presenting research in the design and use of new
and emerging tabletop and interactive surface technologies. As a new
community, we embrace the growth of the discipline in a wide variety
of areas, including innovations in ITS hardware, software, design, and
projects expanding our understanding of design considerations of ITS
technologies and of their applications.

Building on their success in previous years, ITS again features Papers
and Notes presentations, as well as tutorials, posters, and
demonstrations tracks. For the first time, ITS 2010 will also include
a doctoral symposium.

ITS 2010 will bring together top researchers and practitioners who are
interested in both the technical and human aspects of ITS technology.
On behalf of the conference organizing committee, we invite you to
begin planning your submissions and participation for this year’s
conference!

CALL FOR PARTICIPATION: PAPERS AND NOTES

The use of interactive surfaces is an exciting and emerging research
area. Display technologies, such as projectors, LCD and OLED flat
panels, and even flexible display substrates, coupled with input
sensors capable of enabling direct interaction, make it reasonable to
envision a not-so-distant future in which many of the common surfaces
in our environment will function as digital interactive displays. ITS
brings together researchers and practitioners from a variety of
backgrounds and interests, such as camera and projector based systems,
new display technologies, multi-touch sensing, user interface
technologies, augmented reality, computer vision, multimodal
interaction, novel input and sensing technologies, computer supported
cooperative work (CSCW), and information visualization.

The intimate size of this single-track symposium provides an ideal
venue for leading researchers and practitioners to exchange research
results and experiences. We encourage submissions on (but not limited
to) the following topic areas as they relate to interactive tabletops
and surfaces:

• Applications
• Gesture-based interfaces
• Multi-modal interfaces
• Tangible interfaces
• Novel interaction techniques
• Data handling/exchange on large interactive surfaces
• Data presentation on large interactive surfaces
• User-interface technology
• Computer supported collaborative systems
• Middleware and network support
• Augmented reality
• Social protocols
• Information visualizations
• Interactive surface hardware, including sensing and input
  technologies with novel capabilities
• Human-centered design & methodologies
• CONFERENCE COMMITTEE
• Conference Co-Chairs
• Johannes Schöning
• Antonio Krüger
• Conference Program Committee Co-Chairs
• Daniel Wigdor
• Michael Haller

MENTORESHIPS

To help those with less experience in academic publication, ITS 2010
offers the help of our two Mentors Chairs. The mentoring program is
intended primarily for authors from non-academics, including industry.

Two types of help are available from the mentor: assistance in framing
and composing your research paper (early feedback), and help and
feedback reviewing an already completed paper (later feedback). In
either case, the mentor will help frame your work in context of other
related work, and make meaningful suggestions to improve the quality
of your contribution. Both types of mentorship have the same
submission deadline.

Although we cannot guarantee that your submission will be accepted by
ITS, mentoring would be helpful for you to turn your ideas into a
proper research paper. If you wish to avail yourself of this program,
you can do so by sending e-mail to both of the Mentor Chairs Lucia
Terrenghi (lucia.terrenghi@vodafone.com) and Changkyu Choi
(changkyu_choi@samsung.com). The submission type will vary depending
on the type of feedback you are seeking.

Early-Stages Feedback (Deadline: 2010.05.25):

Send a 1-page document describing your intended contribution. This
1-page must include author names and affiliation (e.g. company name),
and enough information for the chairs to understand both what it is
that you have done.

Completed Paper Feedback (Deadline: 2010.05.25):

Send your completed paper to both mentors chairs by May 25.

For both early and paper feedback, you will receive a response by June 14.

SUBMISSIONS
Papers/Notes: We invite paper submissions of two kinds: Papers (10
pages) and Notes (4 pages). Papers must present original, highly
innovative, prospective and forward-looking research, possibly in one
or more of the themes given above. Notes must also report novel and
complete research, but where the scope and scale of the contribution
is more focused and succinct than papers. Submissions must be
submitted as a single PDF file in the ACM format through the
submission system. A template for submissions can be found on the ITS
website (http://www.its.2010.org).

All accepted submissions will be presented at ITS 2010 and appear in
the ITS proceedings and be archived in the ACM digital library.

IMPORTANT DATES

Paper / Note Mentorship Requests (optional): May 25, 2010

Paper / Note Mentorship Feedback Received (optional): June 14, 2010

Paper / Note Submissions: June 23, 2010

Paper / Note Author Notifications: August 27, 2010

Paper / Note Camera-Ready Deadline: October 1, 2010

The calls for the posters, demos, tutorials, and the doctoral
symposium will be published soon, please check our website for further
information.

ITS 2010 Conference: November 7-10, 2010

http://www.its.2010.org

–
ITS 2010, Saarbrücken Germany
Interactive Tabletops and Surfaces
http:/www.its2010.org

http://twitter.com/ITS_Germany2010

————————————————————-

Johannes Schöning
Innovative Retail Laboratory
DFKI GmbH, Campus D3_2, Stuhlsatzenhausweg 3, D-66123 Saarbruecken, Germany
www.innovative-retail.de
www.dfki.de/~jschoen
www.dfki.de

Beta invites are not needed anymore – the site is launched!!

http://sethsandler.com/technology-multitouch/proud-announce-launch-techsparkedcom/

Are you interested in innovative, emergent, and interactive technology (multitouch, gestures, eye tracking, augmented reality, creative tech, etc) or the interactions we will have with information in the future? Do you create emergent experiences, have interactive applications/software or code frameworks for building interactive installations, applications, or projects? If so, then this opportunity really is for you.

I have some beta invites for a new website that’ll be doing a rapid beta test within the next week. For the beta, we’re especially looking for people that already have or are in the process of creating projects, applications and software frameworks within the interactive, emergent, and creative technology domain.

To sign up, send an e-mail to: mail[at]sethsandler[dot]com (or leave a comment below) with your e-mail, your name, company (if there is one) and [optionally] any information about a framework, application, or project you have that deals in creative and emergent interactive technology.

If you’ve already sent me a request (prior to this post), don’t worry – I already have you on the list and you should be receiving an invite within the next week.

Beta invites are not needed anymore – the site is launched!! http://sethsandler.com/technology-multitouch/proud-announce-launch-techsparkedcom/

If you’re familiar with the Jazzmutant Lemur, you’ll want to get familiar with Argos Interface Builder by Dimitri Diakopoulos using the great c++ framework openFrameworks.

Last summer I took part in Google Summer of Code as a mentor. Dimitri proposed a multitouch music interface builder and I thought it was a fantastic idea. An opensource lemur; who wouldn’t like that??? Dimitri was chosen as a student for GSoC and I was able to mentor him as he developed Argos. It’s come a long way, and with a little help from the opensource community, it has potential to be incredible!

Take a look at the video below to see Argos in use. You can find the source and a binary (for windows users) here: http://code.google.com/p/ofxargos/

Make sure to check out the release notes and official Argos website at http://argos.dimitridiakopoulos.com/ The application is still feature-incomplete, but quickly approaching a usable state! Dimitri can really use community support; so make sure to say ‘hi’ to him and get involved to make argos the next coolest opensource music interface!

If you’re familiar with multitouch, you’re probably familiar with Jeff Han’s TED demo. In it, there’s an example of a lava application that shows an interesting use of multitouch.

A few months ago, I was trying to work on something similar.

The following is what I came up with. I never had the chance to finish and was only able to add mouse support at the time. So, here’s a preview of what might come to a multitouch screen near you at some point in the future.

It’s pretty slow since it uses bitmapdata and filters and the code is a bit of a Frankenstein of information I found online about ‘metaballs’. If I get a chance, i’ll see if I can get the code out.

Meanwhile, have some fun! Click around and push/move the lava!

What do you think? Lava enough for you?

If you’re not already familiar with twitter, then you’re currently missing out on one of the ‘newest’ (although Twitter is past it’s second birthday) social utility/networking websites sweeping the web.

To get a glimpse of the basic concept of twitter take a look at this video introduction from Common Craft:

With the premise of ‘What are you doing?‘  twitter users can post any open-ended message, thought, url/link, question, etc as long as it fits into the space of 140 characters (text letters).  Aside from ‘tweeting’ your own messages, you can ‘follow’ or subscribe to view the messages of others. Now, this doesn’t seem that powerful, does it? Well, it is and hopefully this will be apparent if you’re able to make it through the self-conversation that follows.

The problem with the video above and the basic premise of ‘What are you doing?‘ is that it causes a lot of misconceptions about the uses of twitter.

If you’re a twitter user and you talk to someone who isn’t, you’ll often get responses such as: “So you just let people know what you’re doing 24/7? Isn’t that somewhat creepy – if not stalkerish?” The quick answer would be “Sometimes.” While there are occurrences of people tweeting day and night about what they eat and where they’re sitting, the majority of people have something more substantive and interesting to say, and a smaller minority are using twitter for it’s unique and true ‘power’ – realizing there’s more than meets the eye.

On the most basic of levels, Twitter is the heartbeat of the web and often the world. Unique to Twitter is it’s ‘trending topics’ that show the most talked about unfiltered phrases or words circulating right now in real-time (no delay) across the web. This means if something important (or not so much) is happening or a major event occurs that affects a huge crowd and likely yourself, you’ll see it on twitter before anywhere else. Since trending topics are unfiltered, non-censored, and carry no agenda the most raw and current events display themselves.

To give an example, Michael Jackson died on June 25 and before the news networks and newspapers could announce the news, twitter was erupting in a Michael Jackson panic of speculation and hospitalization announcements. Twitter users broke the news to the majority before the media could, which is an enormous feat considering the power of today’s media outlets.

For most of us though, knowing what’s happening on a global scale might be interesting, but it’s not dire or interesting enough to sign-up for another site we’ll barely visit and less-often use. Going along with the misconception, if Twitter was only about answering ‘What are you doing’ would it be so bad? If you could know that your favorite band just booked a tour to your city,  your favorite author just finished their newest book and is giving away free copies, or the hero you never thought you’d meet could reply to something you wrote, would you want the opportunity? If you could ask a question and get hundreds of replies instantly, would that be beneficial? Could it potentially be educational?

The power of Twitter lies not just in what people are saying, but who is saying it. If I, an illiterate cook,  tweet “I ate the best cheesecake of my life at Mario’s Bakery” it’ll probably go unnoticed. If  Padma Lakshmi or Tom Colicchio of Top Chef tweet the same thing, it carries a new level of effectiveness – at least for those in the food industry, and I’m sure Mario’s Bakery wouldn’t mind. If you’ve ever wondered how something is accomplished or how to improve on an area in your life, all that’s needed is to follow an expert in your field of interest, and twitter gives people this opprotunity.

As an actionscript and flash developer, I follow the most influential flash developers on the web through twitter. The reason I do this is because they’re not tweeting what they ate for breakfast; they’re talking about the new things they’ve learned and sharing them. Grant Skinner has one of the most popular flash blog sites. By following him on twitter i’ve been able to vastly improve on my own techniques that he passes along – often things that never make it to blog articles on his website. By doing this for a number of various disciplines, I’ve vastly expanded my knowledgebase, am constantly seeing things I would never have known otherwise and the best part is that it requires no work or significant effort on my part.

Where else can you get free advice, insight, mentoring, or knowledge from some of the top officials, experts, entrepreneurs, leaders in the world? Typically you would pay hundreds of $$$/hr to step in the same room as some of the people you can follow for free on twitter, and often times they’re more than kind enough to reply to questions through Twitter. How much would it be worth to know what your hero or idol reads or listens to on a daily basis?

These are only a fraction of a percentage of what makes Twitter both interesting and useful. Since the list is truly too large for a single post, i’ll save it for a Part 2 where there will be a more structured list of both the misconceptions and use cases of twitter.

If you’re still reading this, I consider you very patient. hah! If you have some use cases please leave them below as I’d like to dive deeper into the current and potential uses to the Twitter paradigm.

On my last project I had to use a gesture to initiate an event. Due to this, I recently started experimenting in creating a simple multitouch version of some gesture engines that are available. I’ve come across three that are already available in AS3 and chose to start with the $1 gesture algorithm http://depts.washington.edu/aimgroup/proj/dollar/. It only seems fitting to start with this one since Andy Wilson of microsoft research (and many multitouch devices) had a hand in it’s development.

Like most algorithms, this one matches points drawn with a template that’s already stored. After the gesture is finished, it is matched up against templates in the database and given a percentage of how much it matched it’s closest template (from 0-1). One of the coolest things about this engine is that it’s orientation-less. This means, no matter how you’re orientated on the surface it’ll still recognize the gesture.

The main thing I contributed to the already created $1 gesture port was the ability to have multiple simultaneous gestures occurring at once. This means a single user can perform more than one gesture at a time or multiple users can perform their own gestures while someone else is using the device. However, there are flaws with this algorithm that I’m not fond of  that are performance (speed) related. I’ve only tested with up to 4 touches though so if someone can test with more, please let me know how it runs.

Currently, the demo isn’t fully segregated form the core gesture classes and therefore there’s still some work to be done so that the gesture classes can be used without the demo itself. In the meantime, go ahead and test this out and make sure to give some feedback; it also works with the mouse. The demo allows you to draw a gesture and if it matches on in the database, that gesture will ‘light up.’

The tolerance is set at 80% and therefore if a gesture doesn’t match 80% of a template, it’s not recognized. Both the source and swf file are included. To test the demo, just load up the TouchGestureDemo.swf in flashplayer or a web browser.

Stay tuned for more on this as i’ll show the basics for using this in your own projects in case you need help.

Thanks to Tito (Mathieu Vibrel) and the pyMT crew for pointing me in the right direction.

Gesture Demo gesture.zip Version: 1.0

Multitouch Gesture Engine Demo

Author:	Seth Sandler
Date:	October 13, 2009
MD5 Hash:	f59b34d4779b6959bfd2a62d0dcf00df

102.8 KiB 4950 Downloads Details...