Why aren't there DSLs for Operating Systems? (Or are there?)

If you look at C and UNIX, you will see that there is a very intimate relation between those two. If you write an operating system, what is the easiest language to use if you want to build on top of that operating system? The answer is almost certainly the language you wrote that operating system in.

In some sense C was the DSL to build UNIX. It becomming a general purpose language happened after that and because of the success of UNIX.

Also in general operating systems are extremely complex and need a wide range of functionality and extensibility while being able to easily interface with assembly. That makes a DSL tend towards a general purpose language, as has happened with C.

You may be very interested in the STEPS project from Alan Kay’s Viewpoints Research Institute. STEPS was an attempt to build an entire desktop operating system environment with only 20,000 lines of code. In order to accomplish this, the design makes extensive use of DSLs defined using OMeta. There are examples of TCP and the 2D graphics framework being implemented in an impressively small amount of code.

http://www.vpri.org/pdf/tr2012001_steps.pdf

sh IS the DSL*, otherwise, I'm not sure what you mean by "for operating systems".

The question "What is the domain specific language for operating sysyems?" is meaningless and unanswerable, because "operating systems" does not define the D in DSL in any meaningful useful way.

* For instance, when you try to replace all the sh scripts in a distro with say python (as some distros have tried to do) you immediately discover several ways that python is far less convenient for executing external executables and feeding, collecting, piping, their inputs and outputs. Then for all of the arcane annoyances with bash/ksh syntax, it's basic shell / batch / glue functionality is more important than all of it's "not like a better designed general purpose language" annoyances. In other words, exactly, it's not a general purpose language, it's a domain-specific language.

There are a number of DSLs for specific tasks, such as eBPF or Dtrace filters, Julia Lawall’s semantic patches, DSLs for device driver development or writing system call emulators and many more.

A DSL covering more and different parts of OS development would probably have to be so general that it doesn’t make sense not to use a general purpose language…

If macOS has a DSL, it's AppleScript.

AppleScript is a scripting language created by Apple. It allows users to directly control scriptable Macintosh applications, as well as parts of macOS itself. You can create scripts—sets of written instructions—to automate repetitive tasks, combine features from multiple scriptable applications, and create complex workflows.

  set targetFolder to POSIX file "/Users/Me/Desktop/MyFolder"

  tell application "Finder"
      set finderFolder to item targetFolder
      set lstTargets to target of every Finder window
      if {finderFolder} is in lstTargets then
          set target of (make new Finder window) to targetFolder
      end if
  end tell

That said, AppleScript is probably not long for this world. The future looks more like visual programming via Shortcuts.

I'm not sure I understand the question, but I interpret it as being about one of two things: Importing code written in a DSL into the OS at run-time, and creating a custom OS kernel specified in a DSL at compile-time. There do exist examples of both, and there is some overlap between projects.

Widespread examples include firewalls and routing rules written in DSLs, which get compiled into a form that gets run inside the kernel. Example: nftables in Linux.

Some research OSes allow drivers to be written in a "safe" language to run inside the kernel. Some perform JIT-compilation, others create a custom kernel at compiled-time. Go search for Scout, Termite2, and Synthesis Kernel.

Devil is a DSL for device drivers: http://phoenix.inria.fr/software/past-projects/devil.html

The definition of DSL is vague, but at least in some sense, some operating systems do implement such a DSL.

For Windows between 2000 and 7, that would be VBScript. The language itself is primitive, but through various COM APIs (WMI, ADSI, ADO, MSXML, WScript.Shell, etc.) one can do borderline anything with the OS, or even with the whole Windows networks.

Modern Windows, while still supporting VBScript and most of these COM things, has also added PowerShell as another option.

Defining a DSL for writing operating systems would essentially be the same as writing an operating system (a huge amount of work!). The range of what an OS does is wide enough that your DSL will probably be pretty general purpose anyway, though.

DSLs for interfacing with OSes exist in the form of command shells, syscalls, and ABIs.

For many years, IBM has developed its mainframe operating systems in a series of proprietary languages, such as PL/S and PL/X, designed specifically for systems programming.

Compilers and manuals for these aren’t generally available, but here are published descriptions of two older variants, for use by customers who received source listings on microfiche:

http://www.bitsavers.org/pdf/ibm/360/pls/GC28-0786-0_Guide_t...

http://www.bitsavers.org/pdf/ibm/360/pls/GC28-6794-0_PLSIIgu...

Your question isn't completely clear. What is it that you want this DSL to do exactly? Windows has PowerShell, which is precisely a language to reduce the complexity of managing systems. AppleScript is a DSL for controlling your macOS desktop (and more). The various shells available on Unix systems works as glue, but perhaps not exactly a DSL in the same sense that I feel PowerShell is.

Ansible, Puppet or Nix could also be viewed as operating system DSL. Again depending on what your goal is.

Depends on how define OS 'DSL', 'os' just metadata bindings for hardware / software

* embedded os : https://blog.felgo.com/embedded/embedded-operating-systems

* OS modules / daemons : ebpf / systemd

* ebpf : https://news.ycombinator.com/item?id=33489935 ; https://news.ycombinator.com/item?id=33462031

* tiny core : https://en.wikipedia.org/wiki/Tiny_Core_Linux

* yocto : https://www.yoctoproject.org/

* 'bootloaders' don't have to just 'load an os' https://wiki.archlinux.org/title/syslinux

* uefi : https://askubuntu.com/questions/651902/what-is-the-differenc...

* OS device drivers for external devices such as printers (post script printers)

* OS api's

I like your question.

I am currently interested in this problem and more specifically the expression problem.

Also the problem of how do you tell a computer to do X operation when it encounters Y.

Computers are often turning machines and state machines.

I recently implemented async/await with a giant switch statement.

Async await is far more powerful than bash jobs.

I think the scheduling of processes on a computer needs a powerful DSL.

Kubernetes is interesting since it scheduled processes on a cluster of nodes. But it doesn't define pipelines.

Kafka defines a pipeline for processing.

Bash defined pipelines of operations and processes text.

Java streams define a pipeline.

JavaScripts promises and C# async/await are interesting for scheduling tasks.

ETL workflows Extract Transform Load and Enterprise service buses often have visual DSL/GUIs with eclipse tools for defining mappings.

In Python I often chain together processes with POpen. But it's very low level

I think all these topics are linked.

I want a DSL for defining operations and chaining them together similar to a pipeline. I also want when_any and when_all support and multithreading support.

I didn't read a lot about it, but I recall that Microsoft created a language called P that was a DSL for writing device drivers (more generally, state machines, but I think the point was to use it for device drivers). I also recall they (allegedly, at least) used it to rewrite the USB stack for Windows 8.

Looks like they released the compiler under the MIT license and put it on Github, so you may want to look into it.

https://en.wikipedia.org/wiki/P_(programming_language)

https://p-org.github.io/P/

https://www.microsoft.com/en-us/research/project/safe-asynch...

Programming probably has a better shot at this happening if programming can be automated more.

DSLs for operating systems might be easier to write with programming languages that have higher-order unification – meaning that they can automatically piece together programs to fill out the meaning of one smaller word that has a complex, concise meaning – and totality checking, which means that given subprograms can be known to run to completion. And first-class types. (Dependently typed languages.)

This combination allows for tightly controlled and deterministic automation of programming, which is especially useful for getting rid of boilerplate code, conversion between formats, serialization and deserialization – and the maintenance of this kind of code… when all targets are moving targets due to many pieces of software that change from day to day. As found in things as complex and arbitrary as operating systems.

Original LISP was pretty much a DSL for symbolic computation, something that wasn't exactly catered to at the time (it wasn't first, but it was so early in computing you could write a Master's Thesis about IF-THEN-ELSE construct).

That said, various Lisp Machine systems as well as internals of Lisp implementations often contain DSL for implementing the OS/language, sometimes with many smaller DSLs (while the ur-example is "LOOP" macro from MIT, my favourite is a file from Genera bearing a comment - paraphrased - "behold, I implement half of PL/I to implement structure packing into byte vectors").

Of course, in languages like Lisp or TCL the separation between DSL and main language is not so stark as in case of DSLs implemented in let's say C or Java.

This smacks of forgetfulness. I wonder what the age is of the OP.

As others have pointed out, *nix systems (Linux in particular) are rife with DSLs. Not just C but (c|ba|k|tc|z)sh, sed, awk, grep, to name a few. Each of these tools has it's own mini DSL, some more complicated than others, that can than be composed to with other tools, using their own DSLs to manage tasks (e.g. operating system tasks).

Even the task of creating DSLs has many DSLs attached to it (lex, yacc, etc.).

Programs that get used and become popular introduce their own DSLs, often times. Apache, NGinx, etc. all have config files that each have their own special sauce of DSL for their own tasks.

Even many of the newer systems like Docker, Kubernetes, etc. have config files/DSLs to manage them.

I'm sure I'm forgetting even more.

We need less DSL, IMO, more constrained code generation from data models.

There is so much bloat due to everyone making a DSL to learn distributed systems with, or every little bit of UNIX coming with its own text config format.

I’d like to get away from generating yaml for Docker and k8s and import balancing forks of microservice logic v8 style; read kernel telemetry from eBPF in the app to determine how many forks the code can add or needs to subtract, and terraform because it’s still just a Linux box under there.

But the cottage industry that profits from these ideas is threatened by these ideas and sticks with showing off a new arbitrary string parser that ALSO sends the strings to an API for you!

The software industry has turned into a jobs program and has little to do with novel engineering.

Aside from automatic memory management, there is very little evidence of productivity gains from using higher-level languages. $hypedlanguage fanboys can talk until your ears bleed about why $hypedlanguage is better than the competition. But invariably they can not cite empirical evidence that support their claims. Furthermore, productivity is much more than just programming language (e.g C sucks, but I got Valgrind now so it sucks less). Those who write OS'es knows this and stick with what works.

I think a DSL is a more often a type of “user interface” for a large and powerful underlying software system, than a way of writing native code for particular specializations. Operating systems offer many DSLs as a way for programmers to interact with them: Linux has bash and eBPF, Windows has VBScript and Powershell, etc.

If something were to offer a DSL for writing operating systems with, I think it would be either an embedded platform or a hypervisor.

Wasn’t Python originally conceived as a systems configuration language?

ACPI is pretty much a DSL, if I'm not mistaken

Domain specific. The entire OS is domain less, it's a host to run what is to be your domain. The OS has APIs to get anything done. And there are libraries to access those APIs from many languages, some that can be somewhat labeled a DSL supporting language. But until you have a domain, it's just the OS. The OS the non-domain or everything domain.

I'll just state for all us dummies, I suppose, that your casual use of DSL as an initialism without writing what it stands for, is not cool.