HNHacker News
TopNewBestAskShowJobs

claytonwramsey

1,167 karma · joined June 22, 2023

I'm a PhD student with interests in robotics and chess engines. Check out my website! https://claytonwramsey.com/
submissionscomments
claytonwramsey··on Criticisms of “The Body Keeps the Score”
I wasn't very impressed by the reporting quality in this article, but it seems as though there are some other reviewers of the book were much more thorough in their critique. Emi Nietfeld writing for Mother Jones has more detail and actually contacted some experts for comment: https://www.motherjones.com/media/2024/12/trauma-body-keeps-...
claytonwramsey··on Life, Work, Death and the Peasant, Part V: Life in Cycles
This is covered in a previous article: https://acoup.blog/2025/09/12/collections-life-work-death-an...

In short, most peasant farmers must sharecrop at least some of their land, and on sharecropped land, extraction rates are on the order of 50% (for basically nothing in return).

claytonwramsey··on Setsum – order agnostic, additive, subtractive checksum
This reminds me of Zobrist hashing [1] in chess engines. In fact, if you split the sum into 256 columns (instead of 8) and set the prime to 2 for each column, I think it's essentially the same. I'd be curious to see some quantitative benchmarks and their results on performance + collision rates.

[1]: https://www.chessprogramming.org/Zobrist_Hashing

claytonwramsey··on Models of Ice Skating for the Development of Robotic Ice Skating Gaits [pdf] (2020)
hey, a fellow figure skater!

You can still draw arcs without sideways slipping. If you do out the math, you’ll see that a skater traveling in a circle has no sideways velocity, but does have sideways acceleration.

claytonwramsey··on Paged Out #6 [pdf]
Thanks for making this! I got an invite to contribute some time ago but didn't have the time to put something together - it looks amazing though; I'll have to figure out something good next time.
claytonwramsey··on No longer writing my own damn HTML
I did think about that! However, I didn't like the idea of making the client side do work to make up for my own poorly-managed website. Forcing users to run code just to render some boring text seems like a waste.
claytonwramsey··on Build a Database in Four Months with Rust and 647 Open-Source Dependencies
Cargo currently has `cargo tree`, which prints out a dependency tree. There's an extension to cargo which also shows how many people have the ability to push to your dependencies, titled `cargo-supply-chain`.

https://github.com/rust-secure-code/cargo-supply-chain/

claytonwramsey··on 3blue1brown YouTube Bitcoin video taken down as copyright violation
The problem is not YouTube, but the law. The DMCA requires that online service providers (YouTube, Reddit, etc.) comply immediately with any takedown request and without question, so long as it meets sufficient conditions.

https://en.wikipedia.org/wiki/Online_Copyright_Infringement_...

claytonwramsey··on Savoy Style vs. Hollywood Style: A Fight to the Death (Hopefully?) (2011)
> dancing really connected people. I hope it becomes a thing again.

Social dancing’s demise has been greatly exaggerated! If you live in any moderately large city, there is almost certainly a swing dance scene, and you can find people doing social Latin (salsa, bachata) pretty much everywhere. My city’s swing dance club has a social every Sunday, with events on most Saturday evenings too.

claytonwramsey··on Arnis: Generate cities in Minecraft from OpenStreetMap
Is it just me, or does the README have the ChatGPT accent? For instance:

  Whether you're looking to replicate your hometown, explore urban environments, or simply build something unique and realistic, Arnis offers a comprehensive toolset to achieve your vision.
I don’t have a lot of issues with people using LLMs to generate documentation, but it does seem to have a lot of nothing-sentences.
claytonwramsey··on How much memory do you need in 2024 to run 1M concurrent tasks?
The implementation of `sleep` [1] decides the wake up time by when `sleep` is called, rather than when its future is polled. So the first task waits one second, then the remaining tasks see that they have already passed the wake-up time and so return instantly.

[1]: https://docs.rs/tokio/latest/tokio/time/fn.sleep.html

claytonwramsey··on Atkinson Hyperlegible Font
In Firefox, you can the advanced font settings and uncheck “Allow pages to choose their own fonts, instead of your selections above” to force websites to use the default font.
claytonwramsey··on 300μs typo detection for 1.3M words
It's a little odd that they're using `lazy_static` now that OnceCell and LazyLock are in the standard library.
claytonwramsey··on Creating an empty iterator of a certain type in Rust (2018)
Another possible solution for this use case: let each capacity graph store a “dummy” `HashMap<N,(u128, u128)>` for the case where the key is missing. Then, return an iterator over the empty dummy to get an iterator of the same type.

I will however note that simply using an option in the return value is probably the best choice both API- and performance-wise. The consumer may want to do different things if the key doesn’t exist versus if the key has no neighbors. Additionally, returning an Option means there’s only one check for whether the retrieval was correct, rather than checking at every call to `next`.

claytonwramsey··on SIMD Matters: Graph Coloring
I would argue the opposite: the problem is that our languages give us only rudimentary tools to represent data in SoA styles, which makes them difficult to apply for efficient processing. In other words, it's not SIMD's fault but rather the C-like approach to data structures. In fact, SoA is also great for non-SIMD parallel implementations because it yields improvements to memory density and cache performance.
claytonwramsey··on Things I learned from teaching (2023)
funny to see this surface again! I previously posted this article in December, but it moved with me when I moved domains, so it’s at a different URL this time.

As discussed prior: https://news.ycombinator.com/item?id=38558564

claytonwramsey··on Artemis IV OIG Report [pdf]
Some pretty damning results. Excerpts from the main findings below:

  While NASA requires its aerospace contractors to have quality assurance programs that comply with SAE International’s AS9100D standards on quality management systems, we found Boeing’s quality management system at Michoud does not adhere to these standards or NASA requirements.

  The lack of a trained and qualified workforce increases the risk that Boeing will continue to manufacture parts and components that do not adhere to NASA requirements and industry standards.

  Boeing’s delivery of the EUS to NASA has also been delayed from February 2021 to April 2027, and when combined with other factors, suggests the September 2028 Artemis IV launch date could be delayed as well.
claytonwramsey··on I Created 175 Fonts Using Rust
This is really excellent work, and a great write-up. I think it would definitely be possible to speed up a lot of the algorithms with some tricks. Replacing hashmaps with bitmaps and byte-index arrays for character painting and ascii-to-variants seems like a lead, based on what I've read. Of course, that doesn't really matter for this code since it's already fast enough.
claytonwramsey··on Optimizing the Lichess Tablebase Server
note - "chess" is not a Germanic word (deriving from the Arabic شَاه (shah), meaning king). Ironically enough, it comes to English via the Old French eschés, meaning that "lichess" is arguably made from entirely French roots.
claytonwramsey··on Properly testing concurrent data structures
It would be convenient to use async, but the other requirement is that we don’t want to change the outwardly-observable API of the software under test. Since async is “infectious,” we have to use sync implementations for sync APIs.
claytonwramsey··on Open source 'Eclipse Theia IDE' exits beta to challenge Visual Studio Code
For now, you may want to use VSCodium [1], which is a variant of VSCode which doesn't ship any non-free components (and also doesn't include Microsoft telemetry and such).

[1]: https://vscodium.com/

claytonwramsey··on A judge ordered us to turn over privileged documents
Some relevant reading:

Mississippi welfare scandal: https://en.m.wikipedia.org/wiki/Mississippi_welfare_funds_sc...

Mississippi Today’s reporting on the scandal: https://mississippitoday.org/the-backchannel/

claytonwramsey··on Sword Fighting Is Not What You Think
For an alleged expert in sword fighting, this post is awfully short on details. I’ll note that the overwhelming majority of combat in premodern history is not one-on-one, and is instead between teams in a formation (typically each of whom have shields in addition to their weapons).

Bret Devereaux (oft featured on HN) recently finished up a series on the Roman and classical Hellenistic tactical systems; for a view of an army doing sword-based combat, check here [1].

[1]: https://acoup.blog/2024/02/09/collections-phalanxs-twilight-...

claytonwramsey··on Deaf girl is cured in world first gene therapy trial
> At the height of it I thought I would eventually learn to smell the future.

Oddly enough, Salman Rushdie’s Midnight’s Children covers this exact feeling almost in the same way as you describe. If you haven’t read it, I definitely recommend it - it’s a long read but also very enojoyable.

claytonwramsey··on DrEureka: Language Model Guided SIM-to-Real Transfer
Your edit is roughly correct. It's a bit odd that they're comparing a single human-made policy with the very best of the DrEureka outputs; in practice, I would expect to make multiple different reward functions and then do validation on the functions and hyperparameters based on the resulting trained models. However, their comparison isn't necessarily wrong, since it seems (I could be wrong) that they used the reward function from prior papers in the field of policy learning.

If you're interested in methods for actually learning policies for these sorts of dynamic motions, note that this paper is simply applying proximal-policy optimization. They're pulling in the training and implementation methods from Margolis's [1] and Shan's [2] work.

So, in sum, the contribution of this paper is exclusively the method for generating reward functions (which is still pretty cool!!!!!), not all the learning-based policy stuff.

[1]: https://web.archive.org/web/20220703005502id_/http://www.rob... [2]: https://arxiv.org/pdf/2309.06440

claytonwramsey··on Dune 3D 1.1.0 Released
I've been following this project for a little while and it's very exciting to me. It's cool to see some movement on it since FreeCAD hasn't seen a lot of development and the rest of the OSS parametric CAD field is rather inactive.
claytonwramsey··on Did we lose our way in making efficient software?
There is perhaps some irony in the fact that this blog was posted to Medium, which serves 10.88 MB for a 265-word article.
claytonwramsey··on Is the Sun Conscious? (2021) [pdf]
In addition to the other comments, "Nightfall" by Isaac Asimov also covers a similar topic, especially in the full-length novel (though I prefer the short story).
claytonwramsey··on A step beyond Rust's pattern matching
In Rust, let-else patterns don't allow this, but match guards (used in `match` expressions and the `matches!` macro) can do something like this.

  while matches!(iterator.next(), Some((a, b)) if a + 1 == b) {
      println!("Hello!");
  }
However, using the bound values in an expression is a little harder.

  while match iterator.next() {
      Some((a, b)) if a + 1 == b => {
          println!("{a}, {b}");
          true
      },
      _ => false
  } {}
Since this is a well-formed transformation, it should theoretically be possible to implement this as a macro without changing the language.
claytonwramsey··on The return of the frame pointers
That's very interesting to me - I had seen the `[unknown]` mountain in my profiles but never knew why. I think it's a tough thing to justify: 2% performance is actually a pretty big difference.

It would be really nice to have fine-grained control over frame pointer inclusion: provided fine-grained profiling, we could determine whether we needed the frame pointers for a given function or compilation unit. I wouldn't be surprised if we see that only a handful of operations are dramatically slowed by frame pointer inclusion while the rest don't really care.

Page 1 of 2Next →