STOCK

1
STOCK

• Team Batman
• CS4233-A07

2
Our team

• Team members
• Joshua Jamilkowski
• James Johnson
• Timothy Loughlin
• Dylan Streb
• Joshua Walkowski
• How did your team operate?
• The team met twice a week to discuss the upcoming
  work that needed to be done. We met in AK120D
  for all of our meetings
• The team set up a mailing list (batgroup_at_wpi.edu)
  to talk to one another and we also talked over
  AIM.
• Task assignment was usually given out at the
  beginning of each week or whenever one set of
  tasks was completed.
• How did you plan your work?
• Our set plan was to get everything done that was
  assigned by the next time we met and it was
  effective.

3
Accomplishments

• Main requirements implemented
• Create a process instance
• Artifact Versions
• Associating activities, roles and artifacts
• Constraints on removing roles from people
• Limiting access to artifacts
• Roles represent responsibilities
• Activities can have optional steps or
  sub-activities
• Activities have entry/exit conditions
• Add a person to a project

4
Accomplishments

• Artifacts, Roles, and Activities must be
  instantiated
• Base artifact states
• Create a project
• Default entry and exit condition processor
• Entry and exit condition requirements
• Entry and Exit conditions for Activities
• How activities use artifacts
• Join a project
• Many-to-many relationship between peoples and
  roles
• There must be an administrator role for a project
• Activity Pool
• Canceling activities

5
Accomplishments

• Delete a project
• Delete a user
• Messages

6
Architecture
7
Architecture

• Singleton Patterns
• Handle Pool
• Reactor
• Synchronous Demultiplexer
• System

8
Architecture

• Clients and Server
• Reactor Pattern
• Server
• Demultiplexer
• Event Pool
• Event Interface

9
Architecture

• Factories
• Factories can create Projects, Users, Activities,
  Artifacts, Role
• Abstract Factories
• Used as template for Concrete Factories
• Concrete Factories
• Used to model Processes
• Creation of Activities and Artifacts have two
  possibilities
• Basic can create default objects based on the
  type
• Advanced can create advanced objects by
  assigning their own properties.
• To allow users the freedom to create Activities
  and Artifacts they desire on the fly

10
Architecture

• System Singleton
• Manages the Users, Projects, and Processes
• Handles creation and deletion of Users and
  Projects
• There is a standard type of User for the entire
  System the User can be involved with different
  Process types
• To change the type, its only a change to a
  single line of code
• User user new DefaultUser(name)
• Calls a particular Factory to create Projects,
  specified by the client
• Keeps track of the available Processes that a
  Project can use
• Processes must be registered with the System

11
Architecture

• Projects
• Know which Process they are following by keeping
  a reference to the Factory they should use for
  their operations
• Creation of Artifacts and Activities handled by
  the Factory
• Know the Users, Activities, and Artifacts that
  are involved with the Project
• Users are given Roles through the Project.
  Creation of Roles to assign is handled by the
  Factory
• Have an Activity Pool which keeps track of
  Activities that are ready to be started

12
Architecture

• Roles
• Have Privileges, or Privilege functions, that
  they can access and use. Gets its Privileges
  assigned by the Factory
• Roles get assigned to Users through Projects
• Privileges
• Have references to the Project they are assigned
  to and the Factory that the Project uses
• Abstract Privilege class holds all available
  functions that can be performed on a Project or
  the System
• Abstract Privilege just prints, You do not have
  the appropriate privileges to access this
  function!"
• Derived classes override the functions, which
  allows the Roles access to them
• Privileges are the main client to server
  connection.

13
Architecture

• Artifacts
• Have the Roles that are responsible for it
• Have states, such as available, locked, read-only
• Have Version Control
• Version Control
• Keeps track of all the different Versions of the
  Artifact as well as which Version is the most
  recent stable Version
• Can revert back to stable state
• Stores the type of all the Versions it manages
• Handles creation of Versions
• Uses a Version Factory to create a Version based
  on a type

14
Architecture

• Versions
• Represent the real artifact. Stores the filename
• Abstract so that file management, such as
  loading, can be handled by derived classes
• Track their creator and creation date
• File Pointer Version
• A default type of Version. Uses the filename to
  load in the file. Could be used to save the file
  on a server

15
Architecture

• Activities
• Use a Composite pattern for the hierarchical
  structure
• Use an Observer pattern to communicate with the
  Activity Pool
• Have lists of entry and exit Conditions,
• Have Progress, or state of the Activity
• Records the creator and performer of the Activity
• Have a list of Roles that can perform it
• Field to mark, upon creation, whether it is an
  optional Activity or a required Activity. Simply
  causes exit conditions to always return true if
  optional, but doesnt finish the Activity

16
Architecture

• Condition Mechanics
• The string is parsed by using a lookup table to
  build a tree.
• Tokens are separated by spaces and read one at a
  time by a Scanner object. Each token is checked
  to see if it exists in the OPCode hash table
• The parser will attempt to instantiate a
  LiteralCondition object which will then attempt
  to load the class with the same name as the token
  
• Brackets are handled by taking the portion of the
  string within the brackets and creating a new
  Condition object to evaluate the substring. The
  condition object is treated as a ConditionNode
  through the ConditionWrapper class, which uses
  the Adapter pattern.

17
Architecture

• Usage
• The condition class must first be setup by giving
  it a hash table of operations. This is done
  either by giving it an existing hash table of the
  appropriate type in the constructor or using the
  addOPcode method
• Set the condition string, done by invoking the
  setCondition method
• The string can then be evaluated by invoking the
  EvaluateCompletion method. It will apply boolean
  logic to the parse tree and return the result as
  a boolean

18
Things missing

• Persistence is not in the framework as of now.
  The effect of this is as of right now objects
  will not be able to be stored to be returned to
• Also networking and collaboration right now are
  incomplete. The effect of this is that you cant
  have multiple people working on the same project
• The guide, template and tools are also missing

19
Documentation

• We provided a SAD, and Javadoc for most of our
  code.
• Sequence diagrams, class diagrams and package
  diagrams have been provided
• We also have a technical manual which gives an
  overview on what each part of the framework does
• Example
• Activities
• An Activity is an abstract class, of which
  concrete classes are created. The Activity
  structure follows a Composite Pattern. The
  hierarchical structure for activities works as
  follows
• Activity the base class. An Activity can be
  optional or required, set by a field in Activity
• ActivityComposite holds a list of sub
  Activities (either of composite or item type),
  but is also an item itself
• ActivityItem the leaf of the tree

20
Proof-of-Concept

• UI Shell
• Sample workspace
• Text editing
• Send and receive messages
• Manipulate activities
• Data Storage
• Series of text files

21
Your product
22
(No Transcript)
23
(No Transcript)
24
(No Transcript)
25
Metrics

• 4170 lines of code
• 102 classes
• 15 packages
• 36 tests

26
Lessons learned

• What went right
• Most of the functional requirements were
  implemented and almost all level 1 priority
  requirements were included.
• What went wrong
• Persistence and networking due to lack of
  experience in each area.
• What would you do differently
• Spend less time on design phase and more time on
  actual implementation