Hixon10

Yeah, Recently Alexey Milovidov said that they might start using Rust in some parts, but clearly it felt that he prefers C++ - https://youtu.be/PW_jmFwYy5U?si=Y-mM4sjaHBLm96gz

It is interesting, that both non-Linux OS build similar solutions. Microsoft showed https://learn.microsoft.com/en-us/windows/wsl/wsl-container last week.

It sounds super cool, your idea and implementation for await and transactions. Because of my limited Rust knowledge, it's hard for me to understand how difficult it was to implement such a plugin.

Also, your idea of using different domain specific colors is interesting. It might be possible to express this via some kind of effect system. I'm not aware of any popular Rust libraries for that, but it could be worth borrowing some ideas from Scala libraries.

I see, thanks! I don't have much experience in Rust, aside from some pet projects. Which features of Rust's type system are needed to implement such behavior? (It's unclear to me why I wouldn't be able to do the same in, for example, C++.)

"Zero-Copy In-Memory Cache Abstraction: Leveraging Rust's robust type system, the in-memory cache in foyer achieves a better performance with zero-copy abstraction." - what does this actually mean in practice?

Yeah, I like your examples. In such scenarios, it makes sense when we're just trying to protect against our own bugs rather than a user deliberately sending a path that leads to the password.txt file.

Why would it use `chroot`?

I am not sure, is this custom Os.Root implementation good enough to relay on it? I see that it is based on openat, and validation of paths/symlinks. But should we expect CVEs, which will break this protection layer?

What would be an use case for `os.Root`? Based on my understanding ( https://github.com/golang/go/issues/67002 ), it is related to security. However, under the hood, it doesn't use `Chroot`, so I could imagine, that eventually someone finds a way to escape from the Root.

FerretDB blog post https://blog.ferretdb.io/ferretdb-releases-v2-faster-more-co...

What do you think about deterministic simulation testing, which is currently trending?

It's a bit sad that many modern databases were recently acquired. They had the potential to bring a lot of innovations.

1. https://www.warpstream.com/

2. https://www.orioledb.com/

3. https://quickwit.io/

Here's where Rivet's architecture gets fun – we don't rely on a traditional orchestrator like Kubernetes or Nomad for our runtime. Instead, our orchestrator is powered by an in-house actor-like workflow engine – similar to how FoundationDB is powered by their own actor library (Flow [4]) internally. It lets us reliably & efficiently build complex logic – like our orchestrator – that would normally be incredibly difficult to build correctly. For example, here's the logic that powers Rivet Actors themselves with complex mechanisms like retry upgrades, retry backoffs, and draining [2].

It is a bit unclear for me, do you use actors themself to develop Rivet Actors, or it is another actor-like workflow engine, not the final product?

(I would be super happy to read an article, which explains architecture, main blocks of the system, gives some an example)

But it uses atomic clocks and shit to cheat the cap theorem

It is public information?

Yeah, it should be a great episode!

I really enjoyed their thought process about developing requirements for controlling plane databases.

https://news.ycombinator.com/item?id=41258843

https://www.reddit.com/r/java/comments/1ctpebe/low_latency/

I really like an idea to solve scheduling problem via compiling to WASI. Many months ago I had conversation with friends, how to implement deterministic testing in Go, without custom IO runtime (common approach in Scala/Rust/C++). We were talking about a few random things, which require a lot of effort (compare to WASI):

1. https://github.com/Shopify/toxiproxy

2. https://github.com/bytedance/ns-x

3. https://github.com/hnes/cpuworker

But all of them are not too good from the first glance.

Ok, I've checked code a bit. We use squashfs to pack/unpack OCI Bundle, and for lower layer in OverlayFS.

Apologies for my ignorance, but how does squashfs fit into this picture? It seems I'm missing some pieces of the puzzle.

Thanks! I haven't seen before usage of Truffle and ANTLR together, but it makes sense.

Do you know, why they use both ANTLR and Truffle?

Did you have access to their private preview version, or it is some another S3 Express, not S3 Express One Zone?

Does dotnet has any tool/profiler, which allows to count number of copy bytes (not allocations)? For example, if I want to benchmark 2 different function and find out, which one from them copies more (so, do more work).

I wonder, will we have any solution for local development? Or we always will depend on closed control plane?

They have really good tech blog posts. Also, they have https://fly.io/dist-sys/

This Timeline of Events a bit scares me. It looks like, if someone hadn't decided to stop DDOS, deno would still had problems. I would expect to cut off all DDOS traffic on some gateway level, or so.

I would like also to have benchmarks between the current Java API, and you library. Otherwise it is not obvious, does your library outperform standard implementation, or not.

It had to be simple yes/no question, but they haven't managed with this :D

But what exactly podcasts from the list do you consume?

I forgot to mention one more podcast, which discusses latest news. It is online streams on Fridays - https://www.youtube.com/@DevOpsParadox/streams