of these information spaces, that space
must be indexed, resulting in a new index entity. That seems straightforward
enough, but we spent a lot of time trying to agree on what ought to happen
when one person happens to be exploring an infospace while someone
else is trying to index the same space.
Those discussions proved to be difficult simply because we had not made it
explicit that the entity in question was
an index. That is, we talked about it at
first strictly as an information space. It
wasn’t until after a few arguments that
it became clear what we were actually
talking about was an index of that information space.
Whenever the model can be precisely discussed, you can avoid a lot
of unnecessary complexity. When a
model is correctly and clearly defined
right from the outset of a project, the
only kind of feedback that ought to be
required—and the only sort of change
you should need to add to your sprints
in subsequent iterations—has to
do with the ways you want to expose
things. For example, you might decide to change from a dropdown box
to a list so users can be given faster
access to something—with one click,
rather than two. If you start out with a
clear model, you’re probably not going
to need to make any changes later that
would likely have a significant impact
on either the UI or the underlying architecture.
In developing a product for which there
was no obvious equivalent in the marketplace, Agathos and Gosper were already sailing into somewhat uncharted
waters. And there was yet another area
where they would face the unknown:
neither had ever used Agile to implement a UX design. Adding to this uncertainty was the Agile development
methodology itself, where the tenets
include the need to accept changes in
requirements, even late in the development process.
Fortunately, the Polestar team soon
embraced the iterative development
process and all its inherent uncertainties. In fact, both Gosper and Agathos
found Agile to be far more effective
than the waterfall methodology for implementing UX designs. This doesn’t
mean all was smooth sailing, however.
Agile requires close collaboration be-
an area where
i think there is
for trouble has
to do with the
to ux design.
i’ve been through
that process and
have found it to
tween team members and frequent
face-to-face communication, often between stakeholders with vastly different backgrounds and technical vocabularies. It’s therefore no surprise that
one of the team’s biggest challenges
had to do with making sure communication was as clear and effective as
coatta: I understand that some UX
designers feel Agile is less something
to be worked with than something to
be worked around. Yet, this was the first
time you faced implementing a UX design using Agile, and it appears you absolutely loved it. Why is that?
GosPeR: In an ideal world, you would
do all your contextual inquiry, paper
prototyping, and formative testing
before starting to actually write lines
of code. In reality, because the turnaround time between product inception and product release continues to
grow shorter and shorter, that simply
isn’t possible. If the UX design is to be
implemented within a waterfall project, then it’s hard to know how to take
what you’re learning about your use
cases and put that knowledge to work
once the coding has begun.
In contrast, if you are embedded
with the development team and you’re
acquainted, tactically, with what
they’re planning to accomplish two or
three sprints down the road, you can
start to plan how you’re going to test
different aspects of the user experience
in accordance with that.
coatta: In other words, you just feel
your way along?
GosPeR: Yes, and it can be a little
scary to dive right into development
without knowing all the answers.
And by that I don’t just mean that you
haven’t had a chance to work through
certain areas to make sure things make
sense from an engineering perspective; you also can’t be sure about how
to go about articulating the design because there hasn’t been time to iterate
on that enough to get a good read on
what’s likely to work best for the user.
Then you have also got to take into account all the layers of development
considerations. All of that comes together at the same time, so you’ve got
to be very alert to everything that’s happening around you.
There is also a lot of back-and-forth