It’s a flaw with the censors. If you stick bit chat together, the b word can be found inside, which lemmy.ml censors.

I don’t think “someone was mean to me” is a valid explanation for systemic murder of dissidents.

Well good thing that’s not what I said.

It would be great if Iran’s government wasn’t executing their citizens for bogus reasons. All of us in the thread are against that. We can also point out that so long as America goes around destabilizing other regions, this will keep happening. Not just in Iran.

For example, “Think about the reparations Germany had to pay” would be a bizarre comment in a thread about Holocaust remembrance.

Yeah that would be weird, especially since the Holocaust and the rise of Nazi Germany was due to capitalism as a whole, and the rise of antisemitism, racism, xenophobia and homophobia in the west.

It would be strange if I were to write something like the bottom paragraph, encourging others not to repeat the same mistakes that led the Nazis to be a thing, and then for you to say “Just because the people were affected by capitalism doesn’t excuse their behaviour”.

Isreal isn’t acting in a vacuum. But thinking it’s just because of October 7th is looking at the genocide and colonization of Palestinians with no historical analysis. Saying that October 7th is the catalyst WOULD be looking at the situation in a vaccuum.

Israel is doing these things because it is a colony, so it should cease to exist.

It’s not an excuse, it’s an explanation. The thread started with asking how Iran even got to this point. So long as the US exists, you’re gonna get destabilization in countries with resources.

Speaking of Gaza, usually, killing people is bad, right? But would you focus on the October 7th incident, deploring Hamas and their attack? Or rather look at the historical context that lead to that point (Israel’s colonialism and genocide) and focus on the fact that it is still active?

No, but hardfocusing on Trump instead of analysing the circumstances that propped him up and his entourage is useless. So long as the material conditions of the Americans aren’t adressed properly, the anger they feel towards said issue can be misplaced and used for nefarious means

You’re missing the forest for the trees.

Your argument is more akin to focusing on October 7 rather than examining the bigger picture.

I don’t think you understand how destabilizing a region over and over again leads to a lower education, more religious dogma and higher animosity in its people and government.

This also happens in neocolonies in Africa, for example.

This reminds me of a nosleep story a youtuber I watch read.

Strangely enough, same in french.

Once again, the only thing leftist can be reprimanded for is being right too early.

I mean that the article mentions a group based in the DPRK using stolen credit cards to fund their stuff. The rust article shortcuts this by saying it’s the DPRK itself that are behind this style of attack.

The article say the attack style is “known to be used by the DPRK” (emphasis on the “the”) when the article cited mentions no government involvement whatsoever lol.

Anyone else feels like we’re supposed to sleep more often than is recommended?

I think the Lemmy logo being a blank-ish Lemming works well for it. Kinda like an invitation to add in your own characteristics (similar to how one would make their owninstance), even if that design choice wasn’t the intention of the creator.

If there’s a redesign needed, maybe the proportions could be changed, but idk.

I know it’s a lot! I myself didn’t fully read the white paper, but skimmed over it and went through the API documentation, as well as looked at how apps that use Goblins work. I’ll try to summarize it as best as I can.

Object Capability (ocap) is a model of sorts that makes an object (app, library, etc.) secure by only allowing it to have access to certain resources based on what it needs and not what environment it’s in. For example, in a regular environment, an object’s permissions are based on who’s running it, what group they belong to, where it’s being run, etc. . It’s hard to keep track of and keep totally secure, since an object might not be isolated enough. In an ocap environment, that object doesn’t have any permission unless it is given. It cannot even try to do something without permission since it doesn’t have the reference to the object that would allow it to do something. If the object does something malicious, you can also easily trace which permission was allocated to it and easily fix the issue.

It’s use cases are mostly related to things that require interoperability between different objects and safety when interacting with these objects, since they might not bee 100% trustworthy. This can help a lot for multiplayer games, cooperative environments, chat applications, and more. To see a use case, you can go to the section 3.3 of the white paper. It was mostly the part where everything clicked for me. Section 3.3.4 really shows the power of having an ocap environment, I believe.

Currently with Rust, if you want to create an app that uses ocap, you have to implement the model yourself. During my research, I had found libraries that allowed creation of applications that use ocap, but only for accessing file/system resources. It didn’t allow the user to create other objects that use ocap.

I have to admit, I am more up to speed with the Guile implementation, since I believe it is the one that the Racket implementation now derives from.

But my justification for implementing it in Rust was that:

1. Implementing it in Rust would allow ocap applications to have access to the Rust environment. I have explored solutions that would allow to use the Guile/Racket library in order to create applications in Rust with it, but they often weren’t viable. I had also thought about applications having to run a Guile part, then would communicate to a Rust part via OCapN, but I thought it would be a complicated sollution. If it is implemented in Rust, it can have access to Bevy, Tauri, and any other libraries that are also available to Rust programmers.

2. Performance, memory safety and thread safety are all things Rust excels at. Currently there are concurrency issues that affect the Guile implementation (I am not sure about the Racket one, to be honest). I don’t want something that completely replaces the Guile implementation, as it has its use (dynamic typing, easier to use, easier to implement features). I do believe that implementing the library in Rust would allow for use cases not only in lower level environments (embeded, kernels, etc.), but also in environments where performance and resources are critical (certain video games, heavier applications like editors, etc.). Video games have already been created using Guile, like Cirkoban (source code: https://codeberg.org/spritely/cirkoban), which you can play right now: https://davexunit.itch.io/cirkoban. From what I’ve seen, Goblins on Guile tends to be a little slow, but I do believe that it is something that will get better as the implementation matures. Implementing it in Rust I believe will allow for a more performant application, but at the cost of dynamic types and harsher rules.

3. Implementing it in Rust implicitly expands the OCapN environment. I believe there are many use cases for applications to use a distributive ocap model. The more languages that not only support OCapN, but also make abstraction of it, the more it gives choices to people who want to jump in. While I do know the basics of Guile and would like to create an application that uses Goblins with it, I know some people who wouldn’t want to use something if it’s made with a programming language they aren’t familiar with. By having more choices, people will feel more inclined to explore the world of ocap.

I’m always open to criticism though. As I said, I’m still a beginner in software engineering. I just really like and see the potential in what Spritely is developing, and would like to contribute to it as well.

I do have a peculiar way of saying things sometimes. I didn’t mean to put myself down, but more so that I know I can make mistakes and am open to suggestions. Still, thank you!

My goal is to expand the object capability environment and make it easily usable in Rust. Here’s an implementation of the greeter actor using the API that I made:

// Vat Connector currently doesn't work, since vats are not implemented yet
let vat_connector = Some(VatConnector::new());
// New actormap inside vat
let am = make_actormap(vat_connector);

// Create a new constructor, greeter, that takes in the greeter's name to build an actor
constructor!(greeter, |_bcom: Rc<dyn Bcom>, my_name: String| {
    // Creates a behavior for the actor that takes in a String to say hello to
    behavior!(|your_name: String| -> String {
        // Value is returned to handle different responses, but I will clean this up to only return the String itself
        // Also, Value is for JSON. The API should use Syrup for OCapN
        Value::String(format!(
            "Hello {}, my name is {}",
            your_name, my_name
        ))
    })
});

// New actor greeter alice
let alice = actormap_direct_run!(&am, { spawn!(greeter, "Alice") });

// Alice greets Bob
assert_eq!(
    "Hello Bob, my name is Alice",
    actormap_direct_run!(&am, { call!(alice, "Bob") })?
);

This code works using the library. There are still many things I would like to clean up and change, as indicated by the comments. I just want to make it easier to create applications that interpret object capabilities. There are a lot of things that the library does different than Goblins (type restrictions, uses enums for return values, traits instead of meta types, etc.), but it mostly follows a similar philosophy of having a library that allows you to create an app that relies on object capability.

That’s okay! I hope you enjoy your retirement!

It’s mostly that I realised that there weren’t any object capability libraries in rust that weren’t just low level stuff. From what I understand, OCapN would allow one to create a Rust app that communicates with an app using Goblins, but the object capability stuff would have to be handled by the developpers. I currently implemented stuff like creating actors with a constructor and the bcom capability, which would allow one to make object capability apps easily.

I have already started an OCapN implementation in Rust as it was still an integral part of Goblins, but another developper was also working on it, so I’m mostly trying to talk and seeing if I could help out as well. But I know I’m not the brightest person, and if a Goblins implementation in Rust would effectively be useless, then it’s okay. I’ll focus on developping OCapN.

Fair lol. But it is a very interesting project and I recommend checking it out if you’re interested in ActivityPub!

I don’t think they were talking about taxes, unless I’m mistaken. It’s obviously about wage theft, right?

Edit: Nvm I forgot taxes work differently in the US