We’ve got a good range of perspective and experience to draw from. Maria Giudice from Hot Studio is our user-centered designer, Rob Spiro from Aardvark is our user-centered product entrepreneur, Darren David from Stimulant is our multi-touch and NUI innovator, and I am our Agile software developer.

This event seems to have really caught on to the growing energy in the entrepreneurial community around strategies and techniques for creating products that people really want. Eric Ries is giving the keynote on Tuesday just one year after his first big conference presentation at Web 2.0 2009 and Steve Blank is giving the keynote Thursday. Both of these guys and the growing community around them have been inspiration to me and our work at Carbon Five over the last year for the answers they provide about how software development serves the goal of creating successful businesses and products.

Our goal is to give attendees a taste of some of the novel activities we use to encourage collaboration, communication and fun while engaged in the messy business of creating web software. The session is intended to be interactive – we want attendees to try some of this out with us – which should be interesting given that the conference organizers chose to put us in the Grand Ballroom, the same room used for the conference keynotes. “Gather around, everyone!”

Resources

Here are some follow up resources for attendees who are intrigued and want to learn more.

Effective User Stories for Agile Requirements
http://www.mountaingoatsoftware.com/presentations/52-effective-user-stories-for-agile-requirements
This series of slides by Mike Cohn is a good introduction to user stories as a means of capturing project requirements. We often use this presentation to introduce folks new to agile to the ins and outs of user stories.

Agile Estimating and Planning
http://www.mountaingoatsoftware.com/books/1-agile-estimating-and-planning
This book by Mike Cohn is an excellent guide to the planning side of agile software development and what you do with those user stories.

Art of Agile
http://www.amazon.com/Art-Agile-Development-James-Shore/dp/0596527675
This book by James Shore covers the breadth of agile practices, both in planning and development, and includes many activities like those we cover in this session for helping your team collaborate and communicate effectively and efficiency.

Tasty Cupcakes
http://blog.tastycupcakes.com
Tasty Cupcakes is collection of games and activities designed to help illustrate the value and effectiveness of different agile practices. Rather than being specific techniques used in running an agile project, they are more targeted at teaching agile practices and values with short illustrative games.

The Manifesto for Agile Software Development
http://agilemanifesto.org
This is a historic document (2001) in the Agile software movement where a group of folks advocating new values and practices in software development came together to recognize their shared goals and values.

We are uncovering better ways of developing
software by doing it and helping others do it.
Through this work we have come to value:

Individuals and interactions over processes and tools
Working software over comprehensive documentation
Customer collaboration over contract negotiation
Responding to change over following a plan

That is, while there is value in the items on
the right, we value the items on the left more.

We use Pivotal Tracker to manage our feature backlog and the day-to-day activities of tracking a feature from estimation through delivery and acceptance. However, we find it easy to lose the big picture in the detail-oriented view Tracker provides.

Story Mapper uses your project data from Tracker to provide a higher level view geared toward release and milestone planning. This view is based on Jeff Patton’s story mapping techniques and provides the ability to see how the different components of your project will evolve across successive milestone.

All you need in order to use Story Mapper is a Tracker project with a backlog of stories and a subset of labels that represent user activities or components of your system. If you have a large project and have not been using labels in this way, you may have some work to do in Story Mapper before you have a story map that makes sense.

Try it out, let us know what you think, and tell us how to make it better. Comment here so others can see your thoughts or by contacting us directly.

I was telling Ada how video games are made one night, and she ask me if I could make a game. I said yes, we could make one together, and she bugged me all night to get started. I told her to start by designing a game on paper. She drew something that looks surprisingly like pacman (given that she’s never played the game), but she told me the dots were snowballs and that you could throw them at the monsters and use them to build walls. I started programming it as an SPA using canvas. She came up with all the rules, with some suggestions from me.

It may be that I’ve just been doing a lot of JS lately, but building a game like this in JavaScript felt really comfortable and extremely rapid. I had a basic version working with about 200 lines of code, but the details have tripled that. I went through a couple of major refactors, neither of which were troublesome in textmate.

The game is completely un-optimized, but it runs fast enough on my macbook. I know lots of ways to speed it up if I had to. It’s a little rough in a lot of areas, but it’s getting close enough to present.

Play Snowballs

Instructions

Load in Firefox or Safari. The arrow keys move your character, the spacebar launches snowballs (which you have to collect). Hit a monster 5 times to freeze it, then touch it to collect it.

I’m looking forward to participating in a panel Is Canvas the End of Flash? this month at SXSW on the role the new HTML Canvas element is playing in web development and how it compares to Flash. Much of the perspective I have for this panel comes from my long history working with Flash and from our recent work with Canvas for Isilon Systems on InsightIQ.

The panel has been organized by Greg Veen of SmallBatch, Inc., creators of TypeKit and includes Chet Haas from the Adobe Flex team, Nathan Germick from social gaming start up Wonderhill and Ben Galbraith from Palm and Mozilla, also lead of the ambitious Bespin project.

Come check us out if you’re going to be in Austin.

Also check out some of the presentations by friends of Carbon Five at SXSW:

From Dinosaurs to Digital: A Museum Convergence Success Story from Maria Giudice of Hot Studio on her work with Jonathon Denholtz of the California Academy of Sciences.

Social Search: A Little Help From My Friends a panel on social search organized by Brynn Evans that includes CEO Max Ventilla from our recently acquired client Aardvark.

Beyond the Desktop: Embracing New Interaction Paradigms a panel on interactions that go beyond keyboard+mouse includes Nathan Moody of Stimulant, masters of the multitouch Microsoft Surface and NUI design.

Among other initiatives, Carbon Five worked with DNA Direct to roll out their first release of, as founder and CEO Ryan Phelan describes it, “the first genetic guidance program for a top five health plan with Humana, facilitating prior authorization and providing clinical services to ensure appropriate testing with lower out of pocket costs from the right lab.”

Aarvark has more details on the acquisition. You can also read more about the work did helping the Aardvark bootstrap their team and product development.

I thought I’d just send him to Google but a search for agile retrospective returned descriptions that seemed too heavy weight for the small, skilled, agile-literate teams we employ at Carbon Five.

There is certainly a lot of valuable information and insight out there I and definitely suggest doing some reading to understand the fundamentals and options for running retrospectives. However, since we want to do retrospectives often, we need a practice that doesn’t take much time or effort.

Here’s a recipe we are using these days. You can do this in 30 minutes. I actually did this with our architect for a home renovation project I am working on. Great things came out of it. I think it might have blown their minds.

Setup

Get alll team members in a room with a few stickies each.

You’re here to talk about an iteration, project, or other unit… with the goal of improving the next time around.

Thoughts: 5-10 min

Smiley face on stickies with good things from the last iteration.
Frowny face with concerns, risks, fears,…
You don’t have to be exhaustive, use the time you allocate.

Cluster: 5-10 min

Create two teams.
Give the smiles to one and the frowns to the other.
Group the stickies into related clusters.

Discuss: 20 min

Identify the primary smiley clusters.
Confirm that you will continue to see these benefits, can you increase them?

Identify the primary frowny clusters and list the themes on a whiteboard.
Vote to discuss – each team member has 4 votes – put dots next to
the issues you want to discuss.
Discuss the top 3 issues – identify SMART (http://en.wikipedia.org/wiki/SMART_criteria) steps to address them.

Rinse, wash, repeat. Don’t feel you have to talk about everything. You are trying to focus on top issues. Once you address those, the next most important issues will surface for discussion.

We do this every other week with our internal team and monthly including our clients.

If you have other recipes for simple reflection, I’d love to hear them.

Light reception to follow. We hope you can hang out after for a glass of wine and to catch up before the holidays.

http://tickets.commonwealthclub.org/auto_choose_ga.asp?area=2&shcode=1501

Fail Early and Often: Innovative Practices for Online Development
Alon Salant, Principal, Carbon Five

Organizations today increasingly struggle to create compelling software products, web sites and social media while working with the daunting details of limited time and resources. Learn new ways of working and delivering early value with simple and easy-to-apply processes from a pioneering software development firm. Discover how agile techniques and tools have helped to sculpt new strategies and sustainable practices, leading to more success, faster turn-around and reduced expenses.

Location:
Commonwealth Club Office
585 Market Street, 2nd Floor
San Francisco, CA 94105

Telephone Reservations: (415) 597-6700

Time: 5:30 p.m. networking, 6 p.m. program, reception to follow
Cost: $8 members, $15 non-members, $7 students (with valid ID)

This is an open invitation. Please share with others.

It has been very well received with TechCrunch claiming it the best way to use Aardvark and 4 1/2 stars from over 100 ratings in just a couple days.

Working on this project with the Aardvark team was great. We love their intensely user-driven approach for designing and validating features through iterative development. We also pioneered our own best practices for test driven development to the iPhone platform, something that seems to be rare in the iPhone development community.

There’s great stuff about cheap and fast prototyping and testing techniques, building feedback loops in to product design, and how to come up with emerging product definition that can drive an iterative software development process.

SXSW weights community input heavily in its panel selection process. Take a moment to give our proposal a thumbs up.

According to Steve Bachmann, Vinfolio CEO, the marketplace includes 27,000+ unique items already marked for sale – more than 170,000 bottles with over $20 million estimated retail value. That’s far more than any retailer/auction house on the day the marketplace opens.

Carbon Five worked with Vinfolio years ago to create and launch their groundbreaking procurement and storage service for wine collectors. It’s great to see that they continue to push their industry by creating new ways for wine lovers to sell, acquire and enjoy wine.

Personally, I am particularly psyched to be supporting the San Francisco Bike Kitchen in their move to a beautiful new space at 19th & Florida in the Mission. I have been volunteering as a mechanic with the Bike Kitchen for almost four years and have been continually impressed by the dedication and innovation of the all-volunteer staff and board. The bike racks at Carbon Five are full every day and the Bike Kitchen keeps many of us rolling smoothly to work.

Our panel includes Arena Reed, Lead User Experience Designer at Grockit, Rob Spiro, co-founder of Aardvark and Dave Shih, Senior Visual Designer at Hot Studio.

At SXSW Maria and I realized how easy it is to talk about the challenges of coordinating design and development efforts since almost everyone involved in software development has experienced some pain around it. I’m excited about our panel for Web 2.0 Expo because I think we are going to better organize the discussion around identifying best practices. I am particularly inspired by the work of the Aardvark team who are intensely user-focused and test like crazy to validate their ideas and implementations while maintaining an agile software development process with frequent incremental releases.

You can follow our panel on Twitter with hashtag #agileux20 even if you are not at the conference. We welcome comments, questions and suggestions before, during and after.

Maria and I have already started our SXSW Core Conversation When Worlds Collide: Human Centered Design Meets Agile Development two weeks before the event in Austin. The Core Conversation format is a speaker or two in conversation with the audience. Below we respond to a few select questions.

About the Presenters

Maria Guidice is CEO and founder of Hot Studio, a human-centered design studio in San Francisco.
Alon Salant is a principal and founder of Carbon Five an agile software development firm also in San Francisco.

Our companies have worked together over the years on a number of successful projects. We find our collaboration continually challenged by the differing perspectives of designer, developer and client. We love working together and are always looking for ways to do it better.

We Want to Hear From You

Join us for this conversation in Austin Sunday, March 15, 3:30-4:30pm. If you can’t make it, we have created a Google Moderator series to solicit questions from you. Please vote for questions you like and/or add questions and topics that you think we should discuss. Alternately, ask questions as comments to this post. We want to hear from you.

Let’s Get Started

Why is the issue of waterfall vs. agile so emotional for design and engineering teams?

Alon: We all work hard to do the best work we can for our customers. Software developers have struggled for years with the mismatch between heavy-weight planning processes, the ideal world they are based on, and the messy work of getting software built in the real world. Agile software processes provide an approach that deals very well with the real world while retaining strong professional rigor.

Committed agilists bristle at approaches that do too much planning for too far in the future. The further out you plan the more inherent uncertainty there is and the greater the chance that you are wasting energy on speculation.

For designers I think you can flip this argument around. If you start building something without knowing what you are building there’s a good chance you build the wrong thing and have wasted all the time and effort you put in to it.

Obviously there’s a middle ground somewhere. It turns out to be surprisingly hard to find.

Maria: I think the reason that this issue is so emotional goes to the very core of the fundamental difference in the way designers and engineers think about design.

The waterfall process affords designers the time and space to learn about the problem and craft a solution based on insight from understanding human needs, wants and desires. They then can craft a plan of action based upon big-picture thinking and strategic insight. From there they can be specific about details and functionality based on how the system works contextually.

The agile process oftentimes does not afford designers the time to think and requires them to design details out of context. This way of working puts them at great unease and anxiety that they are designing things based on hunches rather than validated user research.

Engineers, however, feel very comfortable working at a detail level that can be changed (theoretically) later on and can build towards a functional product sooner rather than later. Engineers may not understand the need or value to spend the time upfront—”why not jump in early if you have the freedom to change your mind?”

Think of the two processes like carving in marble vs. building in clay. It can be very difficult to switch design mediums they have worked on their entire professional life.

What is your greatest satisfaction when working with designers?

Alon: Designers have the gift of being able to represent ideas and solutions visually, in a form that all stakeholders in a project can understand and respond to. A designer can engage business owners and developers in a conversation about product requirements, priorities and potential solutions then turn that into a visual representation of one or more solutions. The visuals create a level playing field and focus the attention of all participants in a project. I love the role of designer as facilitator.

What is your greatest satisfaction when working with engineers?

Maria: We look to work with engineers that consider themselves equal contributors to the design process. Hot Studio is lucky to work with the folks at Carbon Five for this very reason. Too often designers view engineers as builders of “their product” and they miss the value of thinking about a design problem from an entirely different mindset. Great engineers understand the value of human-centered design and are active participants and contributors throughout the design process. Great engineers bring to the table that unique perspective that does not focus on limitation, but one of unique possibility.

What is your biggest point of frustration when working with designers?

Alon: Many designers, particularly user experience designers, feel they need to understand a problem in both depth and breadth before they can create meaningful solutions. Even when a project schedule and budget allow for up front research too often it is not enough for the designer and they feel they are working with incomplete information.

Projects can rarely afford exhaustive up front research and I get frustrated when designers use this as an excuse instead of coming up with an alternative approach.

I would like to find a design approach that could use some research up front to set a strategic direction and then break up a large problem into smaller problems to be tackled incrementally. Ongoing research could continue to be a part of the design process, conducted incrementally as the next problem to solve comes in to focus.

What is your biggest point of frustration when working with engineers?

Maria: I have worked with many engineering teams over the years, and like designers, they can come in many different flavors. I get frustrated when engineers focus on limitations, not possibility. When design thinking becomes limited to meet a tight budget or the need to jam as many “features” into a product based upon a set timeline, you run the risk of prohibiting “out of the box thinking” that can have an adverse effect on maximum customer experience. What some engineers may think the experience is “good enough”, designers may conclude that “no it isn’t”. This is a big point of frustration for designers regardless of the problem they are trying to solve or the process they are working within.

What will people come away with after attending our core conversation at SXSW on March 15th?

Alon: Our conversation will give people insight into issues in the collaboration of designers and developers and ideas about how to work together better. It is an opportunity for attendees to learn more about human centered design and agile software development and to challenge our ideas on those subjects.

Maria: I think people will come away with thinking that one size does not fit all. Follow a process, whether it’s waterfall, agile or a hybrid between the two, based on the type of project, the team dynamics, and the client’s need.

Can we all get along?

Alon: Sure. But it may be harder than we think. For this collaboration to be truly successful designers and developers need to better understand each others’ priorities and fears. It’s too easy to sit back in your own world view and say, “They don’t get it. If they did they’d do things my way.”

Maria: Absolutely. It really comes down to respect, empathy, and good communication from the client, to the designers, to the engineers. To quote the critically acclaimed “High School Musical 2″ film—”We are all in this together!”

Together, as design collaborators, we can produce great things together and hopefully, have a positive impact in people’s lives.

This week the San Francisco Bike Kitchen opens its doors at its new location in the Mission at 650H Florida Street. The SFBK is an entirely volunteer run organization that provides the tools, parts and instruction you need to fix or build a bicycle yourself.

Carbon Five is proud to be a Titanium Sponsor of the SFBK and a supporter of their efforts to keep San Franciscans safely commuting and playing on their bicycles.

Read more about the SFBK’s plans for the new shop space and the recent move from their downtown location entirely by bike trailer in the rain. SF StreetsBlog’s coverage of the move also provides a good overview of the history and mission of the organization.

We chose our office location in downtown San Francisco so that our staff in the city, south, east and north bay could commute to work without driving. We get to work by MUNI, BART, Caltrain, Golden Gate Transit buses and ferries, by bike and on foot. Supporting the Bike Kitchen is a natural extension of our desire to create a sustainable workplace and work life for everyone Carbon Five.

We’ve worked with Hot on many successful projects over the years. As the name of our session suggests, we find our collaboration continually challenged by the differing perspectives of designer, developer and client. We love working together yet feel we could be doing much better. This session is about the good, the bad and the ugly of this collaboration and our insights into how you can do it better yourself.

I hope to see friends and colleagues at SXSW this year. Let me know if you are going to be there.

I recently came across a scenario where I needed to make an assertion on an argument passed to an expected method invocation but OCMock did not provide the constraint I needed. I was testing a FileDetailsViewController that pushes a new FileContentsViewController on to the view stack when a button is pressed. I mocked the UINavigationController so that I could add an assertion that pushViewController:animated: is called with the right arguments.

The meat of my test is:

@interface FileDetailsViewControllerTest : SenTestCase {}
    FileDetailsViewController *controller;
    id navigationController;
@end
 
@implementation FileDetailsViewControllerTest
 
-(void) setUp {
    controller = [[FileDetailsViewController alloc] initWithNibName:@"FileDetailsView" 
                                                             bundle:nil];
    navigationController = [OCMockObject mockForClass:[UINavigationController class]];
    controller.navigationController = navigationController;
}
 
-(void) testShowContentLoadsView {
    [[navigationController expect] 
         pushViewController:[OCMConstraint isKindOfClass:[FileContentsViewController class]]
                   animated:YES];
    [controller showContentsButtonWasPressed];
}
 
-(void) tearDown {
    [navigationController verify];
}
 
@end

Note that in this example, I some fanciness is required to assign controller.navigationController = navigationController since it is a readonly property in the UIViewController API. I’ll explain what I did in a later post.

The OCMock feature I was missing is the OCMock.isKindOfClass constraint. So I wrote my own.

Following is the header file that declares the isKindOfClass assertion as a static method in an Objective-C category for OCMock. Categories are kind of like Ruby mixins for Objective-C. You can add static or instance methods to an existing class definition. With this approach I can follow the OCMock pattern of providing static factory methods on the OCMock class for the range of constraints available.

//File: OCMockConstraint+Extensions.h
#import <OCMock/OCMConstraint.h>
 
@interface OCMConstraint (Extensions)
 
+ (id)isKindOfClass:(id)value;
 
@end

Following is the implementation, both of my new constraint and the factory method to create it.

//File: OCMockConstraint+Extensions.m
#import "OCMockConstraint+Extensions.h"
 
@interface OCMKindOfClassConstraint : OCMConstraint
{
    @public
    id testClass;
}
@end
 
@implementation OCMKindOfClassConstraint
 
- (BOOL)evaluate:(id)value
{
	return [value isKindOfClass:testClass];
}
 
@end
 
// Static factory method
@implementation OCMConstraint (Extensions)
 
+ (id)isKindOfClass:(id)value {
	OCMKindOfClassConstraint *constraint = [OCMKindOfClassConstraint constraint];
	constraint->testClass = value;
	return constraint;
}
 
@end

This implementation shows both how to write a custom constraint for OCMock and a use of Objective-C categories to provide a nice API for using it.

In many cases, you’ll want to write a custom constraint that is specific to your test scenario and not appropriate to be shared globally in this manner. In this case you’ll probably follow a similar strategy but implemented in your test class instead of mixed in to OCMockConstraint.

I’ve been bootstrapping with the beta version of the Pragmatic iPhone SDK Development book but was disappointed to find no discussion of unit testing for the iPhone. So I’ve been piecing it together as I go.

GTM

Unit testing in Objective-C is provided by the SenTestingKit framework that installs with XCode in /Developer/Library/Frameworks/. However it is not compatible with the iPhone SDK. The Google Toolbox for Mac provides an implementation of SenTestCase for the iPhone that I am using instead. The instructions provided on that page worked for me with one exception that I included as a comment on that page:

I followed the instructions above but was unable to see any messages in the console. I did not see the behavior described above as:

Your target should now build cleanly, and if you check the build log you should see something like: “Executed 0 tests, with 0 failures (0 unexpected) in 0.001 (0.001) seconds” at the end.

It turned out that I needed to set the base SDK in the inspector for my target to an iPhone simulator even though the Overview showed I was building for simulator debugging.

I created a ‘Unit Tests’ target per the GTM directions to run my tests. Now I am happily running my tests with command-B. One point that could be a problem when getting into continuous integration is that my Unit Tests target reports ‘Build succeeded (1 error)’ when a unit test fails instead of having the build actually fail.

I have not gotten into the “Advanced Stuff” described on that page.

Hamcrest

The SenTestingKit assertion methods are pretty lame. They’re verbose and require that you provide a string message for your expectation (e.g. STAssertEqualStrings(a1, a2, description, …)). We’re using and like Hamcrest on many of our Java projects. I was psyched to see there is an Objective-C implementation.

There is no download available for Hamcrest Objective-C so I checked it out from SVN and built the framework product in Xcode for OS X 10.5/i386.

I struggled for a while to get the dependency on the hamcrest.framework build product into my project. I ended up with this solution:

1. Create a ‘Frameworks’ folder in my project root
2. Copy hamcrest.framework to Frameworks/
3. In Xcode, right click on ‘Frameworks’ and ‘Add existing framework…”
4. Browse to the hamcrest.framework folder and add it, making sure to add it to my Unit Tests target only
5. Right click on the Unit Tests target to add a new Copy Files Build Phase that copies to the Products directory and put that build phase early in the target steps
6. Add hamcrest.framework to that build phase by dragging from Frameworks
7. Include Hamcrest in your test class and you’re good to go

#import "GTMSenTestCase.h"
#define HC_SHORTHAND
#import <hamcrest/hamcrest.h>
 
@interface ExampleWithAssertThat : SenTestCase
@end
 
@implementation ExampleWithAssertThat
 
- (void) testUsingAssertThat
{
    assertThat(@"xx", is(@"xx"));
    assertThat(@"yy", isNot(@"xx"));
    assertThat(@"i like cheese", containsString(@"cheese"));
}
 
@end

OCMock

iPhone development requires a lot of mucking around with UI framework classes like UITableView, UIApplicationDelegate and so on. These classes have a lot of dependencies and are depended upon all over the place which can make it hard to get them under test.

Mock objects are a great solution to this problem and OCMock provides an implementation for Objective-C. In this case, the OCMock.framework provided in the OCMock binary release worked for me when installed in the same manner as described for Hamcrest above.

This example of testing [UIApplicationDelegate applicationDidFinishLaunching] illustrates its use pretty well. I have a simple test that creates a mock UITableView to asserts a cell is correctly created in [UITableViewController tableView:cellForRowAtIndexPath:]. It looks like:

#import "GTMSenTestCase.h"
#define HC_SHORTHAND
#import <hamcrest/hamcrest.h>
#import <OCMock/OCMock.h>
 
#import "SortedStateViewController.h"
#import "Country.h"
 
@interface SortedStateViewControllerTest : SenTestCase {}
 
SortedStateViewController *controller;
 
@end
 
@implementation SortedStateViewControllerTest
 
- (void) setUp {
    controller = [[SortedStateViewController alloc] init];
    Country *country = [[Country alloc] init];
    [country addState:@"New York" withPopulation:19306183 andArea:47213];
    [country addState:@"California" withPopulation:36457549     andArea:155959];
    controller.country = country;
    controller.key = @"population";
}
 
- (void) testPopulatesCell {
    id tableView = [OCMockObject mockForClass:[UITableView class]];
    [[tableView stub] dequeueReusableCellWithIdentifier:[OCMConstraint any]];
    NSIndexPath *indexPath = [NSIndexPath indexPathForRow:(NSUInteger)0 
                                                inSection:(NSUInteger)0];
 
    UITableViewCell *cell = [controller tableView:tableView 
                            cellForRowAtIndexPath:indexPath];
    assertThat(@"California", equalTo(cell.text));
}
 
@end

Continuous Integration

So I’m pretty happy with where this is now. I’m working through the Pragmatic book TDD as I go. It’s also have an ObjectiveCTest that I add assertions to as I play with features of the language.

Missing from this toolkit is a good continuous integration solution.

There is now a recently released Xcode builder for CruiseControl. However, we use Bamboo for CI for our Java and Ruby projects and are considering moving to TeamCity. It looks like there is an Xcode plugin for TeamCity and some attempts with Bamboo.

More on that later.

How can designers and developers work together in a process that seems to be contradictory in nature — and how does visual design fit into the picture? How can we best create integration, collaboration and implementation around seemingly divergent methodologies and languages?

Human-centered design — basing its insights on thoughtful user research, iterating early through documentation, and beginning development much later in the process once the design has been fully fleshed out — has become the de-facto process and approach for the creation of useful and desirable products. At the same time, Agile Development — promoting developing early and often in short iteration cycles with tight feedback loops — has become the standard for developing useful software.

Our panel is moderated by Maria Giudice of Hot Studio and consists of designers, developers and clients. We will discuss how the two processes can co-exist, complement and thrive within certain rules and conditions. Our session will describe and explore the differences between the two approaches, when it’s appropriate to use agile development, how to integrate this popular method into the human-centered design and research process — and why client needs and today’s marketplace increasingly are demanding these collaborative techniques.

This session is scheduled for 11:00am Thursday, April 2, 2009. I’ll be the agile developer on the panel.

We’ll be running a similar session at South by Southwest in Austin in March. Details coming soon.

SFMOMA.org is the latest site to be released using SmileMaker, our favorite web CMS.

Read more about this effort on the SFMOMA site.

We worked closely with TMZ to bootstrap the development of Aardvark. They are a fun and talented team working on a great product.

Or course we like the comment by one reader:

Technically it works surprisingly well for a new app in beta – they must have superior techies working on the details, not just marketing and sales guys – I am impressed so far and they are only at the beginning of the zoo alphabet (aa)!!!