vollbrecht

step 1) create a Dockerfile with claude-code / pi.dev + acp_agents + whatever dev env you need. step 2) use microsandbox to create a fs image from that Dockerfile image. ( All secrets you need inside the vm live only on the host and are injected in the tcp stream on egress) step 3) microsandbox by default speak ssh without you needing to have a ssh server in the vm. You can proxy forward everything through it if you need. In my case i use zed and connect into the vm. Bonus points all zed "agent" stuff now runs inside the vm. E.g zed threads via acp calls and all agent stuff live only in the vm.

I don't think its a lag of attraction. If you interested in it, you quickly will realize how much of a behemoth that task really is.

First you have to limit yourself to a specific radio variant, because the actual radio hardware is different on different esp32 variants.

Then you have a massive amount of things this "blobs" actually contain.

And last there is also a lot of continues movement integrating newer radio features. E.g newer BLE version standard implementation and so forth. So you play catch with actual new development.

A standard where you have to pay to play. Cheapest option is 3000$ per product and 500$ annual.

The pressing question is, how much £ per £ lost need to be invested in grid infrastructure to reduce this number?

Nice gimmick that many elements inside that explainer image directly links you to the respective source code, its referring to.

You also now who misses the point? Qualcomm. Why? Well just read the headline qualcomm itself provides.

Rust has now a donated spec that was provided by Ferrocene. This spec style was influenced by the Ada spec. It is available publicly now on https://rust-lang.github.io/fls/ .

This is part of the effort of Ferrocene to provide a safety certificate compiler. And they are already available now.

Thanks for trying to explain this to us.

You are insisting here on talking about the "handle" part, though isn't the crucial part of the complete chain weather we use either did:web or did:plc?

So as you outlined yourself in the article. If you a) use did:web b) ever loose access to that domain you are cooked. No amount of handle changes can help here. If one looses a handle domain one can loose a did:web domain also, so that just moved the problem to a more opaque place.

So your identity is always either a) attached to a domain you might loose b) to some plc provider that might stop work for you.

Please correct me if i get anything wrong here, as that is just how i understand it.

What would in practice happen in a two user scenario where user A replied to user B, and later user B's repository gets completely deleted.

We have this cache thing via wss connections. Do they invalidate this messages from user B? Is user's A worldview now completely dead?

Owning a thing in the internet is a complicated topic i guess.

Preserving past information via copying what a user said so that it does not get lost maybe also in the interest of some users (equivalent to the webarchive). I understand that this contradict the whole "owning your data" premise, but fundamentally since it was open in the first place the thing always can be copied right?

Whatever content is produced in this "open social" network, some of it may have long lasting "value" to an individual. Is there anything to make sure that what they interacted with can not completely broken by the other site of the party?

Ah that make sense. Thanks for clarifying.

Hmm i just tested out the claim that the following rust code would be rejected ( Example 4 in the paper).

And it seams to not be the case on the stable compiler version?

  fn write(x: &mut i32) {*x = 10}
  
  fn main() {
      let x = &mut 0;
      let y = x as *mut i32;
      //write(x); // this should use the mention implicit twophase borrow
      *x = 10; // this should not and therefore be rejected by the compiler
      unsafe {*y = 15 };
  }

You are probably right that this is not the case right now. 25 years ago you could say the same about google employees. Incentives change with time, and once infrastructure is in place it's nearly impossible to get rid of it again.

So one better makes sure that it has not the potential to further introduce gatekeepers, where later such gatekeepers will realize that, in order to continue to live, they need to make a profit over everything else, and then everything is out of the window.

You can find a general overview for the language at hand in "The rust reference"[1]. For a more formal document, you can have a look in to the ferroscene language specification list of undefined behaviour[2] section. From there you can jump to different section, and see legality rules, and undefined behavior sections for each.

The ferroscene language spec was recently donated to the rust foundation.

[1] https://doc.rust-lang.org/reference/behavior-considered-unde... [2] https://spec.ferrocene.dev/undefined-behavior.html

There was an interesting story with the LiMux[1] ( Linux & Munich) project. The local government in Munich used it for quite some time. But than Microsoft came and installed there German Headquarters in Munich. With that new headquarter and enough lobbying, LiMux was forced out by the then new government just the moment it got "successful".

[1] https://en.wikipedia.org/wiki/LiMux

So they provide full information on what happened, with all legal papers attached at the end, and a link to a site that gives you a list of all "blocked sites" that where effected by that order.

While the outcome is quite unfortunate, the way they provide all info here seams like a plus in my book here.

If a state/entity comes after your org tomorrow, and you got to either fight legally or leave the market (like cisco in the story), what would you do?

The mere existence of Tailscale should give a hint that NAT is only a speedbump and not any protection whatsoever. It protects you against nothing. Every method that Tailscale uses to traverse NAT can be in isolation used by any other piece of software. For more info about that you can read the following article.

https://tailscale.com/blog/how-nat-traversal-works

They split data into three branches ( executive, judicative, legislative), only to show that they have data for the executive and not the other branches?

So that is at best a incomplete picture, and at worst a specific framing of a particular view.

I am neither endorsing nor rejecting what is happening (i am not American), just want to point this out here.

Seams not supported in firefox

Yes cheap connectors exist and there is a marked for it, like everything "cheap". But to what point one wants to "defend" a trillion dollar company, on a product that was never marketed as "cheap", that actually comes with a hefty price tag, to skimp on something that is 0.01% of there BoM cost. If you sell for a premium price you should better make sure your product is premium.

Most people are using a prebuild standard library. That comes with the problem that it comes with the features it was build for. Most of the bloat around panic for example can be eliminated by just compiling the std library yourself. This is done via the `-Zbuild-std` flag.

Using this flag one than can use `panic_abort`. This will eliminate the unwinding part but would still give a "nice" printout on a panic itself. This reduces, in most cases, the mention bloat by a lot. Though nice printouts also cost binary space. For eliminating that `panic_immidiate_abort` exists.

But yeah the above is only about bloat and not the core goal to eliminate potential path's in your program, that would lead to a panic condition itself.

Also currently building the std library yourself needs a nightly compiler. There is afaik work on bringing this to a stable compiler but how exactly is still work in progress.

I may see your first point, but how is GPL3 worse than a closed source software?

The espressif ESP-IDF sdk that is using FreeRTOS underneath has rust + std support for quite some time now.

How much value is a vessel itself + the cargo its carrying overall? And how much is that relative to the the cost of repairing all the physical damage alone(Not including other damage). Would it be useful measure to seizure the vessel and use its value to compensate for its damage done, making it a deterrence?

I find it fascinating, calling a CPU implementation FPGA friendly. I don't know why everybody always wants to run soft CPU's on an FPGA.

I mean I understand that its nice for the development stage of a CPU, but for all practical purposes, a FPGA is a thing where you can do hyper specialized things in massively parallel fashion, and essentially don't do something to run general purpose code.

I am not saying that people should stop doing this things, everybody is free to do what they want, still i don't understand why most of FPGA talks are about soft CPU's when the really interesting stuff is something completely different.

I think this is a great peace of software, though i think its mostly tailored for the single dev, or business case for closed source software, but much less a software peace that allow for great community building. I think this is because of:

a) The network effect that you inherently get with for example github b) The barrier to create accounts on yet another platform to contribute.

In that regards i find the original way of just using email's to send patches just such a brilliant idea, because at least it eliminates my second point completely. That's why i think sourcehut [0] is such a nice idea at least in theory. Though now you have to teach people not only how to use "git" but also how to use "git" via email :D

https://sourcehut.org/

One huge problem with respect to fire resistance, in American home's, are the use of truss connector plates. While they have many advantages in cost and allow impressive cheap big houses, they fundamentally weaken the wood when it burns. Often houses just collapse on that joints, not because the overall beam failed, but this interface. In the end the use of "wood" is blamed, but that failed to address the rootcause.

I think NextCloud and OwnCloud are also bad examples, as in the beginning they started with the clear goal to replace Dropbox with a selfhosted alternative. Only later in live they become what they are now, so the original point still stands.

It seams that you currently only support Windows and MacOS via your electron wrapper. Are there plans to also release a Linux version?

It's called pipelining, and the concept works well in all modern processors. Can also work with people, you only have a initial setup delay :)

A nice article that looks into a specific difference between llvm/lld and gnu ld, when it comes to shared objects on linux.