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. Still in the terminal window, 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 all tests will fail and 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. Review 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. On MPs adn WAs, 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 a single function or just a few with teh
description broken into pieces of the functions. It is
still worth your while to do incremental submissions.
-
A typical test in the tests looks like:
TEST1ARG(1, cube, 5);
The number between TEST
and ARG is the number of arguments the
function being tested takes. The first component of the
triple passed to TEST1ARG is the number of
points you wish to give to the problem. This usually is
1, but might be 0 if it is a test checking that the code
compiles as it should. The second component,
here code is the name of the function to be
tested. The third component is the expression that will
be evaluated and have its value passed to the second
component. That is, the above test causes each of the
solution and your work to compute cube 5,
compare the results and return 1 if the results
are the same (or in more complicated instances
equivalent by a notion of equivence specified in
the tests file), a 0 otherwise. You
are encouraged to add more tests to the tests
file. A word of caution, though. If you put in a bad
test, it may tell youthe Solution is broken, when in
fact, it is your test.
-
When you are satisfied with your code and it no longer
generates any errors for the problem on which you were
working, go back to the webpage with the problem
statement, and press "Save & Grade" one last time to
be sure it has been saved, and then return to the
assessment main page to 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 some problems with the stub version originally
provided, or incomplete but still able to compile), you
will need to submit your code to PrairieLearn.
|