If emacs has thaught us anything, it is that when you give people a fully featured language to fool around with, things you could never imagine can start happening.
Why not scheme? It's liberally licensed and already has mind-share. It's a simple, no fuzz language with little obfuscating magic and great expressive power.
It allows you to build your solutions as bare-bones as you like or go on full architect should you need to. Sounds like just what the doctor ordered.
> when you give people a fully featured language to fool around with, things you could never imagine can start happening.
Maybe a package manager is not the best place to have that flexibility? (I noticed this seems to support "unprivileged package management", but still...)
You break the idea of a declarative package by doing this you can have side effects that modify or mess with anything. This means I cannot update a package reliably when it's updated because it may or may not change something.
Almost any programming language can be declarative, the problem is it allows logic as well as having a whole programming language installed instead of a simple parser.
Packages are mostly just declarations of how you want a package to be built/installed, but sometimes they require additional logic or computation. Using python would require a separate file format to put definitions into (e.g, YAML), and those definitions would need a rigid schema and versioning system. Some existing package managers take this approach, but what happens when you need a feature that doesn't exist in the declarative schema? You would need to extend the YAML format and bump the version numbers to allow your new features.
On the other hand, a LISP does not need a distinction between a declarative format and the computation language itself - it does both in a consistent syntax. (Homoiconicity is the term). It makes it much simpler to mix your declarations and computations, alleviating much of the need for a rigid specification on package definitions.
If you look at places where the former system is used, you'll find they usually age pretty quickly - or have many version increments because the original design omitted features people wanted in their package definitions. In effect, this leads to standards proliferation, because people invent new systems when the existing ones don't do what they need. Rather than trying to second guess the features people might need, it can be easier to just give them the ability to add them when they want.
A recent example of the former system is this project from GNOME: https://live.gnome.org/BuilDj. If you look at what it's trying to do, it really just wants to reinvent makefiles in YAML. A clear example of NIH, which will fail because as soon as someone needs to do something which their YAML schema doesn't support, it's a useless tool.
That's actually a great point - something I didn't think of when I suggested python since I don't know scheme :D
Maybe this is reason enough to learn scheme soon.
For practical considerations would you still choose scheme, or would you try and see if some massaging of python can get you the desired results - purely because of the simplicity and adoption rate of the language?
Like I've repeatedly said, as far as LISPs go, scheme is very simplistic and friendly. For things like this, basically a DSL for package-definitions (or other declarative data-formats), a simple LISP like scheme seems pretty optimal.
I see no reason not to look into it. It should take you less than 5 minutes to get started in a repl.
I suspect the fact there's GNU Guile, an entirely in-house Scheme ecosystem, has a lot to do with it. Use Python and be beholden to the Python community (outsiders!) Use JSON (as someone else suggested) and be beholden to the Javascript/JSON community (outsiders! oh and that awful JSON license!) etc.
If emacs has thaught us anything, it is that when you give people a fully featured language to fool around with, things you could never imagine can start happening.
Why not scheme? It's liberally licensed and already has mind-share. It's a simple, no fuzz language with little obfuscating magic and great expressive power.
It allows you to build your solutions as bare-bones as you like or go on full architect should you need to. Sounds like just what the doctor ordered.