tanelpoder

I just added a little comment/errata regarding the NVME_QDEPTH column to the post (search for errata). I should probably rename that column to emphasize that (for now) it’s the Linux nvme module level max QD and not the hardware one (it’s complicated…)

Thanks! Yep I was thinking of doing that next, will be very easy as under the hood the data is stored in Python dictionaries.

Yup same here. Perhaps a better experience would be to first just reach out with a "normal human being" email and later on either side of the conversation can just CC: schedule@example.org address to the email reply.

Downside: now this (external) service knows what you're talking about

Upside: now this (external) service knows what you're talking about - and can create a meaningful name & description for your meeting request (and you'd have some searchable history etc)

That article also mentions a paper "Improving Round-Trip Time Estimates in Reliable Transport Protocols" from 1995:

http://ccr.sigcomm.org/archive/1995/jan95/ccr-9501-partridge...

Click on a CPU type (ARM1) under the Visual Section on the left pane to go to the simulation pages, for example this one:

http://www.visual6502.org/sim/varm/armgl.html

I just got a marketing mail from them, but it took to a generic product page. A web search revealed nothing new, except that Reddit post...

Edit: I posted this link, curious why it got flagged in just 2-3 minutes? (I must be not aware of something)

Yup. I'm using Vim + Hugo + GitHub + Netlify in a similar fashion. Just edit my markdown post, git push and it shows up on my website. I used some other static hosting service previously, don't even remember which one, but switching was super easy as I just pointed the output to some other bucket. So the public web hosting provider is completely commoditized and easy to switch from.

Also, I like treating my blog as a version-controlled, declarative "codebase" that's just a bunch of plaintext files (no MySQL tables, XML or JSON to crawl through).

It works with vanilla vim (and MacVim) these days too. "Vim 9.0.0185 or newer" is mentioned in the Getting Started section.

I was about to install it a couple of years ago, but then started thinking about the privacy threat model.

I realized that having a "copilot" in my everyday editor (not just for public open source coding!) is never gonna fly. I may end up accidentally uploading any file I open to a 3rd party for tab completion and "AI stuff". Even if I can configure it to hopefully ignore some directories, too risky for me. With a separate editor just for coding (Zed in my case), the risk of accidentally opening and uploading a wrong file would be much lower for me, as I'll keep using vim without any AI for everything other than OSS coding.

Edit: I'm sure there's an option only manually load the copilot plugin when you explicitly want it, but it still makes me too uneasy.

Discovered this paper via a bit too vague MIT news article [1] Code examples are in their GitHub repo [2]

[1] https://news.mit.edu/2025/making-ai-generated-code-more-accu...

[2] https://github.com/genlm/genlm-control

TIL about Kate editor, but after 30 years of just using vi in a terminal (Unix, Mac, even Windows in cmd.exe) I switched to Zed editor (https://zed.dev). I had tried other editors in the past, but quickly fell back to vi/vim after a few hours or days, for various reasons. Been using Zed for a couple of months now and no plans to go back. It also uses LSPs, but whenever I connect to some (Linux) dev host from Zed on my Mac, it autoinstalls clangd to a .local directory and so far I haven’t had to manually install any extra software. Just took a while to figure out the best Zed config for me. It’s very configurable, customizable, but the UI itself is snappy & clean (written in Rust, for those who care about it).

Their airplane doesn't necessarily have to be full of water, just like our high altitude (military) planes and spaceships do not have to be full of air. For convenience, yes, but just for survival you'd wear a protective suit with life support systems, just like we do. Edit: But I agree that they'd be impractical for convenient business and leisure travel for the average octopus out there...

And worse, now there'll be a generic romcom about this on some streaming service, called "The Note" or something...

I've written C on-and-off for over 30 years (just various throw-away prototypes and OS/app interaction microbenchmarks) and it took a while + a web search to get it. Diabolical indeed. Edit: And makes sense in hindsight.

VMware even has a vSphere Fault Tolerance product that creates a "live shadow instance" of a VM that mirrors the primary virtual machine (with up to 4 vCPUs). So you can do a quick failover in case of an "immediate planned" failover case, but apparently even when the primary DB goes down. I guess this might work when some external system (like a storage array) goes down in the primary, you can just switch to the other VM (with latest memory/CPU state) and replay that I/O there and keep going... But if there's a hard crash of the primary, if it actually does work, then they must be doing lots of reasoning about internal state change ordering & external device side-effect (somewhat like Antithesis, but for a different purpose). Back in the day, they supported only uniprocessor VMs (with something called vLockstep) and later up to 4 vCPUs with something called Fast Checkpointing.

I've always wanted to test this out for fun, by now 15 years have gone by and I've never got to it...

https://www.vmware.com/products/cloud-infrastructure/vsphere...

I grew up in Estonia (which was occupied by Soviet Union until when I was around 13), I recall some "thermonuclear blast survival zones" posters on my school walls, but I don't recall such a topic from my school days (maybe in the uni, but that was a long time ago).

I had never thought about what these "fire diamond" colors and symbols mean on the big-rigs driving in front of me on the highway...

Thanks for creating it! I'm about to study it over the weekend :-)

The title says Database Protocols, but the author writes only about MySQL and Postgres. There are other databases out there, for example Oracle that I’m the most familiar with and it has had a break/reset mechanism built in to its protocol for at least 30 years [1]. Its a 2 step operation (2 roundtrips), one sending an error back to the client instead of the expected result and the second step will reset “current call” (not current session or connection) state on the server side and then request the client do the same.

Databases/protocols that differentiate between connection, session and call scopes, can reliably perform resets without requiring to tear down the entire connection.

Retrying is safe with no client side transaction idempotency tokens needed, as the error handling will roll back any changes done only by the failed call, not the entire transaction or session.

[1]: https://tanelpoder.com/2008/04/10/sqlnet-breakreset-to-clien...

Edit: added the comment about retry and idempotency.

Also “do it in advance (and reuse)”

If anyone here struggles with self-promoting their (earned) work results, read this. The whole website is pure gold.

The C alternative for the hardware "halt and catch fire" instruction?

The first publicly available version of Oracle Database (v2 released in 1979) was written in assembly for PDP-11. Then Oracle rewrote v3 in C (1983) for portability across platforms. The mainframes at the time didn't have C compilers, so instead of writing a mainframe-specific database product in a different language (COBOL?), they just wrote a C compiler for mainframes too.

I guess since these devices aren't meant for production throughput, but rather about having enough RAM for local experimentation with large enough models, it's an ok tradeoff at this price point...

You can use VirtualBox, then you don’t have to buy Parallels just for this single task. But you’d need an x86 Mac not Apple silicon. I’m using VMware Fusion on my old Intel Mac for the occasional Windows task. I think Fusion is a free download now too

Add sync=1 to your fio O_DIRECT write tests (not fsync, but sync=1) and you’ll see a big difference on consumer SSDs without power loss protection for their controller buffers. It adds the FUA flag (force unit access) to the write requests to ensure persistence of your writes, O_DIRECT alone won’t do that

An example plan is here (this link with an example would probably be better for this submission, but I can't change the URL anymore).

https://db.cs.uni-tuebingen.de/explain/plan/7b1g1c6347g7a37f...

Lots of interesting details in there - a comment about SpaceX StarLink satellites right in the introduction:

"They mitigate soft errors by executing three identical Linux processes on triple modular redundancy (TMR) systems using x86 processors."

For getting started with eBPF performance mindset, I normally recommend Brendan Gregg's book just to see what's possible:

- https://www.brendangregg.com/bpf-performance-tools-book.html

And as a related activity, you could just install the bcc-tools package (on RHEL clones) and check out the /usr/share/bcc/tools directory to see what's already implemented (on latest Ubuntu, these tools seem to be installed in /usr/sbin, etc, but you could "find /usr -name *bpfcc" to get a list of eBPF tools already installed there (and test/man some more interesting ones).

For the bigger picture and other eBPF uses like networking, I'd get Liz Rice's eBPF book (free download):

- https://isovalent.com/books/learning-ebpf/

But the most valuable resource for me when I took the leap from writing bpftrace one-liners to more sophisticated modern eBPF programs was (and still is) Andrii Nakryiko's blog with examples of modern BPF programming:

- https://nakryiko.com/

Author here, yep, I agree, not a bug, just what you get if you start accessing raw stuff instead of stable interfaces and underlying things change (but in this case it was necessary). I mentioned this in the summary in the end.

My understanding is that with BTF + CO-RE, you'll have the flexibility of building your program binary once and it will work on other (BTF+CORE capable) kernel versions without without needing a recompile. But since I had to use lower level methods for stack & pt_regs access, I had to manually add logic for checking kernel structural differences at runtime.

That being said, I have not yet gotten to test if a compiled xcapture binary can just be copied between machines (of the same architecture) and whether it really works as advertised...

Ok, I just read through the article. As I understand, their tests were designed to run entirely on data on the local cores' cache? I only see L1d mentioned there.