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 perfectly 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 because you know what your tabs look like, you know what your code looks 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 (and add A for the other one). 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 different 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.)

Screenshots: 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 of Netbeans.

Code to paste in: At least one template class (if you have an OOP designed project).

And note in terms of the question of whether you should paste in code or write pseudocode, that question is more for your main algorithms section - below. For OOP template classes, and places where you used certain data structures, simply pasting in code is the way to go.

And don't paste in all of your template classes, one should be enough to demonstrate you did them correctly, and via what you write, that you understand what they are and why you used them, in terms of OOP concepts.

So, for example:

"..... using OOP principles, I made two template classes, asdfasfasdfas, one of them is as follows asdfasdfasfaasd:"

And then talk about the purpose of the class above, and the methods etc.

Such as:

"...... as you can see there is one get and one set for each asdfasdfsdfasdfsadfsadfsad"

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.

Screenshots or code pasted in: Maybe just a screen shot, or copying and pasting of an ADT if you have one, or your array of objects. Something like:

"....here is where the LinkedLists are made......"

"....and here is where the studentList is added to. The lines after just clear the GUI fields to prepare them for.....

5. The Rest of your Algorithms

(This is where the question of pseudocode or paste in code comes into play - see Step-by-step Pseudocode vs Actual Code section below.)

What: I used to suggest focusing on your most original parts of your program, and steering away from standard algorithms like searching and sorting, or simple algorithms like calculating an average. But looking at the way that Criterion C has gone over the year, and in particular looking at the latest exemplar, I now think you should put in **almost all** of the rest of your code that you, yourself coded. (Though NOT Netbeans auto-generated code, or any other code you just copied and pasted.)

Obviously there's a happy medium, and not all IAs should be treated the same way. You don't want your Criterion C to be 47 pages long. So if you've got tons, and tons of code, pick and choose what goes here - pick the most unique, and complex, and "ingenious" parts of your program.

But for those with a fairly straight-forward database, then arguably all of the rest of your code not already in C to this point should go here, along with explanations of it. And do keep in mind that putting together database features is not trivial. So you can talk about how you are creating array or ArrayLists etc. of objects to store it in RAM, and if you can save it to a file or to an SQL database, for sure talk about that too. If you've implemented sorting and/or searching, talk about the technique you chose to employ, and basically how it works. And one way or the other, you should talk about how the different classes and interactions between them accomplish all these things, along with how the GUI elements of Java Swing assist in the input and output of it all.

The narrative part is as important as the code you did and pasted here. And you've got up to 1000 words to use, though keep in mind the 2000 word limit, and what word count you are at now, with E still left to do.

Step-by-step Pseudocode Versus Actual Code?

The question remains - especially with this part - whether it is better to use pseudocode for Criterion C, or to paste in you actual code. Refer to the sample IA, to see the pseudocode approach, and add the A to see the latest exemplar with an actual code approach.

One way or the other, you are to demonstrate what techniques you used, and that you know why/how you were using them. There is a good argument to be made that you writing your algorithms here in pseudocode (as in the original IB example) is the best way to show that you understand what you did. And the other point here is that they can always look at you code listing links to see the actual code.

On the other hand, C is mainly to demonstrate the level of complexity of your program, and if you paste in your code, and explain it well enough that it is apparent you knew what you were doing, that should work too.

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.


Something like:

"Refreshing the tables:

..... I refresh the tables to..... and the way I do it is....."


.... here is an example of one of my sorting algorithms.... I used the asdfasdasdf sort, which sadfasfasdfsdfas....."

And so on,

and so on,

and so on,

for most if not all of the rest of the code that you yourself coded (NOT Netbeans auto-generated code.)

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

Such as:

"..... I used Netbeans, which includes tools for making various asdfasdfasfassadf, using asdfasdfsa, and you can change the properties asdasasdfsd...."

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 in-service, 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.