The aladin from plc-dev

Taskgraph-state as DI

Inject application state as dependency into Canvas component and trickle down as prop into item-components

Canvas
Item-components

Break-In TaskGraph-Serialisation/-Building

Show @sjanasek how to build and organize a complete taskGraph for a specific task.

Gozintograph
SQL

Archive prototype branch and merge new architecture into master branch

vue tutorial

Der Kurs:
https://www.udemy.com/course/vuejs-2-der-praxiskurs-inkl-vue-router-vuex-uvm/

Stand: Abschnitt 4

Inverse Distance Weighted Task - UI

Develop or reutilize UI elements that display:

graph generation with option menu (either full parametrization or predefined parameter configurations (e.g. easy, medium, hard))
a guided solution through the task (either on one page or split up in multiple steps)

Possible displaying options for the "graph" itself:

SQL-Task-Database Migration

The following SQLite DB-dumps have to be converted to PostgresSQL-dumps:

https://drive.google.com/file/d/1IyIT2hAYcTlayuqc2l4Xd-4fDs2UxKpI/view?usp=sharing

Minimal JSON Editor

Implement a basic editor for rapid component/node development

Syntax Highlighting Code Editor Component
TaskGraph-State with mocked API calls
"Live"-Editing

Replication of the Gozintograph task

Build generic matrix component
Build generic task traversal component
Reimplement gozintograph generation algorithm
Build/Write the serialised task instruction
Persist instruction to database

Break-In Component Interface

Show @sjanasek how to implement typescript interfaces for UI components.

UI Polishing

Overhaul styling of the refactored UI and replace placeholder elements with a finished version.

Geo Interpolation Task - Solving Algorithms

Implement IDW
Eventually implement the simple Kriging Model

Inverse Distance Weighted Task - Generation

Implement an algorithm that generates a random graph within a set of parametrized limitations.
Wrap it into a REST endpoint, e.g. "/generateIDW" or "/generateInverseDistanceWeighted".

Resources:

Generic Task Replay - Player UI

Build a player interface to replay the serialised steps according to each task.
Possible functionality:

Open replay session via serialised hash in url to share replays
Proceed the task at each step and complete it
return to replay if desired
variable speed through the steps
pause/continue
clickable progress bar

Gitpod Configuration and Setup

Setup and configure gitpod to build and run the full functionality of ALADIN.

SQL Task Worker

Reimplement the backend routines of the SQL task

Maxima Integration

Integrate the CAS Maxima as its own service into the backend

Generic Task Replay - Persist Replays

Cache each replay userside in the browser either in session or local storage.
Provide functionality for logged in users to persist the replay until deleted (or delete after a certain time span).
Serialize replay states into hash to create unique identifier.
Store replays with hash and user_id in mongodb.

Adaptive Tasks - Spaced Repetition

Use the gathered data and statistics to implement a system that adapts the task difficulty and tips/help according to the users familiarity/expertise of the task. Combine this with a [spaced repetition](https://de.wikipedia.org/wiki/Spaced_repetition#:~:text=Spaced%20repetition%20(%E2%80%9Everteilte%20Wiederholung%E2%80%9C,der%20Wiederholung%20gelernter%20Inhalte%20vorsieht.) algorithm that reminds a user of when to practice a task again, to reach the "optimal" repetition rate in order to maximize retention.

Adaptive system according to user statistics
Spaced repetition algorithm
Push notifications/server sent events to remind a user of when to practice a task
Settings option

Containerize application for development

Create docker containers for uniform development environment.

BE
mongodb

Orchestrate with docker compose.

Automate SQL-Table generation for UI-Components

The idea is to take the serialised form of the taskgraph describing the solving of a given task and automatically generate SQL tables from it to serialise them to.
The underlying issue is that by doing it this way, though technically possible, a lot of information is lost in the process and the resulting table needs a lot of manual labor afterwards which renders the process useless in the first place.

A better alternative is to use the Typescript Interfaces for each UI-Component and generate SQL-Table statements from them. This should technically be possible (since the other way around is possible) and almost all missing or deluded information should be inferrable by some heuristic

Generic Task Replay - Record Session

Find a way to capture a user session, when a task is in process.

MutationObserver:
- Captures every DOM mutation
- Probably causes too much dataload and results in complicated logic for excluding unwanted mutations
- Might be challenging to display afterwards
- Provides a complete "user perspective"
Subscribe to Vuex Store Modules:
- Can be easily attached to "Excercise" module to only capture state mutations of interest
- Serialised state provides an easy replay method via displaying in steps
- Minimal dataload

Shibboleth single sign on authentication

Implement a Shibboleth service-provider according to the HTW-Configuration and their federation.

contact HTW datacentre
replicate configuration and setup authentication
embedd authentication into BE (DB + API routes)
embedd authentication into FE

Testing

Write unit, integration and end-to-end tests

FE

Setup Cypress with unit and end-to-end tests
Test Coverage - 0%

BE

Setup Mokka with unit and integration tests
Test Coverage - 0%

Task graph serialisation and persistence

Decide on a format for the task graph serialisation, primarily consisting of the following 3 parts:

queue-worker-instruction for the actual task generation (backend)
API route and the handling of the parameters (web-server)
generic frontend components and their use in a specific task graph
Generic/Dynamic storage of taskGraph-data and the dynamic UI elements

Outlook

("ruleset" for the interaction of the serialised components --> configurator)

SQL UI Components

Implement (generic!) SQL task UI components

Code editor with syntax highlighting
Code output field
Dropdown
Img-box / ERD display

Generic Task Generation (Graph) Algorithm

Provide constraint based algorithms, that provide customized functions, derived from user defined constraints, in order to create arbitrary task data.
Possible Constraint Programming Languages:

CHR
Prolog
Eclipse
SHACL (RDF)
Include a constraint programming language/toolkit
Implement generic graph data structure
Implement generic graph traversal algorithms
Implement generic graph generation algorithms
User-friendly UI that abstracts the selection/generation of constraints in an easy-to-understand-way

Documentation - Architecture

Video explanation
Sketch / Model

Task Configurator

Build a configurator to build a task from a existing set of UI-components and task generation algorithms.

Requires:

Generic UI components
Generic task generation algorithms
Persisted ruleset of allowed component interaction

Stage 1: Live JSON-Editor as a frontend view
Stage 2: Configurator-Dashboard

Statistics

Create personal user statistics and aggregated system statistics

Setup SQL-schema in the aladin postgres db
Implement a worker to calculate user and general statistics
Implement a CRON-job to update statistics
Implement frontend views for personal user and general aggregated statistics

Documentation

Provide general documentation in the github wiki as well as code and configuration explanations in readmes in the respective layer of the github repository.

Code documentation - 0%
Configuration documentation - 0%
General information in the wiki - 10%

Documentation - UI / Taskgraph serialisation

Video explanation
Sketch

Math Formula Processing

To increase the flexibility and ease of use, of ALADIN, an engine that renders human readable math notations into ALADIN components would be highly valuable.
To achieve this the following parts are needed:

Human readable input format, E.g ASCIIMath, Tex, MathML or similar are needed (Should be standardized in some form or another)
Parser for making the input machine readable, preferably in the form of an AST
ALADIN component for dynamically rendering the abstract formula in an interactive form that is specific to the generated task (mapping variables of the abstract formula to the generated task data)
Parse AST into ALADIN component format
Attachable data sources for vartiables/sums/products
Rendering of the abstract formula, preferably in Tex style in the browser (also exporting the formula)

ALADIN architecture

Model current and possible future architecture for ALADIN.

Diagrams.net overview
Version control the diagrams

ToDos

host ALADIN on HTW server
implement user login + permissions backend
make concept for user statistics
implement user statistic backend + frontend
implement spaced-repetition algorithm based on statistics/general algorithm
implement push-notifications to inform users about recommended repetition schedules
make concept for guided tutorials based on replay-system
implement guided tutorial structure
create guided tutorials for every task

plc-dev / aladin Goto Github PK

aladin's People

Contributors

Watchers

Forkers

aladin's Issues

Outlook

Recommend Projects

Recommend Topics

Recommend Org