Phones off Signs out

1. Phones off Signs out

2. Special Visitor • Sean Haneberg • Microsoft XBoxLive • Former UB-CSE student

3. PEER evaluation The project submission for a team is graded as a whole, but each team member receives an individual grade which is based on that submission grade. The procedure for calculating individual grades is described below. The procedure is based on an assessment of each team member's contribution to the overall project submission. To assess individual member's contributions we use a peer-based evaluation mechanism. Here's how it works:Each person is given 10 points per group member to award. For example, for a team of five, each team member has 50 points to divide amongst all the team members, including themselves.  Similarly, for a team of four, each team member has 40 points to divide.A team member may award a maximum of 15 points to any one person.Points should be awarded to team members as an indication of your perception of how much work they did relative to others on the team. If you feel everyone did about the same amount of work you should award everyone 10 points.You evaluate your own contribution.You must award all of the points you have available to you.All points awarded must be whole numbers.Peer evaluations are submitted individually and are confidential – your teammates will NOT know how you rated them. Likewise, you will NOT be told how they rated you.After we get all of the peer evaluations we will calculate the average of the points allotted to each team member.Your individual grade project will be your average score multiplied by the overall project score, divided by 10

4. Example • .ExampleConsider a group made up of Cindy, Peter, Sally and Ulrik. As usual Sally does a fantastic job, Cindy and Ulrik do a moderate job but Peter didn't do much of anything. The table below shows the points that each team member awarded to the others. by Sally by Cindy by Ulrik by Peter Average • Points awarded to Sally 12 15 15 14 (12+15+15+14)/4 = 56/4 = 14 • Points awarded to Cindy 11 10 9 6 (11+10+9+6)/4 = 36/4 = 9 • Points awarded to Ulrik 11 9 10 6 (11+9+10+6)/4 = 36/4 = 9 • Points awarded to Peter 6 6 6 14 (6+6+6+14)/4 = 32/4 = 8 • Sally's average score is 14. Cindy and Ulrik each have an average score of 9. Peter trails the pack with an average score of only 8.If this team's project submission received 80% overall, then Sally would get 112% (!), Cindy and Ulrik would each get 72%, but Peter would get only 64%. Since Peter’s scores were so unbalanced we would look carefully at the documentation in the code to see what each of the team members contributed, and based on this we might adjust (either up or down) the score of any individual; the team as a whole would likely be called in for a meeting to find out what is happening with the team.Keep in mind that in extreme cases I reserve the right to ignore the peer evaluations and grade students based on their documented contribution to the project • .Acknowledgement: The peer-based evaluation mechanism used is essentially that used by Prof. Herreid, Distinguished Teaching Professor (Department of Biological Sciences).

5. LRStruct design

6. Empty vs. NonEmpty state(look Ma, no NullPointerException!) • An LRS object delegates all calls to its LRS State object – which can respond to all messages. • Empty and NonEmpty states respond differently. • There is never a null pointer in the structure! (Think about the implications of this for a while.)

7. What is basic (invariant) list functionality? • insert new item at front • remove item from front • set/get first item (head) • set/get rest (tail) • plus (in Java) methods inherited from Object (toString, equals, etc)

8. How are these methods defined? public LRStruct<E> insertFront(E item) { return _state.insertFront(this, item); } public E removeFront() { return _state.removeFront(this); } public LRStruct<E> setDatum(E item) { return _state.setDatum(this, item); } public E getDatum() { return _state.getDatum(this); } public LRStruct<E> setRest(LRStruct<E> rest) { return _state.setRest(this, rest); } public LRStruct<E> getRest() { return _state.getRest(this); }

9. LRStruct delegates to State! • All of these methods delegate to the state of the LRStruct. • States polymorphically determine what happens.

10. a An empty LRS • LRS<String> a = new LRS<String>(); LRS Empty _state

11. a Inserting an item into an empty LRS • a.insertFront(“fred”); LRS Empty _state

12. Empty a Inserting an item into an empty LRS • a.insertFront(“fred”); LRS _state

13. Empty a _state Inserting an item into an empty LRS • a.insertFront(“fred”); LRS _dat=“fred” _tail NonEmpty

14. Empty a _state _state Inserting an item into an empty LRS • a.insertFront(“fred”); LRS _dat=“fred” _tail NonEmpty LRS

15. Empty a _state _state Inserting an item into an empty LRS • a.insertFront(“fred”); LRS _dat=“fred” _tail NonEmpty LRS

16. Empty a _state _state Removing an item from an LRS • a.removeFront(); LRS _dat=“fred” _tail NonEmpty LRS

17. Empty a _state _state Removing an item from an LRS • a.removeFront(); LRS These gray objects will be garbage-collected at some point in the future _dat=“fred” _tail NonEmpty LRS