In good conclusion

1. problem solvers still new to TALight but now enrolled in a course based on TALight problems, or interested into a didactic path developed under TALight they can get from the cloud.

2. all those new to TALight, included those who want to act as problem makers or take part in the project as problem makers or as TALight platform developers or ecosystem designers.

TALight intends to promote autonomous exploration. We wish these explorations might lead you to find out, discover, experiment and develop resources within you, in your machine, in the cloud, in your fellows, and in the community. But, to be more concrete rather than sound too visionary or idealistic, we exhibit now the intended use of the few basic commands which allow you to access the services of a problem and all other problem contents made available by the problem maker and the cloud hosting service.

Knowing how to properly access a problem served from the cloud is at the basis to advance to deal with problems cloned in local on your machine. Playing with the problems in local will give you more freedom and control and enrich your opportunities for a wide and interconnected learning experience. Working on the problems cloned in local allows you to modify and adapt the problems themself to your needs and curiosities. Even if you do not modify the problms and leav them untouchd, still the habit to launch an rtald daemon dispatching the problem services for the problms sitting in local on your machine and addressing it rather than an opaque rtald daemon serving the cloud will give you full control and understanding on the dialogue that occurs between the solutions of the probelem solver and the service servers written by the problem maker. All this, besides possibly springing you to become a proficient problem solver, will also make it natural for you to digievolve to the next level up and experiment yourself as a problem maker.

Well, to a certain extent a functioning browser is all what you need. Seriosly: if you only have a smartphone, or no permission to install anything on the available PC, or even if you only want to give a look but are also certain you are not going to write any code, then reaching some TALight services from the browser migh actually be the best option for you to start with. In practice, throught the browser you will access a client in the cloud that will connect to our web service server wss://talight.tk/tutorial.

In order to ask for the services of a TALight server you need the two things listed here below. If you do not have them you can get them has explained and this is most advisable because you will get a better experience.

Thing 1: You need to have a terminal or a terminal emulator (with a shell like bash or zsh). If you are on Linux or Mac you already have it.

Thing 2: The second and last thing you need is the TALight command rtal executable binary specific to your platform (either Linux, or Mac, or Windows).

You have two options on how to get it:

1. Option 1 [generally recommended]: if you already know you will next advance to later stages of this tutorial, then, after installing git on your local machine and cloning this repo (explained in later stages of this tutorial), build your own binaries to get all of the TALight utilities in one shot. How to get Rust and build the binaries is explained in the file rtal/README.md of this repo.

2. Option 2: download the already compiled binary made available for your platform and set them in.

tar xvf filename.tar.xz

unzip filename.zip

ls -l rtal*

./rtal --help

./rtal.exe --help

    SET "PATH=%PATH%;C:\Program Files\TALight"

<details><summary>DESCRIPTION LONG for how to set environment variables on Windows</summary>

Windows 10, 8.1, 8

Open start menu,

</details>

In case you get error messages complaining about the fact that `rtal` has non been found then check your path.
In case you get error messages complaining you do not have the proper permissions to execute it then you are likely on Windows and should instruct it (or learn how) to launch the terminal as administrator.
In case you get error messages complaining the fact that the rtal file you just downloaded is not executable then you should tell your system that it should regard it as an executable. If on Linux/Mac this is once again an issue of permissions. In any case, here are the instructions to fix things in this last case.

<details><summary>How do I give executable permissions in Linux or Mac?</summary>

To change the permissions of a file use the `chmod` bash command. Enter the following command to give execution permission (x) to all users (a).

```bash
chmod a+x rtal

Untar with:

tar -xvf sum.tar

If the archive is zipped (you can understand this since the extension will be either .tgz or .tar.zip insetad than .tar):

tar -xvzf sum.tgz

On Windows you can also use any utility like 7-Zip or WinZip.

In any case, with an internet connection working and a browser, you will always have the possibility to ask for the services offered from the cloud as explained in the previous section. Moreover, every git repo has a web site, like the one from which you are likely to be reading this Markdown README.md file. Though not that comfortable (and the dynamic material, if present, might not be rendered) you can simply navigate through that site. Actually, this might even be the most convenient option sometimes for a first look.

Publishing a problem collection on a repo might empower the learning experience and enrich the learning opportunity. In particular, your possibility to test everything in local will be enanched. Not only you can now test your bots in local before sending them to the services in the cloud, but now you can also watch them more closely when both ends of this interaction sit on your local machine. Now you can also modify them and add prints to debug the communication protocol that the problem has defined for them to act within. All this added possibility to experiment is a precious opportunity to get under the hood by doing and has the further benefit to facilitate the transition from problem solver to problem maker. Making is the best and ultimate way of learning and can also offer opportunities for real projects that turn the evaluation from an artificial and frustrating to a stimulating and really inclusive experience. In the next section we will see how the problems you have here played with in this first level tutorial can be fully accessed in the backstage. The problem collection of the tutorial is a public git repo. To follow us there you will need to set up git on your machine. If you did not already have git, then we consider this as a first clear example on how TALight prompts towards self-empowerment since git is the portal towards open source projects and communities.

Sharing the repo with collaborators (and consider having your students among them) might allow for better and new opportunities and energies to come to life. You can collaborate with teachers spread elsewhere in your country but commitment to the same topic. This opens the possibility to really join the forces for the joint design and realization of didactic curricular material.

1. hosting it on a cloud server that exposes the services designed for the problems comprising the collection. The server in the cloud will here serve the requests of the problem solvers by launching the service serving programs written by the problem maker;

2. giving access to its repo so that the problem solvers can clone it on their local machine. The problem solver has now full and direct access to all what the problem maker has decided to ultimately include in the public (or only shared) repo and can also launch its local server to answer its own requests without further need for a working internet connection and without loading on the server at every request. In this way, even a teacher/instructor/field expert/promoter with no server available can put in action its problem collection and active learning material. With no expenses, no limitations, and, under a certain regard, in the best possible way: the problem solver having direct access to the material is both a value and a resource. Not only he might become more autonomous but he might also more easily spot out corrections and also find it natural to brake on through to the other side to enjoy collaboration with the problem maker. TALight might help in vanishing the walls that make school sort of a prison and helps in crating an environment where both the students and the teachers enjoy the experience to be on the same side, working and possibly collaborating towards shared goals. One limitation with this possibility is that most often among the services there are evaluators containing solutions to the problem, which, unless with mature born students, will spoil the problem. Another obvious problem with this modality would then be with

3. one question every instructor should pose itself is: why not to activate both modalities (like for the problems in this tutorial)? Of course, the answer depends on a lot of factors but do not be scared: as long as you keep sensitive on this from the aspects that matter most, you can even experiment and adjust.

Whatever is your platform (Linux, Mac, Windows, ...) the Getting-Started-Installing-Git of the Git Community will give you the best updated instructions on how to install this game changer on your machine. If your are a Windows user, here are two important pieces of advice to follow in the installation process:

1. follow their suggestion (and default option) to get the Git Bash (as they say: "We’ll learn more about those things a little later, but suffice it to say they’re things you want.").

2. ask to activate the support for the symlinks. Notice: though this is a very good thing to do it is not the default option since the versions of Windows before the Creators Update could not manage symlinks natively (make sure you already have that update before installing git. For this follow these instructions).

Even if you do not make any other more advanced use of git, having it installed will simplify other steps in the installation process to follow and, more importantly, will allow you to better connect to this repo or other reports (possibly of TALight problems). Even if you do not intend to contribute to their ongoing development, this means that it will be easy for you to maintain updated your local version of their contents and get the new exercises and/or features currently under development. To get the updates just launch the command

git pull

from any directory of the repo. (In case you have overwritten some files of the repo then a conflict arises. This prevents the downloading of the new content (otherwise your modifications will go lost). If you are stucked in this situation and do not want to delete your modified files before pulling the official version of the repo, then you can simply move your modified files to some other folder or rename them with new names so that the conflict (the risk of loosing work you have done) will be resolved.)

However, we also advise you to get at least a rough idea of what git has to offer you. Again, the Documentation page of the Git community is an ideal place where to get directions.

The main reasons for you to get into git are: not only git offers you important facilities (free and robust) like backups and working directories that you can in simplicity share among your devices, and powerful and intrinsically safe time machines over them and on your work, but it offers you the means to share and collaborate on your projects and, in fact, it is the portal to the world of open source projects (git was designed by Linus Torvalds in order to scale up its projects concerning the development of the Linux operating system to a wide collaborative dimension). Not only TALight is open source software, but we foresee and foster that problem makers from different countries/regions (but maybe of a same discipline) might collaborate on more or less open didactic projects.

1. open a shell (that is, a terminal, or cmd, or power shell)
2. go to your home directory, and enter:

git clone https://github.com/romeorizzi/TALight.git

to clone the content of this repo. Of course, you can achieve the same result by any other means if you prefer.

Attention (for Windows users): This TAL repo makes use of symlinks since they help avoding unnecessary and undesirable duplications of files and help keeping things well organized and readily accessible. This means that for cloning it propery on Windows, after having opened the git bash as Administrator, you must launch the clone command with the correct parameter. More precisely:

git clone -c core.symlinks=true https://github.com/romeorizzi/TALight.git

Also, when you install Git Bash you are given your chance to activate the symlinks. If you missed that chance, unistall and reinstall git with the Git Bash as explained in that section.

You can also clone and/or place the TALight folder in any other directory of your preference as long as you interpret the following instructions accordingly.

Note: cloning is better than downloading since in this way you get connected to the repo. Even if you do not intend to contribute to the project, still this is handy since, in order to update to the current version, you can simply go (from a terminal) to any folder of the repo and enter:

git pull

There are many ways to solve this nuisance, we list them out from the fastest fixes to the best ones:

PATH=$PATH:$HOME/TALight/rtal/target/debug/
export TAL_HOME="$HOME/TALight"

export PATH="$PATH:$HOME/TALight/rtal/target/debug"
export TAL_HOME="$HOME/TALight"

source ~/.bashrc

mkdir ~/.bin
cd ~/.bin
ln -s ~/TALight/rtal/target/debug/rtald ~/.bin/
ln -s ~/TALight/rtal/target/debug/rtalc ~/.bin/
ln -s ~/TALight/rtal/target/debug/rtal ~/.bin/
ln -s ~/TALight/TAL_utils/problem_solver/TA_send_txt_file.py ~/.bin/ 

export PATH="$PATH:$HOME/.bin"
export TAL_HOME="$HOME/TALight"

source ~/.bashrc

Either way and again, you can check that the TALight commands are now directly accessible with

rtal --help

and

rtald --help

PREAMBLE

Once the two executable rtal and rtald are built and conveniently available then you can already use TALight both in local and in connection to an external server exposing TALight problems and other material for a course, a didactic path or project, a competition, a scouting selection, a challenge, or a game. Whether you are a problem solver (usually a student) or a problem maker (usually a teacher, or a senior student), a general truth and assumption in TALight is that working first in local, whenever possibile, is the best way to experiment, learn and develop. You go out in the wide when ready. Active learning is better organized as a multistage process.

After downloading this repo you already have on your machine a set of working test problems to experiment with, and this section offers you a tutorial on them. The first thing to understand is the way the server and the client interact. This can be confusing at first but every mistery will soon be dispelled. Though the rtald command might not be necessary (at least in principle) to the student in certain settings, for experimenting with the problems in our tutorial you need to launch both the server and the client and let them interact. The server rtald is the daemon and you need to activate it first, then you can issue many requests to it through the client rtal. The server offers two main modalities of activation:

1. rtald activated to serve requests concerning problems sitting on your local machine and coming from the local client.

2. rtald activated by a problem maker or provider/dispatcher to serve requests concerning problems sitting on your local machine and coming from clients on other machines but reaching it through the internet. In this case your rtald daemon will need the bind address and the port from where to listen from the outside world and on which to establish connection with other rtald daemons.

In this tutorial we start with examples concerning modality 1 since all main features appear there. In particular, this is certainly true with the problems of this tutorial that are entirely public and already downloaded with this repo. Moreover, working in local prompts you to action, makes for a more concrete understanding, and fosters your experimental attitudes and skills which is one of the goals of TALight. As a problem solver, the time to connect to the internet comes only when you want to work on problems that (in full or in part) are not openly published (competitions, exams, didactic reasons, privacy reasons, copyright reasons, ...) or to multiplayer problems or games. As a problem maker, you should consider offering the services for a problem from an internet server when your aim is to manage a competition, scouting selection, exam, or you want to offer a challenge through the internet with some control on the flow of information (for example when with your problems you want to instruct a client to the use of a product). Or possibly when you want to offer a very user friendly and attractive service.

When creating a problem and designing, implementing and experimenting its services within TALight you do not need to offer these services online through an internet server. You can experiment them in local and share them by other means with other problem solvers or makers and collaborators to that project. Each of these recipients will have the possibility to make them alive in local with the open source TALight platform. In good conclusion, you need modality 2 almost only to offer a service on the web for problems where some services to the problem solver require pieces that for some reason you do not want to make public. Though the example problems are fully public (you download them as a whole with this repo), still their directory structure is organized as they were not. In the public directory of a problem it is customary to place links to all the materials of the problem that can be made public without spoilering in any way the problem (as for its intended use).

In the case of the problems of this tutorial the whole of the materials comprising them is included in the directory with their names. Nonetheless, one of the first uses of the rtal client you will see in this tutorial is how to get the public material for a problem.

MAKE SURE YOUR DEFAULT PYTHON IS PYTHON3

Use

python --version

to make sure that python3 is the defaut python on your machine. If not, then it is time (and needed) that you make python3 the default.

if you are on Ubuntu, this can be achieved with:

sudo apt install python-is-python3 

STARTING THE TALight DAEMON

To operate with problems you have on your local machine, you first activate the TALight daemon rtald on your machine to serve requests coming from your machine itself (modality 1). When starting the daemon, it is a good idea to first turn on logging, by setting the environment variable RUST_LOG=info.

export RUST_LOG=info

echo $RUST_LOG

Both in modality 1 and in modality 2, you must specify to the daemon the directory containing the TALight problems it should take care of. It is assumed that this directory is located on your local file system and each problem is a direct subdirectory of it. In the case of the problems comprising this tutorial they are placed in the ~/TALight/example_problems/tutorial directory. Therefore, you activate (in modality 1) the TALight daemon with the following command from a terminal where the RUST_LOG environment variable has been set:

rtald -d ~/TALight/example_problems/tutorial

If the variable RUST_LOG was unset you can still set it now, and specifically for this execution of rtald with:

RUST_LOG=info rtald -d ~/TALight/example_problems/tutorial

This second possibility holds only for the bash shell and will not work for the zsh you are given by default if you are on Mac. (You can however launch another shell, like the bash, from other shells. On the zsh of Mac just enter th command bash and, after this, the bash is operating on that terminal. At this point the secon option is available also for you, on that terminal.)

The rtald daemon is now active and ready to serve requests concerning the problems present in the directory ~/TALight/example_problems/tutorial. The terminal where you issued its activation will now be the place where the server rtald updates you about the requests of service it receives and what is going on with them. If RUST_LOG was not set, then you will only get the error messages of the problem service server (the one called when you issued a request through the rtal client), if it crashes or malfunctions, but if the environment variable was set you will have access to further feedback that can help you out.

The help page of the rtald command lists its optional parameters that allow you to expose the service in the wide rather than just in local (modality 2). Still, when creating and experimenting, you will launch rtald as above and operate with no need for an internet connection. Only at deploy time (and if the intended use asks for it) you will expose services for your problems to requests coming from the outside (modality 2). One way to stop the daemon is to Ctrl-C when the focus is on this terminal.

Anyhow, now that the rtald daemon is active and ready to serve our requests for a collection of problems, we are going to access the services available for these problems through the rtal client.

Since the previous terminal is now the downstream channel of the daemon you have activated, in order to enjoy and explore the services it gives you access to, you need to open another terminal. Better yet, rather than opening another terminal, I actually suggest you to vertically split the terminal into two, let the left panel to the visualization of this logging, and issue the rtal client commands in the right panel so that you will keep constantly aware of the interactions between the two (expecially useful for the problem maker).

sudo add-apt-repository ppa:gnome-terminator
sudo apt-get update
sudo apt-get install terminator

rtal list

rtal list --help

sudo apt-get install -y fonts-firacode

vi ./baschrc

Exploring the services available for a problem

To explore the services available for the example problem sum try issuing

rtal list sum -v

For this first rtal problem-set specific request, and for all the others that will follow, be told that if you want to address them to another server made available online (and serving the same problems) you simply need to use the -s option that is mentioned when you run rtal --help.

Either way, you should get something like

- sum
  * sum
    # lang [it] ^(en|it)$
    # num_questions [10] ^([1-9]|[1-2][0-9]|30)$
    # numbers [twodigits] ^(onedigit|twodigits|big)$
    # obj [any] ^(any|max_product)$
  * sum_and_difference
    # lang [it] ^(en|it)$
    # num_questions [10] ^([1-9]|[1-2][0-9]|30)$
    # numbers [onedigit] ^(onedigit|twodigits|big)$
  * sum_and_product
    # lang [it] ^(en|it)$
    # num_questions [10] ^([1-9]|[1-2][0-9]|30)$
    # numbers [onedigit] ^(onedigit|twodigits|big)$

From this you understand that three services (sum, sum_and_difference, and sum_and_product) are up for this problem on your local machine. All three services will conduct a dialogue where you (or a bot you designed to act in your place) will be asked 10 questions (all instances of a problem defined by the service). Indeed, 10 is the default value for the parameter num_questions. You can specify a different value for this parameter (in the next example it is set to 13) but it can take only integers in the interval $[1,30]$ as specified by the regexp ^([1-9]|[1-2][0-9]|30)$ reported above. To know how to interpret (if a problem solver) or write (if a problem maker) these regexps, we refer you to regexp syntax. You can also change the default values of the parameters by editing the meta.yaml file in the directory of the problem. For example, try changing the default value for the lang parameter as specifyied in the meta.yaml file. Not all parameters that rtal sends to the daemon to adapt the behavior of the services are specified in the meta.yaml. For example, for all problems you can ask that the feedback is sent to you in black and white even when rtal detects that your tty supports the use of the colors. You can enforce the suppressing of the colors in any case with the -no-color flag (-n is its short form). You get to know about these service-agnostic flags and parameters by issuing rtal connect --help.

Combining the problem specific information you got above by issuing rtal list sum -v with the TALight core instructions you get with rtal connect --help you could decide to try one of the following services:

rtal connect sum free_sum

rtal connect -a num_questions=13 -a numbers=big sum sum_and_product

Connecting to the services in this direct way you will enjoy a direct interaction with the server through the terminal. This can help you to find out about the service and the protocol of the interaction. Actively experiment also with the arguments of the service, they are thought to help you and sometimes they are also meant to offer an excalation on a problem that starts simple to better approach your curiosity and open mindness. For example:

rtal connect -a numbers=big sum free_sum

or

rtal connect -a obj=max_product sum free_sum

After you have got what competence the problem is trying to address, and the protocol for your interaction with it, you can then go for making a bot exhibiting that competence on your behalf.

The plug in of the bot follows this simple template/mechanism:

rtal connect <problem> <service> -- <my_executable_bot>

where the bot containing your solution is assumed to ultimately be an executable command on your machine. It is also assumed that your bot exchanges with the outside world through the stdin and stdout (and stderr if you want to debug it) streams. (The standard but not required assumption is that it is also located on your machine and that you have forged it yourself.)

For example, if you have written your bot in python (or pick up one already done bots from this repo, under the bots folder for the problem of your interest), then a working plug in could be the following:

rtal connect -e sum free_sum -- python free_sum_mysimplebot.py

Actually, if you are on Linux/Max and the python script free_sum_mysimplebot.py is given excution permission, as it is the case in the repo you have cloned (again, better cloning than downloading, but you can also assign these permissions with the chmod command of the shell), then you could more simply write:

rtal connect -e sum free_sum -- free_sum_mysimplebot.py

The -e flag at the beginning is there because right now you want to assist to the interaction occurring between your bot and the service server. Try omitting it for the service call to proceed silent.

And try out a few other interactions, like the ones triggered by one of the following problem service invocations:

rtal connect -e -a numbers=big sum free_sum -- python free_sum_mysimplebot.py

rtal connect -a obj=max_product sum free_sum -- python free_sum_mymaxproductbot.py

rtal connect -a numbers=big -a obj=max_product sum free_sum -- python free_sum_mymaxproductbot.py

In all these examples the bot had been written in python, but it could be just a binary with permission to be executed on your local system. For example:

rtal connect -e sum free_sum -- free_sum_mysimplebot

Where the excutable binary free_sum_mysimplebot could have been obtained by compilation of a source code written in any programming language of your choice like for example C, c++, Rust, or Java.

Fork the TALight repl for your preferred programming language and work from there

This is also a very convenient option to work, within your preferred programming language, on the problems of a TALight collection of problems or didactical path or syllabus for a course made available to you.

1. Open an account (a free one will suffice) on the amazing service https://repl.it.

2. Experiment what this amazing environment can offer you and customize it.

3. go on our TALlight repl for those programming languages you like, and fork them to make them your own. In this way you will end up with a rather personalized environment offering you in one single place both your preferred programming language, the binaries comprising the TALight platform, the problems for that collection/syllabus.

Of course, you will need to update the binaries and the problem collection when they move ahead (which happens rather fast in this first year of actual experimentation in our own courses). One simple way to do this is to return to the original repl and fork it again (you need to manage the recovery of the bots and solutions you have developed from the previous fork. The best way is to download them in local (one click) and then to update this version in local update after update). Then you will updload (or even just copy and paste) an old solution in the currently last and active fork of yours when you need it (mainly when you want to use it as a template to minimize your editing or when you want to come back to it to improve it or complete it to the most difficult tasks and goals, maybe incorporating into it a new technique you have just learned).

Here are our mother repls from which to fork, organized by programming language and syllabus:

Applets for the browser (enhanced visualizations for specific problems/games)

Problem sum also exemplifies how to interact with a service through a browser rather than through the terminal. In this way and by resorting on HTML/CCS/JavaScript technology, nice applets running on the problem solver site can be designed for more user friendly interactions. Just look in the applets directory of the project (~/TALight/applets) and open the file sum-protoapplet.html in a browser.

~/TALight/applets$ google-chrome sum-protoapplet.html

~/TALight/applets$ open -a "Google Chrome" sum-protoapplet.html

file:///home/romeo/TALight/applets/sum-protoapplet.html

In this file, it is easy to spot out and substitute the hardcoded problem-specific parts and get an analogous page for a first browser mediated interaction also for other problems. One can start from here in order to develop ad-hoc applets specific to other problems and offer fun active learning opportunities also to kids that do not yet know how to code.

Here is how to use the rtal client in order to get the public material for a problem.

rtal get eggs 

After issuing this program you will find a file named eggs.tar in your current directory. If you untar this file a directory eggs will hatch. Inside this directory you will find all the material of the problem that the problem solver has decided to make public (simply putting symlinks to those files and folders in the directory public). Notice that among the materials that the good problem solver has decided not to make public is the file correct_table.txt. Do you see the reason why? Launch

diff -r eggs ~/TALight/example_problems/tutorial/eggs/public 

to see other differences and ask yourself the reason why.

Yes, problem eggs is the next problem of our tutorial. But, before leaving problem sum, visualize its statement. We suggest you to use your browser. To do so, first set up your browser so that it can correctly visualize plain Markdown files sitting on your local machine. In the case of chrome how to do this is explained here. Then,

rtal get sum
tar -xvf sum.tar
google-chrome sum/statement/statement.it.md

Of course, you could have visualized this file even before asking for the public folder of problem sum, since the whole of problem sum, including its public directory and its statement where already sitting on your machine as part of the TALight repo (or you could have browsed this Markdown document from there, in the internet). We are however happy that you read this document for last, both as a problem solver and as a problem maker. Then, to grow as a problem maker, run

diff -r sum ~/TALight/example_problems/tutorial/sum/public 

and ask yourself the reasons for these more refined differences.

Clearly, problem making is an art. More than we can say is already in your hearth and passion. Our only intention here in this section is to smooth your way to acquire our tools.

Take a problem you have to:

1. think about the competence you want to transmit and see if you can pose challenges that make it alive and try to go deep on it.

2. compose a document containing the statement of the problem, and think of services that could support, guide, stimulate the problem solver.

3. summarize these services into the meta.yaml file in the root of the folder of the problem.

If you lounch:

tree ~/TALight/example_problems/tutorial/sum 

you will discover the main directories usually comprising the problem folder. These are:

1. statement is the folder were we keep the statement which can be in any format you might prefer (.txt, .tex, .pdf, .doc, .mp4, .mov, ...) and produced with your preferred tools. This folder can contain docs in various languages, and also multimedia.

2. services is the folder were we organize and obtain the executable codes providing the services. It usually contains one subdirectory for every service. In the examples of the tutorial at the next level we have directories for various languages since we want to show to the problem maker that and how he can use the programming language he prefers. There is no need to write more than one code for a same language. One single code in a language of your choice will serve all students (irrespectively of the programming languages they use, if any).

3. meta.yaml contains a list of the services with information on the executable to call to satisfy a request and on the possible parameters for these calls. It is a good idea to begin compiling this file while organizing the statement and taking decision on the problm you want to propose and its services. The incormation here collected is what is returned by commands like

rtal list morra -v

Please, compare the output of this command and what written in the file meta.yaml. Also, try to modify some f its line, like for example substituting the lines

  sum_and_difference:
    evaluator: [services/sum_and_difference/python/advanced/sum_and_difference_server.py]

with the lines

  sum_and_difference:
    evaluator: [services/sum_and_difference/python/simple/sum_and_difference_server.py]

in the ~/TALight/example_problems/tutorial/sum/meta.yaml file

This should allow you to test the simpler versions of codes that serve the intended service. See how simple serving a problem can be before entering in the (only superficial) obfuscations coming with colored outputting and multilingual support. As you can see, both for problem sum and for problem morra all services are implemented both in a simple and in an advanced manner. Starting from the simple and then looking at the advanced should help your way through to all the little proficiency needed on the technical level, and ready to express yourself on the creative side of problem making.

There is also a service for checking whether a meta.yaml file is fit:

rtalc ~/TALight/example_problems/tutorial/sum

it should out no line of error since/when this file is ok. The path it takes as argument is the path of the folder containing the meta.yaml file organizing the services of the problem.