Iteration
3 Details for MPCS 51205
Each
iteration will deliver an incremental accretion of work toward the
final project deliverable. Generally (see specifics within each
Iteration), each student will be responsible for delivering some piece
of the work (documentation, code, etc.).
See
the syllabus for information on grading. Turning in Iteration
assignments is required. Submit your assignments as a tarball and email it to John.
Iteration 3
Due: 5:00 pm, Monday, October 31, 2016 (Two Weeks)
Continuation of Design, Code, and Test:
Consider the functional and technical requirements of the
system, and your design of the high level
architecture. Based on the functional
requirements of
the system and your initial use cases, use stories and current domain model your second requirement for this iteration is some
actual code and tests that implement some portion of your domain
model.
You are to work collaboratively in developing your code and tests,
whiteboarding (and documenting) various design alternatives, using CRC
cards,
finally delivering an updated UML class model that will represent your
"updated model" and code. Your code base should just now be beginning to take fundamental shape, and your tests should be running and verifying that fact.
If there are any Essential Use Cases and stories left undefined, each member of the team is responsible for (like in the
first
iterations) individually delivering one additional Use Case and dependent stories fleshed out from the model. These will detail user intentions as well as system
responsibilities. The verbage should be a simple, general,
abstract, technology-free and implementation-independent description of
one task or interaction of the system you envision. Try your best
to avoid any inherent assumptions about the underlying technology
implementation and the user interface. Your use cases should be based
on the
intentions of a user in a particular context, rather than on the
concrete implementation by which the purpose or intention might be
carried out. Your use case description should be both meaningful
and descriptive from the point-of-view of users in some role or set of
roles as they derive value from a system that will embody the
purpose or intentions underlying the user interaction.
High Level Architecture and Initial Domain Model:
You will have two weeks to produce this third iteration. You are to work together as a team on these deliverables except when you are instructed to individually deliver something.
Considering the functional and technical requirements of the
system (to be named by the class as a whole), envision the high level
architecture and list of candidate classes.
Deliverable One: High Level Architecture Revisit
As a team, continue your development of your high level
architectural model of your proposed
solution. This model will be a continuation of the "rough sketch"
of your "current
architectural approach", becoming much more refined during this
iteration. Your depiction should become formal at this point and
be produced in UML, preferably in Visual Paradigm. Your
architecture rendition
should continue to include more key components and interactions
as your architecture takes on more form. It should also become more "realizable".
Deliverable Two: Convert your developing List of Candidate Classes and CRC Cards into a Class Design Model in UML
Based on the functional
requirements of
the system and your developing use cases and stories, leverage your preliminary
list of candidate from your Candidate Class List and initial CRC cards
and document a preliminary domain model depicting the main domain
classes, their key
attributes, and the relationships between these classes, depicted in
several UML Class Diagrams developed in Visual Paradigm. This
class model does not need to be
complete (or final), but it does need to depict your understanding at
the moment of the classes you've identified, their responsibilities,
and relationships. You are to work collaboratively in producing
this inital model, whiteboarding various design
alternatives, finally documenting the current state of the class model
in UML in Visual Paradigm.
Deliverable Three: Third Iteration of Use Case Model, Revised User Story Map & Revised Iteration Plan
Modify your team use case/story models to reflect the planning changes you encounter. Additionally, each member of the team is responsible for (as in the first
and second iterations) individually delivering one new Essential Use Case fleshed out
from the model, along with dependent user stories. These will detail user intentions
as well as system responsibilities. As in the first two exercises, the verbage should be a
simple, general, abstract, technology-free and
implementation-independent description of one task or interaction of
the system you envision. Try your best to avoid any inherent
assumptions about the underlying technology implementation and the user
interface yet to be designed. Your use cases should be based on the intentions of a user in a
particular context, rather than on the concrete implementation by which
the purpose or intention might be carried out. Your use case
description should be both meaningful and descriptive from the
point-of-view of users in some role or set of roles as they derive
value from a system that will embody the purpose or intentions
underlying the user interaction.
Deliverable Four: Code
You should begin the serious task of coding your solution with this
third iteration. Ask yourself how you wish to approach this
construction activity. Do you want to do a "risk-based" approach
where you code out the riskier parts of the system? Or do you
want to do a "value-first" approach that attempts to deliver the code
that you consider to be the most valuable to the customer (Professor
Shacklette)? You will want to also produce some tests (coded by
hand or developed using an existing harness such as junit, etc.) that
verify that your code is producing the results you wish (we will
discuss Test Driven Development and Tools in a future iteration).
Your approach should be first to determine whether your planning will
be risk-based or value-based. Then, look at your use cases, story
map, and class models, and decide which classes you should develop with
this iteration. The goal in two weeks is to demonstrate before
the class what your code is doing (an interface, however fledgling, may
be demonstrated). You should continue to enhance the code that
you developed for the second iteration.
Your new code is not intended to be the final version of any of
the classes you choose to implement. Feel free to stub out
whatever functionality you don't yet have time for or understand.
This second "code release" is intended to represent an incremental expansion of central classes and supporting classes.
You can find a quick index to UML diagrams here.