Logout

Criterion B - Solution Overview

Instructions and Advice - Chronological Development


This part of what I'm suggesting you to do is another step that is not referenced in the actual IB IA guidelines, but it's a good idea done in the sample IA (here's a link to that pdf ).

On page 4 of the sample IA you'll see his "Development Plan", which I would add the descriptor "Chronological" to. The idea here is to look at all the other preparatory things you have so far done in Stage B and figure out all of the different steps of programming you now have to do. And since some steps will naturally have to come before other steps, the first thing to do is determine the order of these steps.

 

General Intro

Generally, as with doing an outline in Word, come up with your general/major steps, in order that they should best be done.
Then "flesh out" these steps, in the same general way that the sample is done, with two major kinds of things:

For all of this, be careful to use a bulleted list for this, the same as in the sample.
And in fact, DO NOT write sentences, otherwise they will be included in your total word count.

 

Two Approaches:

I am suggesting there are two good approach to this. And in looking at past IAs, you'll see that both approaches, and a combination of them have been done before. One approach gets you to write actual pseudocode, if you think you're ready for that, and the other is a more general listing of programming steps as you anticipate them.

 

Approach I - Pseudocode of Algorithms


- Pseudocode: pseudocode is "false" code, i.e. not actual Java code that can compile, but a simpler version typed anyway you want, all the way from almost Java, to pretty well just English

- Algorithm: a step-by-step solution to a particular problem

* Keep in mind that it is very possible that this will be too much at this point for many students, and that's fine. But for those who have sophisticated algorithms that they can talk their way through, this is a very useful step.

Here's an example of this approach, with a style which has more English, than coding, bullet points:

....

....

Adding Teachers to a Queue

Sorting of Teacher Queue

....

....

etc.

 

And here's the same example, only with a style more toward Java than English. Note that it's still kind of a mish mash of English and code, but one way or the other, as above, it's a way to think through the algorithm in a "low stakes", "don't need it to compile without red squigglies" way.

....

....

Adding Teachers to a Queue

Sorting of Teacher Queue

....

....

etc.

 

 

Approach II - General Steps Only

If you can't get your head around actual step-by-step algorithms, then another approach is to do what will end up being kind of an "anticipation of your Record of Tasks". So rather than recording what you do as or after you do it, this will be planning your steps ahead of time. And in the end, it will indeed likely be similar to your Record of Tasks, at least through the programming stages.

With this approach, add in the time you expect each step, or at least each major step to take.

So it would look something like this, but a lot more detailed than this simple example:

 

Final Points

Firstly, you may want to do a hybrid of the two approaches suggested above, and include an algorithm or two, to one degree of depth or another, within the step-by-step outline plan. I would encourage this approach, if anyone would like to take it.



Do take a look at past IAs to see examples of both of these approaches, and realize that to one degree or another, most of them would have been a bit backward engineered. There's only so much you can see ahead in the future, so do your best to come up with what you can. And all of this thinking will be extra sorting out in your head how you will approach your programming.

Also note, that would be a good idea to partner up to share/discuss this with someone else. Talking things through always seems to help you get things organized in your head a bit better.