dherman

Really glad to see folks looking into quantitative approaches to give agents feedback on code quality. This post looks like a good start!

My main feedback for the authors would be, the most important problems for sloppiness are global properties, not local ones. In my experience an agent, like a human, has finite capacity for its attention, but if it runs into local sloppiness that gets in its way, it can fix it on a by-need basis. The technical debt issues that matter are usually global issues that aren't so easy to fix: they require global analysis and global refactoring.

I don't know the answer, but I think we're going to need ways to measure architectural properties, like separation of concerns, clear architectural layering, well-defined interfaces, etc.

My high school Latin classmates and I made garum and left it to ferment in my back yard for a month. Young and foolish as we were, we stored it in a plastic Tupperware container. The day I brought it back to school for the class tasting, I had it sitting on a stack of piano books in the passenger seat of my car.

Weeks later, the rotted fish stench just wouldn't fade from my book of Beethoven sonatas. I ended up throwing it away.

Cool!

Ha, I just tried the same trick with Rust:

  //$HOME/.cargo/bin/rustc "$0" && ${0%.rs} "$@" ; exit
  
  use std::env;
  
  fn main() {
      println!("hello, world!");
      for arg in env::args() {
          println!("arg: {arg}");
      }
  }

Total hack, and it litters ./ with the generated executable. But cute.

In case it was directed at me, I’ll say yes, it’s on my mind, but my first goal was to have the full power of the entire OS facilities, the full Cargo ecosystem, and full native performance with the safety of Rust. That said, I think wasm has still only just begun to take off and it’s on my radar.

That's a cool idea! The closest thing today is probably neon-serde, a cool community library that lets you generate bindings from lightweight Rust annotations:

    https://docs.rs/neon-serde2/0.8.0/neon_serde2/

Another thing I'd love to explore is using TypeScript declarations (e.g. from a .d.ts file) to auto-generate bindings.

If you're interested in playing with any of these ideas feel free to hop onto our community Slack and chat!

Neon maintainer here, happy to answer any questions folks might have!

It's a pretty exciting time for Neon. We're nearly feature-complete for a 1.0 release, which will come with a bunch of benefits and should help us build momentum for future improvements:

  * No more legacy backend -- just one simple and clean way to use Neon, fully audited for safety.
  * Strong ABI and API stability guarantees.
  * Convenient APIs for general-purpose multithreading and creating custom async Node events.
  * Ergonomic and modern use of JS promises, which interact beautifully with async Rust code.

Some of the things I'm looking forward to exploring post-1.0 is even more ergonomics and performance improvements.

For context, one of the co-authors is Niko Matsakis, a recent hire at AWS and one of the longest-running leaders in the Rust community (among many things, inventor of the borrow checker and Rust's ownership system). So even if Amazon's involvement in the Rust community is only recently ramping up, I think this post suggests that they intend to invest in the Rust project itself.

I'm happy to see so many companies stepping up and investing not only in using Rust but in investing in its ongoing sustainability. And the fact that many companies are doing it, not just one, makes me optimistic that decision-making can keep happening in the community, not behind closed doors.

The Bayeux Tapestry Museum is hands down the best museum experience I’ve ever had. It’s really something else.

I remember sitting outside a Mountain View Starbuck's with Lars Hansen, then at Opera, and Brendan Eich, then at Mozilla, and listening to Lars explain that he'd lost faith that ES4 was realistically implementable. I think that was the day I knew it was dead.

I spent years working on ES4 and I'm not sorry it failed (namespaces in particular were just a disastrously bad idea). The whole affair was a formative experience for me.

I’m excited about Actions generally, so I’m glad to hear your team is aware of the challenges of building a reliable ecosystem of third party dependencies by reference to repos.

Still, recommending git SHAs has real ergonomic and maintainability issues, and while it’s more defensive it doesn’t prevent left-pad style broken builds due to disappearing content.

And at the same time, GitHub is investing heavily in package management infrastructure. I don’t say this lightly because designing good dependency management systems is much more subtle and difficult than people typically recognize, but from where I sit this appears to be fundamentally a dependency management concern. It seems a shame not to try to put GitHub Package Registry to good work here. Is that something potentially on the horizon?

If you ever have the opportunity, I highly recommend the show about Polynesian voyaging at the Bishop Museum planetarium in Honolulu. You learn a little bit about navigation by stars (in particular you get a taste of how unbelievably complex it is), some of the history of Polynesian voyaging and the recent history of the PVS, the Hokule’a and the amazing modern voyagers who’ve revived ancient Polynesian cultural traditions. It just leaves you in awe of Polynesian culture, knowledge, and accomplishments. I always make sure to catch the show whenever I visit Honolulu.

Wasn't it Joe Hewitt?

The reason for layering is that the lower layer code remains compatible and even, let's say, idiomatically acceptable if excessively verbose.