I was storing two timestamps (as a UNIX timestamp) in the database. One designating the date-time the user logged into the application and the other the date-time of the last activity the user performed. Because I was using UNIX timestamps, which are just the number of seconds sine the UNIX epoch, I subtracted one from the other and used that difference as the input to the PHP function date().

I couldn’t for the life of me work out why the date function was saying that I was logged in for an hour longer than I should have been and it was driving me crazy. It turns out that the reason was that my timezone locale setting in PHP is ‘Europe/London’ and that this causes the date function to adjust for British Summer Time (GMT + 1) thus when I used my timestamp difference in the date() function it translated the difference into a readable format but also added an extra hour.

The solution is to use gmdate() which is identical to the date() function except that the time returned is in Grenwich Mean Time format.

Questions

The application is going to revolve around questions so there obviously needs to be a table to store some of the details of each question. Each question will need an ID it will have some question text, it will also have a correct answer.

The answers are stored in another table so the question table will hold an identifier that relates to the correct answer instead of the correct answer itself. This is because the same answer may be used more than once (TRUE / FALSE for example) and referencing the answers instead of replicating them will save space.

Some question types are complicated so there will also be instructions to go with the question so the person knows what is expected of them. Again these will be repeated several times and so stored in another table.

So the Question table would look something like;

• Q_Questions
  • ID: int(4)
  • QText: text
  • CorrectAnswer: int(4)
  • Instructions: int(4)

Answers

The answers table is much simpler seen as it only needs to store the actual answer and its ID.

• Q_Answers
  • ID: int(4)
  • AText: text

Lookup Table

A question may have more than one answer and an answer may be suggested for more than one question. This is modeled using a look up table is used. The look up table is a table that records which answers appear with which questions. This is achieved with two one-to-many relationships. The look up table has two fields…

• Q_QAL
  • QID: int(4)
  • AID: int(4)

…one that refers to the ID of the question and another that refers to the ID of the answer. Both fields are assigned as the primary key, this ensures that there are no duplicate entries. Whenever you want to associate an answer with a particular question you create a record in this table with the respective IDs. This way you can have as many or few answers associated with a question.

Instructions

Each question will only have one set of instructions so there is no need for a look up table but the instructions should be stored separately from the questions as mentioned previously so the table would look something like this;

• Q_Instructions
  • ID: int(4)
  • IText: text

Relationships

I haven’t mentioned relationships in depth in this post or the other tables of the database because I’m trying to keep each post simple and focused on one topic. I’ll go into more detail about the other tables of the database such as those dealing with multiple users and user specific tests in another post.

This is the XML document type definition I’ve come up with for the KQuestion project. The latest version will also be available at (klkl.co.uk/Kquestion/kquestion.dtd). Note: Although its not clear on this page (because of word wrapping) normally everything between each pair of < & > is on one line but it is clear in the above link.

KQuestion.dtd

<!ELEMENT QUESTIONBLOCK (SINGLEQUESTIONS|COMMONANSWERS|
MULTIPLESTATEMENTS|ORDEREDQUESTIONS)+>
<!ELEMENT ORDEREDQUESTIONS (SINGLEQUESTIONS|
COMMONANSWERS|MULTIPLESTATEMENTS)+>
<!ELEMENT SINGLEQUESTIONS (INSTRUCTIONS,(QUESTION)+)>
<!ELEMENT COMMONANSWERS (INSTRUCTIONS,ANSWERS,(QUESTION)+)>
<!ELEMENT MULTIPLESTATEMENTS (INSTRUCTIONS,ANSWERS,(QUESTION)+)>
<!ELEMENT INSTRUCTIONS (#PCDATA)>
<!ELEMENT QUESTION (TEXT,SCORE,CORRECTANSWER,(ANSWERS|STATEMENTS)?)>
<!ATTLIST QUESTION ORDER ID #IMPLIED>
<!ELEMENT TEXT (#PCDATA)>
<!ELEMENT SCORE (#PCDATA)>
<!ELEMENT CORRECTANSWER (#PCDATA)>
<!ELEMENT ANSWERS (ANSWER)+>
<!ELEMENT ANSWER (#PCDATA)>
<!ATTLIST ANSWER NUMBER ID #REQUIRED>
<!ELEMENT STATEMENTS (STATMENT)+>
<!ELEMENT STATEMENT (#PCDATA)>
<!ATTLIST STATEMENT NUMBER ID #REQUIRED>

There is very good documentation on document type definitions at W3C (http://www.w3schools.com/dtd/default.asp) you should read that if you want to know more.

This post follows the multiple choice question theme. I’ve spent quite a bit of time working on how to go about parsing an XML file using PHP. I had to pay particular attention to the structure of the XML file with reference to which elements appeared where and which were repeated but in different orders throughout the document.

I’m the sort who likes to learn by doing and having a play with things. I read a basic php xml parsing tutorial on sitepoint written by Kevin Yank (PHP and XML: Parsing RSS 1.0) it explains the process pretty well so if you want to know the specifics of creating the parser object I recommend you read that brief tutorial or consult the php manual.

When using PHPs built in XML parser there are three functions that are required:

• An element opening function which is called whenever the parser encounters an opening element.
• A data function which is called whenever some data between elements is encountered.
• An element closing function which is called whenever the parser encounters a closing element.

The openElement function

function openElement($parser, $tagName, $attrs) {
  global $SQ, $CA, $MS, $Q, $A, $answercount, $ANo, $tag;
  $tag = $tagName;  if (!$SQ || !$CA || !$Q || !$A) {
  	switch ($tagName) {
  	case "SINGLEQUESTIONS":
  		$SQ = true;
  	break;
  	case "COMMONANSWERS":
  		$CA = true;
  	break;
  	case "MULTIPLESTATEMENTS":
  		$MS = true;
  	break;
  	case "QUESTION":
  		$Q = true;
  	break;
  	case "ANSWERS":
  		$A = true;
  	break;
  	}
  }  if ($A) {
  	if ($tagName == "ANSWER") {
  		$ANo[$answercount] = $attrs['NUMBER'];
  	}
  }
}

The function takes three arguments ($parser, $tagName, $attrs)

• $parser is a reference to the parser being used to parse the document.
• $tagName is the name of the element that triggered the function (It is always returned as ALL UPPERCASE).
• $attrs is an array of the attributes that the element had e.g. if the element was <answer number=”3″> then the value of $attrs[’NUMBER’] would be “3″. (notice the case is always uppercase for attributes too).

The global statement at the top of the function is important to make sure that any variables the function manipulates will be available to the other functions.

The $SQ, $CA, $Q, $A variables have been used as boolean flags in my implementation to represent whether or not the parser is within specific elements. The switch statement checks to see if the element responsible for triggering the function ($tagName) is one of the elements being monitored and then sets the corresponding flag variable to true.

The flag variables are required because the same elements do not always appear in the same order in the document type definition so it is important to know which elements the parser is in when dealing with the information it will later glean. The $tag variable represents the last element that
triggered the function.

You can see that the $A variable is used to track whether or not the parser is within an answers element. The answers element contains answer elements (See MCQ XML). The last bit of the function stores the ‘number’ attribute of each answer element in an array I’ve called $ANo this is because the CORRECTANSWER element is a relative reference to the number attribute of the answer elements.

Once the answers are put into the database the relative values in the array will be replaced with unique identifiers from the database.

I’ll comment on the other multiple choice question XML parsing specific functions in other posts.

One of my objectives for Kquestion is for it to be able to parse and generate an XML of multiple choice questions. That’s because I think typing the questions into a template will be a lot quicker than using the application, however, both methods should be available. I’m going talk about the different formats of multiple choice question and then in another post how I’ve implemented them in XML and then talk about the document type definition created for the format.

Isolated single questions

This type of question consists of question text and a list of possible answers. They are isolated in that the question and the answers are used only once.

Question: One plus Two equals:
Answer 1: 5
Answer 2: 3
Answer 3: 1
Answer 4: 2
Answer 5: 4

Common answer questions
Questions of this type share a common list of answers.

Question: What is the colour of grass?
Question: What colour is blood?
Question: What is the colour of a tangerine?             

Answer 1: Red
Answer 2: Orange
Answer 3: Yellow
Answer 4: Green
Answer 5: Blue

Questions with multiple statements

Questions of this type consist of multiple statements and the student must determine which statements are true and which are false then choose the answer from a list of answers.

Question: When you get a headache;
1. You should consider taking paracetamol.
2. It would be sensible to avoid sources of loud noise.
3. You will need to make an appointment with your doctor to have a hole
   drilled into your head to relieve the pressure.     

Answer 1: If 1, 2 and 3 are correct.
Answer 2: If 1 and 2 only are correct.
Answer 3: If 2 and 3 only are correct.
Answer 4: If 1 only is correct.
Answer 5: If 3 only is correct.

There are other, more advanced, multiple choice question formats that I’ve not mentioned here but I’ll cover those at some point in the future.

next time… The XML.

XML is used to store Information about something in a logical format. Information is data that has meaning and that meaning can be represented in XML via its structure. A well written XML schema should be easy to understand and follow. Data should be stored within elements (sometimes referred to as tags) whereas information about the data (metadata) should be stored in attributes.

Below is the XML structure I devised to contain the information about the different questions types discussed in my ‘Multiple Choice Question Formats‘ post. I will refer to the element that contains the different question types as the question type element but in reality the name of the question type element will change depending on the question type.

Single Questions

<SINGLEQUESTIONS>
 <INSTRUCTIONS></INSTRUCTIONS>
 <QUESTION>
  <TEXT></TEXT>
  <SCORE></SCORE>
  <CORRECTANSWER></CORRECTANSWER>
  <ANSWERS>
   <ANSWER NUMBER="1"></ANSWER>
   <ANSWER NUMBER="2"></ANSWER>
   <ANSWER NUMBER="3"></ANSWER>
  </ANSWERS>
 </QUESTION>
</SINGLEQUESTIONS>

• The SINGLEQUESTIONS element contains all the questions of this type.
• The INSTRUCTIONS element is used to instruct the student how to answer the question.
• The QUESTION element contains all the relevant information for one question. More than one of these elements can reside within the SINGLEQUESTIONS element.
• The TEXT element contains the question text.
• The SCORE element contains the score obtained for answering the question correctly.
• The CORRECTANSWER element obviously contains the correct answer
• The ANSWERS element contains the ANSWER elements
• The ANSWER element has a NUMBER attribute to distinguish it from the other ANSWER elements and contains the answer text.

Common Answers

<COMMONANSWERS>
 <INSTRUCTIONS></INSTRUCTIONS>
 <ANSWERS>
  <ANSWER NUMBER="1"></ANSWER>
  <ANSWER NUMBER="2"></ANSWER>
  <ANSWER NUMBER="3"></ANSWER>
 </ANSWERS>
 <QUESTION>
  <TEXT></TEXT>
  <SCORE></SCORE>
  <CORRECTANSWER></CORRECTANSWER>
 </QUESTION>
</COMMONANSWERS>

The elements in this example all have the same meaning as in the first example. The difference is that they are ordered differently. In the first example all the question and answer information was contained within the QUESTION element. Now because the answer set is common to all of the questions within the COMMONANSWER element is has been removed from the QUESTION element and is only listed once.

The application will understand that all questions within a COMMONANSWER element will refer to those answers. This grouping helps to prevent repetitive data being stored. If a separate group of questions all refered to a common set of answers then these would be listed in the same format as this but within a new COMMONANSWER element.

Multiple Statements

<MULTIPLESTATEMENTS>
 <INSTRUCTIONS></INSTRUCTIONS>
 <ANSWERS>
  <ANSWER NUMBER="1"></ANSWER>
  <ANSWER NUMBER="2"></ANSWER>
  <ANSWER NUMBER="3"></ANSWER>
 </ANSWERS>
 <QUESTION>
  <TEXT></TEXT>
  <SCORE></SCORE>
  <CORRECTANSWER></CORRECTANSWER>
  <STATEMENTS>
   <STATEMENT NUMBER="1"></STATEMENT>
   <STATEMENT NUMBER="2"></STATEMENT>
   <STATEMENT NUMBER="3"></STATEMENT>
  </STATEMENTS>
 </QUESTION>
</MULTIPLESTATEMENTS>

The MULTIPLESTATEMENTS question is almost the same as the common answers format. The difference is that each question has a set of statements which the student evaluates as true or false and then chooses the correct answer.

True || False && Because Of?

Another type of question I refer to as ‘true false because of’ consists of two statements which the user must decide if they each true or false. Then the student must decide if the second statement is the reason for the first.

I have decided to include this type of question in the COMMONANSWERS question type because all of the questions refer to the same set of answers (see below). Due to the design of the COMMONANSWERS element both statements must reside in one block of text (see the above example). The two statements can be distinguised by using paragraph, <p> html elements.

Question:
The day is split into a light part and a dark part.
The earth rotates as it revolves around the sun.

Answer 1: Both statments are true and the second statement is a correct
          explanation for the first.
Answer 2: Both statments are true and the second statement is NOT a
          correct explanation for the first.
Answer 3: Only the first statement is true.
Answer 4: Only the second statement is true.
Answer 5: Both statements are false.