The content on this page is the work of Professor Glenn Blank.
Be advised that Professor Blank is no longer on the active faculty at Lehigh.
This content continues to be available as a courtesy, but it may not be maintained or current.

CSE432 - Object-Oriented Software Engineering
Term Project Roles, Deliverables, and Grading Criteria

Projects should tackle non-trivial problems and exploit inheritance and dynamic binding.
"Real world" projects, with customers outside of class, are recommended and will be evaluated more highly.

Project roles:
    Customer (real world client, requests a project, works with analyst, evaluates product)
    Project manager (coordinates team participants by roles, manages schedules and resources): 10 points
    Librarian (documentation, project schedules and minutes, test data, deliverables and maintenance manuals): 10
    Subcontractor (works on a specified part of another project, negotiated with team and project manager): 10 pts
    Subcontractors may be hired for specific tasks by either an analysis/design or programming/testing team.
    Every student must participate on an analysis/design and on a programming/testing team (2 per team).
    Every student must participate as one of project manager, librarian, or subcontractor on one project.
    Customer and analyst/designers may not work on the same project.
    Analyst/designers and programmers may not work on the same project, though project manager role continues.
    Project manager should be one of the analyst/designers (to provide continuity for a project).
    Requirements, analysis and design specifications due at dates specified during semester (see syllabus below)
    Each team member evaluates other team members, by role, with Team role assessments.
Note: Every student will be an analyst/designer on one project, a programmer on a second project, and at least one of the other roles on a one of the two projects.

Project delivarables:
The syllabus lists milestones for deliverables. For each one, the librarian (or project manager if a team does not have a librarian) should email me a link to a project website. Also with each deliverable, the whole team should submit meeting minutes, which should include the team members present, minute taker for this meeting, agenda, date, time and place for this meeting status of previous action items, decisions made (usually organized according to the meeting agenda), and new action items (for next meeting), and agenda for next meeting. Each individual project member should submit team project role assessments (form available here) to me via email, after each team submits its analysis/design for handoff (around mid-semester) and when each team submits its final project.

Project evaluation criteria:
Analysis/design (30):
    Analysis and design: 30 points
    Requirement specs (5). How complete are they, were they revised per suggestions, did they communicate well to the customer and programmers?
    Use cases (5). How complete are they, did they communicate well to the customer and programmers?
    UML diagrams (5). How complete are they, communicate the design well to the programmers?
    Do they exploit dynamic binding and abstraction and other patterns?
    Contracts (4). How complete? Do they use formal or informal notation? Are all preconditions and postconditions defined, abstract classes and methods marked? Do they communicate the contract well to the programmers?
    User interface and/or database design (3). Is it obvious to the programmers what the user interface should look like, and is a separate class design provided if necessary? If a database is needed, is a schema provided?
    Sequence diagrams, CRC cards, redesign as needed, minutes process (5). Do sequence diagrams show the dynamic behavior of the system adequately. If the system requires multiple threads, is this made obvious to the programmers? Have the analysis and design documents been revised in a timely manner in response to recommendations from the instructor or the programmers?
    Test plan. (3) Do the analysts provide the programmers with a test plan outlining criteria for unit, system and acceptance testing? How would the programmers, analysts, customer know that a project has been implemented successfully? Do the analysts verify that the system has been tested adequately and report on the status of the program to the at the end of the project life cycle (the semester) to the other stakeholders?
    Role assessment forms (1) handed in twice providing helpful feedback for analysis/design at mid-semester handoff.
Program/testing (30):
    How much of the project is complete? If not, how useful is it a prototype? (12)
    How well does it follow or revise the design? Were designers involved in changes? Does the design/code involve any refactoring (please comment on any)?(4)
    Code quality and comments. Was the code set up for Javadoc and was Javadoc comments provided (or something analogous for C++ code)? (4)
    How visibly and effectively is a test plan followed? Were Junit tests done? (4)
    How acceptable is it or will it be to the customer? Is there a user evaluation report? (3)
    Project documentation for user and maintenance. User manual, developer notes, bug report, to-do list. (3)
    Role assessment forms after submitting final projects (1)
Other roles (10):
    Customer, project manager, librarian, or subcontractor.
    Criteria are role specific and take into account role assessment forms.