The Computer Science Dossier Overview

Page 1 of 7

The Dossier is quite possibly the single most challenging piece of work a High School student can undertake. The IBO have indicated that, from 2010, the burden will be considerably eased but meanwhile we must get students through it. The students should be made aware of the requirements for documentation as well as programming as documentation is by far the most time-consuming part of the process and marks are awarded accordingly. There are four main sections each with its own type of activity:

The intention behind this part of the course is to get students to:

Do more pre-planning Construct thorough designs before coding Select suitable problems Choose real-word problems

and also to address problems of the previous system such as:

Lack of flexibility in problem choice Heavy penalties for misinterpreting a single mastery factor

---------------------------------------------------------------------------------------------------------------------------------------------------Workshop participants should familiarise themselves with the Computer Science Guide and the Teacher Support Material. Copies of these are available from your school or from IBO or from this course (see the link useful documents from the OCC).

Richard Jones & Andrew Meyenn, Aug-08; [Link]

Page 2 of 7

Formal requirements
There are 14 criteria, grouped according to the four stages given above:

Stage

Criteria/activities
Analysing the problem Criteria for success Prototype solution Data Structures Algorithms Modular organisation Programming style Usability Error handling Success Hard copy Evaluation User documentation

Stage A - Analysis

Stage B Detailed Design

Stage C The Program Stage D - Documentation

In addition teachers award a holistic achievement level according to criteria they set for the students. This is expected to be based on the students commitment to the project. The dossier is marked out of 50 and scaled to 35 to give more granularity to awards.

Richard Jones & Andrew Meyenn, Aug-08; [Link]

Page 3 of 7

Mastery Factors
Students at SL and HL must achieve mastery of 10 aspects out of a possible 15. There is a 10% penalty for each one missed so 8 factors mastered gives 80% of the total mark and so on.

Standard level
1. Arrays 2. User-defined objects 3. Objects as data records 4. simple selection 5. complex selection 6. loops 7. nested loops 8. user-defined methods 9. user-defined methods with parameters 10. user-defined methods with appropriate return values 11. sorting 12. searching 13. file i/o 14. use of additional libraries (not in JETS) 15. use of sentinels or flags

Higher level
1. Adding to random Access File 2. Deleting from Random Access File 3. Searching in a Random Access File 4. Recursion 5. Merging sorted data structures 6. Polymorphism 7. Inheritance 8. Encapsulation 9. Parsing a text file (or other stream) 10. Hierarchical composite ds 11. Up to 5 Standard level mastery factors

Up to 4 for implementing a userdefined ADT

Notice that SL 10 would also satisfy 8 and 9. Examples of HL ADT implementations are given in the Subject Guide and include structures like stacks, queues, trees, lists and hash tables Richard Jones & Andrew Meyenn, Aug-08; [Link]

Page 4 of 7

Standard Level Mastery Factors

The table below outlines the 15 available master factors. Students must satisfy 10 of these. Students are penalised 10% of the final dossier mark for each factor missed. There is some level of subjectivity in judging non-trivial. This is addressed in the explanation part of the table and also in a subsequent activity. Non-trivial use would normally be satisfied if the problem is reasonably sophisticated and the mastery aspect is implemented for a reason that is linked to solving a logic or processing issue and not just included to artificially satisfy a mastery claim. There is no need for multiple arrays. An array as a lookup An array to store input An array to store file data Examples: A GUI Display/control Object An object to support processing, e.g. bank account Example: A file record represented as a record object in RAM. class record { int field1; String field2; } Accessor and mutator methods could also be added. Any example of a simple if statement would satisfy. Multiple Boolean conditions or switch statement Any use of for; any use of while Two for loops processing a 2D structure (probably) any combination of for and while any combination of while as long as one loop is correctly nested inside another. Many methods in OO objects are somewhat trivial eg accessor methods like String getName( ). Suggest to student to include more complex methods to claim mastery. Implementing a bubble sort or binary search clearly satisfies non-trivial. Allows claim for 9 & 10 if appropriate. The parameter(s) should be used sensibly inside the body of the method.

1. Arrays

2. User-defined objects

3. Objects as data records

4. simple selection 5. complex selection 6. loops

7. nested loops

8. user-defined methods

9. user-defined methods with parameters

Richard Jones & Andrew Meyenn, Aug-08; [Link]

Page 5 of 7

10. user-defined methods with appropriate return values

11. sorting

The return value should be used by the calling statement and the parameters used, as for 9. A non-trivial example of this mastery aspect also satisfies aspects 8 and 9. Accept reference to array as parameter; implementation of bubble, selection or insertion. Possibly Return 1 or 1 or true/false to indicate success (use of a flag). Linear or binary can be implemented. Sequential file or direct access; text or binary file. JETS covers: Math, file I/O, [Link], [Link], hence any use of other Java libraries is allowed here. input(x) while (x != -99) { do this input(x) }

12. searching 13. file i/o 14. use of additional libraries (not in JETS)

15. use of sentinels or flags

Note: the term Library in factor 14 allows students a great deal of scope to utilise appropriate features of Java without needing to directly implement the code. For example, a student could use the [Link] method and claim mastery, but they could not also claim mastery of factor 11 as they have not written the code.

Richard Jones & Andrew Meyenn, Aug-08; [Link]

Page 6 of 7

HL Mastery Factors
The table below outlines the 15 mastery factors of which students must satisfy 10. Students are penalised 10% of the final dossier mark for each factor missed. There is some level of subjectivity in judging non-trivial. This is addressed in the explanation part of the table and also in a subsequent activity. Non-trivial use would normally be satisfied if the problem is reasonably sophisticated and the mastery aspect is implemented for a reason that is linked to solving a logic or processing issue and not just included to artificially satisfy a mastery claim. 1. Adding to a Random Access File 2. Deleting from a Random Access File 3. Searching in a Random Access File 4. Recursion Sequential Text files are not acceptable. Must use seek( position) in an instance of the RandomAccessFile Class. As above. Deletion by flagging a deleted file or by packing and reclaiming, either is acceptable. As above. Recursion should be clearly required, properly terminated and not a simple iterative routine implemented recursively. Binary Tree insertion or traversal and similar examples are acceptable. Note: the structures need to be sorted (a merge Sort does not qualify). Merging 2 sorted arrays or 2 sequential files into one structure or file. Use of overloading or overriding that is implemented directly by the student. Simply using overloading or overriding of inbuilt Java classes would be not usually be acceptable. Could be linked with factor 7, 8 and 12 to 15 depending on the implementation of the ADTs. Students needs to use their own class tree or extend a Java class. E.g. a GUI that is extended from a JFrame would be acceptable. Intention is that the student implements a hierarchy of some sort. Passing some data to an inbuilt Java class and using an inbuilt method is not appropriate. Student must implement their own encapsulation. e.g. defining a class for a node of a linked list along with the required methods would allow the student to claim this factor and potentially factors in 12 to 15 for ADTs. Use of the BufferedReader of other data stream handling class. StringTokeniser used with a file would be appropriate. [Link]() could be used.

5. Merging sorted data structures

6. Polymorphism

7. Inheritance

8. Encapsulation

9. Parsing a text file (or other stream)

Richard Jones & Andrew Meyenn, Aug-08; [Link]

Page 7 of 7

Composite data structure refers to a data structure that combines other structures into a single structure. Class node { int x; String n; int m []; node left; node right; } Class node defines a data structure that is a composite of five other data structures. The IB does not require the structure to be a tree, it can be an array or list with at least one element being composite. The same rules apply as for SL, but in HL a student can claim any 5 SL masteries for ONE (1) HL mastery factor. Applies to stacks, queues, linked lists, binary trees, hash tables etc. implemented using either arrays or dynamic structures. See below for further information and also refer to the Computer Science Guide pp 66-67. Other ADTs are obviously possible, it is suggested that students work to include only those listed above. It is important for the teacher and student to appreciate that the code needs to be written not just instantiation of existing Java classes.

10. Hierarchical composite ds

11. Up to 5 Standard level mastery factors

12. Up to 4 for implementing a user-defined ADT

The May 2006 Subject Guide has a great deal to say about mastery aspects and gives examples of acceptable and acceptable practices. A copy of this report is available under the useful files from the OCC link in this workshop.

Richard Jones & Andrew Meyenn, Aug-08; [Link]