This approach would seem to require an execution environment that allows dynamically hooking / modifying code in response to changes made by extensions. While various dynamic programming systems like those associated with JavaScript, Smalltalk, Lisp, etc. may have some support for this, it’s less likely to be found in the statically typed languages, as those often assume type checking should be paired with ahead-of-time compilation.

It’s less clear to me how dynamically typed languages might provide extension-time sanity checks, so that’s a big part of why I focused on a statically typed approach. If you see a way to do something similar in a more dynamic environment, please do let me know!

The way we manage this is by creating a schema for the interface and using it to validate capabilities match it. But I don't know if you need to gaurntee more things than the interface. It's not clear to me from your post what we're trying to check x3

This approach would seem to require an execution environment that allows dynamically hooking / modifying code in response to changes made by extensions. While various dynamic programming systems like those associated with JavaScript, Smalltalk, Lisp, etc. may have some support for this, it’s less likely to be found in the statically typed languages, as those often assume type checking should be paired with ahead-of-time compilation.

It’s less clear to me how dynamically typed languages might provide extension-time sanity checks, so that’s a big part of why I focused on a statically typed approach. If you see a way to do something similar in a more dynamic environment, please do let me know!

The way we manage this is by creating a schema for the interface and using it to validate capabilities match it. But I don't know if you need to gaurntee more things than the interface. It's not clear to me from your post what things specifically we're trying to check x3

In reply to @mpcarc:beeper.com
when's the close again? submit submit

In reply to @mpcarc:beeper.com
when's the close again? submit submit

In reply to @gnu_ponut:matrix.org
i was gonna submit something about Draupnir but it's not like revolutionary or amazing or anything. But we do use a capability based plugin system that allows you to hotswap different implemtnations of various capabilities that the plugins are using. So for example a protection (we call plugins protections) that needs to be ban a user uses a capability interface called UserConsequences. And when we create the protection you have to provide a capability to fulfill that interface (it's just dependency injection but y'know). Users get to choose and configure capabilities on a per plugin basis and if they know enough to script they can change the functionality of protections by just writing new capabilities to fill the interface rather than changing the code. It's a little bit different to AOP becaues rather than hooking in arbritrarily anywhere as a dev you're also exposing the option to change the behaviour to users in a structured way. Not too amazing but just thought i'd bring it up as an example of this. I'll have to check out Effekt to be able to understand your post deeply i just needed to mention this x3

In reply to @gnu_ponut:matrix.org

This approach would seem to require an execution environment that allows dynamically hooking / modifying code in response to changes made by extensions. While various dynamic programming systems like those associated with JavaScript, Smalltalk, Lisp, etc. may have some support for this, it’s less likely to be found in the statically typed languages, as those often assume type checking should be paired with ahead-of-time compilation.

It’s less clear to me how dynamically typed languages might provide extension-time sanity checks, so that’s a big part of why I focused on a statically typed approach. If you see a way to do something similar in a more dynamic environment, please do let me know!

The way we manage this is by creating a schema for the interface and using it to validate capabilities match it. But I don't know if you need to gaurntee more things than the interface. It's not clear to me from your post what things specifically we're trying to check x3

In reply to @jryans:matrix.org
Hmm well, the features they focus on seem quite desirable, but perhaps a bit orthogonal from malleability... Their system seems a very nice version of interactive programming, where the build loop fails away and you can make live changes.

Video game devs have made lots of interesting stuff at least IMO tangentially relevant to malleability. Working with code as an interactive, multimedia human-oriented thing, instead of plaintext. Partially the product of constraints: soft real-time (multiplayer) interactivity, collaboration with creatives / non-programmers, and the horrendous difficulty of debugging rendering on GPUs. Unfortunately the culture is often directly opposed to malleability, with heavy proprietary stacks, DRM/anticheats, ship-once products, constant "crunch time," etc....

I believe Arcan is an example of an ambitious project (a new infrastructure for graphical desktop) which started as a game/multimedia engine. The similarities are not just incidental.