Computer Science Projects Internal Assessment

Mastery Item Claimed Justification Where Listed Random Access File – Searching Lines P. 53 Random Access File – Deleting Lines P. 56 Random Access File – Adding Lines P. 56 Recursion Lines P. 58 Parsing a Text File Lines P. 52 Inheritance etc Polymorphism Mastery Items

Inserting data into an ordered sequential file What’s ok Not writing the entire file into RAM

Deleting data from an ordered sequential file What’s ok Not writing the entire file into RAM

Arrays of 2 or more dimensions What’s ok Must be used for a non-trivial reason

Deleting data from a Random Access File What’s ok Making the deleted file space available for re- use, so that a new record/data item can be written in its place (requires storing the record numbers of deleted items or marking for deletion). Compacting the amended file in some way so that unnecessary memory is not taken up.

Deleting data from a Random Access File What’s not Marking a record as ‘deleted’ without making any provision for its re-use.

Searching for specified data from a Random Access File What’s ok Reading sequentially through a file in order to find a record/data item whose position is not already known (therefore the seek() method cannot be used). e.g. in order to process that item / to check for duplicate records / look for ‘deleted’ records.

Searching for specified data from a Random Access File What’s not Reading the whole file into memory and then beginning the search.

Adding data to a Random Access File using the seek() method What’s ok Using a calculation based on record length and record number to: write a new record (or data item) to the end of a file write a new record in the position of a previously deleted record (data item)

Adding data to a Random Access File using the seek() method What’s not seeking to the start of a file with seek(0), and writing a stream of data to the file seeking to the end of the file with seek(file.length), and appending to the end of a file

Recursion What’s ok A method that: -calls itself with changed parameters -has a terminating condition -is a valid use of recursion e.g. traversing a tree e.g. a sort routine (justified and explained)

Recursion What’s not algorithms introduced solely to gain the mastery aspect e.g. a quicksort routine where the choice of sort routine has not been justified by the candidate algorithms introduced where an iterative solution would clearly be the preferred way e.g. searching through a linked list (not the ‘normal’ way of processing a linked list)

Parsing a Text File What’s ok Using methods such as java.util.StringTokeniser to separate strings (read in from an input stream) into different components. The different tokens (strings) would then be processed in some way. e.g. to separate lines of text into record fields e.g. reading in data from a csv file

Parsing a Text File What’s not Use of parseInt(string) or parseDouble(string) would be considered a trivial example. e.g. reading strings from a text file and converting them into integers.

Merging of two or more sorted data structures What’s ok Merging two sets of data that are already sorted. What’s not Appending one file onto another. Using a mergesort routine (data sets are unsorted).

What’s ok Extending a built-in Java class where significant changes/additions are made to the super class. e.g. extending and customising GUI classes (J Frames etc.). Creating a class, extending it to a sub-class, and making use of both classes in the program Creating an abstract class (with basic data members/methods) and extending 2 (or more) sub- classes. e.g. a currentAccount class and a savingsAccount class could extend an abstract bankAccount class. Inheritance

What’s not Extending (inheriting) a built-in Java class without any significant changes to the super- class. Creating a (super) class and then extending it, but only then making use of the sub-class (in other words, the super-class wasn’t needed).

Encapsulation What’s ok Data members that are declared as private (accessible by methods from that class only), or protected (accessible from that package), so that other classes can only access the data members through public methods in the encapsulated classes. What’s not All class data members declared as public.

Polymorphism What’s ok Method overriding, where a sub-class (or a class that implements an interface) overrides the parent class’s methods in a non-trivial way. Method overloading – 2 methods with the same name but with different parameters and different behaviour (e.g. constructors)

Polymorphism What’s not Overriding methods from a Java library file. e.g. use of methods such as equals() as in string1.equals(string2) in which the String class is simply overriding methods of the Object class.

Up to 4 aspects for the Implementation of ADT’s What’s ok It is the code (or modified code) that has been written (and extensively documented) by the candidate that will gain credit. e.g. for Linked Lists, mastery marks will be awarded as follows: creating a node-style class with basic methods (constructor, get and set methods); additional methods e.g. to add / remove from the head / tail; implementing basic error-checking (e.g. trying to get an element from an empty list); addition of further methods to create a fully-functionable ADT;

Up to 4 aspects for the Implementation of ADT’s What’s not Where all the candidates from a school follow a ‘template’ approach laid down by the teacher. Using a pre-written Java library class (such as java.util.LinkedLists) to provide the methods for the student’s ADT.

Hierarchical Composite Data Structure Object which has several data members, of which one also is a object. An array of objects. e.g. linked list (or tree) of records, array of records, record where one of the fields is another record,

Use of additional libraries e.g. graphical libraries or utilities

5 mastery items from SL

Recomendations for Teachers Insert a detailed appraisal of each student in the dossier (at the beginning). Set (no pass) deadlines.