|
I
read with interest (and some alarm) your comments about the Boundary-Control-Entity
class model, but have not been able to find additional material
to help me understand the pattern and its impact on interaction
design and designers. Can you point me to additional information,
or give me a quick description of what this model looks like? I'm
familiar with UML and with many commonly used design patterns, but
you lost me somehow when you described the sequence of elaborating
use cases with activity diagrams, then building the activity diagram
as a Control class, in the sense that I don't have enough information
to understand how that "makes UI design redundant". Are you saying
that's true simply because it isn't explicitly inserted as a part
of the process during/after use case creation, or that the Boundary-Control-Entity
model itself somehow locks out interaction design. I guess I'm too
visual or something, because I'm not following you. ;-)
Thanks,
Dan Davis
uidesign.net
reply...
Hi
Dan,
The real issue here is that you only get one chance to get it right.
After that the pain of change is too great. Couple that with the
fact that the Use Case is always never written with the involvement
of a UI Designer and your heading for trouble.
There is a 2nd issue. I do not believe that the BCE approach scales
to any size at all. Use Cases are procedures. When you describe
a whole system with them, you describe a series of procedures. If
you then hard code those procedures, you have byb default built
a system of modal wizards.
The job of the user interface designer is often to work through
the task analysis / procedure descriptions / Use Cases and design
from them an optimal user experience based on an a-modal environment.
In other words a UI which supports swapping between tasks, doing
tasks in any order and so forth.
With BCE this is not possible. The only solution is the procedural
modal one. Hence the job of the UI designer to produce an a-modal
design is lost. The UI Designer is redundant and good UI design
is dead.
When you couple this to the fact that it is very easy to poke a
hole in the Controller class idea, the whole thing just doesn't
gell.
For example, imagine a sub-use case called "Login" which is composed
into many other Use Cases. The User presses the Login button on
the screen. The system plumbing then says "Ah ha, this is the "Login"
Use Case. What happens next, it determines a number of control classes
which need to be instantiated. One for each of the possible main
Use Cases that are composed into the Login Use Case.
This is nonsensical.
As the User proceeds through the interface the code would constantly
have to assess which of the control classes it had instantiated
are no longer needed as it becomes obvious which of the main Use
Cases is actually being followed. These "extra" objects would then
have to garbage collected.
Then there is the maintenance issue. With a BCE approach, you have
hard coded the user interaction into a class as lines of Java or
C++ or whatever. If you want to make a minor change to an interface,
you have to go and re-write the control classes.
Then we could look at the re-usability of these control classes
which is really non-existant.
Moving on to the Activity Diagrams. This is the latest material
which was presented at UML2000, the recent OMG conference. The essence
is that you use the Activity Diagram to elaborate the Use Case to
get something from which Control logic code can be built. An Activity
Diagram is to a Use Case what a Sequence Diagram is to a Class Diagram.
I
hope that helps at least as partial expalanation.
Regards,
David Anderson
Editor
|