Feature Wiki

Information about planned and released features

Tabs

Introducing Assessment Question Service

This requests comprises also the following sub-projects: 

1 Initial Problem

The component Test & Assessment needs to be divided into a question service and (at least) two clearly separated components using the question service to split up the large component Test & Assessment:

  1. Test Object
  2. Test Question Pool Object
  3. Assessment Question Service
First thoughts in 2018 were, that the existing T&A and its code could be split up into three components. But this task wasn’t as practicable as imagined, so the Assessment Question Service is based on a completely new code and as a new service, that can be used by components like question pool and test players.
 
For now when we talk about splitting up the T&A, we talk about the originally idea of having separate components/services for question service, question pools, test players and maybe further components and services.

2 Conceptual Summary

This proposal provides for the separation of Test & Assessment into individual maintenances:

  1. The pool object is the container for questions. It is an easy to manage component and provides comparatively low requirement to the maintainer even without a documentation.
  2. The test object is very complex and should be looked after by an experienced ILIAS developer. It contains a lot of settings and places high demands on the maintainer without any documentation.
  3. The question service needs to be extracted and is very powerful and complex. It should urgently only long-term experienced developers take over the maintenance.
It is important that maintainers can work closely together. The maintainers of the components that are separated in the future can not back themselve. Nevertheless effects of a breakdown in the split maintenance naturally diminish.

Subproject 1: Assessment Question Service

In a first step, the new area of responsibility Assessment Question Service will be created as a new development area. The codebase will be moved to this new room for later refactoring. For further steps, the violations of responsibility which are to be resolved are clearly recognizable.

  • Creation of the new ILIAS service
    • Service Directory "AssessmentQuestion"
    • service.xml
  • Moving all question related PHP classes into the service directory
    • GUI classes
    • Obj classes
    • classes for feedback handling
    • utility classes
  • Modification of all includes to the moved classes
    • within the new service
    • within the test object
    • within the learning modules

Subproject 2: Decoupling of the Solution Database

The actual, necessary decoupling takes place in this step: If the access to data violates the planned responsibilities, these are cleared. Consumers should only know IDs of questions and solutions and assign them to results in their own responsibility. Questions and solutions no longer require information from consumers.

  • Porting the solution database of the test object into the question service
    • Rename table tst_solutions to asq_solution_values
    • This table keeps on storing solution information as a key/value storage
    • A solution includes any number of records
    • Introduce a new table asq_solutions
    • This table manages a new solution ID per participant solution
    • The solution ID is used in asq_solution_values
    • Consumers can use the solution ID in their result data
    • Actual decoupling by restructuring the IDs and references
    • The table tst_test_result is updated with a new column for the solution ID
  • Abstraction of a new object layer to represent submitted solutions
    • One instance of ilAsqSolution represents one row in asq_solutions
    • One instance of ilAsqSolutionValue represents one row in asq_solution_values
  • Refactoring the existing question classes by integrating the solution objects
    • Removal of all parameter transfers regarding participant ID and test run
    • Conversion of all affected methods to use a replacement parameter of type ilAsqSolution
  • Abstraction of a new object layer to represent test results
    • An instance of ilTestResult grants access to a participant's answer result for a question
    • An associated solution ID is managed via ilTestResult as well
    • The handling of question, solution and result data gets changed within the test player
    • To display a question with a solution, ilTestResult finds the corresponding ilAsqSolution. This is used in the GUI class of the question
    • For the other direction, the questions GUI continue to read out the solution transmitted by the participant from the POST parameters, but then store it independently via ilAsqSolution
    • The solution id used is returned to the player for creating / updating a result using ilTestResult
    • An allready existing ilAsqSolution can be found by the player using ilTestResult and than the player passes it to the question when storing a solution submit

Subproject 3: Question Interface

For the question service to become a technically maintainable component that remains flexibly expandable, a suitable architecture of the code base is required. A well-defined API that allows consumers to embed the question also provides the foundation for a true plugin slot.

  • Implementation of a suitable object graph that disentangles further processes in the GUI and object classes of a question and a suiteable interface to be used by consumers of the servic
    • ilAsqSolutionSubmit (internal interface reading POST parameters)
    • ilAsqResultCalculator (calculates a result for a given ilAsqSolution)
    • ilAsqRenderer (responsible for generating the output using the templates)
    • ilAsqAuthoring (interface for authoring processes)
    • ilAsqQuestion (interface for using a question as assessment item)
    • ilAsqSolution (interface for the handling of solution data)
    • ilAsqFactory (a factory provided by the DIC that can be used to instantiate all necessary objects)
  • In the event of errors within the question service, due to incorrect or missing parameter handovers, the consumer should be able to act accordingly. Suitable exceptions must be identified and implemented during the development.
The current state of the detailed interface description is available within the a pull request: PR 1183

Big Picture

Component

Purpose of use ... today

The only module for online tests in ILIAS at the moment. It is strongly linked to the question pool (legacy) and cannot be further developed due to the fact that no maintainer can be found to take care of this challenge.

The Test is respsonsible to score answers and to score test runs

The Test offers a correction mode for lecturers

And Test Runs are linked with the ILIAS Learnig Progress 

It is possible to define feedback, hints for given answers and to link learning material to a question.

In addition, a question can be embedded in additional content using the ilias page editor.

The test can be used for very many test/learning scenarios

...in future

Gradual replacement and removal from the ILIAS core.


The most important point here is the migration of questions.

Measures

Concept for future online test modules.

A concept which allows to guarantee the functional spectrum but not to create a further unmaintainable monolith.

The only module for creating and collaborative authoring questions in ILIAS at the moment. It is strongly linked to the ILIAS Test (legacy)

In addition, the question pool offers the possibility to link questions with competences and taxonomies

It is possible to define feedback, hints for given answers and to link learning material to a question.

In addition, a question can be embedded in additional content using the ilias page editor.

Concept for future online question pool(s)

A concept which allows to guarantee the functional spectrum but not to create a further unmaintainable monolith

The focus here is on a specific question.

  • Create Question (13 different Question Types)
  • Authoring  Questions
    • Question
    • Answer
    • Scores
    • Feedback
    • Hints
  • Preview Questions
  • Serve HTML for playing Questions.
  • score answers: A Player may ask for the score for a given answer 

Migration of old Questions from Test & Pool to Question Service (funding needed)

The Question Service is not responsible for

  • online tests
  • score test runs
  • a correction mode
  • Test Runs
  • link learning material to a question.
  • embedd questions in additional content
  • test/learning scenarios
  • collaborative authoring (Permission Check)
  • Assigning of competences to a question
  • Assigning of taxonomies to a question
  • Link learning material to a question

2.1 What is a question?

In Assessment Question Service and also in the new T&A a question is the smallest component. A question or the question service contains e.g. following:

  • Defined question type
  • Title
  • Author
  • Description
  • Lifecycle
  • Question Text
  • Working Time
  • Answers
  • Points
  • Feedback
  • Hints
  • (Versions / History)
 
The different types consider further points like shuffling answers, answer images, etc.
It is important, that the new service contains at least all existing functions of existing T&A.

An open discussion is the usage of an editor for creating questions.
 
The question service itself can be used in different contexts, it focusses on specific questions and question types. The ASQ can be seen as an ILIAS-internal interface, that needs other components like e.g. Questionpools and Testplayers. It has no noticeable influence on users without these components.

2.2 Creation and Authoring of Questions

In the Assessment Question Service it is possible to create specific questions, until now 14 different question types are implemented. 

  • Multiple Choice Questin (Single Answer)
  • Multiple Choice Question (Multiple Answer)
  • Multiple Choice Question (Kprim Answer)
  • Error Text
  • Hot Spot / Image Map Question
  • Cloze Question (including long menu gap)
  • Numeric Question
  • Formula Question
  • Test Subset Question
  • Ordering Question (vertical & horizontal)
  • Matching Question
  • Essay Question
  • File Upload Question
  • Text Order Question
The implementation of new types is possible.

For every question type the ASQ saves assigned answer options, points for correct/incorrect answers, uploaded files, etc.

2.3 Feedback and Hints

As a part of a question the ASQ saves common solution feedback and hints for questions.

In the register "Preview" a question with the status "Completed" can be displayed with its specific components such as title, question, answers, etc.

2.4 Deleting Questions

The Assessment Question Service will enable administrators to delete questions from the database (e.g. reasons of copyright, privacy information, etc.).

Following concept was discussed on a workshop:

  • Questions, which neither is used by a test nor a question pool, can be deleted irreversible.
  • Question pools only can be deleted, if they are not used by any test player.
  • Deleting sequences: 
    • test (players)
    • question pools
    • automatically, if a questions isn't used by any components (synchronous or asynchronous, e.g. cronjob)

2.5 The question service is not responsible for...

The Question Service currently does not include the following features which surround the question. These are especially the following.
But: We like to work with other components and other maintainers to guarantee, that the new T&A and all its components create a sustainable, stable and maintainable environment and future for tests, exams, etc.

Link Learning Material to a Question
A specific question can be used in many different contexts. The context (test player or pool) is responsible to assign the concrete learning material for this context to the question. Possibly the Question Services needs an interface to show/edit/share the Learning Material to a question in the Question Service.

Link Competences to a Question
A specific question can be used in many different contexts. The context (test player or pool) is responsible to assign the concrete competences.

Link Taxonomies to a Question
A specific question can be used in many different contexts. The context (test player or pool) is responsible to assign the concrete taxonomies. Currently the administration of the taxonomies is located in the question pool.

Embed a question in additional content
A specific question can be used in many different contexts. The context (test player, pool or learning module) is responsible to embed the question.

Usage of the Page Editor
The editing of the pages is not included and could be a part of the test player. We see the need of the Page Editor in different use cases, so we are open to discuss this point.

Results/Manual Scoring
The results in a test will not be saved in the Question Service, rather the test player should be responsible for the results and manual scoring.


For all those features we are open to discuss the special placement in a special component (Question Service, Pool, Test Player). 

Request for Change

Changes for specific question types have been handled separately.

3 Replacement of T&A

ASQ and new test players do not interfere with preexisting tests using the old T&A implementation, but T&A will be phased out slowly in the future considering the need of the ILIAS users.

3.1 Migration path to ASQ

Funding needed, see: Migration path for question types to ASQ

The migration from old question pools to new question pools needs new question pools, based on asq technology. Each question type needs an own path for migration.

4 User Interface Modifications

4.1 List of Affected Views

None.

4.2 User Interface Details

None.

4.3 New User Interface Concepts

No new user interface concepts necessary for implementing the assessment question service. A possible different user navigation concept could be discussed during the development of test player(s) and question pools.

5 Technical Information

The maintainer strongly supports this request but needs to say: this will be a new implementation that will probably bring up some technical issues, that cannot be seen at the moment. Nevertheless the mission to get a decoupled assessment question service needs to be completed.

This request also requires two further requests to be implemented:

5.1 Architectural Paradigm

Assessment Question Service - Fundamental Work for a auditable and stable system.


This work we did to cover the current requirements and all(!) known future requirements. We decided us to a complete reprogramming of eacht Question Type.


With the Assessment Quesiton Service we introduce an other way of Software Development in ILIAS. A very clear and clean Architecture. 

The following paradigms are applied

CQRS

CQRS is the the acronym of Command Query Responsibility Segregation. It is a pattern defined by Greg Young:

  • Summary by Greg Young: http://codebetter.com/gregyoung/2010/02/16/cqrs-task-based-uis-event-sourcing-agh/
  • CQRS Documents by Greg Young: https://cqrs.files.wordpress.com/2010/11/cqrs_documents.pdf
CQRS suggests to separate the read-/query- from the write-/the command side. This is especially valuable as we can provide on the side where the student gets a question for answering, only questions of a willingly provided revision.

CQRS and Event Sourcing
We use the Event Sourcing as the data storage mechanism for the domain. So we use the event model as persistence model on the command side. At the read side we use a classical data structure well known from other ILIAS modules.

A very good start to get to know this paradigm is the followoing comment in early stage of the project:
https://github.com/ILIAS-eLearning/ILIAS/blob/7b261f43c6fe59938d72b84b270196089afbaa91/Services/AssessmentQuestion/docs/development/cqrs-and-event-sourcing-paradigm.md#internal-implementation-of-the-command-side

5.2 Public Services

The Assessment Question Service provides the followoing Services for Consumers

5.2.1 Question Service

  • getAvailableQuestionTypes() : 
    QuestionType[...]

  • createQuestion(QuestionType $type) :
    QuestionDto

  • getQuestionByQuestionId(Uuid $id) :
    QuestionDto

  • saveQuestion(QuestionDto $question_dto):
    void

  • createQuestionRevision(string $name, Uuid $question_id) :
    void

  • getQuestionRevision(Uuid $id, string $name) :
    QuestionDto

  • getAllRevisionsOfQuestion(Uuid $id) : 
    QuestionDto[...]

  • addQuestionType(        string $title_key,        string $factory_class,        string $editor_class,        string $scoring_class    ) :
    void

  • removeQuestionType(QuestionType type) :
    void

5.2.2 Answer Service

  • getScore(QuestionDto $question, Answer $answer) :
    float

  • getMaxScore(QuestionDto $question) :
    float

  • getMinScore(QuestionDto $question) :
    float

  • getBestAnswer(QuestionDto $question) :
    Answer

  • storeAnswer(Answer $answer, ?string $uuid = null) :
    string

  • getAnswer(string $uuid, ?int $version = null) :
    AbstractValueObject

  • getAnswerHistory(string $uuid) :
    array

5.2.3 UI Service

  • getQuestionComponent(QuestionDto $question) :
    QuestionComponent

  • getQuestionEditForm(QuestionDto $question, string $action) :
    QuestionFormGUI

  • getQuestionFeedbackForm(QuestionDto $question, string $action) :
    QuestionFeedbackFormGUI

  • getQuestionHintForm(QuestionDto $question, string $action) :
    HintFormGUI

  • getAsqTableInput(string $label, array $columns, string $byline = null) :
    AsqTableInput

  • getDurationInput(string $label, string $byline = null) :
    DurationInput

  • getImageUpload(string $label) :
    AsqImageUpload

  • getImageFormPopup() :
    ImageFormPopup

5.2.4 Link Service

  • getCreationLink():
    UiStandardLink

  • getEditLink(Uuid $question_id) :
    UiStandardLink

  • getPreviewLink(Uuid $question_id, ?string $revision_name = null) :
    UiStandardLink

  • getEditFeedbacksLink(Uuid $question_id) :
    UiStandardLink
       
  • getEditHintsLink(Uuid $question_id) :
    UiStandardLink

  • getRevisionsLink(Uuid $question_id) :
    UiStandardLink

  • setQuestionUidParameter(Uuid $question_id) :
    void

5.3 Question DTO

The QuestionDTO which is used in the mentioned Services has the following properties

  •  /** @var Uuid */
    id;

  • /** @var QuestionType */
    $type;

  • /** @var ?RevisionId   */   
    $revision_id;

  • /** @var ?QuestionData */   
    $data;

  • /** @var ?QuestionPlayConfiguration */   
    $play_configuration;

  • /** @var ?AnswerOptions */
    $answer_options;

  • /** @var ?Feedback  */
    $feedback;

  • /** @var ?QuestionHints */
    $question_hints;

5.4 Has to be done but funding needed

Transformation of Legacy ILIAS Tests and in the new environment.

Migration of question from T&A to the new Question Service:

  • Effort: 2-3 days development per question type + internal and external testing
  • Testers for quality control are needed.

5.5 Would be possible now!

Fully audited Question and a fully audited Tests

5.6 Possible way for the replacement test and question pool

See global picture. We have to discuss at least:

  • Taxonomy-Assignments
  • Comptences
  • Additional Content sourounding the Question.
  • Migration of old Questions
  • Post Correction Mode 

5.7 Project Discussion - Archive

The development of ASQ took place in over 700 commits with a total of over 100'000 changed lines of Code resulting in a  PHP Library of over 20'000 lines of code.

https://github.com/ILIAS-eLearning/AQS

Initial concept
2018-11-20 initial interface and database migration concept see #1183

https://github.com/bheyser/ILIAS/blob/9d74d279d85892c69a48b12f80543908decd109f/Services/AssessmentQuestion/docs/readme.md


Technical discussions of new approachesFollowing technical new approaches were designed by Björn Heyser, Adrian Lüthi and Martin Studer. Consulted with the SIG E-Assessment and discussed extensively with the Technical Board.

Discussion: Using CQRS as Architectural Paradigm
2019-05-27 ilias with cqrs components: see #1859

Readme: https://github.com/studer-raimann/ILIAS/blob/feature/trunk/ilias_with_cqrs_components/vendor/ilias/IliasComponentCourse/README.md

Discussion: Assessment Question Service with the DDD and CQRS
2019-06-15 Assessment Question Service with the DDD and CQRS / Eventsourcing Pattern: see #1931Readme: https://github.com/ILIAS-eLearning/ILIAS/blob/bd89c8194b07cc257abee749bea10b55b74e6f72/Services/AssessmentQuestion/Readme.md

Discussion: API Change
2019-07-25 Feature/6 0/asq api change proposal: see #2016Readme: https://github.com/ILIAS-eLearning/ILIAS/blob/5784e0a1b78a56cb5751d93dc824e6ffa3b51a24/Services/AssessmentQuestion/docs/readme.md

"Final"Concept Discussion
2019-07-28 Conceptual Discussion Feature/6 0/asq concept: see #2021Final Concept: https://github.com/ILIAS-eLearning/ILIAS/blob/7b261f43c6fe59938d72b84b270196089afbaa91/Services/AssessmentQuestion/docs/development/cqrs-and-event-sourcing-paradigm.md

First basic prototype
2019-08-07 First basic prototype of ASQ is finished

Most Question Types exis
2019-10-22 Most Question Types exist, prototype is continuously refactored meanwhile.

Cloze Question is implemented
2020-01-30 Cloze Question is implemented as the last of the preexisting ILIAS Questions 

Publication of the first ASQ Version in form of a library
2020-03-19 Publication of the first ASQ Version in form of a library for the official review process.

Update of asq to Kitchen Sink UI started
2020-07-22 Update of asq to Kitchen Sink UI started

Publication of the second ASQ Version
2020-09-23 Publication of the second ASQ Version in form of a library for the official review process.
The development of ASQ took place in over 700 commits with a total of over 100'000 changed lines of Code resulting in a  PHP Library of over 20'000 lines of code


Rebuild the whole Data Base Structure / as result of the review and wish of the community
https://github.com/ILIAS-eLearning/AQS/issues/1

6 Privacy Information

We save for each change by question authoring, the change of the question and the executing user. We need this to display a question history. 

7 Security Implications

The assessment question service offers service endpoints. These will now have to be addressed by the test and question pool. Authorisation is in the responsibility of test pool(s), test player(s), learning modul(s).... The consuments of the question service.

8 Contact

9 Funding

If you are interest in funding this feature, please add your name and institution to this list.
Crowdfunding: https://docu.ilias.de/goto_docu_dcl_3700_17_3226.html

10 Discussion

JourFixe, ILIAS [jourfixe], 12 NOV 2018 : We accept Björn's suggestion to split up the existing test and assessment component into three new components, incl. a new assessment question service for ILIAS 6.0. All questions about implementation and interfaces are tackled in pull requests as agreed with the Technical Board. The PM will change the related pages and suites in the feature wiki, Mantis and Test Rail accordingly. Please note that all existing test question plugins won't work any longer with this new service without according changes. New plugins made for this plugin slot won't work with versions before 6.0.

Neumann, Fred [fneumann], 31 SEP 2019
The proposed changes in the authoring interfaces look nearly all convinging and straight to me. I just have doubts with 7.6  - getting the ordering questions into one type. These subtypes are used differently. The horizontal ordering is mailny used for ordering words in a sentence which is at best entered in a text area. The vertical ordering may use images and has the option to nest terms (currently in an own authoring view.) It would make the authoring interface of common question type rather complex to support both equally.

Kunkel, Matthias [mkunkel] @ SIG EA, 13 NOV 2019 : The separation of the Test&Assessment has been postponed to ILIAS 7 because the project cannot be finished satisfactorily until 'Coding Completed' at NOV 29. Therefore, this feature won't make it into ILIAS 6 but is now suggested for ILIAS 7. Please add it to the JF agenda to schedule it again.

JourFixe, ILIAS [jourfixe], 16 DEC 2019: We re-schedule the current suggestion for ILIAS 7. In addition, we would like to get rid of TinyMCE in the question service and use only the new page editor. But before making a final decision we have to discuss the options with the maintainer of the IPE, Alexander Killing (who is not joining the JF today). Migration of questions created with the Tiny needs to be supported as well. Martin will invite to a 2h VC at beginning of January.

Studer, Martin [mstuder], 20.03.2020: We published a first version of the Assessment Question Service: https://github.com/studer-raimann/AssessmentQuestion

Kergomard, Stephan [skergomard], 07 DEC 2020: Sadly, I won't be able to join the JF today, sorry. Here a few thoughts:
First: There where a lot of changes made in the FR last Friday and I have a hard time really going through the whole text. I think this is really not ideal to discuss the topic today.
And then: As a representative of the HSLU, I see a few conditions, before I believe the ASQ can be merged:

  • The points from the TB review should be implemented fully.
  • As I don't see a good way to have the current and the upcoming Test & Assessment visible in the interface in parallel (Would we have two Questionpools? Could you mix questions from the current and the new Test & Assessments in Learning Modules and other potential "integrated players" or would you need two versions of each question to use them in parallel? If we need to have two versions: How do we make sure they don't drift apart? ...):
    • There needs to be a plan with a timetable for the process until the complete removal of the current Test & Assessment and the full activation of the new system.
    • There needs to be a deadline for the removal of the current Test & Assessment. If this deadline can not be met, the ASQ needs to be removed again.
    • If the new service is implemented in a core component, there needs to be a way back, until we are absolutely sure we can remove the current Test & Assessment. ILIAS needs to remain fully functional without activating the ASQ until the current Test & Assessment is completely removed.
    • We don't need to implement all functionality in the new Test & Assessment. But we need to be sure that we are fine with loosing the corresponding functionality, the moment we get rid of the current Test & Assessment. Not having all functionality implemented shouldn't be a condition for not removing the current Test & Assessment. Implemented Plugins shouldn't be a condition for not removing the ASQ if the deadline is not met.

Klees, Richard [rklees], 07 DEC 2020

Dear Martin,

this topic has been debated for a long time in various circles and I'm glad that this comes up on the JF today. I already said a lot about the question service in my capacity as a TB member, most of which is documented in our common feedback in the various PRs linked here. Still, I'm also a community member, and I also want to document my opinion regarding this request from that point of view.

First and foremost, I'm very thankful that you took over the responsibility for a question service when it became appearant that the T&A is too big for just one maintainer in 2018. The plan that the community, the maintainer and the TB have laid out for the T&A was to factor out a question service from the existing code to make the maintainance of the T&A easier by distributing the responsibility for the various features over more people. I truly understand that this was and is hard to accomplish, but a lot of problems I see with your request today originate in the deviation from that original plan.

I see that you and your company already invested a lot in the implementation of the new question service and that for various reasons it most probably will not be possible to stop or even delay the integration of your new question service further without causing substantial damage to our community and you. So I won't be in your way to integrate the new question service (as long as the technical change requests from the TB are implemented).

Still I want to point out my doubts and concerns regarding your current approach and hope that the JF, the PM and most notably you will find a way to address these concerns in a comprehensible and reliable manner. My most notable concerns are:

  • I can hardly see how the reimplementation of the question service caters to our initial goal to make the T&A more maintainable. When we started, we had one huge T&A code base with one maintainer and some other people more or less familiar with the code base. It was complicated, but battle proven. When the new question service is merged, that code base still exists and will still be used for an indefinite time. On top, we get a second code base for the T&A which is currently not known in the community, is not battle proven and uses various new techniques currently not known in the ILIAS community. So currently from my POV the maintenance situation has stayed the same as best. It more likely will get worse, as we would have new code without a clear idea how to get rid of the old one.
  • The T&A is not only complicated from the perspective of the code, but also from a feature perspective. I find it hard to see how we could make sure that use cases or expected behaviour is transfered to the new service appropriately. It might be ok to drop some of the behaviour, but how would we identify the behaviour we in fact have dropped? How would we decide which behaviour can be dropped? The situation is very similar to the code: The current T&A is complicated, but there are people in the community who deeply know how the current T&A works. We will get a second implementation that most possibly requires new knowledge. Thus, there will be more to know and more to test as well.
  • Even if the question service is included in into the core of ILIAS, there is a tremendous amount of work to be done to replace the current T&A with new implementations based on the new question service. Even if we aim to replace a part of the current T&A only, e.g. removing the "question"-parts and replacing it with the new question service, there is a lot way to go. In this time we will have to maintain the old and the new T&A-stuff. How long will this process take? How will we handle new feature requests in the meantime? Bug reports and testing? Documentation? We will in fact have two competing systems from various perspectives and I fear that the community will show rips at that borderline or at least requires substantial effort to prevent these rips.
  • The ressources to finish that effort someday are not currently allocated. I also cannot see a clear plan how we could get to the initial goal to improve the maintainability of the T&A, as initially planned. I totally understand that it is not possible to guarantee ressources or make a detailed plan for the complete undertaking. But, as outlined in the previous items, I see that we will move to an overall worse state when including the new question service. This might be ok temporarily, but the current T&A and the new question service should not exist side by side indefinitely. How can we make sure that this won't happen?
The T&A is a component of ILIAS that is very important to many. We probably will need to take risks here to move it forward, but we should at least understand and acknowledge these risks to have a chance to mitigate them. Please understand that I come from a place where I deeply care about the future of ILIAS. My doubts currently prevent that I can support your approach with a clean conscience, even if I disregard any technical dimensions. I hope that you will find a way to convince me or prove me wrong in the future.

Best regards!

Becker, Maximilian [mbecker] 07 DEC 2020
I see a few key challenges here and wonder if this is truly intended and would consider discussing thoroughly if this is acceptable:

  • The solution as laid out does not lead to a separation of Test and QuestionPool. It does separate the questions from the QuestionPool. This does in fact lead to a situation where some work could be shared among separate maintainership-fiefdoms, but 
  • the definition what belongs to a question and what doesn't, which happened a bit behind closed doors, leads to a requirement that the one question service with generic minimal question implementations demands for a number of new QuestionPool & Test couples, each addressing special needs in testing, which are then - again - most intimately tied together over considerations what the questions need to be, that the QuestionService defined off of their plate.
    From my observation, the feature set of the current questions is relatively stable, most of the variable are in test presentation, scoring and result presentation.
  • Many of the service advantages, phrased as "Git for Questions", are defused over the questions being conceptually disconnected from the features in 2.3.
  • Most of the migration path is left to yet unknown creators and maintainers of new Pool-Test-Combos. Future People.

JourFixe, ILIAS [jourfixe], 07 DEC 2020: We had a long discussion today about the suggested question service but still have some conceptual questions before making a final decision. It is not really clear what is the relation between question and question service and of what a question consists of. There are also objections in the community that taxonomies, page content and links to learning material should not be part of a question - or at least under the control of the ASQ (see suggestion in chap. 2.3). In addition, it would be very helpful if all information provided by Stephi, Martin and Adrian today in the JF would be found in the wiki page as well. This concerns also the questions posted to this request in the last days (see chap. 10).

There is a need to specify this relation with the community and stakeholders before making a final decision about the request as this determines the future steps to realise the planned separation of the existing T&A.

We kindly ask all stakeholders and interested developers to participate at the upcoming workshop(s) to help us pushing this large development activity.

Studer, Martin [mstuder], 07 DEC 2020

Dear Becker, Maximilian [mbecker]

the definition what belongs to a question and what doesn't, which happened a bit behind closed doors, leads to a requirement that the one question service with generic minimal question implementations demands for a number of new QuestionPool & Test couples, each addressing special needs in testing, which are then - again - most intimately tied together over considerations what the questions need to be, that the QuestionService defined off of their plate.

Thank you for your feedback. How you mean that? I think we are really near by the concept previously proposed by Björn: https://github.com/bheyser/ILIAS/blob/9d74d279d85892c69a48b12f80543908decd109f/Services/AssessmentQuestion/docs/readme.md

I think we should discuss this on concrete cases. A good example is taxonomies. 

Currently the taxonomy trees are builded in the question pool. 

They where also used in the question pool for navigation.

Taxonomy is already a service and is only used from the context Question Pool / and from the test, by choosing Questions from pools. 

Currently the question service doesn't know all the consumers. At this moment it would be possible that a question could be located in more than one pools as it is already possible for questions in tests (or when a question is exported an reimported).

The question has an UUID. The Question Pools know this UUID and are responsible for maintaining the list of question they provide for editing.

If the Question Service should be responsible for taxonomies then he should know where the questions are located, because the taxonomy has to be builded specific for a Question Pool. 

The Taxonomy Service is already a Service. We see that the responsibility of Connecting a Question with a Taxonmy Node is in the responsibility of the Module which handels the Permission and espacially, where the Taxonomy Tree is located.

Do you see it differently? How would you approach this? If you agree with this point here. Feel free to suggest the next point, which we should discuss concretely. The boundaries here are suggestions. They are based on how responsibility would have been divided if the two objects test and question pool had been continued.

A possible way could be to implement something like a QuestionContext Service. This service could be responsible to connect a Question with the consumers and could be responsible for the the things sournding a Question - like Taxonomies or Competences. The consumers would use this Service to communicate with the Question Service.

On the other hand, we could decide, that there will be only one single implementation of a Question Pool. And this Pool is responsible for those things.

Studer, Martin [mstuder]

Dear Kergomard, Stephan [skergomard]


First: There where a lot of changes made in the FR last Friday and I have a hard time really going through the whole text. I think this is really not ideal to discuss the topic today.

Correct, but I would like to note that the whole topic has already been discussed in detail - sind 2018-11-20 (https://github.com/ILIAS-eLearning/AQS/tree/review/docs/0_History) and is also well documented (https://github.com/ILIAS-eLearning/AQS/tree/review/docs). You have been involved in these discussions for the last year. So I hope that at least for yourself - regardless of this feature wiki page - it would have been possible to participate.


The points from the TB review should be implemented fully.

I completely agree with you! I hope you also noticed how much extra work we did because of the feedback.


As I don't see a good way to have the current and the upcoming Test & Assessment visible in the interface in parallel (Would we have two Questionpools? Could you mix questions from the current and the new Test & Assessments in Learning Modules and other potential "integrated players" or would you need two versions of each question to use them in parallel? If we need to have two versions: How do we make sure they don't drift apart? ...):

This is an important question! I think we should and have(!) to clarify this question in the context of the projects Test Question Pool as Independent Object and Test Player as Independent Object which have unfortunately come to a standstill. Here it will be necessary to evaluate which use cases exist and the amount of work one wants to and can put into them.


There needs to be a plan with a timetable for the process until the complete removal of the current Test & Assessment and the full activation of the new system.

I completely agree with you!


There needs to be a deadline for the removal of the current Test & Assessment. If this deadline can not be met, the ASQ needs to be removed again.
Which advantage do you see in this action. If the schedule cannot be kept. the current test and question pool is no longer maintainable. Are you not destroying the whole test & assessment with this action? i don't think i understand your statement. can you explain it in more detail?


If the new service is implemented in a core component, there needs to be a way back, until we are absolutely sure we can remove the current Test & Assessment. ILIAS needs to remain fully functional without activating the ASQ until the current Test & Assessment is completely removed.
Back to where? To the soon no longer maintainable Test & Assessment?


We don't need to implement all functionality in the new Test & Assessment. But we need to be sure that we are fine with loosing the corresponding functionality, the moment we get rid of the current Test & Assessment. Not having all functionality implemented shouldn't be a condition for not removing the current Test & Assessment. Implemented Plugins shouldn't be a condition for not removing the ASQ if the deadline is not met.

I fully agree with you that we will require a future Test & Assessment that meets the high standards that the current Test & Assessment meets. But this will not be possible in the future with the current Test & Assessment. I think we need a maintainable and expandable system. With the Assessment Question Service we have made big step in this direction. Please help us to look into the future.

,  & Studer, Martin [mstuder]


Dear Richard
Stephi, Adi and myself have discussed your feedback together. It was important to us that all three of us work on your feedback, as your statement is already the second statement by a technical board member and you have a very high standing as a person in the community. That's why we felt that a common answer is very important.


Thank you for your work as a member of the TB. We understand that the new Assessment Question Service was an important and time consuming part of your work in the last months as well. We thank you and the other members again for the useful discussion and the reviews of the code. Now we are glad to explain some of your remarks as a part of the ILIAS community. The ideas and comments from the community are very important for us.


I see that you and your company already invested a lot in the implementation of the new question service and that for various reasons it most probably will not be possible to stop or even delay the integration of your new question service further without causing substantial damage to our community and you. So I won’t be in your way to integrate the new question service (as long as the technical change requests from the TB are implemented).

The last weeks we are working on the implementation, that are requested from the TB. It took a while, but Adi and Martin are confident to finish this work in 2020. Thanks for preparing the way to the ILIAS trunk.


Still I want to point out my doubts and concerns regarding your current approach and hope that the JF, the PM and most notably you will find a way to address these concerns in a comprehensible and reliable manner. My most notable concerns are:

  • I can hardly see how the reimplementation of the question service caters to our initial goal to make the T&A more maintainable. When we started, we had one huge T&A code base with one maintainer and some other people more or less familiar with the code base. It was complicated, but battle proven. When the new question service is merged, that code base still exists and will still be used for an indefinite time. On top, we get a second code base for the T&A which is currently not known in the community, is not battle proven and uses various new techniques currently not known in the ILIAS community. So currently from my POV the maintenance situation has stayed the same as best. It more likely will get worse, as we would have new code without a clear idea how to get rid of the old one.
We understand your doubts as to the new architecture of the question service and its code, but we are interested in working closely with the future maintainer and stakeholders of the new components. Our knowledge has to be shared, because that is the key point for the future. For a sustainable, maintainable T&A. Without support and maintainance from the community and future maintainer the splitting-up of T&A could not be reached.

  • The T&A is not only complicated from the perspective of the code, but also from a feature perspective. I find it hard to see how we could make sure that use cases or expected behaviour is transfered to the new service appropriately. It might be ok to drop some of the behaviour, but how would we identify the behaviour we in fact have dropped? How would we decide which behaviour can be dropped? The situation is very similar to the code: The current T&A is complicated, but there are people in the community who deeply know how the current T&A works. We will get a second implementation that most possibly requires new knowledge. Thus, there will be more to know and more to test as well.
A good point. We still have a long way to go – and to test the new question service as well as the other future components. But: We should not shy away from this huge task. For new implementations (and features) we need new ways, if we could see, that old components of ILIAS aren’t sustainable.

  • Even if the question service is included in into the core of ILIAS, there is a tremendous amount of work to be done to replace the current T&A with new implementations based on the new question service. Even if we aim to replace a part of the current T&A only, e.g. removing the “question”-parts and replacing it with the new question service, there is a lot way to go. In this time we will have to maintain the old and the new T&A-stuff. How long will this process take? How will we handle new feature requests in the meantime? Bug reports and testing? Documentation? We will in fact have two competing systems from various perspectives and I fear that the community will show rips at that borderline or at least requires substantial effort to prevent these rips.
As a maintainer of a single T&A component we could not give a sample solution and timetable. We need other maintainers, ideas and discussions.

  • The ressources to finish that effort someday are not currently allocated. I also cannot see a clear plan how we could get to the initial goal to improve the maintainability of the T&A, as initially planned. I totally understand that it is not possible to guarantee ressources or make a detailed plan for the complete undertaking. But, as outlined in the previous items, I see that we will move to an overall worse state when including the new question service. This might be ok temporarily, but the current T&A and the new question service should not exist side by side indefinitely. How can we make sure that this won’t happen?
We don’t have the competence to answer this alone…

  • The T&A is a component of ILIAS that is very important to many. We probably will need to take risks here to move it forward, but we should at least understand and acknowledge these risks to have a chance to mitigate them. Please understand that I come from a place where I deeply care about the future of ILIAS. My doubts currently prevent that I can support your approach with a clean conscience, even if I disregard any technical dimensions. I hope that you will find a way to convince me or prove me wrong in the future.
We try to support our LMS and its sustainability. The current T&A has reached its limits and we try to find a solution – together with you and the community.

Best regards!
Stephi, Adi & Martin



The project was successfully reviewed by the technical board.
After discussions with the TB, project Manager and SIG EA leader become clear, that the ASQ is not requested for ILIAS 8.
Further clarification would like to be done, before a clear decision could be made.
The ongoing discussions about the future of Test & Assessment, risks and profits for ILIAS has economic influence on our company - we already invested 1.5 man years in this project.
Therefore we will publish a question pool, test player with ASQ as a plugin. We are open for discussions. Those projects we will made with paying clients. And we will focus on theirs needs.

Glaubitz, Marko [mglaubitz] and Falkenstein, Rob [rob], 18 Aug 2021:

11 Implementation

{The maintainer has to give a description of the final implementation and add screenshots if possible.}

Test Cases

Test cases completed at {date} by {user}

  • {Test case number linked to Testrail} : {test case title}

Approval

Approved at {date} by {user}.

Last edited: 19. Apr 2023, 12:28, Kunkel, Matthias [mkunkel]