Ne02ptzero

FYI you can use sendfile ish with uring, since splice(2) is implemented. Not as user friendly as sendfile, but should work fairly similarly.

At first glance, I thought France was not really into bouldering...

You'd be very wrong! There is at least 40 bouldering gyms in Paris (and suburbs) alone.

I wonder as well. Most of the climbing gyms are missing in France's big cities (Arkose, ClimbUp, etc) and the School Room is not even on the map :( !

You can guarantee that you and someone else are listening to the same thing even across an ocean.

How can you guarantee that? NTP fails to guarantee that all clocks are synced inside a datacenter, let alone across an ocean (Did not read the code yet)

EDIT: The wording got me. "Guarantee" & "Perfect" in the post title, and "Millisecond-accurate synchronization" in the README. Cool project!

Out of curiosity, any documents on this, even for something else than AWS's S3? I find the idea very interesting

Executing cargo bench on Limbo’s main directory, we can compare SQLite running SELECT * FROM users LIMIT 1 (620ns on my Macbook Air M2), with Limbo executing the same query (506ns), which is 20% faster.

Faster on a single query, returning a single result, on a single computer. That's not how database performance should be measured or compared.

In any case, the programming language should have little to no impact on the database performance, since the majority of the time is spent waiting on io anyway

Segments are provided by community members, and you can adjust/edit them if you're finding the segment to be badly timed yourself.

Side topic: Didn't we have a is_const_eval equivalent in C? I seem to remember a dark magic macro doing precisely that on the lkml somewhere, but can't find it.

We ensure the CRDT is synced with at least two nodes in different geographical areas before returning an OK status to a write operation [...] we ensure durability of written data but without having to pay the synchronization penalty of Raft.

This is, in essence, strongly-consistent replication; in the sense that you wait for a majority of writes before answering a request: So you're still paying the latency cost of a round trip with a least another node on each write. How is this any better than a Raft cluster with the same behavior? (N/2+1 write consistency)

You know it's a big outage when other people are writing status updates for you

For the monthly expenses, with most of the components running on-premises, there was a 90.61% cost reduction, going from US$ 38,421.25 monthly to US$ 3,608.99, including the AWS services cost.

I might be missing something, but $3k/month (let alone $38k/month) sounds absolutely insane to me for how little metrics they're collecting (4k5 metrics per second, 2.7TB of data per year). Is the money going for network bandwidth or something along those lines?

NASA actually made a pretty informative page about it[1], with some simulation of sound on Mars, compared to Earth. Hopefully we won't need the simulation much longer!

[1] https://mars.nasa.gov/mars2020/participate/sounds/

I've made a blog post about this some time ago[1]!

Definitely not exhaustive as this thread though.

[1] https://ne02ptzero.me/blog/c-tricks-that-i-use-everyday.html

Looks awesome!

Just so you know, there's this[1] firefox addon that always force the redirection to old.reddit.com. I imagine there's a similar thing for chrome.

[1] https://addons.mozilla.org/en-US/firefox/addon/old-reddit-re...

Paul Frazee [00:11:59.05]:

Yeah, so Mathias was working on that, while I was in the Secure Scuttlebut community… And then at one point I decided – well, Electron got to the point where I was like, you know what, _I think it’s actually possible to make a browser off of Electron_.

What a day we live in, making a browser with browser-code. Who knew?

How does one submit a new package to https://cppget.org? I can find a 'Submit' button or documentation about this.

I think a fork is just an internal branch on the original repositoriy for the Github Servers. From a data / sys admin point of view, it makes sense, since a hard-copy of a repository (and all the git objects with it) is just generally useless.

You should add a previous.

I think you're right. From the documentation [1]:

  set 0 to stop ksmd from running but keep merged pages,
  set 1 to run ksmd e.g. "echo 1 > /sys/kernel/mm/ksm/run",
  set 2 to stop ksmd and unmerge all pages currently merged,
      but leave mergeable areas registered for next run
  Default: 0 (must be changed to 1 to activate KSM,
             except if CONFIG_SYSFS is disabled)

I use calcurse[1] for this. It handle pretty much every "calendar" files out there

[1] http://calcurse.org/

Here's a video about the Concorde history, especially why did it commercially failed: https://www.youtube.com/watch?v=a_wuykzfFzE