What are some suitable persistence services for storing programming tasks?

Question

My team of tutors and lecturers aims to have a centralized repository of programming tasks. The idea is to have a database to which we can easily add new tasks, modify the existing ones and group them into their respective theme.

For example, the task that requires the student to create a stateful lambda that recursively computes the Fibonacci sequence would be labeled (or tagged) with lambda and recursion.

We aim to be able to easily query those tasks using not only tags, but other means of specification, for example tools used in the associated solutions. That implies we also wish to associate the tasks with other things, among them solutions, commentary-based recordings and possible reference materials.

What we have looked at so far:

• GitHub:
  • pros:
    • Easily accessible;
    • Perfect for reviewing changes;
    • Very convenient views of some of the files;
    • Externally set up;
  • cons:
    • Poor support for tagging and grouping files (tasks);
    • No support for associating files (cross-referencing is error prone);
    • No support for querying and filtering the tasks;
• Relational database:
  • pros:
    • Easily accessible, since we are all programmers;
    • Good association mechanisms;
    • Great support for queries;
  • cons:
    • Poor support of visual browsing;
    • Would have to be internally set up;
    • Certain file types would require to be stored externally to the DB and references from within it;
• MS Teams' private Team files:
  • pros:
    • Easily accessible;
    • Good visual browsing;
  • cons:
    • Slow;
    • Poor support for associations;
    • Poor support for modification;
    • No support for querying and filtering the tasks;

As you can see, all of the aforementioned tools have serious issues. Are there any tools specificalyl designed to solve this problems? Of course there is always an idea to create one and run it on university's server, but before we jump into doing that, we would like to explore ready-to-use possibilities.

Answer 1

I think that you should consider to split the "programming task" content and the other content that you want to manage according an appropriate mindset for each content type and their life cycle.

One idea is to split them in

• student work related files (most of the "programming tasks" content, I think),
• instructional content (keep the instructions separate from the student work related files)
• reference material,
• assets associations (most of the tagging might be better to be managed of a specialized tool)

Something like the above will give you a balance between order and flexibility. Also it might give you a base to choose a "base tool" and extend it by using appropriate plugins / add-ons.

---

Student Work Related Files

I think that the "programming tasks" mainly include source files, code libraries, technical reference material. I imagine that most of these files might need to be copied by the students and you might want some of them being managed through a template engine so each student or student team will have their unique copy.

You might need to update them frequently to make them effective based on the student cohort characteristics and the enviroment effects on them.

You might want to generate the student copies when the lesson start, so you will be able to include the latest version or make "last minute" changes i.e. when the material is related to emerging technologies or looking to have a "state of the art" mood or due to students needs and environmental changes.

You might want to tag these materials with very specific tags including metrics about their effectives as learning resources. A tool like GitHub might work very well, I think.

Instructional Content

This refers mainly to the instructions for students. While it migth make sense to have this together with the work related files i.e. as a Readme.md, IHMO, this content requires educator mindset, i.e. you might need to share these with instructional designers and educative program managers that might know nothigh about GitHub and the specific technologies. This instructions will not change as frequently as the student work files. You might want to tag this content using certain educative framework / taxonomy that might not be as specific as the one used for the student work related files.

This kind of content might have schedules related to the whole academic year cicle or program life cicle, i.e., each class should have a copy create at the begining of the the academic year cicle or intermediate terms.

For this you might be better managed in a general CMS / LMS. It might be possible to use GitHub but it will require a different file structure and addition / update procedures than the student work related files.

Reference Material

Past lecture recordings, other kind of videos, classic booksetc. These are resources that are added but not edited. This type of material could be on a CMS or even on a GitHub repo but more oriented to be used as a library, archive but it is very likely that it will be distributed rather than centralized in an unique place. The clasification usually will be done using someting more close to traditional library classification methodologies, problebly this should be done in next category.

Assests Association

The point of managing this type of content by separate is to be able to organize your "heavie assets" (in other space / tools) without having to move them around frequently, including those that you are not able to move around at all.

The "tradidional" way is to use links and back links. You might use a relational database having records for each of the other content types including their metadata and a related table with a pair of fields one for the type of link and another for the actual link.

Another posibility is to play with "embedding", "blending", "knowledge graph", "mind mapping" on a content delivery tool. For this you could use MS Teams maybe extended with some plug-ins / add-ons.