Criterion C - Development

Instructions and Advice


Please do include a word count for the complete Criterion C. And remember throughout this, you are aiming for between 500-1000 words (of the total of 2000 words), so choose your words carefully.

(Overall key point from past grading: In order to achieve high level of complexity and ingenuity, at the very least you should be sorting and searching if using a database at your core. And you should be using ArrayList etc., rather than a self-made linked list etc., and there should be some sort of original, non-database, algorithm, which is hopefully at least a bit "ingenious". And remember, SL/HL does not count here; everyone is compared to everyone else in terms of complexity.)

Criteria C - Development

1. A short introduction (a sentence or two) about how you used Netbeans to develop your Java program, and you used Java's Swing tools for making a Graphical User Interface. And maybe a bit, again about what the program does. Basically you introduction will summarize what is to follow in this section.

2. Summary List of All Techniques
Examples include, but are not at all limited to the following list. ***this is just to get you to see that you have actually used tons of different programming and Java techniques which you learned last year.***

- parameter passing
- random number generation
- for loop
- while loop
- do while loop
- nested loops
- recursion
- method returning a value
- arrays, 2d arrays
- user defined objects made from an OOP "template" class
- encapsulation of private methods that work on public attribute of a "template" class
- making an array of objects
- simple and compound selection (if/else)
- sorting (bubble sort etc.), and in particular sorting an array of objects based on one key attribute
- searching (linear search, binary search…)
- saving to a file
- opening a file to a table
- error handling (for example catching a divide by 0 error, or a null pointer while using an array of object…)
- Option pane generation for communicating with the user
- GUI tabs
- GUI popup menus
- Use of a flag value (such as -999, or "not set yet")
- overloaded constructors, which work differently depending on the parameters sent
- parsing a file using StringTokenizer
- inheritance between a super class and a sub class
- use of some other specialized library you imported
- linked list, or any other ADT, like binary search tree class...
- …and then all of the specific things you did with your ADT, like "add", "check to see if it's empty"…

So, basically everything you did in your program. This is what will mainly determine how complex your program was.

3. Structure of the Program (including OOP Design)

What: Here, write about your class structure, explaining generally how each class interacts with each other. Probably a central feature of this structure will be the GUI class. (Though if one of the schmantiest parts of your program is the interaction between different GUIs, for example, you could save the discussion of this interaction for the "Main Unique Algorithms" section below.)

Why: So why did you choose to split up your program into different classes. (We talked about this early on last year.) And why did you choose to divide up the tasks of the different classes the way you did.

Part of what will come out of the above "why" is the fact that you did indeed develop an OOP program, so here you need to discuss the benefits of OOP design, particularly vis-a-vis being able to make multiple instances of the same kind of object, and the fact that via encapsulation the attributes of that "template" class can only be manipulated the way that its public methods allow, etc., etc. (Try to remember all that you learned about this, and refer back to notes and homework assignments if you need to - which, given how long it's been since we talked about these things, you should.)

And if you have got your head around the concept of abstraction, it would be great if OOP as a means of abstraction entered your discussion here too. Remember a key point made several times last year, quoting from the IB syllabus: "Sub-programs and objects support abstraction, which facilitates: ease of debugging and maintenance, reuse of code, modularity."

*** And do note that this is the only place you will likely talk about using OOP and "template classes", and object instances of them, so make sure you convey here that you are doing so and how it's Great!! (Remembering that to many programmers, they are very impressed by those who have mastered OOP programming, as you have.)

Screenshot potential: If you have more than a couple of classes, for sure do include a screen shot of your classes as they appear in the projects tab Netbean.

4. Data Structures Used

What: Here, you should talk about all non-primitive programming components. These include:
- arrays,
- arrays of objects,
- ArrayList, and/or LinkedList
- files,
- any ADTs you might have custom made, particularly linked lists or trees (It is unlikely you would have done this, since you could have used ArrayList or LinkedList.)

Plus, you could have a section titled, or a sentence or two about, "Use of User Defined Objects", and here you would discuss where and how you used instances of object of classes you created, including if they ended up being in arrays.

Or at least write a sentence conveying the fact that you used objects of a template class. For example, "I used an ArrayList of Student objects. Each object of the Student template' class consisted of 8 attributes such as name and address."

Why: Discuss why you used each of the above. Since it will be mainly arrays, ArrayLists and arrays of object you will be talking about here, go right back to the time where you had never even heard of arrays. Imagine life without arrays in programming - there would be a lot of copying and pasting and so on! You learned about arrays in this course, and so here is where you show how you understand how they work and why they were useful to use for you particularly in this program.

And if you did implement a list or tree, then go back to the notes on those to find good ways of explaining why they offer advantages over arrays.

Screenshot potential: Maybe just a screen shot, or copying and pasting of an ADT if you have one, or your array of objects.

5. Main Unique Algorithms

What: Do not go over standard algorithms like searching and sorting, and don't do simple algorithms like calculating an average. Rather, look through your program for the parts that are most unique. Certainly if you have a schmancy, sophisticated algorithm that is central to the functioning of your program, go into lots of detail explaining how it does its magic. More likely, since you may not have anything too original outside of your database features, remember that that's not a trivial thing to put together. So your algorithmic section here should be mainly a discussion of how your database works, from the input, to the storage, to the fact that you are using an array of objects to store it in RAM, to how you go about saving and then opening it; how it will be sorted to be able to be searched efficiently, and all about how the different classes and interactions between them accomplish all this, along with how the GUI elements of Java Swing assist in the input and output of it all.

Part of this can be in narrative form. But step-by-step pseudocode should be used for the schmancy algorithms, or even schmanciest part of basic database algorithm. (Refer to the sample IA.)

If you do have a schmancy, sophisticated algorithm, do also write up a bit about the database side of you application, which you may very well also have, but be briefer than the above paragraph would have you be.

Why: The difference between the what and the why in this case is a bit more tenuous, but in the case of a schmancy algorithm, you talked about how it works, now why is this approach so schmancy. And in the case of your database functionality, just generally, how is it that a computerized data base the way you've got it designed powerful and efficient? Maybe here mention specific parts like using a binary search instead of a sequential search.

Screenshot potential: Probably not, but pasting in a sophisticated part of your main schmancy algorithm is a good idea.

6. User Interface/GUI Work

What: Remember that not everyone in high school can work with GUI like you are able to do. Your interface will impress. So talk about the Java Swing components you used (combo boxes, tabs, etc.)

Why: Here, it should be pretty straight-forward, and there's no need to waste too many words of your word count, but come up with a good, concise reason why having your interface a GUI interface was good for the functioning of your computer; indeed good for your client.

Screenshot potential: For sure put in at least one example, perhaps more.

7. Software Tools Used

What: Keep in mind here that Netbeans is the real thing; it's one of the most popular Integrated Development Environment (IDE) used by programming professionals the world over - and you. So describe it at least a little bit. You could also mention any other tools you used, like Fujaba, Omnigraffle, Excel, or anything else you can think of that you used beyond Netbeans to do your project.

Why: Why is Netbeans so useful? And in particular, why was it both useful and appropriate to your project?

Screenshot potential: Maybe one screenshot of your Netbeans working environment.


Grading Points

This is the one where, particularly as an SL student, it should be quite hard to get what is described as "a high level of complexity and ingenuity in addressing the scenario". But you have to remember that this is a 20/30 % IA, and your first major program, so there is only so much sophistication you can be expected to achieve.

As a guide for what will bump you up to the 10-11-12/12 range, ArrayList or LinkedList should be assumed to be employed, rather than using arrays only. There should also likely be saving capabilities (dependent on the nature of your program). And there really should be a good portion of your project which is beyond the basics of database creation - though, again, do realize that for a first big program creating all that is needed for a fully functional data base kind of program is pretty darn good in and of itself.