Loading ...
Sorry, an error occurred while loading the content.

RE: [agile-usability] Cross-application integrity

Expand Messages
  • Desilets, Alain
    ... I find Scenarios and Personaes very useful for that. I find they provide more texture and contextual information than say, UserRole, UserTask and UseCases.
    Message 1 of 3 , Sep 13, 2006
    • 0 Attachment
      > I am interested in ensuring that the day-in-the-life
      > narrative stories ares built in from the beginning rather
      > than waiting for summative usability testing to catch these
      > issues and then having to beg for rework resources.
      > Do you have recommendations on how to get context and
      > environment requirements as inputs into development? Others
      > real world inputs could
      > include: time pressures, distractions and recovery
      > strategies, error prevention, work flow efficiency, satisfaction, etc.
      > I assume that these real world design constraints would be
      > conveyed in stories, but not sure how to achieve the goal of
      > optimized user workflow while using stories that
      > fundamentally compartmentalize parts of the system.
      > I know how I'd do this using a waterfall or spiral method,
      > but not sure how to address these whole-system issues within
      > the context of agile timeboxing.

      I find Scenarios and Personaes very useful for that. I find they provide
      more texture and contextual information than say, UserRole, UserTask and

      By Scenario, I mean a short story that describes a particular journey
      through the system by a particular person. The story could happen in one
      day, or over many weeks. I usually reference UserRole and UserTasks in
      those Scenarios. Here's an example:

      Below is an example of such a scenario at the end of this message. It
      was written in the context of designing a multilingual wiki (i.e. a wiki
      that allows a community of volunteers to collaboratively maintain wiki
      content in multiliple languages). It's a bit on the long side, but you
      don't have to make them that long. I wrote it that long because I wanted
      to get a feel for what the whole system might feel like to a volunteer
      translator who is somewhat pleasure driven, but also wanting to "do the
      right thing".

      Note that in writing such scenarios, it's important to stay grounded in
      actual user data. In other words, don't make up scenarios or people.
      Tell the story of real people and real things that they have experienced
      or could have experienced. In this case, Hakan (pseudonym) is a real
      person who actually does volunteer translation time on a wiki, and I
      have had long conversaions about it with him.

      Note how the volunteer-based nature wiki work and its consequences in
      terms of how the system needs to support the user, really come alive in
      that story. This is the kind of stuff I find harder to convey with more
      abstract UserTasks and UseCases.

      == Example of scenario
      Hakan is a Turkish contributor to the Fluwiki site. His contributions
      are mostly at the level of translation. He has a genuine interest in
      preventing pandemic flu, and he has some knowlege of the domain (in
      particular, he knows the terminology fairly well), but he is by no means
      a domain expert. Hakan is somewhat pleasure driven in his Fluwikie
      volunteer work. He knows that Fluwikie is fulfilling an important
      mission and wants to work in the best interest of the site by
      translating the items that are of highest priority. But at the same
      time, he finds translating whole pages more fun than translating short
      updates to existing pages, and sometimes, he just feels like giving
      himself a treat and translate stuff that he finds fun to translate
      regardless of site priorities (after all, he is doing this work out of
      the goodness of his heart).

      One day, Hakan has a few hours available to do some translation work. He
      checks to see if there have been any specific requests for content to be
      translated into Turkish (LookForRequestsForTranslations ). He sees that
      there are 3 such requests.

      Hakan looks at the 3 requests and see that the 2nd one asks for a
      complete page to be translated (it does not have a translation in
      Turkish yet). He doesn't feel like working on small updates at the
      moment, so he chooses the 2nd request. He creates a new page on the
      site, and types in the translation (CreateNewTranslationOfCurrentPage
      and CreateContentOfNewTranslation ). This takes him a full hour (Hakan
      takes pride in the quality of his translations), and that's all he had
      available so he leaves the system after that.

      Two days later, Hakan has more time to put into translation work. He
      sees that the first request (translating some minor changes to a page)
      is still there. Moreover, he now notices that the requester had written
      a note beside his request saying that this change corrected an error
      that could lead to life threatening situations. So Hakan now feels
      obligated to translate it, eventhough there are other more fun requests
      to translate.

      Fortunately for him, the change that needs to be translated was done in
      English and Hakan reads English very well. So he brings up a tool for
      translating changes from English to Turkish. The tool shows him the
      changes that have been done to the English page (in context, i.e. the
      changes are embeded and highlighted within the full English text). He
      reproduces those changes in the Turkish page (TranslateUpdatesToAPage ),
      and saves them, tagging the two versions as being aligned with each
      other (SignalEndOfTranslationTask ).

      Now, there are no more pending requests for translation into Turkish,
      and Hakan still has some time available (but not much). So he looks for
      Turkish pages which are out of date with their sister pages in other
      languages (FindOutOfDatePagesInLanguageOfInterest ). There are many, but
      he chooses some that are visited often, or some that have only minor
      changes that need to be translated
      (FindOutImportantPagesThatAreOutOfDate and
      EstimateTranslationEffortForAParticularPage ). Hakan does a few of those
      (Translate pdatesToAPage and SignalEndOfTranslationTask ) until it's
      time for him to go to bed.

      Some days later, Hakan comes back again and has several hours ahead of
      him. But he again feels like translating whole pages, not just minor
      changes. Looking at the list of translation requests, he sees that there
      are none that are about translations to complete pages. So he goes
      hunting for pages in English that do not have translations in Turkish
      yet. There are quite a few, too many for him to do in one session. So he
      chooses the one that is most frequently visited, in terms of visit in
      any language version of that page (SeeWhichPagesAreMostVisited ). He
      translates a few until he runs out of time.

      Yet another day, Hakan logs on to the site and sees that someone has
      requested for a change to a Spanish page to be translated to Turkish
      (RequestForATranslation ). Hakan does not know Spanish, but he has heard
      that the system provides tools that can help people translate from a
      source language they can't read to a target language they can write.
      Hakan has never done this before and he is intrigued. So he translates
      the update from Spanish to Turkish
      (TranslateUpdateFromForeignLanguageToWriteableLanguage). The system
      shows him the Spanish page on the left, translated automatically into
      Turkish, and with the changes highlighted in red. The quality of the
      automatic translation is horrid, but it is good enough for Hakan to
      understand the change that was made and reproduce it in the Turkish page
      (GistUpdateToAPageInAForeignLanguage ). He then saves his translation to
      the Turkish page (SignalEndOfTranslationTask ).
    Your message has been successfully submitted and would be delivered to recipients shortly.