Iteration 4 Details for MPCS 51221

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 to the subversion repository according to the directions on the syllabus page.

Iteration 4   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 requirements of 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 work collaboratively in developing your code and tests, whiteboarding (and documenting) various design alternatives, continuing to use CRC cards, 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 first 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 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 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 level 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).  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".  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 framework(s) 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 requirements of 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 passed between 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 responsibilities, 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.