4 Details for MPCS 51221
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.).
the syllabus for information on grading. Turning in Iteration
assignments is required. Submit your
assignments as a tarball to the subversion repository according to the
directions on the syllabus page.
Due: 5:00 pm, Tuesday, November 21, 2017
Continuation of Design, Code, and Test:
Consider the functional and technical requirements of the
system, and your design of the high level
architecture and initial domain model. Based on the functional
the system and your use cases, user stories and current domain models, your requirement for this iteration is more code and tests that implement more of your domain
models within your microservice architecture.
At the conclusion of this iteration, your microservice architecture
should be pretty firm (there's always some last-minute tweaks) and your
domain models should be fairly
well fleshed out in terms of the models themselves. You are to
collaboratively in developing your code and tests,
whiteboarding (and documenting) various design alternatives, continuing
to use CRC
finally delivering updated UML class models that will represent your
"fourth iteration model" and code. Your code base should now be beginning to mature, and your tests should be running and verifying that fact.
High Level Microservice Architecture and Domain Models:
You will have one week to produce this fourth 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, revisit your high level
architecture and list of candidate classes.
Deliverable One: Use Case Model/User Stories and Map--Final Iteration:
If there are any Essential Use Cases and stories left undefined, each member of the team is responsible for (like in the
iterations) individually delivering one additional Use Case and dependent stories fleshed out
from the model. Note that we would expect for additional use
cases and stories to be identified with each new iteration, although
this is not a requirement. These will detail user intentions as
well as system
responsibilities. As in the previous iterations, the verbiage
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 language about the underlying technology
implementation and the user interface as you write the use cases and
stories (note of course that this is not the same thing as saying you
have no idea or plans on what those underlying technologies might be...we sure hope you do...nonetheless, you want to avoid that terminology in your description of what the system will do). Your use cases should be based
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 continue to 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 Two: High Level Microservice Architecture and Domain Models--Final Iteration:
As a team, continue your development of your Microservices Architecture Blueprint and high
architectural model of your proposed
solution. This model will be a maturation of the "rough sketch"
of your "current
architectural approach", becoming much more refined during this
iteration. Your depiction should enhance the UML model you
produced in the third iteration, in Visual Paradigm (or whatever tool
you are using).
should continue to include more key components and interactions
as your architecture takes on more form. It should also become
more "realizable". We would expect that protocols and
technologies (RabbitMQ, RMI, sockets, TCP/IP, SOAP, REST, MySQL,
MongoDB, etc.) would
begin to be identified in your models. You should continue to
document your microservice architecture using your artifacts including Microservice
Architecture Catalog, Service Operation Analysis, Service Operation
Decomposition, Technology Stack Decomposition, and your Event Model. Again, these are intended to help you as a team think and communicate about what you are building.
Deliverable Three: Fourth 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 have encountered. Additionally, each member of the team is responsible for (as in the first several 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 three exercises, the verbiage 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 & Testing Strategy
In this fourth deliverable, you will want to begin
integrating whatever remaining
technologies you wish to include (i.e., such as asynchronous messaging
over RabbitMQ, writing to your MySQL or MongoDB instance, etc.).
You should begin fleshing out any stubbed classes, functions, services
that you have previously left in a "to-do-later" state.
You should continue the serious task of coding your solution with this fourth (and penultimate) iteration.
Ask yourself how you wish to approach this
construction activity. Continue whatever risk-based approach you
have identified works for you and your team. 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.
Continue to look at your use cases, story
map, and class models, and decide which of the remaining (and newly identified) classes you should develop with
this iteration. The goal in Class 10 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.
You should be able to describe, in detail, what testing
or approaches you are using, and what your approach to unit and system
testing is, particularly as it pertains to dockerized services.
Deliverable Five: Refine Your Messages & Services Model
Based on the functional
the system and your developing use cases and stories, use Visual
Paradigm (or whatever tool you are using) to complete your description of the messages that will be
the various services and services and components in your model.
Specifically, what messages will be passed from one service to another
over RabbitMQ? Specifically, what information will be delivered
to MySQL? Specifically, what information will be delivered to
MongoDB? This messaging model does not need to be
complete (or final), but it does need to depict your matured understanding at
the moment of the services you have identified along with their
and relationships. You are to work collaboratively in producing
this initial model, whiteboarding various design
alternatives, finally documenting the current state of your model
in UML in Visual Paradigm.
You can find a quick index to UML diagrams here.