HNHacker News
TopNewBestAskShowJobs

alilleybrinker

413 karma · joined July 28, 2020

www.alilleybrinker.com

(I'm linking my keytrace.dev: did:plc:geozyv62fx63m7jhr4eraubc)

submissionscomments
alilleybrinker··on US appeals court rules geofence warrants are unconstitutional
Orin Kerr's analysis of this new ruling, which is linked from the Tech Crunch article, helps break down where the specific splits with other courts lie. This is useful even if you don't agree with Kerr's analysis of the validity of any specific courts' decisions: https://reason.com/volokh/2024/08/13/fifth-circuit-shuts-dow...
alilleybrinker··on The U.S. government may finally mandate safer table saws
Since they actually make a product using their patented technology, they would definitionally not be a patent troll. Even if they’re litigious, that’s exactly how the system is supposed to work when you’ve invented a valuable technology which you sell to recoup the costs of R&D plus the profit of your invention.
alilleybrinker··on Programming Beyond Paradigms
I think this article is _closer_ to right than a lot of writing on programming paradigms is, but still misses a central idea.

Programming paradigms can't be defined intensionally, by listing their features, nor extensionally, by listing programming languages that fit each paradigm. Either way results in unsatisfactory definitions from which reasonable people will identify errors of excluded languages.

This is because programming paradigms aren't sets, they're cognitive categories. Programming paradigms are subjective mappings of conceptual framings of program structure onto specific languages. A language fits a paradigm if that mapping is subjectively natural.

Of course, people tend not to like subjective definitions, but this is more accurate.

alilleybrinker··on Rust data structures with circular references (2021)
Oh yeah Aria’s writing is excellent. https://faultlore.com/blah/
alilleybrinker··on Rust data structures with circular references (2021)
Always worth plugging “Learning Rust with Entirely Too Many Linked Lists,” the canonical writing on the type of iterative approach for implementing data types with circular references in Rust: https://rust-unofficial.github.io/too-many-lists/
alilleybrinker··on Tech Debt: My Rust Library Is Now a CDO
Bob Nystrom (munificent) addressed in elsewhere in this thread, and I’ll repeat his point here: vendoring does make a meaningful difference, because he’s taking responsibility for the code.

Separately, I do hope VEX becomes more real / takes off to help address issues of non-applicability for vulnerabilities. That said, I don’t think this is a non-applicability scenario.

alilleybrinker··on Tech Debt: My Rust Library Is Now a CDO
Yeah, I'd put the blame for that on the tools / systems which consume and report this kind of vulnerability data. They (at least as far as I've seen) don't really differentiate between severities of vulnerabilities. On the one hand, a strong preference toward "just patch" for vulnerabilities can make a lot of sense (the more that mechanism is flexed, the better it moves when you really need it, and rapid integration of fixes reduces time for exploitation by attackers), but here it's applied to a maintenance notice that ought to be treated a little differently.

Nonetheless, I think RustSec's feed is working as intended, and I'd put the expectation on the consuming tools (including `cargo-audit`, which I believe is largely maintained by the same people that maintain the RustSec vulnerability database) to change.

alilleybrinker··on Tech Debt: My Rust Library Is Now a CDO
It seems like the RustSec "unmaintained" notice worked as intended. Unmaintained dependencies represent a latent security risk as they will almost certainly not respond to any future vulnerability; identifying this risk before an incident happens is much better than trying to figure out response in the moment during an incident.

Armin's answer here, of taking on explicit ownership and responsibility for the third-party code they use, seems like a reasonable and socially desirable response. Yeah, I get that it's annoying, but this is (IMO) pretty much how open source is supposed to work.

alilleybrinker··on Digital forgeries are hard
(Assuming this is the same case; I haven't been following Craig Wright closely)

It looks like the case was very swiftly decided against Wright. Here's reporting from The Guardian about it today: https://www.theguardian.com/technology/2024/mar/14/australia...

alilleybrinker··on Standards for Software Liability: Jim Dempsey, Lawfare, UC Berkeley Law
To be clear, I wasn’t staking anything as my position. I was summarizing the position of the author.
alilleybrinker··on Standards for Software Liability: Jim Dempsey, Lawfare, UC Berkeley Law
At the moment there's an effort from the Office and the National Cyber Director (ONCD), CISA, NSF, DARPA, and OMB to encourage a move to memory safe languages, including but not limited to Rust (see [1]).

This included an RFI for which there were many responses, including a number of major tech companies (Microsoft, Google, others). The general consensus supports a move to memory safe languages, BUT many of the respondents also caution about the need to prioritize and carefully manage such a transition, and the need to continue to support and assure code written in memory unsafe languages using other assurance techniques like fuzzing, integration testing, unit testing, static code analysis, and more.

Hopefully that helps explain where things stand at the moment regarding at least US movement on this topic, and also to assuage concerns about a unilateral mandate that things get rewritten in Rust (or another language).

[1]: https://www.whitehouse.gov/oncd/briefing-room/2023/08/10/fac...

alilleybrinker··on Standards for Software Liability: Jim Dempsey, Lawfare, UC Berkeley Law
I agree that there are details to sincerely work out here. I know in earlier drafts the wording of the "commercial" definition was such that it could be read to classify cases like a solo OSS developer who makes $10/month from GitHub Sponsors as "commercial" (and thus assign liability to them). This received substantial pushback from organizations like (as I recall) the Eclipse Foundation and the Electronic Frontier Foundation. I'm not sure where the draft language stands now.
alilleybrinker··on Standards for Software Liability: Jim Dempsey, Lawfare, UC Berkeley Law
Yeah, the doc acknowledges this concept is "drawing on tort law principles." In this case the author, Jim Dempsey, is proposing a rules-based framework for establishing a floor regardless of what underlying system is used (warranty, torts, etc.). So he's not _inherently_ assuming a tort law framing, and is instead making a recommendation for how it should operate regardless of whether the resulting system is based around tort law.
alilleybrinker··on Standards for Software Liability: Jim Dempsey, Lawfare, UC Berkeley Law
Cool thing to note: this argument was made a lot in responses to the Office of the National Cyber Directors' recent Request for Input on improving open source software security.

That said, there's a state of tension on this topic right now. The European Union's draft Cyber Resilience Act has included language across multiple versions that would in at least some cases assign liability to producers of open source software. They've tried to modify the language to exclude non-commercial open source projects, but there's been a lot of wrangling over the exact definition of "commercial."

alilleybrinker··on Standards for Software Liability: Jim Dempsey, Lawfare, UC Berkeley Law
I think this reading is _mostly_ right. To make it a little clearer:

1. A rules-based approach to define a minimum standard, likely based around existing descriptions of software weaknesses where the rules basically say "you aren't allowed to have this type of software weakness" (the doc specifically gives path traversal as an example). HOWEVER, liability would only be established if a weakness is actually exploited, to help avoid the problem of people proactively scanning for weaknesses and then troll-suing as a way to make money.

2. A process-based safe harbor to avoid liability for exploitation of weaknesses NOT on the rules-based "no no list." Basically, if you can show you followed the safe harbor process requirements, you get the benefit of the safe harbor. This is to protect and encourage organizations to go above and beyond the floor established by the rules-based standard.

alilleybrinker··on Teaching C (2016)
It’s not mentioned in the article, but I also think that learning how to debug and observe the behavior of C programs is useful given the limited ability to catch issues at compile time and high likelihood of code weaknesses and errors in C. Learning not just a traditional debugger like gdb or lldb, but also at least being introduced to tools like perf, strace, and ideally more powerful things like dtrace or bpftrace would be very helpful.

In my own Masters program we had a class on software systems which heavily featured both practical coverage of C and lots about debugging and observability. One of the most aggressively _useful_ classes I’ve taken.

alilleybrinker··on Memory safety is necessary, not sufficient
Just a small clarification here. The author isn’t just a fan of Rust. Steve was a member of the Rust Core Team for years and was co-author of the book “The Rust Programming Language,” which is the main recommended introductory text for the language.
alilleybrinker··on ISO C++ Directions Group response to RFI on open source software security
There’s also a bit of “have your cake and eat it too” with claiming as a benefit how stable C++ is (so old code continues working forever), while also claiming they can’t be judged against the security of old code.
alilleybrinker··on Operating systems with Rust – video lectures (2014)
I got a chance to teach Rust as part of an undergraduate introduction to programming language theory class way back in 2016-2017, and spoke about it at RustConf 2017. Here's the video for the talk: https://www.youtube.com/watch?v=0PhfaFkzdBA

My key takeaways were basically that students took to it better than I had anticipated, and that Rust proved to be a useful way to illustrate a number of interesting programming language ideas.

Note that because it was a PL class, not a Rust class, that students were not expected to walk away as capable, ready-to-run Rustaceans.

alilleybrinker··on Go, Containers, and the Linux Scheduler
I feel like this isn't the first time I've read about issues with schedulers-in-schedulers, but I also can't find any immediate references on hand for other examples. Anyone know of any?
alilleybrinker··on Gleam: a type safe language on the Erlang VM
Gleam is written in Rust and is a nice example (besides Rust itself) of what it looks like to write a language in Rust. By my own tracking (https://github.com/alilleybrinker/langs-in-rust) Gleam is one of the most popular languages written in Rust and is one of the few top languages in that list which isn't a reimplementation of an existing language!
alilleybrinker··on A four year plan for async Rust
Note that in general, the Rust project has chosen a time-based, not feature-based, release model. New Rust versions come out every 6 weeks, and new Rust editions have a consistent cadence of every 3 years. There are advantages and disadvantages to debate between time-based and feature-based release models, but Rust pretty clearly has chosen their preference.
alilleybrinker··on A four year plan for async Rust
To pick out one example of what makes it challenging: not all executors place the same type system constraints on tasks they execute. Tokio, for example, is a work-stealing executor which requires tasks to implement the `Send` trait so they can be sent between threads, while other executors may never move tasks between threads and therefore don't require the `Send` bound.
alilleybrinker··on Why Async Rust?
Agreed on the grandstanding! I can’t think of another topic area where the option space is extremely rich and full of trade-offs and the discussion space is so full of strong claims of there being one obvious and unquestionably best solution.
alilleybrinker··on Ante: A low-level functional language
If anyone is interested in other programming languages also written in Rust, there's a community-maintained list! https://github.com/alilleybrinker/langs-in-rust
alilleybrinker··on Sigstore - A new standard for signing, verifying and protecting software
The RFC trying to introduce sigstore for RubyGems is an interesting look at this in practice: https://github.com/rubygems/rfcs/pull/37
alilleybrinker··on Show HN: I'm making a dynamic language in Rust
For a longer list of languages written in Rust, see https://github.com/alilleybrinker/langs-in-rust
alilleybrinker··on Single dependency stacks
Apparently Tailscale for a long time just used a JSON file as their data storage, and moved from that to SQLite with a hot-swappable backup with Litestream [0], and hey they've done fine with that.

[0]: https://securitycryptographywhatever.buzzsprout.com/1822302/...

alilleybrinker··on Our User-Mode WireGuard Year
Thanks for the pro-con list!

The experience of...

1) build a thing because it's immediately useful for a specific use-case, 2) someone reuses it for another use-case because it's already there and saves some work, 3) times passes 4) oops really important stuff now relies on this thing in ways that weren't originally intended

... seems like a common pattern (see: JWT succeeding as the format for interoperable tokens by dint of just being around).

In this case, it seems like the pros are basically user-centered pros (`flyctl proxy`, existing tool interop, etc.) and the cons are basically fly-centered cons (state synchronization, maintaining the agent and making it work right).

The cons that do affect users (slowness, maybe they can't speak 51820/udp) seem _annoying_ but not deal-breaking for a lot of use cases. If the slowness persists over a long time it will be interesting to see how users opt to route around it (architect applications / processes to not rely on this channel).

alilleybrinker··on Apple removes Python 2.7 in macOS 12.3 beta
Sure, and perhaps in that context "deprecation" is the right description, but in general I've only heard that word applied to an API being in-process for removal, not as the descriptor of the final removal itself.
← PreviousPage 2 of 3Next →