Return to Quizable.org

Quizable was written to be a quick and easy way for busy teachers to put online, deadlined, and auto-graded questions in front of their students.

Issuing questions using Quizable was designed to be similar to sending an email: type some text (your question) and click “send.” We find the usual online question systems (Blackboard, Moodle, etc.) to require too many clicks in order to pose a question. This makes regular use of these tools for online questions somewhat prohibitive.

As you'll see below, Quizable does not use a fill-in form for question creation. Instead, one composes questions via a simple text-based coding scheme. Currently, multiple choice, numerical, short answer, and drawing-type questions are possible.

To begin using Quizable, a few set-up steps are required.

To begin, go to Quizable.org and either log in or create an account for yourself.

Once logged in, you'll see two tabs, one for teachers and one for students. Under the teacher tab, you should see this:

Click the “Create a new class” link to create a class for yourself. The following screen should come up.

• For the “Class title,” fill in a course description that will always be familiar to your students, so they'll always know they are the right place.

• For “Class code,” fill in some shortish code your students will use to initially join your class. You will tell them this code in class or on your syllabus, etc.

Next, you'll return to the list of your classes as shown here.

Create as many classes as you need. Quizable is able to handle as many of your classes as needed, keeping them all separate and distinct. For now, we'll work with just the one “Astronomy 101” course.

Once you have created a class (see above), your students will interact with Quizable as follows.

First, tell your students to go to the site at www.quizable.org, and create an account for themselves. Once this is done, tell them the “class code” you created for their class (see above), in this case astr101-F13-9am. Every one of your classes should have a different class code. With their accounts, your students can “join” the appropriate class using a given “class code.”

When a student signs in, here is the main screen they will see:

If they click the “Join a class” link, they will see this form

Here they should enter the “class code” you gave them. This will connect them with the appropriate class you're teaching (and keep random other people from doing so). They can also properly identify themselves for your record keeping later.

Once done, they will become part of Quizable's grade tally for the class associated with the class code, and have access to all questions you pose for that class.

Thereafter, either tell your students to check Quizable regularly for questions you post, or communicate with them in some other manner (likely email), when you have posted new questions for them to answer.

Note by using your own “student” tab, you can join your own class and see exactly what your students will see. We find it useful to always “do” our own questions, to be sure everything is working properly.

You can see, the course code is clickable, followed by your description of the course. A “grade report” link is available for tallying all students points as per your needs. Clicking on the course-code link will bring up a list of questions current written for this course. Initially there are no questions, as shown here

but a “Write a question” link is available.

When this link is clicked a question creation form will be shown.

As per our design, there aren't many things to click on when writing a question. Questions are written by typing some coded text into “The Question” box. Currently Quizable offers multiple choice, numerical, short-answer, and draw-it type questions.

If you upload an attachment, it will be made available to your students. Images (jpg, png, bmp, etc.) will be shown as an illustration to your question. Other files (such as PDFs or doc) =will be available as a clickable link.

Be sure to set a deadline for when students need to answer this question, by clicking into the “Date” and “Time” boxes.

Now, let's write a question. With only a few clicks and a bit of typing, you'll have your question up and ready to go. Again, posing a question here is a lot like typing an email: you do a bit of typing then click “go.”

Multiple choice questions are coded with this pattern:

mc//question-text//choice1//choice2//..//choiceN//#end//points-worth//allowed-attempts//deductions-per-attempt//answer-on-expire(yes/no) 

This means to create a multiple choice question, type the following into “The Question” box.

1. mc (this is the code for multiple choice).
2. Two forward slashes like this: //
3. The text of your question
4. //
5. The first answer choice
6. //
7. The second answer choice
8. //
9. As many more answer choices as you require, each separated by a //
10. The exact word #end (to signify the end of your answer choices)
11. //
12. The number of points the correct answer is worth
13. //
14. The number of attempts a student can have to answer the question.
15. //
16. The point deduction per attempt.
17. //
18. A yes or no on whether or not the correct answer should be shown when the question expires.

That's it to composing a multiple choice question. Here is the question that was generated from the text-coding above:

This question was generated from this text typed into “The question” box:

mc//Which is closest to the Sun?//Earth//Venus//*Mercury//Saturn//#end//3//4//.1//yes

as shown here

To test your questions, simply return to your main menu (see upper right of your screen), and “pretend” you're a student. Join your own class (you'll need your course code), and test away!

Numerical questions are questions that students answer by suppling a single number (as in, the answer to some problem). Numerical questions are coded in this way:

num//question-text//correct-answer//units//allowable-margin-%//absolute-value-(yes/no)//points-worth//allowed-attempts//deductions-per-attempt//answer-on-expire-(yes/no) 

In other words, to compose a numerical question, type

1. num (the code for a numerical question).
2. //
3. The text of your question.
4. //
5. The correct numerical answer.
6. //
7. The physical units student should use when forming their answer (e.g. feet, Joules, etc.)
8. //
9. The margin of numerical error you are willing to allow for incoming numbers (type a number between 0 and 100, which will be interpreted by Quizable as a percent).
10. //
11. A yes or no on whether or not Quizable should immediately take the absolute value of incoming answers.
12. //
13. The number of points the correct answer is worth
14. //
15. The number of attempts a student can have to answer the question.
16. //
17. The point deduction per attempt.
18. //
19. A yes or no on whether or not the correct answer should be shown when the question expires.

As an example, to create a question that looks like this (with a 5% margin of error and not taking the absolute value of incoming answers)

you would type the following text into “The Question” box:

A short answer question is one where the student is required to type a few lines of text for an answer. These are not graded automatically by the computer. They are coded in this way:

to produce a question like this:

To code a short answer question,

1. Start with sa (for short answer).
2. //
3. Type the text of the question.
4. //
5. How many points the question is worth.

Note that students are only granted one attempt to answer such questions.

You (the teacher) has to do grade these answers manually. You'll know such answers need grading when next to the question in your class menu, you'll see the following (see the red oval).

Clicking on the link in the red oval will bring you to a grading page, where you can score and comment on the students' answers.

A “draw-it” question is one where the student is required to draw something for an answer. These are not graded automatically by the computer. They are coded in this way:

to produce a question like this:

where a “mini-paint” program is brought up, to be used for drawing an answer.

To code a draw-it question,

1. Start with dr (for drawing).
2. //
3. Type the text of what should be drawn.
4. //
5. If you upload an attachment image with the question, supply a yes or no here as to if the image should be placed as the background to the drawing canvas. This allows students to draw or annotate an answer over some “starting” image you supply. If you don't have at attachment, be sure this option is no.
6. //
7. How many points the question is worth.

Note that students are only granted one attempt to answer such questions.

Like short answer questions, you (the teacher) must grade draw-it answers manually. You'll know such answers need grading when next to the draw-it question in your class menu, you'll see a notification that there are ungraded drawings. Also like short answer questions, you can grade and optionally comment on the incoming drawings.

In this mode, students can submit answers to homework which are “peer review” graded by others in the class. Grading is handled using an up or down vote system. That is, every other student in the class may up- or down-vote an answer submitted by other students. As for submitting answers to assigned problems, students are to submit a link to their work (as in a Google-docs or Dropbox share link).

To code a peer-reviewed homework assignment:

1. Start with pr (for peer reviewed).
2. //
3. Type the name or reference to the first problem in your assignment.
4. //
5. Keep typing in names or reference to homework problems. At the end of the list of homework problems, type //#end//.
6. Next type the number of points that are earned if a solution is up-voted.
7. //
8. Then the number of points lost if a solution is down-voted.
9. //
10. Now the number of points given just for participating in the up/down vote process across the problem set.
11. //
12. Now the number of minutes that must elapse between voting.
13. //
14. Now a yes or no on if the teacher should also be assigned a problem to solve.

Here is an example: pr//5.1//5.2//5.3//5.4//#end//1//1//1//2//no

This will assign problems 5.1 - 5.4, one problem per student, to all students in the class, with one point earned for an up vote, down vote, or for participating in the voting process. The owner of the class will not be assigned a problem to solve.

Note that the system randomly assigns at least one problem per student.

• If the number of problems assigned are less than the number of students in the class, the system will cycle through the list of assigned problems as many times as needed until each student has been assigned one problem. In this case, some of the same problems will be assigned more than once.

• If there are more problems than students in a class, the system will cycle through the number of students, until all problems have been assigned. Some students may be assigned more than one problem in this case.

Each student is allowed one vote per problem, which cannot be changed. Submitting answers is deadlined as usual, but the up and down-voting is not.

Quizable has MathJax built right in, so typesetting an equation is as easy as embedding a little bit of LaTex into your questions. Simply put any mathematics-to-typeset between $ and $ to have them properly formed in the question.

For example, here's a multiple choice question that ask the the order of the equation.

mc//What is the order of $x+x^5-2x^2+5$?//1//2//3//4//*5//6//#end//5//3//0.1//yes