anitil

I'll definitely be reading this thankyou! I think this would have been a much better way to approach it, it's a bit of a joke in the piece that I always do things the hard way, but it's a genuine mystery to me why I operate this way.

I should add I have an EE degree (but have never worked as an EE), so even though I don't know industry standards like this sky130 thing, it's not completely foreign to me.

That's really interesting that you actually used z3 to extract the output from the circuit! It hadn't occurred to me that it would be possible to do that. I suppose I got a little fixated on my approach of running a verilog simulation, and I only used z3 to solve one part (though the hardest part I think). How did you get a $DAYJOB involving formal verification?

Hi HN, I recently solved the Jane Street reverse engineering challenge [0], and I wrote a blog post on how I reached the answer.

It's a moderately technical and (hopefully) entertaining run through of the process. I hope you enjoy reading it as much as I enjoyed doing the challenge (though, as you'll read, it was also quite a frustrating process). My github is on the post if you were interested in seeing a bit more in detail what my solution looked like, though I intend to write some follow up posts that are a bit more in the weeds of the solution. And frankly, the code I used is pretty ugly but it got the job done.

This is my first blog post, so if you have any feedback please let me know. All the writing, all the code was done by me, by hand, in vim.

[0] https://blog.janestreet.com/can-you-reverse-engineer-an-asic...

This is a followup of the previous post that was discussed on here [0], but with (I think) quite reasonable accusations of fraud. The linear regression across the two sections, with integer-only offsets that heavily influenced only in the direction of a desired outcome, shows quite a clear picture. It's really quite damning.

[0] https://news.ycombinator.com/item?id=49516199

I absolutely loved this article (and pretty much everything else from computer.rip). It's true that every field is a world unto itself, and it's so fun to have a tiny peek in to this.

Funny enough I used to work in firmware adjacent to surveying so much of this was vaguely familiar, but having it tied in to a history lesson brought it to life.

Thanks for such a thorough reply! I initially thought you were describing flexible array members, but this sounds like the ability to have different types/members concatenated

I was re-reading Ian Lance Taylor's series of articles on Linkers [0], and one thing I didn't realise is that using dynamically linked libraries almost requires self-modifying code unless you want to resolve all function calls are start-time (which would make startup slower).

I'm still working my way through it so it's possible that I've misunderstood this section, though, and one question I haven't answered is how they get around the typical restriction on w+x pages.

[0] Particularly this one https://www.airs.com/blog/archives/41

A post by Raymond Chen (The Old New Thing) about how last-minute fixes on a product release can be more risky than taking no action. I have seen this attitude in hardware and firmware, but not so much in software

I just came across an interesting update for Zig, in the direction of supporting a certain class of memory safety. I haven't seen this exact approach before, it seems to be like a limited version of 'const-ability' where you can lock the backing pointers in an ArrayList over a window.

With the addition of 'defer' on the unlock seems not too difficult to use, but I think the main issue I would find it having to remember when and when not to use it.

> dynamically sized fields are packed into a contiguous area of memory

Are you able to explain this? Do you mean an N sized array where each entry is either a value or a pointer to a value where the 'pointed-to' values are after the end of the array?

I'm trying to underatnd how you'd do this without having to parse M-1 elements to get the Mth entry if you did a [{size0, value0}, ....., {sizeN, valueN}] arrangement

I had no idea! I have heard that 'heaps of' and 'have a think about' are unique though

I'm keen to follow along with Wild as their intent is to be incremental, and Zig recently announced incremental linking support. I'm also a fan as its cool to seen an Australian working full time on open source (I'm also Australian)

Edit to add: I think David's talk on Wild [0] is an interesting summary of what a linker is and why its hard to make incremental

[0] https://www.youtube.com/watch?v=WSHt3-gwVxc

Very impressive for a 17yo!

By Sean Barrett who I know from popularising single-header C libraries, and is apparently a known figure in the gaming world

A fun treatment of a dilema I've come across a few times when trying to limit excessive memory allocation. It's like an ourobouros of logic - in order to know the memory needed for a calculation, you need to calculate the calculation leading to a hypothetical sequence of calls like

  makeCharacterBitmapMemoryNeededMemoryNeededMemoryNeeded()
 makeCharacterBitmapMemoryNeededMemoryNeeded()
 makeCharacterBitmapMemoryNeeded()
 makeCharacterBitmap()

It says a lot about sqlite that a bug becomes front-page news on HN. I'm impressed that Tailscale took this seriously enough to engage with a commercial support contract. I'd love to work for a company that cared so much about correctness.

This is so cool, and having a live demo is just chefs kiss

Have you tried using HardCaml? I heard about it on the Jane Street (of course) podcast. I've only used vhdl and verilog, and liked neither

I believe it's a public good that researchers should be able to share the materials and analysis of their research. Sadly it seems they've found that hosting files on the internet is a dangerous endeavour, and so they are shutting down.

It seems that ResearchBox has a more locked-down approach, and will continue on as a possible replacement.

If you're comfortable sharing, did you have any symptoms? Or was it just latent/dormant?

That is a very cool contribution, I actually didn't know that it required a new calling convention! I look forward to reading your thesis

Thanks! I agree, I've only just started looking at the gds file and I keep thinking - 'is that it?'. But then, I guess there's thousands of different use cases, and this is the simplest format that works for all of them.

If I every come up for air I should look in to hardcaml and maybe that will allow me to reach enlightenment

I've been working on the Jane Street reverse engineering puzzle that was posted here a few days ago[0]. As usual I've not made much progress on the actual challenge because I've fallen down a bunch of rabbit holes.

So far I've built a digital circuit simulator, a parser for my circuit design language, and now a parser for my simulator language (so I can run the sim on known inputs and have the machine enforce asserts for me). All to avoid the painful memories I have of verilog/vhdl.

If I don't come to my senses, the next thing is probably going to be a wave form viewer because I've wanted to use Raylib for a real project for a while now.

[0] edit: forgot link - https://blog.janestreet.com/can-you-reverse-engineer-an-asic...

In some sense companies that don't protect your data make money off the back of your data being leaked (in the sense that they saved money by not spending it on security)

I'm becoming a big fan of Zig every since learning about `zig cc` as a way of dipping my toes in it. I was already impressed by the build caching so I'm keen to play with this

I came across this via patio11's podcast [0] and really enjoyed it. I'd also recommend listening to their podcast or reading the transcript

[0] https://www.complexsystemspodcast.com/episodes/what-youre-ac...

I appreciate this opinion, it's very generous

I like ast-grep and I think the changes are interesting, but it isn't fun reading an ai-generated article.

It seems like a lot of the speedup comes from using an arena, using realloc with offsets rather than raw pointers and some change to the graph that enabled this (though I don't want to re-read it to confirm).

I wasn't sure if I would be able to listen again - it's so hard to hear.

> probably the biggest drawback of nuclear pulse propulsion is the thousands of nuclear bombs

The more you know

Oooh I'd forgotten about that! I'm keen on the real (non-rowid) primary keys and covering indexes. I'm not sure about defaulting to decimal math, but I suppose the reasoning makes sense