You are designing a software system for giving computer-based exams. In particular, you must provide:
A language for specifying exams, and
A program (interpreter) that will give (aka "run") an exam written in your language. Giving an exam entails asking students questions from the exam and reading in their answers. It can also involve giving students progress reports (i.e., what percentage of questions they got right), either at the end or during the exam. Since this is a computer-administered exam, your system should also be able to skip or change questions based on how a student is doing on the exam.
The language you provide would be used by a teacher to write down an exam that your system would then give to a student. The teacher specifies (in the program) which questions to ask, when to skip questions based on past results, when to print summaries of a student's progress, and when to print other messages to the student. Your system (interpreter) "runs" this program to administer the exam to a student.
Your system (language and interpreter) should support the specific exams and interactions shown on the sample exam page.
You will do the project in two stages: a design stage, followed by an implementation stage. Each stage has a separate due date, as described below.
The goal of the project is to make sure each student can define, design, and implement a domain-specific programming language within a software project. This is an individual project -- you may not work with your homework partner, or any other students, on this project (see the collaboration policy for more details).
For this phase, you must propose a language design for electronic exams. You must submit both the proposed language and Scheme expressions showing how to represent the sample exams in your language:
For the proposed language portion, submit the data definition(s) that you need to write down exam programs. The design should be sufficient to capture the sample exams.
For the examples, write both sample exams in your language.
You do not need to be able to give exams at the end of this stage. In other words, you do not need to implement the interpreter until the next stage. For this stage, we are only asking for the data definitions (the language) and examples of data (how to write the exams in your language).
Not sure how to start? Design phase suggestions.
Submit an electronic file design.scm or design.ss (under turnin name project-design) containing your work for this phase.
For this phase, you must provide a function give-exam
that, when run, administers an exam to a student, outputting any
progress information that the teacher specifies in the exam program.
This program should consume an exam (as you define it in your data
definition) and return void. The sample
exams page show an acceptable format for interacting with students
during the exam. You may design another as long as it conveys the
same basic information.
We expect that you will revise or enhance your original language design as you try to implement the language. That's fine. Your project report will describe all changes you decided to make.
Warning: This phase is going to take you longer than you think. If you start this the weekend it is due, you're unlikely to finish enough of it to pass the project. One week into the implementation phase, you should have enough code working to ask the questions and read the answers, even if you can't skip questions or print summaries.
Provide a text file with answers to the following questions:
What must the TA do to run your program? Provide concrete instructions (such as "execute (give-exam exam1)") for each of the two sample examples. The TAs won't grade a program that they can't run.
What is the state of your implementation? Explain which features/aspects work and which don't. If you didn't get progress-based question skipping to work, for example, say so. This gives the TAs guidelines on how to test your system.
How have you changed your design since the version you submitted for the design deadline? Explain the changes and why you made them (i.e., I found I couldn't do X because of problem Y with my earlier definition). We're interested in seeing what doing the implementation taught you about the language design.
What, if anything, do you think could be cleaner in your design or implementation? If you are satisfied with your design, say so. If you think certain aspects should really be easier to use, easier to write, etc, explain those aspects and what you'd like to see different. No danger of losing points for honesty here (you'll only lose points for problems that we detect without reading your report) -- we just want to hear your assessment as we determine our own.
A file exams.scm or exams.ss containing your work for this phase.
A file report.txt containing your project report. Please submit these in plain text, rather than in Word format.
Submit these via turnin, under the name project-final.
In general, the design phase counts for 25% of your project grade, the implementation phase (including final language design) for 70%, and your project report for 5%.
We will grade your language designs on a 4-grade scale (check+, check, check-, no credit). At this stage, we're looking to see whether you thought out the design phase well -- did you identify appropriate data, control, etc? Does your design adequately support the sample exams?
There's no single right answer for this part, and while we will make suggestions on your designs, we won't give you a single right answer to follow when doing your implementation. Part of the exercise is for you to have to work with, and perhaps revise, your initial language design when it comes time to implement your exam system.
In the implementation phase, we will be looking at your final language design and its implementation. More specifically:
A passing (C) grade on the project requires a reasonable language design that captures almost all of the sample exams (but not necessarily the ability to skip questions) and a give-exam function that correctly processes the (smaller) portion of the language that you're specifying.
A grade of B requires that you satisfy the requirements of a C grade, but also support the ability to skip questions. The final language design also has to be fairly good (meaning the design should organize the elements of the language well, not use dummy values to hack around poor design choices, etc).
A grade of A requires that you satisfy the requirements for a B grade, and that you provide a cleaner, macro-based interface to your data definition for exams. You should also have a very good language design for an A.
We will not grade your user-interface based on its visual appearance. Simple text I/O is fine for this assignment. In contrast, adding features while your program isn't yet robust will cost you points.
We will grade your report for writing (complete sentences, spelling, punctuation, clarity, etc) as well as technical content.
We will look for whether you followed good coding practices, such as uses of helper functions, in your prototypes.
We expect you to follow the Laws of Homework on this assignment, with the exception that you may use I/O primitives, begin, and set! where appropriate. Contracts are expected. You do not need to include the test cases for the individual functions (but we hope you are testing as you go along nonetheless).
For I/O in Scheme, you will most want the commands (all documented in the help-desk):
Example:
(define (age-to-year)
(begin
(printf "Enter your age: ")
(let ([age (read)])
(printf "You were born in ~a or ~a~n"
(- 2001 (+ 1 age)) (- 2001 age)))))
This is an individual project. Collaboration is not permitted on this assignment. The course staff are the only people you may approach for help with this project (but do come to us if you need help). You may not ask anyone outside of the course staff questions on any aspect of this project. This includes:
Violations of this policy follow the general course collaboration policy, and may result in an NR for the course.
Why this policy? Given the fairly open collaboration policy on homeworks, this assignment helps me assess how much each student understands of the course material. Since some students struggle in timed situations such as exams, the project gives you a more open-ended setting in which to demonstrate what you've understood of the course material.