HNHacker News
TopNewBestAskShowJobs

smj-edison

878 karma · joined February 20, 2024

Email is: stephen dot mason dot jones at the big alphabet company.

Github is https://github.com/smj-edison/

submissionscomments
smj-edison··on Show HN: The load-bearing vocabulary of Claude
I like to imagine that there's this one employee that oversees RHLF, who has a particular style of writing, and that got so ingrained that it's just them x1000.
smj-edison··on FDA authorizes first wearable device that monitors ketone and blood sugar levels
Tbh those sound more like Mast Cell Activation Syndrome (MCAS) symptoms...
smj-edison··on AI has access to a vastly larger working memory than the human brain
I also find them bad at what I call "abstraction compression." They're really bad at noticing when a helper function is needed, when some structure they repeated five times slightly differently can become a struct, when a whole section of code can be encapsulated in a simpler design.

I'm lucky that for my side project (an interpreter) I've written all the code myself, so I've built up its design in my mind over the past year, and so as I mull over what I'm writing I start coming up with simpler designs.

Interestingly using Opus 5 (and LLMs in general) has made me worse at this, since I don't feel the pain of writing something over and over again. On the other hand, I don't really want to implement a whole stdlib, so I have it write more of the auxiliary code. The hardest thing is that I have to manually manage the context, which is painful when I personally remember every helper function and why. I have to remember to keep the list of helper functions updated, which is irritating.

smj-edison··on Why does Opus 5 feel worse to work with?
That's the smoking gun
smj-edison··on Why does Opus 5 feel worse to work with?
So is it the LLM or us that's getting the RLHF? /s
smj-edison··on Why does Opus 5 feel worse to work with?
I did this too, but it usually thinks its writing is fine in my experience. Even when spawning a subagent, it thinks its effusive comments are fine. It's driving me nuts. Before I commit I end up ripping out 90% of the comments, and rewording the rest, otherwise I'd be drowning in comments. This is my style guide: https://github.com/smj-edison/zicl/blob/main/CLAUDE.md#style...
smj-edison··on GLM-5.3: Frontier coding with emergent cyber capabilities
I just can't get it to stop writing two paragraphs every time it makes a small ownership bugfix in my code. Every time it has to explain in excruciating detail every internal thought it had while fixing it. I find myself going in after and deleting all of its comments, or severely trimming them. Otherwise it ends with the code being unreadable.
smj-edison··on GLM-5.3: Frontier coding with emergent cyber capabilities
Now that you mention the original meaning of cybernetics, it makes cybersecurity a way more interesting word (security relating to the interface between humans and technology). Never thought of it that precisely.
smj-edison··on Squeak 6.1
How so? Never heard this perspective. Is it substantially more than reflection?
smj-edison··on 7.1 Earthquake in Japan
Wow, it's incredible how far civil engineering has come in the past 600 years. To think that we used to have bridges collapse all the time, and buildings crack and collapse, and now we have buildings that can withstand a whole earthquake.
smj-edison··on We have proof automation now
Most math does proofs somewhat informally (as in the proofs are written in a conversational style, and they're considered valid when they convince the majority of mathemeticians), but those proofs can be traced back to ZFC (a specific formulation of set theory and first order logic).

Type theory, especially dependant types, are a pretty recent development, and aren't really used in practice in math. Even in Mathlib (what most people mean when they say they've used lean), they encode first order logic. The proofs are dependently typed, but the actual logic of the proof is all in ZFC.

smj-edison··on Memory safety absolutists
Not familiar with the idea of "zapped", and I thought that Rust had a similar provenance model?

Working with pointers in Zig is much nicer, since

1. They're not nullable. If you want a nullable pointer, you would use `?*Object` instead of `*Object`.

2. They distinguish between single item and multi-item pointers. `*u8` is a pointer to a single u8, so I couldn't add to it or index it. `[*]u8` is a multi-item u8, which you can index.

3. Pointers track their alignment. I could make a pointer with `*align(128) Object` if I wanted to tag the bottom bits for example. Zig will require casts when changing alignment, for example casting from `*Object`.

4. Everyone uses slices when possible, pretty much Rust's slices.

5. A smaller detail, but there are sentinel pointers/slices, where you guarantee that the last item is a certain things. For example, a C string would be `[*:0]u8`, because it ends with 0.

smj-edison··on Memory safety absolutists
> but your software is almost certainly not an operating system kernel.

In general yes, but right now I'm contributing to folk.computer, which is a multithreaded task scheduler/central DB (among other things not relevant to the topic at hand). The biggest use of atomics is during statement insertion and removal, by using RCU operations in the central trie.

One of our current performance drags is the interpreter we use is not threadsafe, so we have to serialize and deserialize objects as they move between threads. This contributes to about 30% of Folk's CPU usage. So I'm currently working on making a threadsafe interpreter by porting the Tcl interpreter we use (Jimtcl), and I'm learning all the fun things around atomic ordering and threaded data structures. So I'm definitely the audience for these data structures.

smj-edison··on Memory safety absolutists
Interesting, this is pretty cool! I'm guessing it doesn't work with pointer to int casts though? I'm using NaN packing, so I necessarily have to cast it to an integer.

EDIT: though I'm considering switching to a tag + 64 bit union, because of 54 bit addressing and pointer tagging. It makes it tricky to get my data layout right though, since it makes all of the structures larger.

smj-edison··on Memory safety absolutists
There's some interesting work going on with this with Metamath Zero[0], where he's working on verifying everything down to the compiler, to make sure the compiler always emits correct code. His language, Metamath C, also allows for refinement types, which means you can prove certain properties. It's still in its infancy, but I've been watching it from the sidelines for a bit now.

Though in terms of practicality, Graydon Hoare has mentioned in the past that he isn't a big fan of complex systems, and so it's better to have a simple type system that covers 95% of the cases, and an escape hatch when it doesn't. I think that's still a fair assessment, but I've fallen down the proof rabbit hole so I am curious to see how far it could be pushed.

[0] https://github.com/digama0/mm0

smj-edison··on Memory safety absolutists
Rust allows you to use a literal iirc like r#raw, which helps with migration. This isn't too different from Zig's @"var" for example, which I'm glad modern languages have an escape hatch for naming things that don't parse normally.
smj-edison··on Memory safety absolutists
Interesting. I stopped working with Rust about two years ago, so it looks like there's been a lot more polish in these areas.
smj-edison··on Memory safety absolutists
I think this crate description encapsulates what's difficult about unsafe rust, which is how unergonomic pointers are. Like why do I need to use `addr_of_mut!`? I'm sure there's a good reason, as Rust tends to think these problems through, but it's very unintuitive compared to returning `&mut`. I feel like I'm juggling way more concepts, which to be fair helps with safety, but it can obscure the algorithm itself.

Does cordyceps have a derive macro? I can imagine that helps a lot with correct implemention, though when it comes to linked lists I can see people wanting to do it themselves.

smj-edison··on Memory Safety Absolutists
Thank you! I've seen the latter two mentioned in the past, but I never got very far into the books before getting confused with all the moving pieces. I think now that I've worked a lot in languages that put structs and pointers in the forefront, I'd understand it a lot better. Perhaps I'll have to go back and give them a proper read this time...
smj-edison··on Memory Safety Absolutists
Yeah, probably not. I wouldn't mind fuzzing it with Zig-Fil, but the interpreter (Zicl) is embedded in a larger C project that uses a lot of dynamic linking, so chances of using it in production is pretty much zero. I do have a lot of asserts that only have a small overhead, so I'll probably use ReleaseSafe most of the time, since it does catch a lot of the issues.
smj-edison··on Zero roadkill as Amazon canopy bridges secure 15,000 crossings
Depends how you interpret it tbh. At least in my tradition the focus is on seeing the good, bad, and ugly of history. There's many bible stories that are more cautionary tales than role models.

Now to be fair, there's also examples of God (as portrayed by the writers) being vindictive and harsh. I don't have great answers for that, but I do wonder how much it is seeing through their perspective of the situation and how much it was God. (I obviously come at this as a believer).

As to being the only moral text... I certainly hope it's not, because we've learned a lot since then, and I hope what's considered truth can expand beyond one book.

EDIT: not to dismiss your points, just to say that some of us view it in a more nuanced way.

smj-edison··on Memory safety absolutists
This is perhaps a different take, but one reason I love Zig and C is because I've learned how to reason in pointers. I've worked with Rust in the past on a ~12,000 LOC side project, so I was all in with tree ownership and XOR mutability. But it turns out there's all sorts of delightful data structures that you can only express with unsafe in Rust. Intrusive doubly linked lists are the coolest thing ever. The fact that I can have a LRU cache that changes what's at the front by shuffling some pointers, while still keeping stable addresses so the hash map stays stable? That's freaking cool. Atomic operations with pointers for linked lists is really slick for implementing an allocator's free list between threads. Being able to walk a live heap using a breadth first search by just... following pointers, made the elegance of Dijkstra's algorithm come alive.

Now, maybe I'm only running into these algorithms because these are the problems I'm running into, but in the Rust community I consistently got the message that linked lists were a legacy data structure. In some cases they are, but when they do apply they do so brilliantly.

I know working in Zig leaves plenty of room for memory unsafety. Perhaps that's a bad thing. But I'm implementing an interpreter, and these algorithms are essential for it to run fast. I really do need to be aware of where every allocation happens, and what instructions the computer is running. So for now I stick with Zig, even though I know I'm opening myself up to memory exploits.

smj-edison··on PennyLane is an open-source quantum software platform for quantum
Interesting to see it mention quantum chemistry, could anyone familiar with the field chimu in on whether it is viable to get accurate bond energies? It mentions Hartree-Fock, but I thought that that wasn't accurate enough to find transition states.
smj-edison··on The state of open source AI
> you can use their LLM to trivially clone their software.

Perhaps, but what you can't clone is familiarity, polish, integration, and network effects. These companies desperately need a moat, and so for example all the new additions to Claude's web interface are becoming the products that the vast majority of people will use and be locked into (if it goes according to their plan).

smj-edison··on Against Usefulness
Dynamicland hasn't published any of their code, while folk computer priorizes being open source. So yes, a lot of the ideas come from Dynamicland, but there's the important detail that you can actually use folk computer.
smj-edison··on Einstein's relativity rules chemical bonds in heavy elements, new research shows
Yes and no. If we could "just" run full QM, there's still the issue of building abstractions regarding the emergent behavior. A full system is still useless if you can't describe things like ligands, carbon rings, etc. So regardless of whether we can simulate it, we still need terms for higher level concepts.

But yes, nano and even femtosecond level second stuff is pretty mind bending.

smj-edison··on Einstein's relativity rules chemical bonds in heavy elements, new research shows
Thank you for the kind words! I've been wanting to do this research precisely because of firsthand experience with how hard chronic illness can be, and I'm hoping to attack it with a systems approach.

I haven't seen that website before, but it sounds pretty accurate from what I've heard. It's insane how high of a mountain needs to be climbed just to catch up to the state-of-the-art, and how much work is needed to push through to figure out something truly new.

Here's to making the world a better place!

smj-edison··on Einstein's relativity rules chemical bonds in heavy elements, new research shows
Disclaimer: I'm only a freshman, so there's still a ton I don't know :)

Right now the lab is having me get comfortable using software like Gaussian and ORCA by simulating a bifurcating reaction. This is a reaction that, depending on the catalyst's momentum, will change what site it bonds to (it makes either a 6-membered or 7-membered ring). I'm finding the intermediate states (where the molecule is most stable) and transition states (the tipping point), and then running trajectories to see which output is more likely.

Once I've finished simulating that, I should be comfortable enough with the process to jump on the bigger project, which is machine learning interatomic potential (MLIP) model distillation. There's a lot of exciting work around speeding up DFT methods by using machine learning (note this is not generative AI, it's merely predicting the molecule energy based on atomic positions). So my one year goal is to get on that project and start contributing.

My five year goal is to, well, graduate. But then I'll probably do a PhD in computational chemistry, since I'm really interested in ways to speed up and scale existing methods. My big dream is to simulate large biological systems while still having bond formation and breaking, to automatically elucidate biochemical pathways, but there's still a lot of steps in-between.

smj-edison··on Einstein's relativity rules chemical bonds in heavy elements, new research shows
I'm only a freshman, so I don't feel very qualified to comment on that :) I hope so though!
smj-edison··on Einstein's relativity rules chemical bonds in heavy elements, new research shows
And also emergent behavior means that at each level, we need different abstractions to deal with the problem. Even with chemistry, there's ideas like benzene rings that are aromatic, that you couldn't predict that from particle-particle interactions. So it's not just that it's hard to understand quantum mechanics, it's that understanding QM doesn't mean you'll understand the problems that chemistry deals with.
← PreviousPage 2 of 15Next →