Spritely Institute

That is why I created https://codeberg.org/ZelphirKaltstahl/guile-examples. I like GNU Guile and many things exist, even in the batteries that are included, but are not easy to find or one needs to figure out how to effectively use them. Also got an awesome list somewhere, but I need to migrate that to codeberg later. Compared to some other languages, the ecosystem is small though. While in Python often you have 3 or 4 libraries solving the same or similar problem, in GNU Guile you often only have 1 or need to write your own. Knowledgeable people are able to quickly throw something together, or call out to C libraries using FFI, but I have not done FFI yet. Some day I really should look into that ... And into Hoot by Spritely Institute [1] If one wants to check out more algorithmic stuff, I also have some stuff on that: AoC 2024[2] (and previous years too), and guile-algorithms[3] (not that much yet, but useful things, and trying to keep it fully functional). Some time ago I also wrote a toy implementation of a decision tree in Guile[4]. It is even parallelized and achieves linear speedup in my tests. I call it a toy, because you will have to do all the data preparation yourself, because it only deals with numbers, and there are probably smarter ways of storing the data for each node, maybe even avoiding duplication. There is also no library like numpy or dataframes like in Python, so I am using possibly not so optimal data structures. But it is probably worth checking out…

There's also Spritely's[0] work on Ocapn[1], and Hoot[2], their Guile Scheme implementation in Wasm. [0] - https://spritely.institute/ [1] - https://github.com/ocapn/ocapn [2] - https://spritely.institute/hoot/

The animation on the Syndicated Actors home page [0] does a pretty good job of showing the difference, I think. Goblins is much more similar to the classic actor model shown at the beginning of the animation. The "syndicated" part, as far as I understand, relates to things like eventually consistent state sync being built-in as primitives. In Goblins, we provide the actor model (actually the vat model [1] like the E language) which can be used to build eventually consistent constructs on top. Recently we prototyped this using multi-user chat as a familiar example. [2] [0] https://syndicate-lang.org/ [1] https://files.spritely.institute/docs/guile-goblins/0.17.0/The-_0060_0… [2] https://spritely.institute/news/composing-capability-security-and-conf…

Spritely is the solution. Been baking for a few years now. Just pushed an update last week, in fact: https://spritely.institute/

Author of Eon here, there's still some open questions I have here about managing the lifetimes of these certificates. Renewal is supported via a Capnproto callback and there's some ad-hoc integration in with NixOS nginx to restart it on a certificate renewal. https://github.com/RyanGibb/eon/blob/3a3f5bae2b308b677edfb3f9719c023c9… This doesn't work in the general case, e.g. for postfix and dovecot, and is only becoming more pertinent with short lived certificates. It would be great if the service manager could use these capabilities directly. I think GNU Shepard's integration with Guile Goblins and OCapN is a step in the right direction here: https://spritely.institute/news/spritely-nlnet-grants-december-2023.ht… I've written a little more about this here: https://ryan.freumh.org/eilean.html

Thanks for including this. Hoot looks fantastic. There's a side project, Goblins https://spritely.institute/goblins/ that does distributed development too. Great to see that people are still supporting Scheme tools. There's a lot of utility here, even if people (and job adds) go for the "latest" tools.

Check out https://ocapn.org/ https://www.spritely.institute/ https://files.spritely.institute/papers/spritely-core.html

I really like the idea of the fediverse, so I donate to lemmy[0] and the spritely institute[1]. I also donate to asahi linux[2]. [0]https://join-lemmy.org/ [1]https://spritely.institute/ [2]https://asahilinux.org/

I believe this is what the Spritely Institute (https://spritely.institute/) is working on with Spritely Goblins (distributed computing using object capabilities) and Hoot (Scheme to wasm compiler).

Curious if this overlaps at all with the use cases of the spritely project [1]. Another question is whether esoteric languages are strictly needed for these architectures or simply more convenient. [1] https://spritely.institute/

i encourage the readers of this comment thread to check out the spritely institute, especially it's blog [0]. i don't wanna spoil what it's all about, but i ensure you it's a topic (and institute!) worth diving into. i poured 10h+ just reading the blog and all the related links and projects :) [0] https://spritely.institute/archive/

Oh boy, you didn't even answer my question about Nix. I guess you can't in a way that doesn't concede to my point - guile is definitely not obscure in the sense that nix is. For what its worth, here is at least one recent funded project that is using Guile: https://spritely.institute/goblins/ You also seem to think that I am some kind of Guix/Guile evangelist. No (I actually also prefer CL). I just happen to think that Guix is a better solution than Nix and that it uses a much better language. > No, it is not. Software development is a social and technical field, not a branch of philosophy. And I guess you get to say what's good and bad in field? Lol

A tough road ahead, I agree. Currently there is other work going, by the Spritely Institute [0] non-profit. They are working on standard specifications fo the Object Capability Network (OCapN) [1] and Cap'n Proto may align with that. Spritely's object capabilities vision [2] looks very promising. Their open standards approach is very early stages still [3]. [0] https://spritely.institute [1] https://github.com/ocapn/ocapn [2] https://spritely.institute/static/papers/spritely-core.html [3] https://ocapn.org

This is awesome, always great to read Andy Wingo blogposts. Eager to see what the future of Scheme in Wasm looks like! Here's a bit more or info on the Spritely side on why they want Scheme in Wasm (it's both funny and great to see how the money on decentralized/web3 projects is leaking back to the real world!) https://spritely.institute/news/guile-on-web-assembly-project-underway…

@garrinm This sounds very cool! I will keep watching your project, as i'm very excited for it! Kudos! Also, you might also consider collaborting with the folks at https://spritely.institute

I'm more interested in what the Spritely project is doing along these lines: https://spritely.institute/ ...but agreed that ultimately being strongly tied to an instance run by someone else is not ideal. I'm glad there are people working on it!

I felt the same but after reading this[1] and following along with the REPL it finally started to click. There are actually much less rules than "normal" programming languages. I had started to write my own basic functions that would be in a "standard library" (trim(), trunc(), remove() etc) and got the hang of it after a couple hours. The only thing I don't like about the language for "serious" work on massive projects is missing static types (may make it less readable though..), and the tooling (most people lean on Emacs) could be better. So I'm guessing there's some additional conventions for function naming, besides appending ? to the name for boolean return and ! for functions that mutate. [1]https://spritely.institute/static/papers/scheme-primer.html

I mean, they're pretty much the same right? You can't abstract away the services and you need to pass arguments to the executable (ntpd in this case). I don't see more or fewer issues, but I also don't see the value to using Scheme instead of a conf. file like format. At the end, there's talk about adding the possibility to live reconfigure services, which is pretty cool but I don't really see what kind of users are targeted by that use-case, at least not regular users like me who's running Linux on a single laptop. The link at the end (https://spritely.institute/news/spritely-nlnet-grants-december-2023.ht… is IMO much more interesting since it would make it possible to orchestrate several machines and their services as well. If you have live reloading as well, I think it would make for good developer experience. My main gripe with Guile is its ergonomics and tooling: no LSP, no linter, no step-debugger that I know of and the docs are often unhelpful imo. Maybe I'm not Scheme brained enough but I think it's a shame because there are some really cool projects out there (anything https://spritely.institute/ really). P.S: I know that some people will tell me to get used to REPL based development which I think is fine for small-ish projects but I can't understand the flow one uses for larger projects where many components might need to talk to each other.

Bell Labs is wonderful to read about, and I've really loved delving into it. Alan Kay's talks in particular. However, it should be seen as a starting point! Alternative hypothetical pasts and futures abound. One issue is that the stuff from the past always looks more legendary seen through the lens of nostalgia; it's much harder to look at the stuff around you and to go through the effort of really imagining the thing existing. So that's my hypothesis - there isn't a smaller volume of interesting stuff going on, but viewing it with hope and curiosity might be a tad harder now, when everyone is so "worldy" (i.e., jaded and pessimistic). Proof: https://worrydream.com/ (brett victor) and the other people doing dynamicland and realtalk, both discussed straightforwardly here: https://dynamicland.org/2024/FAQ/ https://solidproject.org/about -- solid, tim berners-lee and co, also. https://malleable.systems/catalog/ -- a great many of the projects here are in the same spirit, to me, as well! https://spritely.institute/ -- spritely, too https://duskos.org/ -- duskOS, from Virgil Dupras https://100r.co/site/uxn.html -- 100 rabbits, uxn, vibrating with new ideas and aesthetics https://qutech.nl/ -- quantum research institute in the netherlands, they recently established a network link for the first time I believe etc etc. These are off the top of my head, and I'm fairly new to the whole space!

> It isn't onerous. Here's an example using Scheme in the browser: > https://www.spritely.institute/news/building-interactive-web... That looks pretty damn onerous to me: 1. (Guile) Declare all the JS symbols you wish to use. 2. (JS) Write wrappers for the symbols from #1 above. In short, you're still writing custom glue code for manipulating the DOM from the wasm language, and you'll need more custom glue code if you ever want to call your wasm functions from JS (for example, from the `onclick` attribute in an element tag, from `setInterval()`, from resolution of a promise, etc). This is not what I meant by my response in the following exchange: >>> It's true you have to use JavaScript glue code, but it's also true that won't be true forever. >> I won't live forever and I'd like to deliver my product before I die. Right now, it is true that wasm DOM access is non-existent, needs glue code to be existent, and the DOM <--> wasm interface, even with glue code, is limited as hell. I don't know if there are plans to address this. It is irresponsible of me to use wasm for a client today under the assumption that, by the time I need a DOM <--> wasm interface, it will be there. Before the limitations of the DOM <--> wasm interface is ever addressed, the product might even have reached end of life.

Nah thanks, I'll stick with ActivityPub. The fact they even felt the need to create another protocol instead of using, improving and contributing to ActivityPub makes me think they want to bake a busines modell for themselves into the technology and they can't do that if they don't have full control over the spec. ActivityPub is organically grown from a community to serve that community. Bluesky is created to combine making the profits of a commercial centralized social network + profiting from the investment from crypto bros. ActivityPub is not perfect and nobody is pretending like it is (there is a big blog post from the co-author about what retrospectively they should have done differently, sadly I couldn't find the link), but a specification is not static ! If you have a suggestion to improve it you can propose changes and a lot of things are left to the implementation, so you can just do things differently than other ActivityPub application currently do. In fact there are people building the future of the ActivityPub ecosystem right now: https://spritely.institute/ There is no need to create yet another specification. The only feature this claims to have, that all ActivityPub implementations currently don't have is identity portability and that can actually be implemented without changes to the ActivityPub spec, just no ActivityPub Application has implemented it yet.

Hoot[1] already exists and does a very good job of running scheme in web assembly. Everything Spritely is working on is pretty cool. 1: https://spritely.institute/hoot/

> I do wonder what a language with the same “taste” and minimalism as Scheme but embracing the actor model would look like. There is Spritely Goblins: https://spritely.institute/goblins/

Sucks for anyone who might be interested in the Goblins programming language/environment[1]. [1] https://spritely.institute/goblins/

Yep! https://spritely.institute/news/shepherd-goblins-update.html

Hoot is another interesting one: https://spritely.institute/hoot/

This isn't quite a standards conforming Scheme just yet. On the other hand, Hoot supports WASM-GC on release [0], and has had wasm support for a few years now. (Though Safari support has been a pain point - they've found a few bugs in WebKit's wasm support.) [0] https://spritely.institute/news/hoot-0-6-1-released.html

Related: Guile Hoot is a Scheme to Wasm compiler written in Scheme. https://spritely.institute/hoot/

I recently shared a project I did using Hoot, by Spritely institute. It's Guile Scheme compiling to WASM, and it works really well! See https://spritely.institute/hoot/ Latest on my project, in case you want to try it out: https://deosjr.github.io/dynamicland/whiskers.html

"give a man an inch and they'll take a mile" and what not, but, I wonder how hard this would be to port to Hoot, a web assembly/wasm-ified Guile Scheme. https://spritely.institute/hoot/ It would be neat to have some real management APIs for the things running on a page, to be able to manage long running processes & workers. A bit more niche than for general webapps, but systemgo comes to mind; a re-impl of some of systemd in go, specifically designed to be run on the web in Browsix. https://github.com/plasma-umass/systemgo