paroneayea

Hi! Yes, Spritely started Hoot to get Spritely's programs, built on top of Spritely Goblins, to a wider audience. And the network protocol we use / co-designed is OCapN, which is indeed in the family of CapTP languages: https://ocapn.org/

The good news is there are four fairly mature implementations (two Scheme implementations across Guile and Racket, a Dart implementation, a Javascript implementation) and one upcoming one (a Zig implementation). We have a whole specification and test suite and even an implementation guide!

The experience Jessica Tallon and I had with doing standardization work on ActivityPub led us to decide to take a different path when starting the group for OCapN: instead of bringing the topic of what we wanted to achieve to a standards group, we decided to start a "pre-standards group" which, effectively, works pretty much exactly like a standards group but does all the heavy lifting of making sure we have a decent spec, interoperability, a test suite, etc before bringing to a formal standards group (or really moving outside of "stealth mode": we haven't advertised OCapN too much to make sure we had a design that was fairly solid between a few core implementations before trying to push for wider adoption, which can quickly ossify a spec since making changes past that point requires getting the whole ecosystem to change). We've mostly achieved that now, and there's an open debate about whether, should we really bring this to a formal standards group at all?

Regardless, OCapN is pretty awesome, and we'll probably revamp the website and etc pretty soon to make it clearer that it's ready for more projects to start implementing!

Well that seems like some bug in your blog promotion pipeline

Yes! But it's still valuable. How am I understanding your argument at all?

I think my friend Jonathan Rees put it best:

  "Language is a continuous reverse engineering effort, where both sides are trying to figure out what the other side means."

This reverse engineering effort is important between you and me, in this exchange right here. It is a battle that can never be won, but the fight of it is how we make progress in most things.

The point is not primarily the court. The court is an example of someplace where we have accountability, but we build accountability mechanisms as foundational to most of our computing.

Tracebacks, debuggers, logging, etc. We put enormous resources into not only the bad case, but the potential that a bad case could occur. When something goes wrong, we want to know why, and we want to make sure that something bad like that doesn't happen again.

I think the perspective here is completely wrong. The problem is that people are now building our world around tooling that eschews accountability.

Over a decade ago now, I had a conversation with Gerald Sussman which had enormous influence on me: https://dustycloud.org/blog/sussman-on-ai/

At some point Sussman expressed how he thought AI was on the wrong track. He explained that he thought most AI directions were not interesting to him, because they were about building up a solid AI foundation, then the AI system runs as a sort of black box. "I'm not interested in that. I want software that's accountable." Accountable? "Yes, I want something that can express its symbolic reasoning. I want to it to tell me why it did the thing it did, what it thought was going to happen, and then what happened instead." He then said something that took me a long time to process, and at first I mistook for being very science-fiction'y, along the lines of, "If an AI driven car drives off the side of the road, I want to know why it did that. I could take the software developer to court, but I would much rather take the AI to court."

Years later, I found out that Sussman's student Leilani Gilpin wrote a dissertation which explored exactly this topic. Her dissertation, "Anomaly Detection Through Explanations", explores a neural network talking to a propagator model to build a system that explains behavior. https://people.ucsc.edu/~lgilpin/publication/dissertation/

There has been followup work in this direction, but more important than the particular direction of computation to me in this comment is that we recognize that it is perfectly reasonable to hold AI corporations to account. After all, they are making many assertions about systems that otherwise cannot be held accountable, so the best thing we can do in their stead is hold them accountable.

But a much better path would be to not use systems which fail to have these properties, and expand work on systems which do.

Hi! I actually have, and have been using as my main device, an MNT Pocket Reform, and at one point was using an MNT Reform.

MNT's devices are honestly kinda incredible. I can't recommend them for everyone yet, though that will change soon. Both of them are a kind of "laptop of theseus"; you can open and change and repair them, and honestly I have. Both device's guts are dramatically different than where they started, but changes happened piecemeal.

The Pocket Reform is an incredibly cute device. I can't pull it out anywhere without people fawning over it. Not even just hackers! It's an open hardware cyberdeck you can use as your main device. What's not to love?

The MNT Reform Next will be closer to what many people want out of a laptop. It'll still be chonkier than a normal laptop. But again, these things are incredibly upgradeable and hackable.

Now for the caveats: for most people, I would wait until the MNT Quasar module comes out. The reason being is that while the current "best" module, the RK3588, is honestly pretty good with the 32gb version, it lacks one critical thing for most people and one other critical thing for me in particular. The first thing it lacks is support for suspend. Honestly, it does make working with a tiny computer like this a bit less appealing than the Pocket Reform's form factor could be, since what you really want to do is just be putting it to sleep and taking it out everywhere. The other thing is that Blender doesn't really run on the rk3588 either. You can kind of get a patched version working based on Lucie's patches, and I did, but it doesn't support the Eevee renderer, which is a must-have for me personally.

But the MNT Quasar board will be apparently fixing both of those above issues, and yes, at that point this will be a device that I can recommend generally. And I'll also note that I got the very first MNT Reform when it came out, and holy moly the state of the hardware now vs when it originally launched half a decade ago... it's hugely far between, but the amazing thing is that to get it up to the current state, I didn't need to throw things away, I could just open and tinker with things bit by bit.

In many ways, the MNT Pocket Reform reminds me of the book the main character has in the solarpunk book A Psalm for the Wild Built; a computer that is issued to you at the age of 16 and that which you carry with you for life. You can upgrade and repair it easily, but you don't need to throw it away.

So yeah, it's not for everyone. But if the idea of supporting repairable, upgradeable open hardware made by a lovely bunch of queers in Berlin sounds great? That you can hack on, that has a neat little community, that will be a conversation point amongst fellow hackers for its quirkiness? It's appealing to some, but not all.

Does your makefile also do this https://github.com/xtellect/spaces/blob/422dbba85b5a7e9a209a...

This repo is full of so many strange and hilarious things. Look, I'm a lisper, and this is even too many parentheses for me https://github.com/xtellect/spaces/blob/master/spaces.c#L471...

DenchClaw finds your Chrome Profile and copies it fully into its own, so you won’t have to log in into all your websites again. DenchClaw sees what you see, does what you do. It’s an everything app, that sits locally on your mac.

Wow that sounds great. Hey don't worry these things never blackmail anyone. Let it know if you're gonna turn it off, I bet it'll make some REAL interesting choices based on your browsing history

Wow, sorry, but given how incredibly insecure all the "claw" agent type things are right now, does this really sound wise at all?

It sees everything you do, really? What's it gonna do with that data? You don't know.

Put all your customer data in there, all your customer relationships. It's fine, it couldn't leak all that information, it couldn't screw up any sensitive business details I'm sure. This is gonna go great.

Sorry AFK everybody I'm gonna go get myself a VibeMBA.

Anyway, good luck, I'm really looking forward to the user stories in a few weeks! I'm sure this won't go badly at all.

I mean isn't what happened to Google leading people to use generative ai tools instead of searching that web searches started filling with generative AI garbage, both in terms of web content as in terms of Google itself generating it

Also a note since there are a number of comments on here about this being a rival for Systemd: Shepherd precedes Systemd by quite a bit! Shepherd was previously known as "dmd", the "daemon for managing daemons", which was made in 2003! So in that sense, if anything was imitating anything (and not claiming anything was), it would be the reverse :)

It may be possible to get Shepherd to work with Hoot eventually! I'm not sure what on earth it would mean though. What daemons would you manage in the browser? But it's indeed a fun idea!

That's almost every article on HN, though. Don't use inheritance, don't use C, use Kubernetes, don't use Kubernetes, etc etc.

I suspect the thing that's bothering people in the comments here isn't as much that the author is making an argument but that the author is making an argument on cultural grounds?

Jessica Tallon's implementation of petnames and edge names was extremely simple within the paper davexunit linked, but used in-band mechanisms to communicate edge names that didn't require any sort of large trusted authority. You could retrieve them directly from fellow peers, who could publish their current set of edge names. This even works in a p2p context over ocapn, etc. The implementation was naive but it did work and used a publish-subscribe mechanism directly from other peers.

That said, edge names are only one way to share contacts. In fact "share contact" on peoples' phones is a great way to have contextual sharing: "Oh, let me introduce you to my friend Dave. Here's Dave's contact info!"

At any rate, petnames aren't a particular technology, they're a design space of "Secure UI/UX". However I do agree more research needs to be done in that space; we've only barely begun to scratch the surface.

The European Commission deserves thanks for funding the commons, a thing that rarely happens by governments, but should! NGI Zero was thanked though?

NLnet being the operator of the call is no small thing though, having been through the process they are very thoughtful, knowledgeable, thorough in how they run things. They even run the software they fund and verify it's working and check that the overall ideas are sensible, which is something I can't say of many other grant programs I've interacted with. So NLnet does deserve thanks.

Pre-Scheme is an incredible piece of history, largely forgotten and lost to time outside of a very small group that knew about it. Live hackable at the REPL, and yet with static type inference (Hindley-Milner!), compiles to C, no GC? It's something I've always wanted, and it existed, but it felt like one of those lost pieces of technology that was at risk of fading into the dustbin of history.

But no more! It's so exciting that Andrew Whatson has begun reviving the project with such great enthusiasm and making it so that Pre-Scheme can run on top of a variety of Schemes. And it's wonderful that NLnet has recognized how important this effort is. I think Pre-Scheme could play an interesting role alongside Zed and Rust, and indeed I know that Andrew plans to incorporate many of the newer ideas explored in those languages on top of Pre-Scheme eventually.

Go Pre-Scheme revival... I'm cheering it on, and can't wait to use this stuff myself!

Pre-Scheme is one more path to moving away from low level programming being done on top of directly programmed C for one thing, and the revival effort directly ties in by moving Pre-Scheme to be on top of r7rs, an open standard. This opens up Pre-Scheme to a variety of other ecosystems that NLnet already invests in, including Guix, Mes, and Guile, which have put a lot of efforts into secure and highly reproducible (and indeed bootstrappable) computing. There's definitely some ties in with security and security-oriented communities NLnet already funds, and this project directly works towards moving towards a more standardized approach, leading to hopefully broader adoption.

Also, I just tried opening with Chrome 125.0.6368.2 on Linux, and things ran fine... I wonder if this is a Chrome on Mac OS issue specifically. Would love to know what caused that, let us know if there's anything in the developer console. You can file issues here: https://gitlab.com/spritely/cirkoban

Well I'm "glad" it's a presentational issue rather than a performance issue then. Baba is You takes a similar approach in that holding undo takes a while, so we're not completely alone. :)

In our case the choice to have undo be very visible, well it may be a bit overdone, but I think it's partly because in some ways this is a showcase of Goblins' time travel feature, and so we wanted to add some juice to the effect to highlight it. It would definitely be better if we had a "level reset" feature, which would make us comparable to Baba is You: holding undo takes a bit if you did a lot of things, but you can also just start over.

The other thing I really wished we had added was a level select menu but... all this stuff was accomplished in a week and two days; game jams are intense, there's always things you wish you had gotten done. Now that the jam is over, it might be worth adding some quality of life improvements, but of course now that the jam is over we are back to working on the core tech again instead of the demo. :)

But also, hi jsnell, nice to see you again! Glad you got to play the game, and hope you had fun. :)

There is step debugging available in Guile plus Geiser, but it's not very reliable. You can call ,next for instance, see: https://www.gnu.org/software/guile/manual/html_node/Interact... https://www.gnu.org/software/guile/manual/html_node/Debug-Co...

Unfortunately the problem is that Guile optimizes away whole chunks of code, and thus debugging information is not as good as it could be, and if you set traps they might be optimized out too. My understanding is that this could be made better, but could use a champion.

(The other trick is to turn off the optimizations when debugging, which is sometimes what I do.)

Thanks! Though definitely the shoutout goes to the Spritely team in general, particularly the Hoot team, and in this case, particularly David Thompson, who put together that lovely game jam template with the breakout clone! :) It's truly incredible working with such a talented team of people every day.

(And hope that was meant to be "shoutouts" and not "shootouts" ;) !)

Yes, we have made use of JS invoking WASM-GC managed Scheme objects in our Hoot demos at Spritely.

This would lead to a massive confused deputy vulnerability for unix domain sockets as already exists for localhost + port.

For a great example of this, see how Guile's live REPL was localhost + port... cool, only local users could access it, right? Except browsers could access localhost + port, and it turned out this was a path to being able to do arbitrary code execution in the browser https://lists.gnu.org/archive/html/guile-user/2016-10/msg000...

Switching to unix domain sockets was the recommended path, and that's only because browsers don't support them.

If you want to support unix domain sockets, you could, but it would have to be via object capability security discipline, and the poster explicitly talks about an ACL "protecting" things... it wouldn't.

Luckily this is 3 years old and hopefully will never make progress.

I agree with this assertion. WebAssembly, on its whole, is extremely good.

The string stuff is, IMO, something the group has not come to realize the "right direction" on, but so much has been done right! Hopefully strings can get there too. :)

Stringref is an extremely thoughtful proposal for strings in WebAssembly. It’s surprising, in a way, how thoughtful one need be about strings.

Here is an aside, I promise it’ll be relevant. I once visited Gerry Sussman in his office, he was very busy preparing for a class and I was surprised to see that he was preparing his slides on oldschool overhead projector transparencies. “It’s because I hate computers” he said, and complained about how he could design a computer from top to bottom and all its operating system components but found any program that wasn’t emacs or a terminal frustrating and difficult and unintuitive to use (picking up and dropping his mouse to dramatic effect).

And he said another thing, with a sigh, which has stuck with me: “Strings aren’t strings anymore.”

If you lived through the Python 2 to Python 3 transition, and especially if you lived through the world of using Python 2 where most of the applications you worked with were (with an anglophone-centric bias) probably just using ascii to suddenly having unicode errors all the time as you built internationally-viable applications, you’ll also recognize the motivation to redesign strings as a very thoughtful and separate thing from “bytestrings”, as Python 3 did. Python 2 to Python 3 may have been a painful transition, but dealing with text in Python 3 is mountains better than beforehand.

The WebAssembly world has not, as a whole, learned this lesson yet. This will probably start to change soon as more and more higher level languages start to enter the world thanks to WASM GC landing, but for right now the thinking about strings for most of the world is very C-brained, very Python 2. Stringref recognizes that if WASM is going to be the universal VM it hopes to be, strings are one of the things that need to be designed very thoughtfully, both for the future we want and for the present we have to live in (ugh, all that UTF-16 surrogate pair pain!). Perhaps it is too early or too beautiful for this world. I hope it gets a good chance.

Thanks very much! Yes, progress has been fast, and it was really fun to show things working with an example that's live and interactive and hopefully fun to look at and play with.

Yes indeed. Glad you found both! When planning the game jam entry, I said "well I guess this is a paired-down version of Fantasary from the original list of Spritely sub-projects, but maybe that was a silly name so we should call it something else." But the other engineers on the team said they liked it and wanted to run with it, so there we are. :)

Thank you! I updated the post!

It's being supported in an extension that looks on track to be broadly available across WASM runtimes soonish.

The case was correct, but I misspelled "van" as "von"... how embarassing! Fixed on the website.