Editor

From siette.wiki.en
Jump to: navigation, search

Contents

Create a Subject

NewCourse.jpg

Modify data of a Subject

Create a Topic

NewTheme.jpg

Modify data of a Topic

Create a Item

NewItem.jpg

To create an item just select the item in which you want to create it, the type of item you want to create, fill the minimum necessary information and click on the button "Insert" to save the changes.

Modify data of a Item

Complex items

Interactives items

The use of applets to capture the student's response is advisable only in cases where the student's response is interactive or when the activity requires a manipulation or creation of objects. For example, if the answer is a picture, there must be a graphical environment for the student to draw the answer. If the response is oral, provide an environment where students can speak into the microphone and their responses are recorded on the computer.

Since, in general, specific processing is required to correct the responses, the applet must implement the procedure to evaluate the student's response and determine if it is correct or not. The assessment by the applet may be partial or total, leaving a final part of the assessment embedded in the internal mechanism of Siette.

In order to include interactive items in Siette, it is necessary to insert a given code in one of the following internal items: single answer, multiple choice or short answer ((currently, items with applets can only be used with simple answer items, or short answer items, but not multiple choice items )).

An applet is inserted into the stem of an item as a piece of HTML code via tags <APPLET></APPLET>.

<APPLET MAYSCRIPT
  CODE = "IconDemoApplet1.class"
  CODEBASE = "/siette"
  ARCHIVE= "biblioteca/sietteapplet.jar,asignaturas/demo/icon/icon.jar"
  WIDTH = "300"
  HEIGHT = "380"
  NAME = "enunciado"
>
<PARAM NAME = "IMAGEDIR" VALUE ="asignaturas/demo/images">
<PARAM NAME = "IMAGE0" VALUE ="abal17m.jpg">
<PARAM NAME = "CAPTION0" VALUE ="Abies alba">
…
</APPLET>

In this piece of code it should be indicated that the applet can interact with the script of the page (MAYSCRIPT option), include Siette's standard library for applet management(ARCHIVE = "biblioteca/sietteapplet.jar,.." option) and assign a fixed name to the applet (NAME = "stem" option). The communication functionality is implemented in the "SietteApplet" or "SietteJApplet" classes which inherit from JAVA classes, "Applet" and "Applet" respectively, which can be found in the library "sietteapplet.jar".

The following code shows the implementation required in Java. The functionality of the communication between the applet and the page support is implemented in the superclass.

    class MiApplet extends SietteApplet {
    ...
       String evaluacion() {
          if (condition1)
             return “A”;
          else if (condition2)
             return “B”;
          else
             return “C”;
       }
       void resolver() {
          drawResult();
       }
    }

The following figure illustrates how to implement the communication between the applets and Siette. When the page loads, you start the applet which interacts with the user. Then the applet calls the "evaluation()" function which should return a string.

This string is sent to the page containing the applet, simulating the response of the student, and is compared by the inference engine Siette with options that are defined when creating the item. Function "resolve()" is invoked by Siette to force the applet to show the correct solution.

From the technical point of view, communication between the applet and the page takes place through Java-JavaScript communications, which may limit the use of applets in those browsers that do not support this technology.

InterativeItem.jpg

The implementation of interactive items can be achieved using other technologies, however, in practice, they have not been implemented yet. For example, a similar interaction can be achieved with Macromedia Flash code embedded in the page of the item, provided that the code is able to interact with the JavaScript on the page that contains it.

Generative items

SIETTE allows to define question template from which multiple questions can be generated by instantiating the values of the variables of the template. Template instantiation takes place when the student is doing a test and he/she is shown the appropriate question which matches the template. Unlike conventional questions, questions that have been built from a template can be reused in the same test. The maximum number of times that the same template can be used in the same test is set when defining the question.

To define a question template you can use any programming language supported by the server where SIETTE is installed, e.g. JSP or PHP. Since SIETTE requires JSP to operate, you can be sure that the language will be available.

The first step in creating a template is to create an internal inquiry SIETTE. Then you have to edit the question and indicate the type of language you use and the maximum number of occurrences:

GenerativeItems.jpg

In order to define templates, you need to have minimum knowledge of the language, however, many of the templates are so simple that just a few programming skills are enough. Below there are some examples which can serve as a guide to build these types of questions:

Example 1

The following text corresponds to a free response question

    <%
       Random r = new Random();
       int x,y,z;
    
       x       = r.nextInt(2,5);
       y       = r.nextInt(6,9);
       z       = x*y;
    
    %>
    <pre>
      ¿Which is the result of this calculation: <%= x %> * <%= y %> ?
    </pre>


and the next text corresponds to the pattern of responses and a valid example:


    <%= z %>

The stem of this template contains two sections. In the first one, which is defined by the sequence <% and the sequence %>, appears the definition of some variables. The first line Ramdom r = new Random(); creates an object that will allow random generation, the following line defines three integer variables that are instantiated, then x takes a integer value between 2 and 5, i.e. it may take any value from the set {2,3,4,5}. The variable y takes values between 6 and 9 and the variable z is the product of the multiplication by x and y. Below there is the text of the stem itself, where the question is posed by inserting the value of the variables x and y, once they have been instantiated. To indicate that you want to use the value of these variables, you should include them in the sequence <%= and the sequence %>. Finally, you place the value of the variable z, once it has been instantiated. Therefore, the following questions can be generated from this template:

GenerativeItems1.jpg GenerativeItems2.jpg

Example 2

The following statement corresponds to a multiple-answer question:

  <%
  String[] as1 = {"green", "orange","purple","brown"};
  String[] as2 = {"blue","red"};
  String[] as3 = {"yellow","blue","black"};
  int[]    ap  = {2,3,6,12};
  
  String s1,s2,s3;
  int p;
     s1 = Random.select(as1);
     s2 = s1.equals("green")?"blue":"red";
     s3 = s1.equals("green")?"yellow":
           s1.equals("orange")?"yellow":
            s1.equals("purple")?"blue":
              "black";
     p = Random.select(ap);
  %>
  
  In order to make a particular shade of <%=s1%> paint, Mary uses <%=4*p%> parts of
  <%=s2%> pigment, <%=2*p%> parts of white, and <%=p%> parts of <%=s3%>.
  What is the simplest ratio of these pigments?

Below there are three possible answers. The first answer is the correct one, while the others are distractors:

    4:2:1
    6:3:2
    12:6:3
    1:1/2:1/4

In this question, the generation is done by random selection of colors, according to some rules. First, choose a color from the set {"green","orange","purple","brown"}. Then, choose the second color; it is blue if the first one is green and if not, it is red. Later, choose the third colour. Finally, choose the number that will be used to multiply the proportion, which is always fixed. The following example is this template once it has been instantiated:

GenerativeItems3.jpg

Example 3

Another type of generative questions is based on the definition from a dictionary of terms, which are labeled with a set of attributes. This requires the following steps:

(1) First, you should create the "corpus" of knowledge of the question, which may consist of one or more "dictionaries". A dictionary is a text file with a structure similar to the one below:

  I:                 pronoun 1p m f s
  you:               pronoun 2p m f s p
  he:                pronoun 3p m s
  she:               pronoun 3p f s
  we:                pronoun 1p m f p
  they:              pronoun 3p m f p
  am:                verb 1p s
  is:                verb 3p s
  are:               verb 2p s p
  are:               verb 1p p
  are:               verb 3p p
  John:              name m s
  Peter:             name m s
  Mary:              name f s
  Molly:             name f s
  John and Mary:     name m f p
  Peter and Molly:   name m f p
  Susan and Peggy:   name f p

The file has no reserved words besides the first character ":". You can put any sequence of characters to the left and any set of tags to the right, separated by blanks or commas. Labels can be placed in any order and must not contain spaces. There may be multiple entries if necessary. This file will be uploaded to the server, in the section "files" in the subject.

In this example, the tags or attributes represent parts of speech, gender, number and person. Labels are chosen freely. In another example other labels will be used.

(2) Then you have to create the template like this: (write in the stem)

  <%@page import="siette.util.corpus.Dictionary"%>
  <%
    Dictionary d = new Dictionary();
    d.setDictionary("demo/dictionary.txt");
  
    String gender = Random.select( new String[] { "m","f" } );
    String number = Random.select( new String[] { "s","p" } );
    String person = Random.select( new String[] { "1p","2p","3p" } );
  
    String[] attPronoun = { "pronoun", person, gender, number };
    String[] attVerb = { "verb", person, number };
    String[] attName = { "name", gender, number };
  
    String pronoun = d.select(attPronoun);
           pronoun = d.cap(pronoun);
    String verb = d.select(attVerb);
    String name = d.select(attName);
  
  %>
  <i>Complete the sentence with verb to be </i><br/>
  <br/>
  <center>
     <%= pronoun %> ________ <%= name %>
  </center>

This code does the following actions:

For example: If gender is instantiated to "f", number to "s", and person to "3p", the third person singular, feminine pronoun is chosen from the dictionary (actually tags have no specific semantics, only terms that are marked with labels "f", "s", "3p" and "pronoun" get selected, i.e. in our case it is the pronoun "she" that gets selected). The same is done with verb, which necessarily selects "is", and with noun. You can choose "Mary" or "Molly" (but never select "Peter", for instance, because "Peter" is not labeled as "f"). Thus a question which says:

  <i>Complete the sentence with verb to be </i><br/>
  <br/>
  <center>
    She ________ Mary
  </center>

(3) Now you should write the appropriate grammatical tense, so in the fields of the response pattern and the good example appears:

 <%= verb %>

File:Ejemplo de preguntas generativas 3.1.png

External items

Siette allows the use of external items. External items are those whose production is not controlled directly by Siette, but by an external application processor. This application should have a web interface, which is normally a cgi-bin program, a Servlet or a JSP page, PHP, etc.

As in the case of interactive items via applets, external items require an item which serves as the base. These basic items can be either simple answer, multiple choice or open response, and as with the items that include applets, the evaluation of items is performed in two stages: first the external application and then the base item.

To implement external items, it is enough to indicate in the field, which contains the stem of the item, the URL which you must call to make the presentation and mark the field external item so that Siette transfers execution control. Optionally, the URL can contain all the necessary parameters for the call that the application needs.

ExternalItem.jpg

When it comes to the test, the external items are considered the same as the rest of the items in Siette, but when an external item is selected, Siette calls back the URL listed in the stem. In addition to the characteristic parameters of the URL, Siette automatically incorporates two new parameters in the call; (1) url that contains the URL which should be called back by the external application once the presentation of the item has been completed. This URL includes the item identifier that receives a response (2) answer, which indicates to the application the area through which it must send the answer to Siette. (If you redefine this parameter explicitly in the call URL, SIETTE does not get overwritten) For example, in the former case the call will generate the URL:

http://castor.lcc.uma.es/siette/externo/pagina.jsp?answer=answer&url=http://polux.lcc.uma.es/siette/generador/RespuestaExterna&id=11376

Once the preview has been displayed, the external application should return the execution control to Siette and provide it with the result of the item implementation??, which is stored and evaluated in Siette according to the type of item and the response patterns stored for that item. Continuing the example, the external item response might be:

http://polux.lcc.uma.es/siette/generador/RespuestaExterna&id=11376&answer=France

In this case, the external item, having completed the submission of an inquiry, determines that the student's response is "France", and returns this value to Siette by calling url prefixed ?? with parameter instantiated answer to the value of the response. Once this is done Siette check the return value matches one of the possible response values, and (depending on item type) determines whether the answer is right or wrong just as if the item had been presented as an internal item the system itself.

From a technical standpoint, the call to the external application is done using the GET method, and application response to Siette can be implemented both by GET as POST.

ExternalItem1.jpg

External items are a good alternative when the interaction with the user is complex, or when you want to incorporate other applications or more sophisticated evaluation systems into SIETTE,for example if several steps are required to do the exercise, or if interaction with resources located on other servers is necessary. Another advantage of this technique regarding the use of applets is that it is technologically more robust since it does not use communication through JavaScript, which is why it does not have the constraints of compatibility with certain browsers.

Create a Test

NewTest.jpg

A test is a sequence of questions which the student responds to. A session takes place each time the student does a test.

A test is defined by a set of rules for:

SIETTE stores the student's answers, and calculates their score according to the criteria of the test. If you change the test criteria, the answers can be re-evaluated without having to take the test again.

Only minimum information is necessary to create a new test:

          Number of questions answered
    f = -----------------------------------
           Minimum Number of Questions

Modify data of a test

Import and export subjects

You can import and export subjects in a lot of formats in Siette. You can check the format in whitch you can export and import subjects in the next list:

Export Subjects

You can export a full subject or a part of it (subset of items or topics)

Export a full subject

We can export a full subject through the tab Export in the subject menu.

666px

The options of export are:Las opciones de exportación son las siguientes:

After selecting the options, we export the subject clicking on the button. Once exported will see the next screen where we have available this export. We can download it or delete it. We can also see the messages in case of any errors in the export by clicking the button view details. 666px

De esta forma, Siette da soporte para poder tener diferentes versiones de una misma asignatura o para guardar y recuperar posteriormente antiguos ítems.

Exportar subconjunto de Ítems

Otra opción de exportación es realizar una exportación de un subconjunto de ítems. Ese subconjunto de ítems lo obtendremos al realizar una búsqueda. Entre las opciones disponibles para realizar con los ítems encontrados en la búsqueda encontramos la opción de Exportar

400px

Cuando exportamos un subconjunto de ítems podemos ver que en la lista de Exportaciones anteriores el nombre de la exportación tiene el sufijo "parcial". A continuación podemos ver una imagen en la que se ha exportado una asignatura completa y un subconjunto de ítems

666px

Importar Asignaturas

Siette dispone de dos formas en la que se pueden importar asignaturas. Se podrá importar una asignatura completa y se podrán importar también ítems sueltos.

Importar asignatura completa

Se podrá importar una asignatura completa a través del menú Nueva asignatura y el botón Importar asignatura:

File:ImportarAsignatura01.png

Se seleccionará el archivo XML necesario para la importación y al pulsar aceptar, si todo va bien, se mostrará una ventana como la siguiente. En caso contrario se mostrará un mensaje de error con los fallos ocurridos.

400px

Importar ítems y temas sueltos

Se podrán importar ítems y temas sueltos a través de la pestaña Importar en el menú de la asignatura.

666px

Seleccionaremos el archivo XML necesario para la importación y debemos elegir el criterio que se seguirá para la resolución de conflictos (en caso de que un ítem o tema, que va a ser importado, ya exista en la asignatura):

Una vez importado un subconjunto de ítems podrá ver los resultados provocados por la importación en la pestaña Importar. Los ítems recien importados aparecerán en el arbol con su nombre en rojo. Conservarán este estado hasta que se guarde la asignatura o hasta que cierre la sesión.

800px

Personal tools
Namespaces
Variants
Actions
Navigation
SIETTE Manual
Toolbox
In other languages