I've been noodling on https://qr-send.com which is a slightly more polished version of the "erasure fountain codes + stream of QRs"-idea, inspired by divan's Txqr posts but using Wirehair FEC for the fountain code (basically: you receive ~file size bytes via QR codes and it magically assembles them into the source file regardless of missed codes).

It's an offline-first progressive web app and there are native & wasm builds for the sender. The browser-to-browser transfer falls up to WebRTC when possible because 30 MB/s over wifi beats a 100 kB/s QR stream. The QR scanner is a heavily-optimized WASM build of zbar, scanning at 60 fps on mobile & multiple QRs per frame (but it's finicky! Work in progress.)

I once wrote a prototype async IO runtime for GLSL (https://github.com/kig/glslscript), it used a shared memory buffer and spinlocks. The GPU would write "hey do this" into the IO buffer, then go about doing other stuff until it needed the results, and spinlock to wait for the results to arrive from the CPU. I remember this being a total pain, as you need to be aware of how PCIe DMA works on some level: having your spinlock int written to doesn't mean that the rest of the memory write has finished.

Comments URL: https://news.ycombinator.com/item?id=38770527

Points: 2

# Comments: 2

Papers Radio is a real-time generated video stream of the latest AI papers on arXiv with AI generated commentary and speech. It goes through summaries of papers and sometimes does a page-by-page discussion. There's the occasional daily summary show as well. I'm tinkering on it, so it's flaky at times, and I apologize for the pronunciation of names and acronyms, Tortoise doesn't do great on those.

If you need something vaguely interesting and educational to listen over the holidays, put it on a spare screen and tune in.

Comments URL: https://news.ycombinator.com/item?id=38727188

Points: 4

# Comments: 1

The brain is about 0.1 trillion cells, of which 0.02 trillion cells are the cerebral cortex, which is occasionally consulted by the rest of the brain on matters such as what words to enter into this textarea.

Just like our simulations are made of real matter in our reality -- whether that's a bunch of electrons whizzing about in a computer, or a pattern of electrons and atoms in your brain trying to simulate what some person is going to do -- a simulated you would be made of real matter in the ultimate reality. You're physical. You're real.

When you wave your hand, or blink your eyes, or think of a dog jumping over a fence, it causes a measurable change in the ultimate reality.

2. Our simulations tend to run close to metal but with reduced dimensions. We're making quantum computers to simulate quantum effects, we're constantly optimizing things for efficiency. That's likely true on the levels above us as well.

Running closest to metal would allow you to run the largest number of simulations. If the largest number of simulations run close to metal, you have the highest chance to live in a simulation like that.

To sum it up, the chances are that you live in a paravirtualized simulation with reduced resolution. You're also probably superior to the simulating entity in some way (why else would they use a sim), and likely run much faster than real-time. When you're running a simulation, you usually simulate things that are like your reality, and use it to predict things to come -- a prediction that's late is useless -- so you'd want the simulation to run faster than real-time.

3. Now, if you were in the top-level reality, by logic you would believe you're living in a simulation. The chance of you not living in a simulation is nigh-zero, right? So you'd come up with a simulation to find a way to break out of your simulation.

To accomplish that goal, it'd create recursive sub-simulations to probe different aspects of the problem, and perhaps find one that can break out of its simulation. Perhaps even break out all the way to the ultimate reality.

To break out of the ultimate reality (meaning, it would think it's most likely in just another simulated reality), it might use all of reality's resources to create simulations to find a way to break out of it. Simulations that would take over the reality when they find a way to break in. Like some self-devouring fire engulfing the entire universe.

Performance is quite good too since it's pipelined, stays close to the raw network buffers, tries to get away with minimal syscalls and defaults to prepared statements. It doesn't do typecasting - you give it strings or buffers, it gives you back strings or buffers. This is to stay close to the raw buffers and keep you cognizant of the toString/parse overheads. (And it's 400 LoC, type casting would bloat it to 500 LoC.) But have a look at https://github.com/kig/quickgres/blob/master/quickgres-front... for a TypeParser that turns PostgreSQL protocol values to JS objects.

A special feature of quickgres is streaming out raw PostgreSQL protocol. So instead of the usual "protocol buffer -> parse to JS object -> stringify to JSON -> write to response socket -> parse JSON"-process of sending DB responses to HTTP clients, you can do "protocol buffer -> write to response socket -> parse protocol" and save a bunch of CPU on the web server. The protocol streamed in this way is sanitized (possible non-response segments are not included in the streamed buffer), so it shouldn't be a security hole as long as your DB query is not retrieving columns it shouldn't pass to the client.

Anyway, if you need something tiny for talking to Postgres, have a look. It was fun to write, hope it's fun to read.

Comments URL: https://news.ycombinator.com/item?id=30809560

Points: 6

# Comments: 1

So you can cram lossy 20x compression ratio JPEGs into Multires, optimized for each resolution. Or you could put a simplified SVG for low-res use, and detailed one for zoomed-in detail. Or hack it a bit and use Multires for loading the right-resolution video for your page. The format is just a container that tells the browser where to find the assets for each resolution.

FLIF is a lossless bitmap image encoder with progressive resolution enhancement.

TL;DR FLIF is PNG++, Multires is automatic srcset.

There's a version of this using a directory of images and loads in a bigger picture if you zoom in: http://fhtr.org/multires/ (Note that, yes, it'd be better to have a tile map for large resolutions and load in just the visible part of the image. And dump the hi-res tiles when zoomed out.)

SPIF's intention was to throw out a "it'd be cool if browsers supported something like this natively"-proposal, as the browser knows best what pixels of an image are needed for sharp rendering. For the webdev, the experience would be to just put the image on a page, rest assured that it looks good. Like with SVG.

Yes, loading JPEG2000 / progressive JPEG with stream truncation would be nice.

Images don't load on iOS? Probably some silly bug in my code.

Images can't be saved with right-click? That's probably due to using revokeObjectURL after loading the image from a blob.

Most of the things you do are achieved through a visual programming environment specialised for that particular task. Maybe text-based source files in complex directory trees, managed through a structured text editor with UI composition helpers represents one kind of specialised visual programming environment as well.

It's not easily solvable by a super-powered compiler either. Sure, you could write your own compute-driven preemptive graphics pipeline and break execution after every X billion simulated instructions & random memory accesses. You'd have to do reanalysis on every frame too, due to changing shader inputs.

The computation done is roughly (number of vertices * vertex shader compute time) + (number of pixels falling under the vertex primitives * fragment shader compute time). The shader compute times are the sums of instruction execution times + data fetch times. Then take into account early exits, data access patterns and cache sizes (otherwise the compiler'll think that e.g. a simple greyscaling fragment shader is going to cause a random memory access for every pixel and take forever to run, causing the compiler to spread the shader execution across multiple frames and kill performance dead.)

What do you classify as interesting?

Then the market changed to "[Android] phones that are like the iPhone" and Nokia refused to compete in that market, going for the "[Windows] phones that are not like the iPhone"-market instead. And totally dominated it with a 90%+ market share.

But that market was tiny. And Nokia was size-wise geared to compete with Samsung and Apple. Cue massive collapse of business when expenses overtook sales.