Why Open Education Needs a Common Language!?
- André Dietrich, Sebastian Zug
- Article , Community , Examples
- September 6, 2024
A better question would be: Why do commercial offerings and e-learning platforms dominate online education and “NOT” Open Educational Resources (OER)?
Before we attempt to answer these questions, we want everyone to complete the following sentence for themselves:
Open Educational Resources (OER) are primarily about …
- … the use of content.
- … their creation.
It is no wonder that many initially think of licenses and terms of use. Creation (2.) seems boring and time-consuming. As an OER enthusiast, one starts with big ideas, which often fail due to a lack of technical skills and underestimated effort. Thus, most projects unfortunately end in static formats such as PDFs, Word documents, images, or PowerPoint presentations. Podcasts or educational films are more elaborate, and creating a website requires even more effort. With some programming knowledge, one might even create an entire app. With a Word document, an individual can still make changes (leaving aside the collaboration of author teams), but PDFs, videos, and podcasts are one-way products (which cannot be adjusted afterward), and with websites and apps, an outsider might be able to make changes but faces insurmountable technical hurdles or simply lacks access rights. In the worst case, development and hosting even incur costs that one has to bear themselves.
Participation, as we wish for it and as we know it from the open-source world, is actually not possible in this way. Cynically viewed, the PDF file is the stone tablet of the digital age, static and optimal for print media (but not suitable for reading on a smartphone), not interactive, and difficult to change. However, a computer enables us to experiment, simulate, immerse in content, change something, and verify it.
Why can’t an OER enthusiast simply change two lines in an app or translate it? Or why can’t a user (students/parents) rephrase quiz questions or even restructure content?
As mentioned before, because the technical skills are lacking and secondly, because it could otherwise lead to a huge mess with different versions.
But that’s exactly what OER creation is about: diversity, changeability, and continuous improvement …
Spoiler Alert: The following video shows how interactive teaching content is created at TU Bergakademie Freiberg with LiaScript and hosted on GitHub (we will get to both). Each point represents a file and each figure a person who changes, adds, or deletes a file; these are on one hand employees of the Software Development and Robotics working group and on the other hand students.
If we orient ourselves towards the open-source movement, then OER could actually work, right? Many initially small projects that grow over time and through organized and decentralized participation of many over the years. How does that work?
About the Economics of Open-Source Projects
One thing is clear: Everyone who works on an open-source project has a common goal. They use a library or app for their own purposes and give back a part of their value creation. When large companies like Facebook or Microsoft release open-source projects, the many volunteers are an enormous force that not only finds bugs but also brings in extensions, writes tests, and documentation. They benefit from it themselves.
Imagine if large educational publishers in Germany put their content online under a free license as an OER/OS project, so that many teachers and learners could work together on the materials or create their own versions from them. Unthinkable! And why is that?
Because open-source projects have something that OER (still) does not: a common (programming) language. A language in which communities develop around small or huge projects, be it the Linux operating system, the Firefox browser, AI projects, or educational apps.
Besides the language, there is another ingredient that allows the work of countless authors to be organized, versioned, and orchestrated.
A decentralized version control tool called git is used for this, with GitHub.com as the largest platform.
Review systems, discussions, automated tests (spelling), and much more are already integrated here.
These problems are considered solved here and are nothing new for most developers and have been for over a decade.
What does the e-learning community or edTech have to counter this? Right, an almost endless number of platforms, tools, and formats that drive us more and more apart and isolate us rather than bring us together. Who knows that on Moodle XY, which is hosted at school ABC in Weißenfels, a teacher is developing a similar course to mine …
In the following sections, we will deal with the LiaScript language. There are already many good tutorials and courses on git and GitHub. In the following video, you will get a very good brief introduction to the concepts of git and GitHub. Believe us, it is worth it.
Unlike all other platforms you may have tried, GitHub will be the last one you will use.
Fun Fact: Git also comes from the pen of Linus Torvalds, the developer of Linux. He was dissatisfied with the commercial version control tools at the time and sought a way to work on Linux in a decentralized and offline manner. Here is a short history of git:
https://git-scm.com/book/en/v2/Getting-Started-A-Short-History-of-Git
LiaScript – A Language for OER
The idea for LiaScript originated in 2017/2018 in the “Industrial eLab” project. It was about developing online labs for teaching in engineering sciences. The following video shows our first steps with LiaScript.
We were looking for a way to quickly and easily produce teaching content as a team. Markdown, as an easy-to-learn and already established markup language, offered itself as a common foundation. HTML is also a markup language, as the name HyperText Markup Language suggests, but it is much more complicated. Markdown has now become the standard for blogging (JAM-Stack), documentation of IT projects (GitHub), with editors in Moodle and others – all use/support Markdown more or less.
Try sending the following message via WhatsApp:
With such annotations, Markdown allows simple formatting like code, italics, bold, and strikethrough in texts, and these can also be combined/nested. Texts can be structured just as easily:
You can immediately see what is a table and what is a list. As a finger exercise, everyone can try to expand the table with more cells or columns. Then simply press the “Compile” button at the top right and observe how the result changes. In your mind, try to remember which menu items in Word or PowerPoint need to be clicked for this. If you can do that, then we are more than impressed 😉
Visual Metaphors & Quizzes
You can think of Markdown as a kind of “visual metaphor” to describe the structure of texts and other elements. Your canvas is a simple text file and your brushes are the keyboard. No clicking and remembering complicated sequences with different menus, just writing and seeing what happens. This was also our core idea in developing LiaScript, to bring the didactic experts on the team on board. We wanted to extend the visual and simple language of Markdown and add more interactive elements that seamlessly integrate into the Markdown language.
The following example shows a simple “to-do” list:
We have simply further developed these to-do lists, as shown below, to also include quizzes and surveys in our teaching materials. This allowed the didactic experts to gather feedback from the students or observe their progress.
The square representation above is reminiscent of checkboxes as used in HTML. For single-choice quizzes, one would use round radio buttons, where only one option can be selected:
More Quizzes
If you extend this idea by using double brackets [[...]] for quizzes, you can create a variety of other quizzes in the form of cloze tests, selection options, matrix quizzes, etc., in combination with other Markdown elements.
Here is an example of a “German Grammar Test”:
Admittedly, the above example for a quiz is a bit too large; it was only meant to serve as an example. LiaScript offers additional possibilities to provide hints or additional options, making it easier to design or configure a quiz.
Surveys
Admittedly, the above example for a quiz is a bit too large; it was only meant to serve as an example. LiaScript offers additional possibilities to provide hints or additional options, making it easier to design or configure a quiz.
Try converting this multiple-choice survey into a single-choice survey yourself.
The advantage of developing learning content in this way was that it could be created by us without any configuration effort and as a team, with the computer scientists creating the learning content and the didactic experts creating the surveys and quizzes to test the knowledge level.
Multimedia
YouTube offers a variety of educational materials, but they cannot be directly embedded in Markdown because most Markdown viewers prohibit JavaScript or embedding external content via IFrames.
To also be able to use such content and embed it in LiaScript courses, we have extended the syntax as before. The following example first shows the general Markdown syntax for embedding links and images; then come the LiaScript extensions:
The double question marks ?? in the last links indicate that the content should somehow be embedded. LiaScript uses various browser-side strategies to embed simulations from Phet, 3D models from SketchFab, or circuits from Falstad.
We have explained the internal workings of LiaScript in more detail in the following blog post:
Embedding Multimedia - How does it work??
Programming in Markdown
When learning to program, many code examples are essential. For this purpose, Markdown already has a syntax, so-called code blocks, which are enclosed with at least three backticks.
The top term is an indicator for the programming language and the syntax highlighting to be used, followed by the actual code. Originally, we used a separate editor for our robotics projects, which forced students to constantly copy code back and forth. Our Arduino robots were programmed in C++, which raised the questions:
- Why can’t the code examples be executed directly?
- And what is actually necessary to execute code in other languages?
Our solution was to append a <script> tag that defines how the above code or text should be interpreted.
For JavaScript, this is relatively simple:
Every code block to which a <script> tag is appended is interpreted in LiaScript as executable code with console output.
Click on Execute and observe how the output changes.
Such execution instructions can also be attached to quizzes, surveys, or to-do lists to adjust their behavior.
@input simply defines a general placeholder here and everywhere, indicating where the current code should be inserted in the script.
Within a code block, changes are tracked using linear versioning. In other words, you can move forward and backward in your versions and change an old state, which is then appended as a new state – no change is lost.
The didactic experts on our team could directly analyze the students’ approach to programming. At this point, many ask: Where are the data/states stored in LiaScript – the code, the quizzes, and surveys? The answer is simple: directly in the user’s browser. Modern browsers have built-in databases like IndexedDB, which we use to store the courses and all related information. With LiaScript, it is therefore not necessary to send data around the globe and store it in a central database. Instead, LiaScript works in a decentralized manner. Knowledge can also be tested offline, meaning each user can go through the learning materials at their own pace and completely anonymously.
In the “Industrial eLab” project, we reused this data for research purposes. We ourselves did not yet know the possibilities a modern browser offers.
Projects
In addition to simple code blocks, projects can also be defined that consist of multiple code blocks/files.
These are simply concatenated and also appended with an additional <script> tag.
To avoid confusion with the blocks, it must be specified which block is to be inserted where.
@input(0) addresses the first code block and @input(1) refers to the JSON file, etc.
Open the upper part, adjust both code blocks, and click on “Execute”. Whether a block is open or closed is defined by a plus or minus sign in front of the file name.
External libraries or external services like our CodeRunner can also be used for execution. The scripts necessary for this quickly grow in scope and complexity, making them difficult to maintain. To counteract this, we developed a macro system that allows recurring tasks to be simplified (automated), as is common in computer science. In LiaScript, Markdown documents can be treated like libraries that implement specific functions and can be reused in other courses or Markdown files. The idea behind this is explained in the next section; if this is too technical for you, you can skip this part.
Extensions and Macros
Macros are an excellent way to simplify and automate recurring tasks. In short, these are just text replacements that can be inserted at any point. To do this, simply define a command/name in an HTML comment at the beginning of the document, followed by everything that should be inserted:
As in other programming languages, these can also be parameterized in LiaScript.
In the macro body, the places to be replaced are marked with @0..9:
Importing Extensions
Of course, no one wants to always copy all commands back and forth.
As you would expect from a library, such macro collections can be easily integrated into the current course using an @import statement.
In the following example, another document is imported that allows embedding ABC notations for creating musical scores.
Why shouldn’t you be able to program with music as well?
Notes are a form of programming language that allows you to compose music.
And in LiaScript, this can also happen interactively using ABC notation.
Change the code and click on “Compile” to see and hear the changes.
As shown in the section “Programming in Markdown”, you only need to append a <script> tag.
In the example below, this happens automatically by appending the macro @ABCJS.eval.
Text can also be analyzed to improve readability or style, for example. At TU Freiberg, this is used in foreign language classes to provide students with direct feedback using various metrics:
As already mentioned, we mostly use LiaScript for learning to program. An overview of existing extensions can be found here:
https://github.com/topics/liascript-template
Otherwise, we are happy to add new extensions for you or support you in this process in LiaScript.
And for scientific publishing, there are also extensions that you can use:
Additional Features
Different Display Formats
Since computer scientists tend to optimize and automate work, we have integrated the function in LiaScript to read a document either page by page like a normal book or to include animation steps. Thus, the same document can be used both as a slide set in lectures and by students in book mode or presentation mode with built-in speech output. Modern browsers nowadays offer text-to-speech functions, the quality of which can vary depending on the device, operating system, and browser.
We don’t want to go into too much detail here, but the following video provides a brief summary of the usage.
Similar to quizzes, everything related to animations or speech output is marked by two curly braces {{}}.
Recently, you can even use your audio recordings or video recordings to narrate your courses. You are already familiar with the LiaScript notation for audio and video. The following video shows how you can link these with the comments.
ASCII Art
ASCII Art stands for “American Standard Code for Information Interchange” art, a graphic design technique where images, symbols, or text are created by arranging characters from the ASCII character table. This art form, which dates back to the early days of computer technology, originated from the need to create graphical representations on devices with limited graphical capabilities.
In LiaScript, ASCII art can be used creatively to integrate visual representations directly into texts. This can be particularly useful for creating simple diagrams, sketches, or symbols without requiring external image files.
Of course, LiaScript and Markdown can also be seamlessly combined with ASCII graphics. This allows for interesting combinations with quizzes, but also animations. The LiaScript elements just need to be “marked” with quotation marks:
Automatic Visualizations
Datasets in tables are automatically analyzed, and various rules are used to try to find the best representation. Switch to the table view, rearrange the columns, and observe how the visualization adjusts.
Anyone who wants to start drawing right away can do so and draw simple diagrams and curves. If it looks like a diagram, then it probably is a diagram …
Formulas
In LiaScript, formulas can be easily inserted into Markdown documents by using the proven LaTeX syntax. This syntax allows for clear and precise representation of mathematical expressions, which is particularly important in scientific and technical texts.
The inline notation is used to insert formulas directly into the text.
This is done by placing the mathematical expression between two dollar signs ($...$).
This method is ideal for shorter formulas or simple mathematical expressions that fit into a sentence.
For more complex or extensive formulas that require their own line, the block notation is used.
Here, the mathematical expression is placed between two double dollar signs ($$...$$).
The formula is then centered and prominently displayed.
LiaScript offers much more, but we want to leave it with the “static” elements and move on to dynamic elements in the next section. A feature that we wanted to integrate from the beginning and which we still see as a hidden gem of LiaScript is the use of JavaScript.
JavaScript Everywhere
JavaScript? At first glance, this doesn’t sound particularly grand, but we were inspired by Bret Victor. Here is a lecture that summarizes many of his ideas, many of which should also flow into OER projects:
We have reinterpreted the use of JavaScript.
Free <script> tags can appear anywhere in the text in LiaScript.
Unlike Jupyter Notebooks, where text is written around the code, in LiaScript the code is directly embedded in texts, tables, etc.
The execution of a script can have a result that is also displayed directly. Unlike in JavaScript, where the code merely manipulates the document from the outside and makes changes that are difficult for the user or reader to interpret. What does this look like specifically?
In the simplest case, calculations that you do not want to perform yourself can be executed within such a script:
This is nothing special yet. But if we imagine how many educational materials use current climate, economic, or social data, it quickly becomes clear how important it is that this data is not only correct but also up-to-date.
A simple example of this is calendar calculation:
This document will now always display the actual number of days and format it accordingly. The highlighted background indicates that this text or number was generated by the calculation of a script. The user also has the option to inspect and modify the respective code by double-clicking. You don’t have to blindly trust the results of calculations summarized in a document; you can also directly verify them and perform your own calculations.
In LiaScript, we can go a step further and link scripts directly with input options as well as connect scripts with each other.
This means that if the result of one script changes, the dependent scripts will also be recalculated.
The parameter ‘output’ is used to give the script a name.
This result can then be referenced within other scripts throughout the document using ‘@input(name)’.
Within LiaScript, a processing graph is created where scripts whose inputs ‘@input’s have changed are recalculated.
Change the values of the sliders and observe the changes in the diagram.
Now everyone is probably thinking: “Phew, that’s really just for programmers.” But far from it. Thanks to ChatGPT, which also generates “Markdown”, we can have such diagrams or other elements created by AI. An AI will not achieve this right away if it has not been trained on LiaScript, but we can give it context. In this case, the context would be an example from the documentation that we would like ChatGPT or Claude.AI to adapt for our purposes.
In the following blog post, we show how to generate various diagrams with a single prompt, using the above example, without writing a single line of code ourselves:
https://liascript.github.io/blog/creating-interactive-diagrams-with-chatgpt/
Why LiaScript?
We believe that OER does not need another platform, learning management system, or authoring tool that only further separates OER creators. Instead, we need a simple language that anyone can use and extend. A language in which teams can collaborate to work on content, functionality, and representations together, each in their own way. A language for OER offers another advantage over platforms and tools: users can freely express their creativity, develop their own functions and extensions using this language, and are not trapped in fixed input masks and structures.
Decentralization can also foster innovation by allowing for experimentation and local adaptations without the failure of a single project endangering the entire system. A decentralized approach could also promote the development of open, community-shared resources that are freely accessible and can be further developed by the entire educational community. This would not only improve the sustainability of the projects but also promote the democratization of knowledge.
In summary, LiaScript offers the following:
Accessibility: Anyone can create or edit materials with a simple text editor. No special software is required.
Interactivity: Add quizzes, simulations, and videos directly into your documents to make learning more exciting and effective.
Collaboration: By using GitHub, you can work on projects together, track changes, and manage different versions of a document – all in a form understandable to non-technicians.
Decentralization: Your content is not tied to a specific platform. It can be freely shared and adapted, creating a true community around learning.
Decentralization in combination with Git and GitHub/GitLab/Bitbucket also offers a completely different form of sustainability: No intermediate version is lost; each of these intermediate versions can be recalled and restored as a course. Anyone using Git or another version control tool has the entire history of a project locally. If GitHub goes offline tomorrow, all participants still have the complete state and can still make changes and synchronize versions with each other without GitHub as a central repository.
Decentralization
Finally, we want to clarify how courses are shared when they are stored and developed in a decentralized manner. For this, only the URL of the plain text file is needed, which either refers to a version on GitHub/GitLab (free) or is hosted by the OER content creators themselves. This “document” can be found, for example, on GitHub in the following project:
https://github.com/LiaPlayground/Warum-offene-Bildung-eine-Sprache-braucht
To access the plain Markdown file, you either click on the corresponding file and then on the small “Raw” button to get the following URL:
If you look closely, you will notice that the URL has changed from github.com to raw.githubusercontent.com and the additional /main/README.md suffix has been added.
This means the main branch of the project is used, and the README.md file is downloaded.
As mentioned earlier, on GitHub you could also access other branches or previous versions.
What is now missing is that this URL is passed as a parameter to the LiaScript website.
At first glance, this may seem cumbersome, but it has the advantage that we can change and adapt our content at any time without the URL changing. The LiaScript website is a so-called PWA (Progressive Web App), a pure JavaScript application that can also be installed on the end device. The URL parameter instructs the app to download, analyze, and render the Markdown file located behind the URL locally in the user’s browser. The first load may take a little longer as the entire structure is analyzed first. The result is stored in the browser itself in the internal IndexedDB database, so it can also be accessed offline. If you click on the home screen in the table of contents, you switch to the following index view:
https://liascript.github.io/course/
Here, any visited course can be recalled, and you can continue with the material. The LiaScript site is more of a reader/interpreter for LiaScript Markdown than a traditional website. We update the website/interpreter, and you update your content.
Classrooms
Additionally, within a course, you can go to “Share Classroom,” select one of several synchronization solutions, choose a random name for the classroom, and then click “Open.” You can share the new URL in the browser with your students, classmates, or colleagues, who can then join the same room. Not only will the same course be opened, but all quizzes and surveys will also be anonymously synchronized. The code editors have a collaborative mode where everyone in the room can work together, and there is a chat that also understands LiaScript syntax, allowing live surveys to be conducted in class similar to Mentimeter.
Where are these data stored now? Here, too, only decentralized mechanisms are used. The states of the browsers are synchronized, and if someone leaves the room, they take their own data with them. And when everyone has left the room, these data are forgotten as well. We call this concept Classroom-Lite …
Where do I start?
We hope we have convinced you, and if you now feel overwhelmed by the many features and wonder where to begin, how to create and share a course.
As a starting point, we recommend the LiaScript website, which we host for free on GitHub:
Here you will find more information and also the documentation, which is also written as a LiaScript course, as well as suggestions and news in our blog. We also have a YouTube channel where we regularly introduce new features and use cases:
https://www.youtube.com/@liascript4180
For those who want to dive right in, we recommend watching the Shorts as well as the interactive documentation translated and recorded in LiaScript:
https://www.youtube.com/watch?v=ElxYssylmaw&list=PL7LrRfaZulhc3w4rebIl8Dnck6zqdKeNn
The entire project is hosted on GitHub:
You can give us feedback there, report bugs, or contribute your own extensions. For quick answers and discussions, we also have a chat on Gitter:
https://app.gitter.im/#/room/#LiaScript_community:gitter.im
… or just send us an email at:
or follow and contact us on Twitter/X: