A guide for how to attack an MP:
- For each problem in the assignment, go into the VSCode Workstation
for the problem, and start a terminal window. To make sure you have
all the necessary pieces, in that terminal window, start by
executing make. This will create the grader
executable. Run the executable (./grader). Examine
the failing test cases for places where errors were produced by your
code. At this point, everything should compile, but the score will
be 0.
- Read and understand the problem from the assignment on which you
wish to begin working. (Usually, working from top to bottom makes
most sense.) There is a tests file in this
directory. This is an important file containing a partial set of
test cases; you'll want to add more cases to test your code more
thoroughly. Reread the problem from the main webpage for the
problem, examining any sample output given. Open
the tests file in the
WORKSPACE directory. Find the test cases given for
that problem. Add your own test cases by following the same pattern
as of the existing test cases. Try to get a good coverage of your
function's behaviour. You should even try to have enough cases to
guarantee that you will catch any errors. (This is not always
possible, but a desirable goal.) And yes, test cases should be
written even before starting the implementation of your
function. This is a good software development practice.
- If necessary, reread the statement of the problem once more.
Place your code for the solution
in problem.ml
(or problem.mll
or problem.mly as specified by the assignment
instructions) replacing the stub found there for it. Implement your
function. Try to do this in a step-wise fashion. When you think
you have a solution (or enough of a part of one to compile and be
worth testing), save you work and execute make and
the
./grader again. Examine the passing and failing test cases
again. Each failure is an instance where your code failed to give
the right output for the given input, and you will need to examine
your code to figure out why. When you are finished making a round
of corrections, run make, followed by ./grader
again. Continue until you find no more errors. Consider submitting
your partial result so that you will at least get credit for what
you have accomplished so far, in case something happens to interfere
with your completing the rest of the assignment. You can submit one
problem at a time in earlier assignments. In later assignments,
problems tend to be pieces of functions. It is still worth your
while to do incremental submissions.
- When your code no longer generates any errors for the problem on
which you were working, return to steps 3) and 4) to proceed with
the next problem you wish to solve, until there are no more problems
to be solved. Each problem is submitted in PrairieLearn
indepentantly of the others, but some later assignments have only
one problem.
- When you have finished all problems (or given up and left the
problem with the stub version originally provided), you will need to
submit your code to PrairieLearn.
|