Criterion C - Development

Instructions and Advice


First of all keep in mind this important point:


You should write your Criteria C as if things work as planned. You are discussing the techniques you used, regardless of whether you got them to work or not. 

You can talk about Netbeans without your program working. You can talk about arrays without your program working. You can talk about GUI without your program working. Etc. etc. In C, you talk about all the things you did, regardless of whether or not you got them to work.

If the program never does work as planned, fine. But that is addressed in two other places, not in C. Those two places are: 1, with a lost point or two in Criterion D, and 2, in your evaluation of Criterion E (and no points gained or lost, regardless of planned functionality or not.)


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.

This is important, not just because it is required, but because it will “keep you honest” with not writing too much or too little; you can keep track as you go, rather than being surprised, and in a fix at the end.

(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

General Advice / Style

In terms of the general style of this, and E as well, let me paste this general advice from the Miscellaneous Points page:

Pictures, pictures, pictures. Screen-shots, screen-shots, screen-shots. I think there is a tendency to not do enough of this becuase you know what your tabs look like, you know what your GUI looks like, you know what Netbeans looks like, etc. But your reader does not (or does not necessarily). And a picture is indeed worth a thousand words in a lot of cases.

Keep in mind that programmers and computer science types are more used to graphical, non-narrative communication than you are. You are not writing a book here, or an essay, you are communicating things about your IA and your IA process in as good a way as you can, and the more image-based, or image like (bullet points, diagrams, tables and so on) the better.

See the "Richard Mulkman" Example from IB example for Criterion C for sure. Don’t worry about the particulars; rather just note the visual style of it; it’s not at all a narrative form, rather it’s a real mixture of graphical communicative styles - very visually varied.

The biggest point here: Less Narrative, More Visual

And particularly for this, and B also, where there are many differnent sections, Do Definitely have titles, and format them somehow so they stand out, look nice, and are consistent.

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. Do title this section "Introduction".

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)
And as for the titles of your section, do title this one "Structure of the Program", and also you can certainly use the "What" and "Why" as sub-titles, too.

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."

For all of this, you would be wise to BOLD or underline KEY OOP terms, to draw attention to the fact that you are indeed making the connection to what you have learned in class.

*** 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 DON'T DO VERY MUCH NARRATIVE here. Rather, step-by-step pseudocode should be used for the schmancy algorithms, or even schmanciest part of basic database algorithm. (Refer to the sample IA.)

You can also take screen shots of your code, but this should assist the description of your algorithm, rather than just being a "copy and paste, here it is" approach. They can look at your code in your code. Here you are trying to explain in easy to follow phrases what you did and how you did it.

----> Key Point <----: So rather than long paragraphs with long, hard to follow sentences, and rather than just copying and pasting your code, this should be a pseudocode, or bullet pointed, or series of short bulleted sentences which is you describing in a way that is easy to follow what your schmantzy algorithm does and how it does it.

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.)

But don't just "talk", i.e. write, SHOW. There should be at least a few screen-shots of limite size highlighting some of the GUI stuff you have taken advantage of; again, remembering that not everybody and his dog used the GUI approach.

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. Still, this is what keeps good students from getting IA (6s and) 7s that they may be able to get in the exam portions of the course.

As a guide for what will get you up to the 7, 8, 9, range (out of 12), 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.

But to get up even further, to the 10+ range is both very difficult, and rare. This is where it turns out that over the past few years my students grades must have been moderated down by two or three marks. As was clear during my November 2020 IB inservice, the level of these top Criteria C are way above what can be covered in the two year IB CS course itself. Web applications and interaction with online databases is likely the most common way some students are able to get to this level, or the use of any industry level sophisticated frameworks to add functionality much beyond a local database.

If you do start to add lots of extra features and use lots of extra libraries, remember to add them to your actual Netbeans project folder hierarchy; don't link to them outside, like on your Desktop or Downloads folder, because when you link your project in the IA submission, those files will not be accessible to anyone trying to run your project.