drdexebtjl

That’s insane. Windows does not have a stable syscall ABI. The way you’re supposed to interact with the kernel is through the userspace library. Of course the kernel team refuses to cooperate.

Do you want to keep reverse engineering the syscall ABI for every Windows edition and update ever? Do you want to ask your users to disable Windows Update?

Regardless, I don’t even understand how that’s relevant, since you’re still introducing a dependency on a proprietary ABI.

All you could tell from this snippet is that .NET 11 eliminated 2 instructions, one of which is a branch.

You should learn assembly anyway, but it won't make this part any more insightful.

To me it’s the fact that if you try to do it in real life (sorting a collection of objects in the real world), you just end up doing merge sort by accident.

It feels like an optimization of merge sort for computers, rather than a different approach.

This is also reflected in the way that it’s usually taught. Normally merge sort is presented first, and quick sort follows from observations about what would happen if you picked different partition points instead of dividing them in half, and how you can reduce the additional space requirements.

These days I was surprised to see, on my personal computer, information from PRs in private repos from my work’s org on GitHub. These are usually secured behind SSO flows which I don’t/can’t do on personal devices. So now I also don’t trust them to keep our code private anymore either. Nice.

It used to be that you could have a single GitHub account and join multiple orgs, some of which have enterprise plans with GitHub. They completely fumbled this during the pressure to ship AI features. Some enterprise controls that are supposed to affect only my work at a specific GitHub org affects me account-wide. I’m part of quite a few orgs on GitHub for OSS projects, and I never consented for that one org’s policies to basically take over my account.

I thought of going through the process of creating another account specifically for my work at this company, but GitHub is itself solving the problem in a very unique way: by being a place I don’t want to be in after I clock out.

My guess (not involved with PS2 emulation specifically at all) is that this will improve low-level emulation.

So things like making a clone of the hardware with an FPGA, making emulators cycle-accurate, removing game-specific hacks that are no longer needed due to more accurate emulation, and achieving 100% bug-for-bug compatibility with original hardware.

Sorry, I think I misunderstood your argument as whataboutism.

What for? Malicious actors have no shortage of stolen identities.

… should also be open, but that’s irrelevant to the discussion.

The crucial distinction is which half is in which “half-in” agreement.

They are not offering Canada conditions that the UK would have wanted.

Sites would just block the Internet Archive crawler as well.

> Really good reasons to not totally change what you are doing in your app between environments.

Mocks do that.

If you want to not totally change what you are doing in your app between environments, point it at an actual S3 bucket in all environments.

The same argument can be made for the other side: the customer can also trivially mount the S3 bucket as a filesystem, if you decide to ship the tool with filesystem support instead.

Then you would have to embrace their bad decisions, such as this one, and if you do, what’s the point?

Everything just needs to run from a container with their expected runtime environment.

This isn’t true. Ntfy has Web Push. See [1].

[1]: https://docs.ntfy.sh/subscribe/web/

No. A huge selling point of these code-first workflow engines is that they make writing durable workflows a lot like writing non-durable code, to the maximum extent that the language allows, such that the workflow orchestration disappears.

That is, they require good taste and opinionated API design first, porting skills second. The SDK for each language ends up being substantially different.

Frontier models are not very good at this yet. I've tried. Ultimately I couldn't justify the effort when there are other workflow engines out there.

Mostly C#, as I see your Rust SDK is under development.

Unfortunately it appears someone vibe-coded a port of the Java SDK for .NET and namesquatted the `Dbos.Transact` package on NuGet [1], making it look like an official SDK. It's also not a very good port, mirroring the Java implementation instead of using idiomatic C#.

If you ever plan on releasing a .NET library, I suggest opening up a dispute resolution [2] with the owner (it really is just an email to the guy, CCing NuGet support) and reserving the `Dbos` prefix [3].

[1]: https://www.nuget.org/packages/Dbos.Transact/0.0.0-alpha.0.4... [2]: https://learn.microsoft.com/en-us/nuget/nuget-org/policies/d... [3]: https://learn.microsoft.com/en-us/nuget/nuget-org/id-prefix-...

So like ntfy.sh?

I think it’s nice that it’s just an SDK and a Postgres database, but they don’t have SDKs for the languages we use at work.

Why? They’ll use it as many times as they want while claiming they used something else.

No, I think they’re saying two separate things:

- ACR uses audio fingerprinting

- ACR does not collect screen recordings

Both can be true if the TV hashes the frames locally and ACR “collects” the hashes.

Yeah, but this only works for the immutable object store. The rest of the tree is still copied.

CoW and reflinks let you share everything, including the non-immutable paths, and even stuff like node_modules.

Doesn’t that set the origin to the local repo instead of upstream?

Also, it’s not really CoW. The immutable object store is hardlinked (since it’s immutable it doesn’t really CoW, but that’s not a very important distinction). But working files are full copies, and so is the rest of .git. With a CoW filesystem you can CoW everything, including node_modules and build artifacts.

Assuming you're using a filesystem that supports it like ZFS, Btrfs, XFS, etc, it's as simple as:

  cp -R --reflink=always /path/to/source /path/to/dest

On macOS with APFS:

  cp -R -c /path/to/source /path/to/dest

That's it. You get a copy that only stores additional space for metadata, not the files themselves.

You're about to be very surprised!

  echo old > a
  ln a b
  echo new > a  
  cat a b                   # prints "new" and "new"

Some programs like GNU sed [1] do create new inodes, but that is a property of the application, not the filesystem:

  echo old > a
  ln a b
  sed -i 'c new' a
  cat a b                   # prints "new" and "old"

With reflinks in a CoW filesystem the inodes are different from the start, but share the same underlying blocks:

  echo old > a
  cp --reflink=always a b
  ls -i a b                 # prints different inodes
  echo new > a
  cat a b                   # prints "new" and "old"

[1] https://www.gnu.org/software/sed/manual/html_node/Command_00...

Hardlinks are the wrong abstraction. You modify one copy and it changes on all linked paths. You want reflinks instead.

edit: spellchecker corrected reflinks, this is what I meant.

How's that any different from, say, Windows updating and backing up the company's code to OneDrive?

Actions speak louder than words. If the company doesn't even supply and require work devices, they don't effectively consider their code to be valuable IP.

That’s the case with a personal subscription directly with OpenAI or Anthropic, but enterprise customers are opt-in, AFAIK.

And there are solutions around it from other providers and model routers. OpenRouter lets you explicitly say on a per-request basis you don’t want to be routed to a provider that trains on your input, for example.

Are you saying you don’t trust ZDR claims from inference providers?

They don’t care about your code. There’s more and better data on the public web.

No, the subtitles are already in SRT. No video decoding is happening. ffmpeg was using 2% CPU and 0% GPU. The bottleneck is IO. ffmpeg must read the entire file, parse the container format and collect the subtitles.

If the SSD was completely idle and could reach it's max rated read speed of 550 MB/s, assuming absolutely no overhead, ffmpeg would finish in just over 2 minutes (70000 MB / 550 MB/s / 60 s/min = 2.12 min). So, in the best case scenario, I'll be stuck waiting for 2 minutes for the subtitles to appear, if the client doesn't time out. Real-world speeds are 10x slower, as we've seen, but they're more than 10x faster than 4K Blu-ray bitrates, so they're sufficient.

How large is your 47 minute video? If it's ~8 GB, which is typically on the high end for episodes from streaming services, and if you have an PCIe 3.0 NVMe SSD, which reads at ~6 GB/s, you'll extract subtitles in about 1 second.

Not necessarily, but they do prevent government services from being improved by hiding the inefficiencies.

People with influence to fix bureaucracy don’t suffer through it because they can afford the middlemen.