New Domain

Moving this blog to a dedicated domain: blog.manipulus.net.

A Few Studies on the Dragging of a Box

While variations in mapping and latency between pieces are sure to create perceptual and aesthetic differences; It should be possible to utilize a change in these relationships within the same piece to create more complex (yet hopefully unified) interactivity.

The studies can be viewed here.

The source can be downloaded here.

Latency and Mapping Studies

As part of my exploration for my thesis research I’ve been attempting to build small interactive pieces through the design of a restricted set of proposed interactive variables including ‘latency’ and ‘mapping’. The goal being to produce some minimum level of compelling, complex, or emergent interactivity out of basic overlapping ‘manipulations’

While latency is strictly defined as the delay between input and some response, for my purposes I refer to it as the the time between the expression of a final desired value and the alignment of some external property to that value. I begin these studies by varying this time between input and final alignment over a collection of individual elements. I prefer working with cursors as elements as the relationship between a user’s intent and the end visual result of a cursor is exceptionally conditioned and transparent. This relatively automatic act of placing a cursor in space is as close as I can get to using an ‘intended value’.

While I’m attempting to focus on non-visual qualities, I have no misgivings about the important role of an interactive artifact’s visual appearance in our understanding of it. For this reason, toward the end of the series I reinterpret earlier studies as mathematical structures to be visualized in completely new ways.

The studies can be viewed here.

The source for these can be found here. This includes both my own code and the excellent tweening library Tweenlite. Please feel free to remix anything and send me samples!

Second Wind

My pitch was recently approved and I’m currently starting another push to move this project forward; beginning with a committee search.

The past six months have been relatively quiet on the thesis front, but not uneventful. I’ve since moved to Cincinnati Ohio and have been teaching several classes as an adjunct professor at the University of Cincinnati college of DAAP. The experience so far has been entertaining, enlightening, challenging, and most of all meaningful. There many people here I greatly respect and am also personally fond. I’m pleased to walk the halls of the Eisenman building here again.

Interactive Product Design Finals

Better late than never. Student projects from the Spring ’10 Interactive Product Design Studio.

The Stuff of Thought

One critical review of Steven Pinker’s populist science book The Stuff of Thought describes how the title “Things the Mind Does” might be more fitting. The Stuff of Thought is not a neuroscience account of the relation between our crinkled grey matter, and the phenomena we call thinking. Instead Pinker’s linguistic vantage point looks at relatively higher level emergent phenomena. Structures just below the acts of everyday utterances. For someone like myself constantly tip-toeing away from the realm of direct perception towards some kind aesthetics of cognition (if such a thing could be said), an individual with a trained sensitivity to spatial/visual composition trying to understand the untamed world of dynamic and intelligently responsive media, I found Pinker’s account of the metaphoric relationships between spatial, temporal, and causal reasoning worth much of its space on my shelf.

I originally picked the book up a couple years ago, but it languished until recently. Staring at me one morning I thought I’d check it for a contemporary views on Lakoff and Johnson’s ideas of metaphor. Sure enough there was a chapter on it inside that reaffirmed the key points of what was described 20 years prior. As I revisited his ideas though I caught pieces of more contemporary thinking that elaborates on our metaphoric constructions.

Pinker’s discussion of spatial and temporal metaphoric structures are where I found this book most interesting. He describes how, regardless of ontologies be them physical, social, or capitalistic, we understand abstract relationships in terms of potentials for causality. The potential of influence (or may I say the potential for manipulation) is analogous to spatial proximity. Even more interesting is how we cognitively parse physical and continuous spatial relationships intro discreet states based on the functional or causal relationships of the entities involved. For example, being ‘under’ an umbrella is as much or more a statement about being able to stay dry as it is about the abstract positions of the elements involved.

[As an aside, and I may be out of my depth here, the conversion of a continuous variable into a discreet value of causal meaning seems to be some very basic form of 'thinking'. McCullough describes intelligent systems as those that respond to input in deliberate and varied ways. This is useful for categorization of existing artifacts, but less so for thinking through the creation of them. Perhaps it wold be more helpful to say that 'interactive' systems convert continuous input into discreet output, the variety of input and the the complexity of the conversion reflecting the general complexity of the system. This would give a starting point for those learning how to design such systems, a small reoccurring problem to understand. A mapping problem really.]

The verified importance of causality in our thinking, not to mention Pinker’s particular interest in verbs, makes my apparent fixation on designed manipulation less discouraging. (Perhaps it’s fitting that both Pinker and Miyamoto both are interested in verbs; Pinker finds in them the clues for how we interpret the world, Miyamato uses them to define how we play with it). Reading about the eternally present, if even implicit, agent in statements of action struck me in how similar to manipulation if painted verbs in general. The content is better than heartening though. Pinker presents research by Len Talmy, a linguist whose studies into causal perception have exposed a mental model of force dynamics. His studies look at our perception of action and effect in terms of a set of common mental configurations that concepts like prevention and helping map to. Finally, Pinker discusses our universally shared sensitivity to chains of action and intention exist even when end consequences are identical, and plays a major role in our understanding of ethical actions.

One last take away from How The Mind Works was a few related low level metaphoric structures. In my discussions about manipulation I always hit on the problem of metaphor definition. To manipulate something observable in screen space, it must first be described (and modeled). The limitless ways we would could look at something are exceptionally problematic though. What would be useful would be a limited but powerful set of categories to study. “Metaphors We Live By” showed how a great deal of thinking grows from ideas like Object, Container, and Surface. “How the Mind works” introduced me to some interesting elaborations on some of these constructs. Particularly interesting were the relationships between entity, multiples, and aggregates. Pinker shows how entities are defined by their spatial bounds, but can also be viewed, in a sort of figure ground shift, as an aggregate or media, whose shape is ephemeral and temporary. This shift can be used in language for effect in such statements as ‘There was cat all over the highway.’ (which dismisses the structural qualities that regularly define a the unfortunate creature). Also interesting is the distinction between aggregates and a large collections of similar but individual entities. While this distinction is universal, the placement of the dividing line is not. English treats hair and grass as aggregates but other languages describe them as multiples. i.e.. One might comb their hairs. I like these structures as they provide a cohesive set to select from when choosing a creating a model for something visual. A simple choice with implications for potential forms of manipulation.

If you’re familiar with contemporary ideas of language and mind you might not be interested in reading the entire book, but I’d recommend at least Chapter 4, “Cleaving The Air”. Chapter 5, “The Metaphor Metaphor” could also provide a brief but good alternate to “Metaphors we Live By”.

Tackling Programming Problems

One of the most important but difficult programming skills to acquire is the ability to break apart problems. But how does a student go from a fuzzy idea of some multi-media editing interface to the boolean logic of an if else statement when they have the barest grasp of program flow in the first place. Computer Science students have it easy in a fashion; they can focus on learning existing patterns without the necessity of turning experimental ideas into their new language of logic. Designers of interactivity lack the luxury of years of guided programming experience and are saddled with making systems that interface with the most trickiest components, humans.  (The difficulty last part has its own entire field after all).

Last quarter I tried to pass on some more atomistic problems that often sit in between code and concept.  the first and one of the lowest level problems I’ve found is the mapping problem, the conversion of one value to another. The second is on the upper end and the first step for breaking apart a concept: splitting application logic into data and representation. (The model / view terms are of course yanked from the MVC pattern and are usually used to refer to something a little more complex that what I’m dealing with here. I use them in order to paint what is often a continuous set of code as smaller pieces with specific responsibilities).

Mapping
In any kind of interactive physical whatever one of the most common tasks, and place for designing the system is in ʻmappingʼ the range of input values to a range of output values. Ie. your sensor gives you 0–1023 but your rotating doll head goes from 0–2*PI radians (yuck). This is a mapping problem, and luckily, with a little math itʼs not that hard to solve.

(inputValue / maximumInputValue) * maximumOutputValue;

or, to use the example above:

(sensorValue/1023) * TWO_PI

What this code does is convert the sensor input into a percentage and then turn that percentage into an actual value in the target space. (sensorValue/1023) will turn our input into a number between 0 and 1 (0 if sensorValue is 0 and 1 if sensor value is 1023). Then we take the value of the target space and multiply by the variable. If our doll head turns to TWO_PI radians and we multiple that maximum value by a percentage, we get the actual number we want the head turned to.

Model / View
Interactive systems are kinda muddy. If weʼre going to design them we need to be able to describe them.

The first step (and easiest and most useful way to do this) is to describe what variables are in the system. A stripped down version of Pong with nothing but the ball needs variables for the x & y position of the ball and also the ballʼs x and y velocity.

Next we need the rules by which the system operates. Always start with the most basic version of a rule that you can actually program. We know in Pong that the ball bounces around, but even simpler than that is the fact the ball moves at all. Movement is a very common rule and is described in computer terms as such:

value = value + valueVelocity;

Or

xPosition = xPosition + xVelocity;

This code needs to be run continuously (every time the program updates). This is done by putting it in the the draw() function.

With a few variables and some math we now have a working model of our simple, non interactive, non winnable version of Pong. Problem is, we canʼt see it work.

The second step in describing an interactive piece is to describe how it represents, or visualizes, its model. This section of a program can be labeled the programʼs view. The view for our Pong game consists of drawing a rectangle to the screen based on the x & y values of the ball. ie:

rect(ballX,ballY, 10, 10);

This code also needs to be called every time the program loops. Just be careful not to mix it up with the model code. Theoretically you could put all your model processes in a function updateModel() and all your visualization code in a function updateView() and then your draw function would look like this:
void draw()
{
updateModel();
updateView();
}

(It would be more helpful if the draw function were just called mainLoop, or main, or loop, but oh well).

Now that we have this basic two part structure we can modify the artifacts gestalt by building more complex models or by building more sophisticated visualizations of the model as is.
What if you had two balls? What if the ballʼs x and y position is greater than the screen size? These are questions about the gameʼs model.

Looking at the speed and position of the ball, can we calculate and draw where it will be in a few moments? This is a view question.

As a designer you can work with either component, evaluate the gestalt, and then try something else. It also makes your program easier to understand if the responsibilities of each line of code are grouped together.

Lastly, thereʼs no rules that govern what the relative size (in terms of lines of code) and complexity (in terms of processing and math) of the model or the view is or should be. Your model could be one variable (meanness) and your view could do a lot of number crunching to draw a flower based on that one variable (like last project). Alternately your model could describe all the pieces of a flower, and the view just has to draw rectangles where the petals are.

Game Studies and IxD

Since undergrad I’ve found that most games are exceptionally sophisticated examples of designed interactivity whether poetic or instrumental. Back then there was a shrinking but present stigma, a common acceptance that games are not-serious. Not to say there weren’t a number of people taking these artifacts very seriously (beyond people looking for something to blame school violence on). Today, with Infinity Ward’s Modern Warfare 2 the highest grossing entertainment product in history, and the center of a exceptionally important lawsuit over the rights creatives have over their work, even a die hard pragmatist would find it difficult to dismiss the field, let alone the industry. More to my point here, the nascent IxD discipline, in their exercise of eminent domain over all things behavioral, have found that games are great examples of designed behavior. It occasionally seems though that — perhaps like many fields IxD has appropriated into their study — the existing conversation surrounding game studies has become invisible. Everyone knows what a game is after all. Surely there’s nothing to say about them that’s not prima facie. I wouldn’t doubt though that this has as much to do with practice vs. academia as it has to do with IxD and game studies. Either way, I was sent an entry into a series of articles not long ago that served as a great example for some of this.

These articles present a good example of the term “game” being brandished liberally and to little effect. I question whether the people involved are talking about games or games and interactivity (at least not the main posts, there were too many comments spread around to cover). I think there is a conversation about meaning going on; But it’s indirect, and because of that, very long and to little effect. If there’s really an interest in talking games, I’d recommend at least covering the opening chapters to Rules of Play (http://www.amazon.com/Rules-Play-Game-Design-Fundamentals/dp/0262240459). For a more lengthy deconstruction of the pitfalls in these conversations, keep reading.

Teaching Processing

processing_iconThis quarter I’m an acting TA for the class “Interactive Product Design” over in the industrial design department. The primary goal for the quarter is to give students there a chance to tinker with Arduino and start thinking about how they can invest their forms with some embedded computing. Secondly, the class will also serve to acquaint them with programming, which is almost completely foreign to most of the students. That said, I spent the last class giving a ground level introduction to programming in general and Processing in particular. Competency, even if by the end of the quater, with a few of the most important structures (expressions, variables, control statements, functions) I hope will provide enough conceptual tools for digesting things they find and allowing them to create rather sophisticated interactivity.

Spring Break

I’ve been silent. I’m on break.
Until I get back, you might consider checking out Upgrade Complete by Armor Games. While it claims to comment on the backward-ness of game achievements and grinding, it unwittingly makes for a rather interesting study. In Upgrade Complete, a sci-fi SCHMUP, players destroy alien ships for points which can be spent on upgrading, among other things, the graphics of the game itself.