Robot Framework VS dhall-lang

Fixing a bug is incomplete without preventing its recurrence. Root cause analysis (RCA), coupled with regression testing and documentation, ensures long-term reliability. Antony Marceles, Founder of Pumex Computing, emphasizes, “Fixing a bug is only part of the solution, preventing it from happening again is the real goal.” Marceles’ team uses regression tests via Robot Framework and code reviews with Gerrit to maintain quality, documenting fixes in Confluence to share insights. A 2023 Forrester report found that teams with strong RCA practices reduce recurring bugs by 35%.

Documentation is your best friend. It provides comprehensive guides, examples, and API references to help you navigate the library effectively. Here you can access it, as well as the Robot Framework documentation.

The Robot Framework is an acceptance testing tool that is easy to write and manage due to its key-driven approach. Let us learn more about the Robot Framework to enable acceptance testing.

Well, I work with software quality and despite not having a strong foundation in automation, one fine day I decided to make a change. I have been working with Robot Framework for a few months - and that's when I got a taste of the power of python. Some time later, I dabbled a little with Cypress and Playwright, always using javascript.

Robot Framework

I've used Lua/Busted in a data-heavy environment (telemetry from hospital ventilators). I've also used robot: https://robotframework.org/

I can't say whether any of these will work, but maybe one of: PyAutoGui pytest-qt Robot Framework + plugins

An interesting example is the Dhall language: https://dhall-lang.org/

It is a configuration language with general programming features, but it is decidedly _not_ Turing complete. It seems to sit at a sweet spot between "just JSON, no programming convenience at all" and "full-blown programming language with nontrivial toolchain".

There are languages specifically for writing configs. Like dhall https://dhall-lang.org/

> I'm thinking what is the missing piece here

First, it's cool that you work on it. Creating a new language is not an easy task.

I would suggest to try to stand on the shoulders of giants instead of trying to come up with a completely new thing.

Have a look at dhall: https://dhall-lang.org/ - it is a language that was created for cases like yours. Or, if you want to make POML a fully fledged language (and turing complete, with for-loops etc.) then it would be advised to use an existing programming language and create a DSL-like library.

See react. React did it right JSX. It might look like XML, but that's just the syntax part. You can create components in pure javascript syntax, because JSX is just the wrapper. You could do the same with POML. That will future proof it and relieve you from a lot of headache when people will ask you for more features, but without breaking backwards compat.

Fixing all of those at once might be a bit too much to ask, but I have some quick suggestions. I'd say for a more robust JSON you could try Dhall. If you just want to exchange lumps of data between programs I'd use Protobuf. If you want simple and freeform I'd go with good old sexps.

https://github.com/dhall-lang/dhall-lang

I'll give a shot at some guiding principals:

1. Do not use yaml.

All github action logic should be written in a language that compiles to yaml, for example dhall (https://dhall-lang.org/). Yaml is an awful language for programmers, and it's a worse language for non-programmers. It's good for no one.

2. To the greatest extent possible, do not use any actions which install things.

For example, don't use 'actions/setup-node'. Use bazel, nix, direnv, some other tool to setup your environment. That tool can now also be used on your developer's machines to get the same versions of software as github.

3. Actions should be as short and simple as possible.

In many cases, they will be as simple as effectively "actions/checkout@v4", "run: ./ci/build.sh", and that's it.

4. Do not assume that things are sane or secure by default.

Ideally you don't accept PRs from untrusted users, but if you do, read all the docs very carefully about what actions can run where, etc. Github actions on untrusted repos are a nightmare footgun.

I'm a fan of anything that moves us away from stringly typed nonsense.

See also Dhall (which can render to yaml). I like the idea but found the veneer broke a little too often and left me squinting at Haskell.

https://dhall-lang.org/

I think you're asking for Starlark (https://starlark-lang.org), a language that strongly resembles Python but isn't Turing-complete, originally designed at Google for use in their build system. There's also Dhall (https://dhall-lang.org), which targets configuration use cases; I'm less familiar with it.

One problem is that, while non-Turing-completeness can be helpful for maintainability, it's not really sufficient for security. Starlark programs can still consume exponential amounts of time and memory, so if you run an adversary's Starlark program without sandboxing it, you're just as vulnerable to denial-of-service attacks as you'd be with a Turing-complete language. The most common solution is sandboxing, wherein you terminate the program if it exceeds time or memory limits; however, once you have that, it's no longer necessary for the language to not be Turing-complete, so you might as well use a popular mainstream language that's easy to sandbox, like JavaScript.

One other intriguing option in the space is CEL (https://cel.dev), also designed at Google. This targets use cases like policy engines where programs are typically small, but need to be evaluated frequently in contexts where performance matters. CEL goes beyond non-Turing-completeness, and makes it possible to statically verify that a program's time and space complexity are within certain bounds. This, combined with the lack of I/O facilities, makes it safe to run an adversary's CEL program outside a sandbox.

> Lambda calculus is as pure as can be, and also has terms that don't normalize. That is not considered a side effect.

Many typed lambda calculi do normalise. You can also have a look https://dhall-lang.org/ for some pragmatic that normalises.

> A better example of impurity in Haskell for pragmatic's sake is the trace function, that can be used to print debugging information from pure functions.

Well, but that's just unsafePerformIO (or unsafePerformIO-like) stuff under the hood; that was already mentioned.