This is a project that's been percolating in my head for a while, as a vague desire to make a "better" runtime for software development. But it was never particularly clear for me what that would _actually_ look like. In the last month or so, I felt a bit inspired to ask what such a runtime might look like for agentic development.
My hypothesis is that we really can't review 10k+ SLoC pull requests consistently and really understand them. But if we try to have a higher level view of things, we still can't be confident the agent(s) haven't done something stupid and opened a socket or a file somewhere in that 10k+ SLoC.
Therefore we need a very clear demarcation between computation and side effects. In Othismo that takes the shape of the image definition files (.oth) which describe the namespace + various type definitions describing what the interface of an object (should) be. It's somewhat like TypeScript, we don't actually do anything to verify an object conforms to this interface.
I'd love your feedback on the syntax used to define images overall, I feel like it doesn't do a great job giving me a clear notion of the environment lexically. I'm more comfortable about the syntax for describing the behavior of objects, although things like `operator` and `readonly` are really only necessary because I've not done anything to support auth at the protocol layer yet.
You can run the same website hosted at othismo.com with
`git clone git@github.com:mamidon/othismo.git`
`task run:example:static`
You can also play with the namespace interactively with
``` task build:example:static target/debug/othismo shell examples/static/static.rti
# print out the namespace(s) target/debug/othismo --check examples/static/static.rti ```
You'll need rust, task (it's like make), and node+npm.