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

XP and Big Interaction Design Up Front

Expand Messages
  • Paolo Bizzarri
    Hi everyone, I am reading the otherwise enjoyable book The Inmates are Running the Asylum , by Alan Cooper. As far as I understand, it is strongly against
    Message 1 of 18 , Aug 31, 2004
    • 0 Attachment
      Hi everyone,

      I am reading the otherwise enjoyable book "The Inmates are Running the
      Asylum", by Alan Cooper.

      As far as I understand, it is strongly against iteration development for
      building a coherent approach to interaction among users and programs.
      Basically he claims that this kind of iterative approach does a poor job on
      understanding some basic things about interaction design.

      He also claim some sort of "Big Interaction Design Up Front".

      The points he makes are generally good:

      - good usability cannot be easily added to a product: it has to be designed
      from scratch;

      - good usability has a strong influence over (or even drives) the whole
      software design processes;

      - hearing the customers is good, but you should be really aware that he cannot
      be really able to define a conceptually sound set of requirements.

      Now I believe (given personal experience) that:

      - it is true that programmers use to build the ugliest possible interfaces,
      and cannot understand why customers do not like them;

      - when asked to improve the usability, they normally say: "Oh yes, you mean
      adding fancy icons and better colours"...;

      - at the same time, XP provides a conceptual framework for learning from our
      mistakes and improving our design.

      For the last point for example, we have discovered in our document management
      system PAFlow, that a set of concepts that where completely separated could
      be really unified under a concept called "complex document": basically it is
      a document with several attachments, and some more properties.

      All at once we were able to see an enourmous quantity of duplication, as we
      were doing the same thing on different complex documents in different ways
      with different pieces of codes. With the next refactoring/iteration we are
      going to integrate in a single object (from the point of view of developer)
      and a single concept (from the point of view of the user) several concepts
      that are currently separated.

      I think XP, in particular refactoring is not only about refactoring the code,
      but also about refactoring the domain models and (consequentely) the users
      interfaces. Learning also has a strong role, as we have to understand how
      user works and through which concepts.

      What do you think ? Which is your experience/ideas about it ?

      Paolo

      --
      Paolo Bizzarri - President - Icube S.r.l.
      Address: Via Ridolfi 15 - 56124 Pisa (PI), Italy
      E-mail: p.bizzarri@... Web: http://www.icube.it
      Phone: (+39) 050 97 02 07 Fax: (+39) 050 31 36 588
    • William Pietri
      ... Those interested in this topic would benefit from joining Jeff Patton s excellent group, agile-usability@yahoogroups.com, which contains people from a
      Message 2 of 18 , Aug 31, 2004
      • 0 Attachment
        On Tue, 2004-08-31 at 13:08, Paolo Bizzarri wrote:
        >
        > I think XP, in particular refactoring is not only about refactoring the code,
        > but also about refactoring the domain models and (consequentely) the users
        > interfaces. Learning also has a strong role, as we have to understand how
        > user works and through which concepts.
        >
        > What do you think ? Which is your experience/ideas about it ?

        Those interested in this topic would benefit from joining Jeff Patton's
        excellent group, agile-usability@yahoogroups.com, which contains people
        from a variety of backgrounds.

        >From my personal experience, here are a few comments I have:

        * Cooper's initial take is wrong; you can build good UIs in an
        iterative fashion.
        * Building UIs iteratively, because it allows use and user testing
        before the project is done, can result in better user interfaces
        than BDUF approaches.
        * Once you have released, you cannot revise your interfaces as
        freely as you can refactor your code; it confuses or slows your
        existing users.
        * Since the cost-of-change curve for released UIs isn't flat, it's
        worth doing some lightweight work on information architecture
        sometime before you release. That reduces the risk that you will
        have to radically revise your interface to accommodate features
        already in your story card stack.
        * Even the most agile code is not as agile as a good mockup or
        paper prototype. Especially early in the project, it's often
        worth sketching out UIs before it's time to write code for them.
        But make sure to aggressively throw out the prototypes once
        you've implemented them; otherwise it's very tempting to keep
        them in sync.

        Also, for those who haven't done paper prototyping, this is a great book
        on the topic:

        http://www.amazon.com/exec/obidos/ASIN/1558608702/

        The shopping list alone is worth the cover price, as she's done a lot of
        work to find the right set of items from the zillions in your local
        office supply store.

        William
      • Phlip
        [x-posted to agile-usability@yahoogroups.com ] ... You can t refactor users. ... Wrong. It can t be added to a _crappy_ program. If you let a refactorable
        Message 3 of 18 , Aug 31, 2004
        • 0 Attachment
          [x-posted to agile-usability@yahoogroups.com ]

          Paolo Bizzarri wrote:

          > I am reading the otherwise enjoyable book "The
          > Inmates are Running the
          > Asylum", by Alan Cooper.
          >
          > As far as I understand, it is strongly against
          > iteration development for
          > building a coherent approach to interaction among
          > users and programs.

          You can't refactor users.

          > Basically he claims that this kind of iterative
          > approach does a poor job on
          > understanding some basic things about interaction
          > design.
          >
          > He also claim some sort of "Big Interaction Design
          > Up Front".
          >
          > The points he makes are generally good:
          >
          > - good usability cannot be easily added to a
          > product: it has to be designed
          > from scratch;

          Wrong. It can't be added to a _crappy_ program. If you
          let a refactorable program mature, changing the GUI is
          just another change.

          However, if you release that GUI to a significant user
          population, they will bond with its features in ways
          you should not predict or derail.

          I propose (entirely to make everyone need to hire more
          programmers like me) that programs should version with
          skins, so each user population gets the skin they
          like.

          > - good usability has a strong influence over (or
          > even drives) the whole
          > software design processes;

          Unfortunately yes. In theory, program logic
          encapsulates behind a representation layer. In
          practice, the logic layer takes any shortcut the GUI
          provides.

          > - hearing the customers is good, but you should be
          > really aware that he cannot
          > be really able to define a conceptually sound set of
          > requirements.

          That's why usability experts recommend hiring
          usability experts.

          > Now I believe (given personal experience) that:
          >
          > - it is true that programmers use to build the
          > ugliest possible interfaces,
          > and cannot understand why customers do not like
          > them;

          Right, so leverage this effect instead of fight it.

          > - when asked to improve the usability, they normally
          > say: "Oh yes, you mean
          > adding fancy icons and better colours"...;

          That's why usability experts should show, don't tell.
          They should sketch the interface they want, from
          scratch.

          It's also why GUI programmers should instrument their
          GUI tests to record images of GUIs under test, and
          store these in a gallery for easy review.

          > - at the same time, XP provides a conceptual
          > framework for learning from our
          > mistakes and improving our design.

          Sorting features in business priority leads to an
          effect I call "All roads lead to Rome". The usability
          of primary features influences the design of secondary
          features, so they always reinforce the primary ones.

          "All roads lead to Rome" refers to a peasant's
          decision, trundling a cart full of products out from
          their little village. They can take a road away from
          Rome, and towards the barbarians, or they can take it
          towards Rome and towards the tax collectors.

          You get that pattern by starting at Rome when you
          build the roads.

          > For the last point for example, we have discovered
          > in our document management
          > system PAFlow, that a set of concepts that where
          > completely separated could
          > be really unified under a concept called "complex
          > document": basically it is
          > a document with several attachments, and some more
          > properties.
          >
          > All at once we were able to see an enourmous
          > quantity of duplication, as we
          > were doing the same thing on different complex
          > documents in different ways
          > with different pieces of codes. With the next
          > refactoring/iteration we are
          > going to integrate in a single object (from the
          > point of view of developer)
          > and a single concept (from the point of view of the
          > user) several concepts
          > that are currently separated.

          Right. Duplication removal drives both design and
          usability.

          > I think XP, in particular refactoring is not only
          > about refactoring the code,
          > but also about refactoring the domain models and
          > (consequentely) the users
          > interfaces. Learning also has a strong role, as we
          > have to understand how
          > user works and through which concepts.

          Deploying the features of highest business value,
          first, reduces the odds of reworking those features
          later. Except for the first round of re-work, when the
          users discover their optimal workflow and the places
          where usability lapses.


          =====
          Phlip
          http://industrialxp.org/community/bin/view/Main/TestFirstUserInterfaces



          __________________________________
          Do you Yahoo!?
          Yahoo! Mail - 50x more storage than other providers!
          http://promotions.yahoo.com/new_mail
        • Paolo Bizzarri
          ... I think it is right in general, but it is false for a good XP project. Even in a well refactored code base you could have a new concept that has been
          Message 4 of 18 , Aug 31, 2004
          • 0 Attachment
            > >
            > > - good usability cannot be easily added to a
            > > product: it has to be designed
            > > from scratch;
            >
            > Wrong. It can't be added to a _crappy_ program. If you
            > let a refactorable program mature, changing the GUI is
            > just another change.

            I think it is right in general, but it is false for a good XP project. Even in
            a well refactored code base you could have a new concept that has been
            ignored/not well understood by developers, that has produced a poor
            interaction. XP allows us to dare to propose a complete refactoring of this
            (as said before, we are really experiencing such a thing...).

            > However, if you release that GUI to a significant user
            > population, they will bond with its features in ways
            > you should not predict or derail.
            >
            > I propose (entirely to make everyone need to hire more
            > programmers like me) that programs should version with
            > skins, so each user population gets the skin they
            > like.
            >
            I think you are right, but Cooper make a strong point that he is not speaking
            about GUIs, but about user interaction. In My Really Limited Experience, the
            second drive the first. If you build a good design interaction, you will end
            with a good interface, even if it is not graphically phancy.

            BTW, I am starting to think that he is really speaking about some kind of
            workflows at the level of the user...

            > > - good usability has a strong influence over (or
            > > even drives) the whole
            > > software design processes;
            >
            > Unfortunately yes. In theory, program logic
            > encapsulates behind a representation layer. In
            > practice, the logic layer takes any shortcut the GUI
            > provides.
            >

            see above. I think the focus is Interaction, not the Interface

            > > - when asked to improve the usability, they normally
            > > say: "Oh yes, you mean
            > > adding fancy icons and better colours"...;
            >
            > That's why usability experts should show, don't tell.
            > They should sketch the interface they want, from
            > scratch.

            This was meant to be ironic. My intention was to say that programmers don't
            understand usability, because they see simply as a problem of putting more
            decorations on a window or on a web page. My understanding is that the real
            problem is the user interaction, not the user interface. The GUI is the way
            the user has to interact with the program, but what makes the user work is
            the interaction, not the GUI per se...

            For example, we have seen an application from a competitor of ours. The web
            interface was generally good. However, there was clearly a big problem in the
            application per se.

            Features were scattered around the program, added on the base of the request
            of the customer. Howver, there was no idea of general interaction among user
            and program. This part was never refactored, even if the forms and the web
            pages where generally well designed.

            Regards

            Paolo

            --
            Paolo Bizzarri - President - Icube S.r.l.
            Address: Via Ridolfi 15 - 56124 Pisa (PI), Italy
            E-mail: p.bizzarri@... Web: http://www.icube.it
            Phone: (+39) 050 97 02 07 Fax: (+39) 050 31 36 588
          • Amr Elssamadisy
            I ve been reading this post - and I was wondering - has anyone ever worked with a usability expert ? I haven t and I wouldn t know what that kind of
            Message 5 of 18 , Aug 31, 2004
            • 0 Attachment
              I've been reading this post - and I was wondering - has anyone ever worked
              with a 'usability expert'? I haven't and I wouldn't know what that kind of
              expertise would bring to the game. I consider myself anti-talented when it
              comes to GUIs and usually find that working with the client in tight
              feedback loops helps give them a UI that seems to work well for them.

              Based on Paolo's notes (I haven't read the book) - it seems that workflow is
              the key part. The successful XP teams I've worked on that incorporated
              FIT-like tests with the customers actually thought this way and worked this
              way. That is - the FIT tests were coded use cases - they drove the
              workflow. When work was done in this test-first manner it became easier to
              write and modify a good GUI - because the service layer to support the FIT
              tests were based on use cases....

              Amr
            • jhrothjr
              ... worked ... kind of ... when it ... them. ... workflow is ... incorporated ... worked this ... easier to ... the FIT ... That s an interesting thought,
              Message 6 of 18 , Sep 1, 2004
              • 0 Attachment
                --- In extremeprogramming@yahoogroups.com, "Amr Elssamadisy"
                <amr@e...> wrote:
                > I've been reading this post - and I was wondering - has anyone ever
                worked
                > with a 'usability expert'? I haven't and I wouldn't know what that
                kind of
                > expertise would bring to the game. I consider myself anti-talented
                when it
                > comes to GUIs and usually find that working with the client in tight
                > feedback loops helps give them a UI that seems to work well for
                them.
                >
                > Based on Paolo's notes (I haven't read the book) - it seems that
                workflow is
                > the key part. The successful XP teams I've worked on that
                incorporated
                > FIT-like tests with the customers actually thought this way and
                worked this
                > way. That is - the FIT tests were coded use cases - they drove the
                > workflow. When work was done in this test-first manner it became
                easier to
                > write and modify a good GUI - because the service layer to support
                the FIT
                > tests were based on use cases....

                That's an interesting thought, especially since I've been reading
                Alistair Cockburn's "Writing Effective Use Cases" recently. I got the
                impression that the difference between a use case and a scenario was
                that a use case folded all of the scenarios that showed a user role
                achieving (or failing to achieve) a particular goal into one document
                arranged with a main success scenario and then the variations. (There
                are other things in a use case, of course...)

                I can understand using FIT for a scenario (a single path for getting
                the user role to the goal), but I'm having some difficulty working
                out how to write a single FIT test (or simply managing a suite of
                them) for a use case the way Cockburn describes it.

                Thoughts?

                John Roth
                >
                > Amr
              • Robert C. Martin
                ... I disagree. I have retrofitted several different projects with UI s that vastly improve usability. ... I think this is probably what a usability expert
                Message 7 of 18 , Sep 1, 2004
                • 0 Attachment
                  > -----Original Message-----
                  > From: Paolo Bizzarri [mailto:p.bizzarri@...]

                  >
                  > - good usability cannot be easily added to a product: it has
                  > to be designed from scratch;

                  I disagree. I have retrofitted several different projects with UI's that
                  vastly improve usability.

                  > - good usability has a strong influence over (or even drives)
                  > the whole software design processes;

                  I think this is probably what a usability expert would like to believe. As
                  a design expert, I like to believe that a good software design will drive
                  usability. I think the truth is elsewhere.

                  > - hearing the customers is good, but you should be really
                  > aware that he cannot be really able to define a conceptually
                  > sound set of requirements.

                  Up front? I agree. However, I think over several iterations the customer
                  can do a much better job of defining requirements than anyone else can.

                  > - it is true that programmers use to build the ugliest
                  > possible interfaces, and cannot understand why customers do
                  > not like them;

                  Some programmers did, yes. Then again there was MacPaint, MacDraw, MacWord,
                  and (wonder of wonders) Hypercard.

                  > - when asked to improve the usability, they normally say: "Oh
                  > yes, you mean adding fancy icons and better colours"...;

                  Programmers don't always do that. I've had marketting people do it though.

                  > I think XP, in particular refactoring is not only about
                  > refactoring the code, but also about refactoring the domain
                  > models and (consequentely) the users interfaces.

                  Of course!
                • Ilja Preuss
                  ... Seconded - I am currently doing exactly that. It s not easy, but mainly because the product uses Borland DataExpress to bind the GUI directly to the
                  Message 8 of 18 , Sep 2, 2004
                  • 0 Attachment
                    Robert C. Martin wrote:
                    >> -----Original Message-----
                    >> From: Paolo Bizzarri [mailto:p.bizzarri@...]
                    >
                    >>
                    >> - good usability cannot be easily added to a product: it has
                    >> to be designed from scratch;
                    >
                    > I disagree. I have retrofitted several different projects
                    > with UI's that vastly improve usability.

                    Seconded - I am currently doing exactly that. It's not easy, but mainly
                    because the product uses Borland DataExpress to bind the GUI directly to
                    the database... <sigh>


                    >> - good usability has a strong influence over (or even drives)
                    >> the whole software design processes;
                    >
                    > I think this is probably what a usability expert would like
                    > to believe. As a design expert, I like to believe that a
                    > good software design will drive usability. I think the truth is
                    > elsewhere.

                    I'd think that a good design will decouple the business logic from
                    usability concerns.

                    >> - it is true that programmers use to build the ugliest
                    >> possible interfaces, and cannot understand why customers do
                    >> not like them;
                    >
                    > Some programmers did, yes. Then again there was MacPaint,
                    > MacDraw, MacWord, and (wonder of wonders) Hypercard.

                    We are lucky enough to have a programmer in the team who shines at
                    designing user interfaces. Not every team can have that luxury, I guess.


                    >> - when asked to improve the usability, they normally say: "Oh
                    >> yes, you mean adding fancy icons and better colours"...;
                    >
                    > Programmers don't always do that. I've had marketting people do it
                    > though.

                    That matches my current experience. Hell, the icons they come up with
                    aren't even fancy... :rolleyes:

                    Cheers, Ilja
                  • Adam Carter
                    ... Sorry to come in late on this, but is your comment about the need not to do low fidelity prototyping for users to quickly see new concepts, or was it about
                    Message 9 of 18 , Sep 2, 2004
                    • 0 Attachment
                      Phlip wrote:
                      > Wrong. It can't be added to a _crappy_ program. If you
                      > let a refactorable program mature, changing the GUI is
                      > just another change.
                      >
                      > However, if you release that GUI to a significant user
                      > population, they will bond with its features in ways
                      > you should not predict or derail.
                      >
                      > I propose (entirely to make everyone need to hire more
                      > programmers like me) that programs should version with
                      > skins, so each user population gets the skin they
                      > like.

                      Sorry to come in late on this, but is your comment about the need not to
                      do low fidelity prototyping for users to quickly see new concepts, or
                      was it about the need not to have a long drawn out Design phase?

                      Adam
                    • Phlip
                      ... I don t know. Both suck. All I can imagine is features- GUI- usability- new features. The agile-usability mailing list can answer the long-term lifecycle
                      Message 10 of 18 , Sep 2, 2004
                      • 0 Attachment
                        Adam Carter wrote:

                        > Phlip wrote:

                        > > Wrong. It can't be added to a _crappy_ program. If
                        > > you let a refactorable program mature, changing
                        > > the GUI is just another change.
                        > >
                        > > However, if you release that GUI to a significant
                        > > user population, they will bond with its features
                        > > in ways you should not predict or derail.
                        > >
                        > > I propose (entirely to make everyone need to hire
                        > > more programmers like me) that programs should
                        > > version with skins, so each user population gets
                        > > the skin they like.
                        >
                        > Sorry to come in late on this, but is your comment
                        > about the need not to
                        > do low fidelity prototyping for users to quickly see
                        > new concepts, or
                        > was it about the need not to have a long drawn out
                        > Design phase?

                        I don't know. Both suck. All I can imagine is
                        features->GUI->usability->new features. The
                        agile-usability mailing list can answer the long-term
                        lifecycle questions.

                        My personal view from implementing skinnable GUIs is
                        that whole teams should understand GUIs are easy and
                        safe to change, and a program can easily support more
                        than one GUI.

                        Traditionally, GUI programming fills up with bugs,
                        because GUIs are "easy", so teams appoint kiddie
                        koders to paint GUI screens and put logic inside them.
                        Then they fill with cruft and grow hard to change.

                        Fixing that, by test-firsting a GUI, makes the GUI
                        easier to skin, meaning change its appearance based on
                        its user. The simplest skin is a locale - English or
                        Greek or Sanskrit or Korean or whatever.

                        Skins that diverge inside the Representation Layer
                        could present different GUIs with different
                        click-paths, for different user populations. Users are
                        hard to refactor, but GUIs won't turn to spaghetti if
                        you keep them flexible.

                        Someone said that GUIs are hard to re-skin. I think.

                        =====
                        Phlip
                        http://industrialxp.org/community/bin/view/Main/TestFirstUserInterfaces



                        __________________________________
                        Do you Yahoo!?
                        New and Improved Yahoo! Mail - Send 10MB messages!
                        http://promotions.yahoo.com/new_mail
                      • Kent Beck
                        ... The skill to create usable software is not necessarily linked to the skill to create working software. Some people have only one skill. Other have both.
                        Message 11 of 18 , Sep 2, 2004
                        • 0 Attachment
                          > -----Original Message-----
                          > From: Paolo Bizzarri [mailto:p.bizzarri@...]
                          > Sent: Tuesday, August 31, 2004 2:24 PM
                          > To: extremeprogramming@yahoogroups.com
                          > Subject: Re: [XP] XP and Big Interaction Design Up Front
                          >
                          > This was meant to be ironic. My intention was to say that
                          > programmers don't
                          > understand usability, because they see simply as a problem of
                          > putting more
                          > decorations on a window or on a web page. My understanding is
                          > that the real
                          > problem is the user interaction, not the user interface. The
                          > GUI is the way
                          > the user has to interact with the program, but what makes the
                          > user work is
                          > the interaction, not the GUI per se...

                          The skill to create usable software is not necessarily linked to the
                          skill to create working software. Some people have only one skill. Other
                          have both. Both skills improve with practice.

                          Kent Beck
                          Three Rivers Institute
                        • Steven Gordon
                          Surely, you do not mean to imply that it is possible to create useable software that does not actually work. ... From: Kent Beck [mailto:kentb@earthlink.net]
                          Message 12 of 18 , Sep 2, 2004
                          • 0 Attachment
                            Surely, you do not mean to imply that it is possible to create useable software that does not actually work.

                            -----Original Message-----
                            From: Kent Beck [mailto:kentb@...]
                            Sent: Thu 9/2/2004 11:09 PM
                            To: extremeprogramming@yahoogroups.com
                            Cc:
                            Subject: RE: [XP] XP and Big Interaction Design Up Front





                            > -----Original Message-----
                            > From: Paolo Bizzarri [mailto:p.bizzarri@...]
                            > Sent: Tuesday, August 31, 2004 2:24 PM
                            > To: extremeprogramming@yahoogroups.com
                            > Subject: Re: [XP] XP and Big Interaction Design Up Front
                            >
                            > This was meant to be ironic. My intention was to say that
                            > programmers don't
                            > understand usability, because they see simply as a problem of
                            > putting more
                            > decorations on a window or on a web page. My understanding is
                            > that the real
                            > problem is the user interaction, not the user interface. The
                            > GUI is the way
                            > the user has to interact with the program, but what makes the
                            > user work is
                            > the interaction, not the GUI per se...

                            The skill to create usable software is not necessarily linked to the
                            skill to create working software. Some people have only one skill. Other
                            have both. Both skills improve with practice.

                            Kent Beck
                            Three Rivers Institute







                            [Non-text portions of this message have been removed]
                          • Adam Carter
                            Woops :) That was supposed to go to the agile-usability list ... My brain was getting over a milestone this morning :( Adam Phlip wrote:
                            Message 13 of 18 , Sep 3, 2004
                            • 0 Attachment
                              Woops :) That was supposed to go to the agile-usability list ... My
                              brain was getting over a milestone this morning :(

                              Adam

                              Phlip wrote:
                            • Ron Jeffries
                              ... Is a prototype an example of useable software that does not actually work? Ron Jeffries www.XProgramming.com New and stirring things are belittled because
                              Message 14 of 18 , Sep 3, 2004
                              • 0 Attachment
                                On Friday, September 3, 2004, at 2:38:47 AM, Steven Gordon wrote:

                                > Surely, you do not mean to imply that it is possible to create useable
                                > software that does not actually work.

                                Is a prototype an example of useable software that does not actually work?

                                Ron Jeffries
                                www.XProgramming.com
                                New and stirring things are belittled because if they are not belittled,
                                the humiliating question arises, "Why then are you not taking part in
                                them?" -- H. G. Wells
                              • Ilja Preuss
                                ... Surely not. He seemed to be speaking about skills not being connected. That s certainly different from properties of software being or being not connected?
                                Message 15 of 18 , Sep 3, 2004
                                • 0 Attachment
                                  Steven Gordon wrote:
                                  > Surely, you do not mean to imply that it is possible to
                                  > create useable software that does not actually work.

                                  Surely not. He seemed to be speaking about skills not being connected.
                                  That's certainly different from properties of software being or being
                                  not connected?

                                  That is, someone who knows what usable software should look like might
                                  not necessarily have the skill to also make it work. Sounds reasonable
                                  to me...

                                  Cheers, Ilja
                                • Steven Gordon
                                  If a prototype of useable software actually worked, it would be useable software. If not, it is just a prototype, not actually useable software. I guess what
                                  Message 16 of 18 , Sep 3, 2004
                                  • 0 Attachment
                                    If a prototype of useable software actually worked, it would be useable software. If not, it is just a prototype, not actually useable software.

                                    I guess what Kent is saying is that some people understand useability and can communicate that understanding via a model, mockup, prototype or whatever, but do not have the additional skills to
                                    implement their vision as working software. I would say they understand useability, not that they
                                    have the skill to produce useable software (that does not necessarily actually work).

                                    Steven Gordon

                                    -----Original Message-----
                                    From: Ron Jeffries [mailto:ronjeffries@...]
                                    Sent: Fri 9/3/2004 3:02 AM
                                    To: extremeprogramming@yahoogroups.com
                                    Cc:
                                    Subject: Re: [XP] XP and Big Interaction Design Up Front



                                    On Friday, September 3, 2004, at 2:38:47 AM, Steven Gordon wrote:

                                    > Surely, you do not mean to imply that it is possible to create useable
                                    > software that does not actually work.

                                    Is a prototype an example of useable software that does not actually work?

                                    Ron Jeffries
                                    www.XProgramming.com
                                    New and stirring things are belittled because if they are not belittled,
                                    the humiliating question arises, "Why then are you not taking part in
                                    them?" -- H. G. Wells




                                    [Non-text portions of this message have been removed]
                                  • Adam Carter
                                    I have to double check what you are saying ... Are you suggesting that people who use paper weight design are people who can t implement? Adam
                                    Message 17 of 18 , Sep 3, 2004
                                    • 0 Attachment
                                      I have to double check what you are saying ...

                                      Are you suggesting that people who use paper weight design are people
                                      who can't implement?

                                      Adam

                                      Steven Gordon wrote:
                                      > I guess what Kent is saying is that some people understand useability and can communicate that understanding via a model, mockup, prototype or whatever, but do not have the additional skills to
                                      >
                                      > implement their vision as working software. I would say they understand useability, not that they
                                      >
                                      > have the skill to produce useable software (that does not necessarily actually work).
                                      >
                                      >
                                      >
                                      > Steven Gordon
                                    • Steven Gordon
                                      I was rewording Kent s claim that some people can build working software, some people can build useable software, and some people can do both. ... From: Adam
                                      Message 18 of 18 , Sep 3, 2004
                                      • 0 Attachment
                                        I was rewording Kent's claim that some people can build working software, some people can build useable software, and some people can do both.

                                        -----Original Message-----
                                        From: Adam Carter [mailto:a.carter@...]
                                        Sent: Fri 9/3/2004 7:08 AM
                                        To: extremeprogramming@yahoogroups.com
                                        Cc:
                                        Subject: Re: [XP] XP and Big Interaction Design Up Front



                                        I have to double check what you are saying ...

                                        Are you suggesting that people who use paper weight design are people
                                        who can't implement?

                                        Adam

                                        Steven Gordon wrote:
                                        > I guess what Kent is saying is that some people understand useability and can communicate that understanding via a model, mockup, prototype or whatever, but do not have the additional skills to
                                        >
                                        > implement their vision as working software. I would say they understand useability, not that they
                                        >
                                        > have the skill to produce useable software (that does not necessarily actually work).
                                        >
                                        >
                                        >
                                        > Steven Gordon




                                        To Post a message, send it to: extremeprogramming@...

                                        To Unsubscribe, send a blank message to: extremeprogramming-unsubscribe@...

                                        ad-free courtesy of objectmentor.com
                                        Yahoo! Groups Links









                                        [Non-text portions of this message have been removed]
                                      Your message has been successfully submitted and would be delivered to recipients shortly.