HNHacker News
TopNewBestAskShowJobs

andrew_rfc

228 karma · joined April 6, 2023

submissionscomments
andrew_rfc··on Reverse engineering iWork
I spent a few days brute forcing tables before I came across your repo and it finally clicked what was actually going on; thank you so much!
andrew_rfc··on Zeroperl: Sandboxing Perl with WebAssembly
Would this require using the WASIX libc? I didn’t spend much time on it, but when I attempted to use it the build started failing in mysterious ways - happy to open an issue on the relevant repo with a reproduction / notes on what I think our some bugs.
andrew_rfc··on Zeroperl: Sandboxing Perl with WebAssembly
You cannot today build anything on the Blead of Perl with perlcc.

Support has languished because the language changed fast enough that it never kept up. It may be used in the industry, but for a modern Perl application (or anything past 5.10) it won’t work. Hence why it was removed.

andrew_rfc··on Zeroperl: Sandboxing Perl with WebAssembly
I’m not sure where you got the idea it’s slow, but it executes within 30% of native speed. Which means extracting the metadata from a 30 GB pro video in my test takes 300-400ms.

Speaking of - libexif doesn’t support a lot of file formats, whereas ExifTool does.

If I always opt to choose the easiest path then I’m setting a precedent for myself that I will compromise on all my goals for half finished solutions that take me further from initial idea.

andrew_rfc··on WASM will replace containers
Cloudflare actually uses workerd which is a V8 isolate (which does support WASM with a lot of caveats.)
andrew_rfc··on WASM will replace containers
Speaking of Perl: https://news.ycombinator.com/item?id=43017739
andrew_rfc··on Zeroperl: Sandboxing Perl with WebAssembly
Author here: it wouldn't have been. Sure, it would be nice to have a native version, but that is a lifelong maintenance burden, and ExifTool is already the best at what it does and stays up-to-date with file format changes.

By completing this work, I can use ExifTool in any environment now - and more broadly, there is now a portable, embeddable, and sandboxed version of Perl that others can use in their projects. I can think of a lot of use cases, and helping other developers makes any hardship I endured worth it.

andrew_rfc··on Show HN: An experimental 2D/3D game engine for the terminal
In its current state it’s mostly just something fun to toy around with if you’re interested in game engine development; once it’s more mature I’ll probably ship a game on it. I have POC multi-player setup where you can telnet to a box and join a 3D world with other users.
andrew_rfc··on Bebop v3: a fast, modern replacement for Protocol Buffers
Looks neat. Bebop is licensed under Apache 2.0, not GPL and doesn’t require a commercial license to use for profit.

And I can tell the C# code it generates is going to be plagued by vtable lookups. Some decent ideas though.

andrew_rfc··on Bebop v3: a fast, modern replacement for Protocol Buffers
Apologies if my initial comment came off the wrong way; when I say “not alternatives” I was injecting bias into that statement since I normally use Cap’n Proto on embedded and memory constrained systems (amazing library btw.)

When I created Bebop years ago I tried to benchmark it against Cap’n Proto, but the lack of a semi-decent web or C# implementation mentally made me recategorize.

So I suppose I’m just comparing what’s closest in terms of ecosystem support rather than a purely functional level.

andrew_rfc··on Bebop v3: a fast, modern replacement for Protocol Buffers
you get forward and backwards compatibility out of the box so long as you adhere to the schema guidelines.

The docs go into more detail on how different types are handled. We also have some special features like “binary schema” which let you ship your schema with data so clients are always up to date.

andrew_rfc··on Bebop v3: a fast, modern replacement for Protocol Buffers
Cap’n Proto and Flatbuffers are not alternatives to Protocol Buffers. They solve entirely different issues and have distinct limitations.

They aren’t relevant to what Bebop is doing and thus no benchmark or comparison can be made between them.

andrew_rfc··on Bebop v3: a fast, modern replacement for Protocol Buffers
They were never particularly all that fast, especially not in the browser where support is far from acceptable. Most implementations rely on runtime magic, reflection, and other hacks.

So in that sense they aren’t all that modern as they’ve failed to evolve and keep up with platform evolutions.

Bebop just aims to generate code that modern and current with its target language, works everywhere, and avoids pitfalls protobuf suffers from.

andrew_rfc··on Bebop v3: a fast, modern replacement for Protocol Buffers
You can. I use it to persist settings in my app Borderless Gaming https://github.com/Codeusa/Borderless-Gaming

I’m also working on a textual configuration language that allowa you to import a schema and define data like JSON.

andrew_rfc··on Bebop v3: a fast, modern replacement for Protocol Buffers
If we’re talking specifically about C# binary serialization I’d recommend checking out this independent benchmark another developer did comparing Bebop to everything else

https://youtu.be/XMoNYQPi2k8?feature=shared

andrew_rfc··on Bebop v3: a fast, modern replacement for Protocol Buffers
We don’t benchmark against FlatBuffers or Cap'n Proto for a few reasons:

- They are impossible to benchmark against each other without making an assumption about how often you want to access the data, and which parts of it you want to access. But this means Bebop, Cap'n Proto, FlatBuffers can exist side-by-side / solve different problems: what FlatBuffers and Cap'n Proto do makes sense if you want to access only parts of your objects in limited specific ways, what we do is better if you're always interested in the whole packet.

- We don’t benchmark against Capt’n Proto because it does not have a stable web-based implementation, at least not one that has the features that make it so fast natively, so there is nothing to compare.

Basically, Bebop is great for message oriented applications or where you need the entirety of your packet deserialized in a single step. So we can only benchmark against similar formats (JSON, Protobufs, MsgPack, etc.)

andrew_rfc··on Bebop v3: a fast, modern replacement for Protocol Buffers
The benchmarks are in the repo + provided as screenshots in the README, but to clarify this is speaking to performance improvements relative to v2 of Bebop.
andrew_rfc··on Show HN: Crack this cipher and get $100
worked out beautifully!
andrew_rfc··on Show HN: Crack this cipher and get $100
sure, but man you posted the solution