Interaction

Everyone’s hyped up about getting a Google Wave invite. I have one and I don’t see what the fuss is about. Yes, I’ve seen the YouTube video, and yes I’ve watched the Developer Preview video too. It looks great and all, but seriously folks – it’s one complicated thing… next to email.

And this is why Google Wave isn’t about email. The same way computers aren’t (just) about calculators.

What it is is real-time collaborative messaging with historical playback. Which, granted, is very good for real-time anything. Except that real-time in human terms is highly contextual.

Because people have better things to do besides sit in front of their computers all day long, they are much better off carrying Blackberries and having push email rather than collaborative messaging. In my opinion, push email works just as well – because you don’t need to be in front of a computer to communicate with your colleagues.

Wave is also a tool. Meaning that the interface itself is not the message. In order for users to synthesize information, they have to make sense of it in a collaborative sort of way, which means paying attention to whatever is happening in that messaging window, which takes up at most 1/2 of the screen. It looks and feels like, a video player – but for messages. Think of IM on steroids, not email.

Email works because it’s mind-dumbingly easy. And because of that, nobody needs to take 3 week lessons on how to use email – and that includes your grandpa. And because it’s so atomic, it can easily be transported as a message to any other atomic messaging forms – SMS, blog post, forum post, IM chat, whatever.

Waves, on the other hand, are almost asynchronous streams – anyone can start writing content at anytime into a wave, and hope that it doesn’t make a mess of the conversation. Last I checked, people still pay attention to body language and subliminal messages, both of which are devoid in Wave but affects the way people communicate collaboratively and socially together – i.e. turn-taking and all that jazz.

Which part of a wave is atomic? You have to spend effort to calculate and decide. Then you have to find a way of “clipping” that message – and how do you make it portable? Can you cut and paste portions of your wave onto your blog? SMS? can you print it out?

Like email, most of what is published gets fixed in time. But a Wave, is a collection of content played out over time. Just like how photographs put together over time become videos. But with the added complexity of multiple sources of photographs, it becomes more and more difficult to separate and organize content in a Wave.

And that’s why Google Wave is not about email.

Sites and Articles Relevant to this Post:

• It’s Just Fancy Talk
• EasierToUnderstandThanWave

boon :: Oct.13.2009 :: interaction design, technology, tools, web :: No Comments »

I love this idea: http://www.somebits.com/weblog/tech/good/webapps-with-json.html

boon :: Sep.21.2009 :: interaction design, web :: No Comments »

What I like about A/B Testing using Google Website Optimizer:

• It helps provide real, direct data (as opposed to sheer guesses, or “eye-balling” secondary sources of data)
• It helps you build strong skills in testing
• It’s fairly straightforward to setup
• It’s fairly flexible – allows for HTML markup, etc.

See how 37 Signals puts A/B testing to the works here.

See Carsonified’s blog post about doing A/B Testing with Google Website Optimizer on Wordpress here.

For a quick overview, watch the video from Carsonified below:

How to do A/B Testing with WordPress

boon :: Aug.03.2009 :: evaluation, resource, tools, web, websites :: No Comments »

Update: Rey alerted me to Yahoo! YSlow

This looks interesting:

http://code.google.com/speed/page-speed/

Curious to know how effective this is towards usability/interaction design.

Blurb from site:

Page Speed is an open-source Firefox/Firebug Add-on. Webmasters and web developers can use Page Speed to evaluate the performance of their web pages and to get suggestions on how to improve them.

Page Speed performs several tests on a site’s web server configuration and front-end code. These tests are based on a set of best practices known to enhance web page performance. Webmasters who run Page Speed on their pages get a set of scores for each page, as well as helpful suggestions on how to improve its performance.

By using Page Speed, you can:

• Make your site faster.
• Keep Internet users engaged with your site.
• Reduce your bandwidth and hosting costs.
• Improve the web!

boon :: Jun.12.2009 :: tools, web :: No Comments »

Once again, I am getting my hands dirty with CSS. And I’m no expert, but having read through numerous articles from A List Apart, I’ve been fairly sensitive to how “designer-y” people think and react to CSS issues.

For one, I am currently working with rey who’s coding up the front-end for a site we’re building. And bad habit of hacking up layouts with inline styles has driven him up the wall. I’ve recently made the effort to migrate my styles into our stylesheets, but only when I was styling up a panel quite seriously (as opposed to just using HTML markup and existing styles).

Reusable CSS isn’t quite like reusable code

The gap that I had crossed was this idea that it’s okay to create a style that’s never going to get re-used.

For the longest time, I was using inline styles because it was quick and dirty, and for the most part, many styles were bespoke. I felt that only reusable styles  should be put in a stylesheet. It’s one of those coder things where we like to build reusable components and keep them organized and use them in what we call an architecture. But I had to put that coder thinking aside for awhile, when it came to CSS.

The reason is because styling up a div one way doesn’t mean it looks right when it gets placed in another section of the page. The effect of one small change in one component can and will affect the feel of the other components. This is not just true in terms of the visual layout, but also in CSS – because there are cascading styles that will enforce itself upon any child components.

In an object-oriented programming paradigm, extending a class or object is often an act of empowering (decorating) that object based on elements inherited from its parents (a very bottom-up approach). But in CSS, it almost seems like the reverse when you don’t necessarily want to inherit from a parent element, unless you had a very intimate understanding of the way it was styled from the top-down.

Approaching a user model

Rey uses the term “semantic” a lot when he’s talking about CSS, referencing the act of naming a class based on the purpose of the component that was being styled. Again, this is partly contrary to the way system-thinking works, where you often name it based on a process (e.g. Data Access Object, FileFactory). This other gap I had crossed was about having a user model vs. a system model (which Norman talks about).

The issue here isn’t so much about whether I was naming a CSS class inappropriately, but about the way I viewed my styles with respect to the design of the site. In short, I would be thinking of the site the way a viewer would think about it – an about page, a contact list, a article side-quote, and so on.

Interestingly, CSS would ‘encourage’ me to think in terms of how different components looked and ‘felt’, nested in other components or on a different markup tag. For example, an article side-quote within a blog post vs. outside a blog post. Or a quote within a div or a span, or as a link. Or as a link within a span? Or as a list?

To a programmer, there’s a point where all these elements look like plain-old boxes. But to a designer, they’re like specialised tools that are meant to be used one way and not another. And I believe it’s because designers have a greater empathy for human beings – how we view, organize interact with and consume information.

What the books don’t tell you

I’ve been frustrated by many books on the subject of technical languages like PHP, CSS, and so on. Simply because many of these books completely ignore the fact that there’s an art of programming that can’t be communicated by instruction. It is this art that sets apart good designers and expert designers, good programmers and expert programmers. And this makes the difference between Ruby and Kohana and Django – not that one is particularly better than one another (trying to avoid flame bait here), but that the frameworks have been designed to appeal to a specific type of programming “art”.

Although there’s only “one” CSS (albeit with multiple revisions), there’s still many books on how to write CSS, and different authors will present their formulas based on their own design habits. Some are comfortable using CSS hacks, while some are strong advocates of reusable patterns, but this quote from Alan Cooper keeps coming back to me – that programming is craft and all software is bespoke.

So, there’s never going to be a one-size-fits-all solution. Ultimately, all programmers and designers have to lean on their craftsmanship in order to determine the right solution.

And I still haven’t found a book that helps me do that.

The reason why I feel this is frustrating is because many other crafts like painting or architecture or photography actually have books like that. About the art of the craft. Even some business books are dedicated to just that – the art of business. But almost 99% of the books out there on CSS, HTML, etc. are instructional, not inspirational.

Community as our last hope

Alas, one thing developers and designers do have is the technology itself, not as a solution itself, but as an enabler. I think that if we are going to reach a level of maturity in designing applications the “right” way, it will most likely be facilitated by community interaction, rather than plugins, frameworks or cut-and-paste code snippets.

The reason I say this is because every few months or so, a new browser version is released, a new styling standard has been established, or Microsoft continues to fail in delivering standards-based compliance and even makes it inconsistent with its previous browsers. And the only way we can survive this madness is if we work as a community.

But I am finding it difficult to meet (or fearful of meeting) people who might be willing to mentor me in CSS, of all things. And I assume experts think most web designers out there want cut-and-paste code. In fact, most articles I come across, with a few exceptions, are like that – catering for the cut-throat, deadline driven, plugin-frenzied, shock-effect designers and developers who want all of life’s problems handed on a silver platter.

There’s a lot to be said in the world of CSS, but as long as it’s not catering towards proper craftsmanship, I’ll be doing it the hard way with my bare hands and peering through the grapevines.

boon :: Jun.07.2009 :: design, development, user experience, web :: No Comments »

I started my first web log on Blogger years ago, probably in my little corner of the office as a software developer. At the time, it was just a way to post up random stuff about life, but over the years I slowly realized the potential it had to touch other people’s lives (as well as mine). But by the time I had realized that, I had put up so much junk on my blog that no one would ever read apart from myself, I feared no one would ever take me seriously.

So, I launched a separate blog to discuss about more serious things I cared about, like jobs and careers. And then, when I got into the masters program, I launched this blog, to talk about UX. Now, I manage three blogs, plus a food aggregator that caters for two countries I currently don’t reside in, and that can be a lot of work, sometimes. That’s when I start to relate to some people about what blogs are about, and what they should be, and what they’re not.

So sometimes I think it’s a way to post random junk. Then I think no, it’s a way to inspire others. Then, I think… no, I should make it sell – sell my ideas and make me rich (right).

And the plain fact is – it’s just a tool, dammit. Use it however you want.

*bonk*

Recently, a classmate of mine who is a total news junkie (his own words) introduced me to Dave Winer’s blog, Scripting News. Any self-respecting internet pundit would know about Winer’s claim to fame (the invention of RSS). He is someone who the NY Times calls, “The protoblogger”. Thus, skimming through his articles, I caught glipses of his “proto-posts”.

Dave’s posts are brief, but packed with insight. They are personal, but not revealing. They are vocal, but not contentious. And I think there is a lot of variation as you move out into the blogosphere, but Dave’s blog is like smack in the middle.

And if I ever really needed to give a good definition of a blog, Dave’s would be it.

So, there.

boon :: Mar.15.2009 :: social web, web :: No Comments »

I’ve just spent the last 10 or so hours mucking over Kohana, Doctrine ORM and jQuery – all of which I really enjoy and think are great, but I’m starting to doubt my own ability to code. Do Javascript programmers spend more time building functionality and interaction, or mangling the libraries and fussing over browser compatibility? While I think jQuery is a brilliant API, I’m always wary of the quality of plugins that people write. Same goes for Wordpress plugins. I guess free does come with a price (like the price of not using Java).

Which leads me to think – can there be a lone UX expert who also does web development? I’m sure there are folks out there who make a living doing this, but the literature treats the fields so separately it’s hard to see how these experts manage the line between the two.

Even with a team of two people – a UX designer and a web developer. How do they interact? Does the UX designer have a head start to come up with all the wireframes and storyboards, who then hands it over the programmer to make it functional? Do they work together in an agile fashion?

I think that as most technical work goes – there’s less and less breathing space for UX designers and web developers to work in very small, efficient teams, unless they are very, very good. I’m not saying that everyone else just sucks, but building websites can take a lot more time than you think it does, and unless you’re designing mom and pop websites all the time, it’s going to be hard to guarantee how much time is required to build good sites.

While plugins and APIs can be useful in increasing speed, they also can lock down the interaction and degrade the user experience if not planned well. Maybe established sites understand this all too well, and take a phased approach. Maybe this is why Flickr only launches a new (but exciting) feature only once every few months.

I used to think that as technology improved, so would our ability to build products. But I find that this isn’t always that simple. In fact, despite all the effort being put in to build so many plugins, APIs, platforms, patterns, components, etc – it still takes a lot of effort to put things together properly.

Thus, all software is bespoke, and are not exactly a lego-like mashup of neatly interfacing components that we tend to think it does.

My only question is, if we are to get better, how? Apart from being willing to devote ourselves to our tools and simply, get our hands dirty.

update: I found this presentation from Leah Buley from Adaptive Path, which she gave at SXSW’09. It comes quite close to what I was talking about. I’m not quite sure it always works out so simply, but I like the idea.

boon :: Mar.14.2009 :: development, interaction design, user experience, web :: No Comments »

I ‘ve been working on web applications for a few years now, and while I don’t claim to be an expert on the subject, I have gotten my hands dirty in building apps on all sorts of different web frameworks (about 8 now). After being exposed to the UX community for nearly a year now, I realized just how diverse this group is, though most of us work on UX for websites. I’m curious to know just how much UX people understand web frameworks, and its impact on the web development community.

In this post, I’m going to share a bit about my background as a software developer, in hopes to shed some light on how web frameworks impact UX-related work. My hope is to generate some understanding between the two camps (UX folks and programmers) so that we can attain a common goal, which is to build applications and services that are robust, functional, and satisfying.

Since this post is aimed towards a general UX audience, I’m going to avoid talking about the philosophy and thinking behind UX. I think there is enough literature on that subject for software-types who are interested in UX. Instead, I will talk about the other side of the fence – what are software developers like? What makes them tick? Why do they do the things they do? And why can’t we get along sometimes?

The Philosophy of Features and Functions

In Cooper’s book titled, “The Inmates are Running the Asylum“, he describes developers who commonly make poor assumptions about users, forcing technology on them in ways that cause fustration and confusion. This is partly because of the kind of thinking and immersion that often goes on in building a software application is very counter cultural, and it’s hard to appreciate, let alone design applications for users, while you’re focussing on building applications.

Software developers are extremely technical people, and the whole work of building software doesn’t just include knowledge and skill, but includes other factors such as the culture of working in software teams, physical environments, system-allegiance (open source vs. microsoft, oracle vs. mysql, etc.), organizational structures, the nature of how projects run, and relationships with clients and/or internal staff.

From this tacit and specialized knowledge, software people can often wield enormous influence. It is not difficult to find groups of software people that are isolated or contained, in an environment that they require to do what they feel is needed to build software. Usually, this involves having a computer to yourself, a space that is condusive for software development, some degree of flexibility in terms of work schedules, and close proximity to teammates (though this isn’t always the case, with certain software practices).

A new recruit who is given his/her table in the software group will feel removed from marketing, sales, admin, human resource, and management. There are of course, exceptions to this – but there are many companies that operate in this fashion, and it seems to work fine for a lot of people.

While this kind of environment is good for producing application functionality, it reinforces the idea that functionality is the ultimate goal – thus there is this effort to provide for and manage the production of “function”, since this will dictate the health of the team. Software people are rewarded on producing functionality, after all, and to this end they will deliver. This is why feature creep is so common – software people gain rewards from building features, intrinsically or otherwise.

Frameworks are Bespoke

This is where web frameworks come in. Because of the increasing demand for software of all kinds, there is tremendous pressure on developers to build applications fast enough that meet the requirements, and yet robust and scalable. Software teams often use web frameworks to leverage on, because building applications from scratch can be costly and time consuming.

However, while most frameworks are actually built with enormous flexibility in mind, they are actually bespoke (standalone, designed for a specific purpose), and will dictate the kind of thinking and culture that revolves around the building of an application.

One of the first web frameworks that I started using was Apache Struts, which is based on Java. It was an amazing platform that enabled me to be in control of so many things about an application, such as databases, internationalization (multiple language support), file organization, and templating. However, it required a steep learning curve, and once I managed to integrate all my knowledge and build a software, my time was consumed and wrapped up in making sure everything was built and designed with the framework in mind.

I had to be extremely careful that certain configuration files were in the right place, that I didn’t misunderstand the “thinking” behind the Struts framework that governed the way applications were meant to be built on the framework. And because Struts was based on Java, it also had to have a philosophy compatible with “The Java Way” of doing things, which meant that you also needed to appreciate things beyond the framework itself.

When software platforms change, or when teams migrate to different web frameworks, this thinking needs to change. It is almost like a paradigm shift, because Java does not work like PHP or Ruby, and Oracle is quite different to MySQL and so on. So when technologies change, web frameworks follow suit.

This is why some folks advocate that interaction designers and software developers should not be the same person – building software takes up a lot of effort.

Bridging the Gap

Understanding the differences between web frameworks can be a boon (no pun intended) for UX practitioners who work closely with software people. This of course implies that they appreciate the thinking and the culture behind them. The reason why I focus on frameworks and not just any software technology in general is because it’s a very common way of building web applications today, and are the enabling platforms for interface developers and designers – just that they will probably only see the tip of the iceberg through template files (e.g. Smarty templates, HTML, CSS), Javascript and images.

37Signals popularized the notion that “the interface is the application”. This can lead to some serious misconceptions about the way applications should be built. In the software world, the whole is usually more than the sum of its parts. Interfaces depend on not just images, HTML, Javascript and CSS alone, but on the architecture it sits on – database, servers, and very often, the web framework.

Because of this, software developers are constantly aware of the separation between “view” and “logic”, which are synonymous with the relationship between designer and programmer, interface and framework, user and system. While this makes it very clean and organized, the decoupling of these relationships can sometimes create an artificial “gap”, which can lead to animosity between designers and programmers.

This is the point that is most crucial to both sides. Having a shared understanding of how interfaces are designed and how frameworks run will lead to better software. As an example, certain systems are designed to handle textual data better than others, certain frameworks are designed for certain types of platforms (Struts and Spring for enterprise apps, Django for content heavy/layout-based apps), and the way you build an application will dictate the performance of an application on the interface.

This is only the beginning

We’re only beginning to scratch the surface here, since the discussion on what a web framework really looks like and how do applications get built with it will require more time than this post can afford. But it’s a good start, and no doubt UX practitioners and programmers will share a partnership around technologies for a long time to come. My hope is that we’ll be able to build a better understanding of how this partnership can be built, strengthened, and communicated.

References and related links:

• http://www.graphpaper.com/2009/02-11_are-we-designing-interactions-or-designing-software
• http://unthinkingly.com/extreme-programming-vs-interaction-design/
• http://www.alistapart.com/articles/gettingrealaboutagiledesign

boon :: Feb.26.2009 :: technology, user experience, web :: 1 Comment »

I downloaded and installed Safari 4 Beta and ran it on my Vista-installed laptop.

Performance and Functionality

It takes a bit of time to load up, but seems to run faster than the previous version of Safari. Some bits of Javascript functionality on sites failed to work when I had too much tabs open. I like that the tabs are similar to Mac’s menu that’s flushed at the top, but I don’t like how the tabs are so thin and quite unreadable – hard to tell them apart. When I had too many tabs open the were hard to scroll to. I got used to firefox’s mousewheel navigation when I had too many tabs open on a window.

For some odd reason, when I start Safari up, the window isn’t maximized – which is kind of annoying, but I can live with that.

Favourite/Top sites

If you love Apple, you’ll probably love this. Whenever you open a new tab, it displays a grid of your favourite sites (like the image at the top). It was nice eye candy to start with, but later I wasn’t sure what I’d do with it. And I realized I don’t have to do anything – it kind of ‘remembers’ which sites I’ve been to. I’m not sure if I’m ready for Safari but I guess if I were to use it on a regular basis, it might be useful to have this feature.

I want X feature

I’m still not convinced it’s blazingly fast, so my bet’s still on Firefox. It would be nice to see some hotkey commands, that are straight-up easy to use (key help displayed in menus or what not).

Has a lot of potential.

boon :: Feb.25.2009 :: web :: 3 Comments »