Hacker News Reader

half-kh-hackeron A sufficiently detailed spec is code

How does post-training via reinforcement learning factor in? Does every evaluated judgement count as 'the training data' ?

half-kh-hackeron Our LLM-controlled office robot can't pass butter

the paper already says "Butter-Bench evaluates a model's ability to 'pass the butter' (Adult Swim, 2014)" so

half-kh-hackeron Y Combinator files brief supporting Epic Games, says store fees stifle startups

50c per install (of which there are hundreds of thousands) to a party who should be uninvolved is not reasonable

half-kh-hackeron Save your disk, write files directly into RAM with /dev/shm

file-hierarchy(7) states /dev/shm is tmpfs and that "all users have write access to this directory", so I think you'd have to be making a non-systemd distro

half-kh-hackeron Jemalloc Postmortem

you probably want to look at their 'libmalloc'

half-kh-hackeron The wake effect: As wind farms expand, some can ‘steal’ each others’ wind

"climate change advocate", in contrast to some "climate change opponent"?

half-kh-hackeron Apparently Bluesky has one centralized service, the "relay"

the reference bluesky backend does just keep everything around but this idea has merit!! you're actually reinventing something like AppViewLite right now, which does throw away old data: https://github.com/alnkesq/AppViewLite

bluesky chooses to not refetch data from PDSes all the time so that the load for a PDS stays low (they like it to be possible to run on a home connection)

half-kh-hackeron Apparently Bluesky has one centralized service, the "relay"

- the relay storage volume scales only with the backfill window for consumers that drop briefly - the bluesky pbc operated relays let you reconnect up to 24h later and not miss any events but that requires around 200gb of scratch disk space -- live tailing an rpi relay without dropping a connection can give you events from the full network span (ie the complete set of the firehose) without requiring any backfill window, but it's nice to use a few tens of gigabytes anyway. -- the full firehose is like 20mbps at maximum so it's far from hard to serve a few live consumers

- bluesky's feed gen post-dropping is about internal operation of their appview and not anything to do with network sync semantics

- if you're running an AppView for the bsky data you are likely keeping a copy of all bsky posts in a database, since fetching from PDSes on-the-fly is network intensive over a relatively small pipe, which is what i mean by write volume requirements.

half-kh-hackeron Apparently Bluesky has one centralized service, the "relay"

plainly, free our feeds are grifting.

the relay at this point is non-archival and can be spun up trivially. with a small sliding history window for subscriber catchup u can use like 32gb of scratch disk space and keep a few hours, the relay is literally just a subscribeRepos forwarder from PDSes.

the AppView is vastly more expensive to run since you need to handle the write volume of all bsky activity. if you build a non-bsky app on atproto this is a non-issue

the issue here really is that nobody writes about the state of things in long form outside the network so it's not really known how fast things move and change by those not engaged with the platform

half-kh-hackeron When imperfect systems are good: Bluesky's lossy timelines

this is not correct

half-kh-hackeron When imperfect systems are good: Bluesky's lossy timelines

that's not the appview, that's the client

half-kh-hackeron When imperfect systems are good: Bluesky's lossy timelines

the backend (the AppView) can be found here:

https://github.com/bluesky-social/atproto/tree/main/packages...

there are various supporting services written in Go as well

https://github.com/bluesky-social/indigo

half-kh-hackeron Bluesky now has 30 million users

you can run a resequencing relay good enough to feed an atproto appview pretty cheaply - it just needs to subscribe to a few thousand websocket endpoints to get a live tail of the whole network (incoming traffic is well under 50Mbps at peak in my experience)

running an archival mirroring relay is storage-intensive (on the order of tens of TB iirc?) but only serves as an optimization (you can backfill full atproto repositories straight from the relay instead of needing to reach out to the relevant data server)

half-kh-hackeron Bluesky now has 30 million users

one cool difference between Bluesky and Mastodon (et al) is that server choice on registration is not an immutable permanent decision and you can choose to seamlessly migrate at a later time by updating your DID document

so the slick registration flow nets you less lock-in compared to if e.g. the mainstream Mastodon app were funnelling users onto one megainstance, since you can still get away afterwards without needing people to re-follow you

half-kh-hackeron Using Linear Programming to find optimal builds in League of Legend

gay online sociolect

half-kh-hackeron How to self-host all of Bluesky except the AppView (for now)

Your following list is stored in your own repo, so it lives on your PDS. You can theoretically have partial replicas of the network but nobody has bothered yet; if you want to make software like that, a good start would be subscribing to the firehose and filtering down to DIDs you care about / supplying the watched DIDs parameter to a Jetstream instance

half-kh-hackeron How to self-host all of Bluesky except the AppView (for now)

What else would "self-hosting all of Bluesky" mean other than a copy of the entire site? If you just want to participate in the network host a PDS, which only stores your own posts.

half-kh-hackeron Shipping Threads in 5 months

Speculatively, I think Mastodon being AGPL could have played some role here

half-kh-hackeron Speeding up Electron apps by using V8 snapshots in the main process

A lot of Electron applications in the Arch Linux package repositories use a system electron package, it's nice. They have to be split by major version, though.

half-kh-hackeron CSS @property and the new style

It's needlessly conspiratorial to ascribe intention here, especially when the Servo community have already expressed interest in supporting upcoming (difficult!) standards like CSSOM

half-kh-hackeron Show HN: OBS Live-streaming with 120ms latency

> We've shown that many measurements of latency [...] ignore the full capture and playback pipeline

In the repo linked in OP is a screenshot showing a wall clock next to its playback on the streaming site -- that's end-to-end to me. So how is this relevant?

half-kh-hackeron How much faster are the Gnome 46 terminals?

The methodology of the linked keyboard latency article including the physical travel time of the key has always irked me a little

half-kh-hackeron A Love Letter to Tinkerable Software

my favorite thing about modern landscape of desktop apps is that… Electron apps are tinkerable! you go to the app's resources folder, extract an asar with one command, and then you can edit the node.js-side files. then, you can just change what the BrowserWindow instance is loading to resources you control, and you have end-to-end control over the entire application

half-kh-hackeron Making synthesized sounds more acoustic

I'm working on an additive synthesizer right now and it's so fun to make plucks where the partials have different envelopes

half-kh-hackeron Making noisy SVGs

Which dark mode are you talking about? As far as I can tell the page (& demos) don't ship any styles for prefers-color-scheme: dark at all

half-kh-hackeron A coder considers the waning days of the craft

a whole script? surely it's just something like `find . -name '*.aiff' | parallel ffmpeg -i {} {}.mp3`

half-kh-hackeron Maybe Rust isn’t a good tool for massively concurrent, userspace software

so it's clear to non-Rust devs, we do have basic primitives for "running async code from sync":

https://docs.rs/futures/latest/futures/executor/fn.block_on....

imagine you have an:

    async fn do_things() -> Something { /* ... */ }

you can:

    use futures::executor::block_on;
    fn my_normal_code() {
      let something = block_on(do_things());
    }

but this does get messy if the async code you're running isn't runtime-agnostic :(

half-kh-hackeron Driving London to Bath 60 years ago

Chippenham and Calne are so different :O

half-kh-hackeron Testing a 1,000 player Minecraft server with Folia

I'm excited for Project Valhalla to affect Minecraft performance; a lot of the temporary allocations are things like BlockPos objects (a Vec3i, basically) and VoxelShapes (a tree of axis aligned bounding boxes; so, like, an array of a struct that's six f64s) which seem ripe for becoming value objects that are inlined by HotSpot instead of living on the heap

half-kh-hackeron Switching from C++ to Rust

the docs[0] are clear:

> be careful: if you try to access an index which isn’t in the Vec, your software will panic!

> Use get() and get_mut() if you want to check whether the index is in the Vec.

In my experience, most people are using get() if the source of the index is untrusted

[0]: https://doc.rust-lang.org/std/vec/struct.Vec.html#indexing