Towards an Ontology for the Foundations of Software Languages
This paper introduces the first release of the "Foundations of Software Languages" (FSL) ontology, a knowledge resource designed to unify diverse software language concepts for Computer Science education, which was developed using a standard methodology enhanced by Generative AI.
Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer
Imagine you walk into a massive, chaotic library. This library doesn't just hold books; it holds every single type of "instruction manual" humans have ever written for computers. There are programming languages (like Python or C++), modeling languages (blueprints for software), database query languages, and even the rules for how software is built.
Right now, this library is a mess. The books are piled on the floor, the labels are inconsistent, and no one knows exactly how a "database query" relates to a "compiler."
The Problem:
Computer scientists have been building these languages for decades, but they haven't had a single, unified "map" or "catalog" that explains how all these different types of languages fit together, what tools build them, and what formal rules (math) they are based on.
The Solution (FSL):
The author, Ralf Lämmel, has built a new kind of map called the Foundations of Software Languages (FSL). Think of FSL not as a book, but as a digital, living encyclopedia (an "ontology") that organizes the entire universe of software languages.
Here is how the paper explains this project using simple analogies:
1. The "Master Catalog" Analogy
Usually, if you want to find a book, you look at the Dewey Decimal System. But in the world of software, we have different systems for different things.
- FSL is the Master Catalog. It doesn't just list languages; it connects them. It tells you that "Java" (a programming language) and "OCL" (a modeling language) are both "Software Languages," but they share some concepts (like "object-oriented") while having others that are unique to them.
- It also maps out the tools (the hammers and saws used to build these languages) and the formal math (the blueprints and physics) that make them work.
2. The "Construction Site" Analogy
The paper argues that building software languages is like running a massive construction site.
- The Languages are the buildings.
- The Tools are the cranes and excavators.
- The Formal Systems are the physics and engineering laws that ensure the buildings don't fall down.
- Software Engineering Activities are the phases of construction (planning, building, testing).
Before FSL, we had blueprints for the buildings, but we didn't have a single diagram showing how the cranes, the laws of physics, and the construction phases all interacted. FSL draws that big picture.
3. The "AI Co-Pilot" Analogy
Building a map this big is a huge job. The author used Generative AI (like a super-smart, fast-reading assistant) to help.
- The Human: The author (the architect) decided what to build and checked the work.
- The AI: The AI acted as a research assistant. It helped find new categories of languages, suggested names for relationships, and filled in missing pieces of the map based on the author's examples.
- The Result: The AI didn't build the map on its own; it sped up the process, allowing the human to focus on the big picture while the AI handled the heavy lifting of data organization.
4. The "Technological Spaces" Analogy
The paper introduces the idea of "Technological Spaces." Imagine different neighborhoods in a city:
- One neighborhood is Model-Driven Engineering (where everything is built from blueprints).
- Another is SQL (where everything is about databases).
- Another is XML (where everything is about data tags).
FSL maps out these neighborhoods. It shows you that if you live in the "Model-Driven" neighborhood, you use specific tools and follow specific rules, and it shows you how to travel to the "SQL" neighborhood if you need to.
What the Paper Actually Achieved (The "First Release")
The paper presents Version 1 of this map. It's not the final, perfect version (the author admits it's a "Minimum Viable Product," like a prototype house).
- It organizes the chaos: It groups languages, tools, and math concepts into a structured hierarchy.
- It connects the dots: It shows relationships like "Tool X processes Language Y" or "Concept Z is used in Activity A."
- It's open for business: The map is published online (on GitHub) so other experts can look at it, fix mistakes, and add more rooms.
Why Does This Matter?
The primary goal, according to the paper, is education.
Imagine a student trying to learn computer science. They might take a class on "Programming," another on "Databases," and another on "Software Engineering." Currently, these classes feel like separate islands.
FSL is the bridge. It helps teachers and students see how all these subjects connect. It provides a single, organized knowledge base that ties together the theory, the practice, and the tools of the software world.
In short: The paper is about building the first comprehensive "Google Maps" for the entire world of software languages, using a mix of expert human knowledge and AI assistance, to help students and researchers understand how everything fits together.
Drowning in papers in your field?
Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.