Hi!

My students in IB2 are currently planning their programs. One of the things which I ask them to check before they begin to write their programs is that they will meet a sufficient number of the mastery requirements. So, they have started asking me questions about what qualifies as mastery and I realize that I still have a lot of questions. I hope that someone can clarify some of these points for me.

SL
#11 Sorting. If a student inputs information for one record at a time, then inserts it in the file in the correct location, by rewriting the file and inserting the new record, does this count as a sort? (similar to an insert sort and has the effect of sorting)
#14 Use of additional libraries. I am not completely clear on which libraries would count as additional ones. I do not see AWT listed, so if a student uses a Frame would that satisfy this criteria? If not, is graphing sufficient?

HL
#6,#7 Polymorphism and Inheritance. Must a student create a class and then another which inherits from the first to achieve these masteries. Again, when a student uses a Frame or a JFrame they use inheritance and in virtually all cases, they will use polymorphism if they use commands like setBackground. This seems too simple to qualify as a mastery, so I would appreciate more information.
#8 Encapsulation. Again most classes that would be created by a student would have encapsulation. Is this all that is required? More information would be appreciated.
#12-15 Some of these also seem unclear to me. For example, if a student implements a stack by means of dynamic memory, to achieve two aspects it states that methods must test for a full stack. Can I assume that this is not necessary when using dynamic memory?

With the basic criteria, I am still not clear on how a student would provide evidence that information relating to the problem has been collected when they are doing this for a friend or relative and most likely have had just conversations with them. Do they just summarize the conversation?
Any help and suggestions would be appreciated.

Thank you in advance.
Lynne Mochon
Greengates School
Mexico City

Very good questions - I suspect these issues are still unresolved, and will be worked out during the first moderation process. The only one that seems clear to me is the sorting (see below). I'll give you opinions about the others, but there are no guarantees these are "correct". Sorry, I probably wrote too much.

First a couple general comments:

- I think the HL requirements are purposely flexible (e.g. vague), to allow a wider variety of topics;

- many of the statements in the syllabus are more like "clear guidelines" than "rules";

- I think moderators try very hard to find a reason to GIVE marks, and this is much easier if the students and teachers include brief explanations of why they believe the marks are justified.

- Sorting -
I think what you described is "insertion" rather than "sorting". To qualify as sorting, an existing unsorted list should be manipulated to produce a new, sorted list. This could be done be repeated insertion, so the repetition would be part of the algorithm. It is probably fairly easy for students to repeat the insertion process until the list is sorted, then it would be a sorting algorithm. From the "mastery" standpoint, an application probably needs a sorting algorithm, as we cannot necessarily "assume" that the existing list is already sorted - something may have gone wrong at some point. So simply inserting and hoping that nothing ever goes wrong is probably not "mastery" of sorting.

- Additional Libraries -
This is intentionally open-ended, to allow students to use extra tools appropriate to their problem. raphing is a good example - some projects draw graphs, others don't. Mastery is the real issue. If a program needs to draw a graph of a parabola, but only uses single pixels making a dotted representation (not a curve), someone will need to decide whether that shows Mastery or not. Even the use of dots might be non-trivial in this case, but if the spaces are too large then the result might not be usable. This becomes a judgement call. On the other hand, if the student manages to connect the dots with line segments, as well as labelling the axes, then they have used several library features successfully and that would probably show Mastery. I would encourage students to use SEVERAL features of a library, not just one or two - but again, that would depend on the library. If they use AWT, but only use text-boxes and buttons, it might be okay or it might not. But if they use Labels and put them next to the text boxes, and use Menus as well as Buttons, it's probably fine (assuming it works correctly). The typical non-Mastery scenario is putting a single button to start an algorithm that prints in the text console - I don't think that would show Mastery of AWT.

- Inheritance -
I don't think a student needs to create their own base-class to show mastery of inheritance. The inheritance process (using extends) is the issue. So they must use "extends" somewhere - I would expect they would use it more than once. A typical failure of mastery would be to have a class the extends another class, but contains only a single data member, say a String - and then never use that String for anything. This would violate the guideline that "Non-trivial means that the programmer must demonstrate that the program benefits from the use of the aspect." It is important that the student outlines the "benefit" to the program of their use of inheritance. Although it might be obvious in some cases, it doesn't hurt for the student (and possibly teacher) to clearly state their reasons for using inheritance.

- Polymorphism -
Similar comments to Inheritance - it is important that the student outline where polymorphism is used in a beneficial way. If there are two different classes, say Stack and Queue, that use the same me "initialize" for a method, that uses polymorphism, but it might not be clear where the program benefits - e.g. why not simply call them stackInit and queueInit. Unless the student could convince me there is some advantage in using the same name for both, I probably wouldn't think they had shown Mastery. I guess that example is too simple. If the same algorithm had a choice of creating either a Stack or a Queue (called nameList), and then the same code would execute for either data-structure (e.g. it says nameList.initialize() and later nameList.addItem("..") and nameList.processItem()), then the flexibility of the code in that algorithm is a clear and useful benefit.

- Encapsulation -
I suspect the only way to fail this one is to write a program consisting of only 1 single class. If there are several classes in the program, then encapsulation is being used. If EVERYTHING is public, then it might not be clear that the program is really "benefitting". So I would guess using some private data members, with get and put methods (hopefully with some error prevention code) would clearly show some benefit.

- ADT -
Your last observation about a stack using dynamic memory not needing overflow prevention is spot on. I recall a statement somewhere that "error-handling for hardware failures and system-memory availability are not needed". Implementing a stack using dynamic memory (presumably a linked-list) will already score points in two categories, so it wouldn't need to do everything in both categories, as they can only get 4 marks anyway. The ADT section is purposely flexible - I think the specific examples are intended as guidelines rather than rules. I would certainly agree that the student should not be penalized for not preventing overflows in dynamic memory.

-------------------------
Dave Mulkey

I share your concerns about some ambiguity in some of the mastery factor criteria. I think that they will become clarified fully only after a bit of use!
One thing I have noticed which may help with clarifying encapsulation is that to qualify for encapsulation the class data must be private and used within the class; not simply acessed via accessor functions. In other words to qulaify for this mastery factor the class must do something with its private data rather than just be a data storage class.

That's a GREAT question! I hadn't thought of doing this, but it makes total sense to me. The key issues of ADTs are :
(1) encapsulation ensures that some other module uses the ADT without interfering without knowing about the actual implementation;
(2) completeness provides sufficient features that the ADT can be easily reused;
(3) the "structure" of the ADT to lend itself to re-use;
(4) error-handling ensures reliability.

All of these come down to the same thing - the external user-module (program(s) or method(s)) should not need to manipulate the data storage directly, but always use the interface methods.
So the ADT marks are for a well designed and complete interface (Front-End) with abundant error-handling.

The random-access marks are for the Back-End - the routines that do the disk access, so that is actually "separate" work - and it will probably be programmed in separate methods than the interface.

I don't think there is anything "forbidden" about the basic concept. What you describe seems like "less work" than normal (e.g. 7 mastery factors for one ADT). I suspect trouble might arise if the Front-End interface routines are too similar to the Back-End. So if the interface methods are called : SaveRecord(recnum), ReadRecord(recnum), SortRecords(), etc, then each interface routine connects directly to a back-end method, so there isn't really enough "work" going on - the main program is actually manipulating the data storage pretty directly. But if the front-end and back-end routines are as you describe, then I can't see anything wrong with this. Of course, it also takes care of encaspulation - an 8th mark. It will also contain 5 SL factors (loops, etc), so that makes 9. I guess if uses a recursive binary search, you can get all 10 mastery factors in this one class.

I really like this idea - it encourages students doing the "right thing", more like real programmers. It seems a bit precarious - sort of "all your eggs in one basket" kind of thing. I guess you'd want to emphasize that they must be very careful to do everything correctly - it would be all too easy to lose that 4th ADT mark for handling "all error conditions".

I guess I always assumed the ADTs would use main-memory for storage, rather than persistent storage.
But that's not really a requirement.

-------------------------
Dave Mulkey

Edited: 23/11/2005 at 06:54:41 AM by Dave Mulkey

Can I please ask you to clarify: when you say "binary IO", is that the same as working with a RandomAccessFile? I have a student wanting to write a program using a RandomAccessFile as a HashTable, working with the data directly in the file rather than reading it into a separate data structure. Other than the issue of access time (read/write to disk being slower than to RAM), can you see any big problems with this?

-------------------------
Ståle Brokvam
IT teacher
International School Manila
Philippines

Edited: 22/11/2005 at 06:45:56 AM by Staale Brokvam

My students are coming up with interesting questions about Mastery Factors and ADTs. In general, they are using linked lists:

Would they be able to claim 2 aspects if they implement methods to add at the tail and head, but not remove? Initially, I advised them to implement the 'remove' methods, even if they are not used. They pointed out that the mastery factors are supposed to be 'appropriate'. Any opinions about whether they can claim this second mastery factor and whether or not they should implement unused methods (perhaps in the spirit that it could be reused later).

Also, a student wanted to claim 3 aspects of the linked list. However, in his program, he would never encounter an 'empty list' or a 'dual element' because he pulls his data from a file that has been set up to prevent these kinds of problems in the first place. Again, I suggested that he check for these kinds of errors anyways 1) as a safeguard and 2) to promote reusability. Would this be appropriate or should he just forget about the 3rd mastery factor?

Finally (similar to the above question) another student wants to go for the full 4 aspects. There is a long list of suggested methods for 4 aspects of a Linked List. Is it enought to implement these methods even if he actually uses only a few or even none?

Cheers, Keir