HNHacker News
TopNewBestAskShowJobs

joshka

2,490 karma · joined June 6, 2011

[ my public key: https://keybase.io/joshka; my proof: https://keybase.io/joshka/sigs/ElI6j13SI-_2rTrkLnoKyV-uDepH4JvAQAzp2OWV_W0 ]
submissionscomments
joshka··on The limits of Rust, or why you should probably not follow Amazon and Cloudflare
Every single one of this authors articles that I've read (and it's a fair few), are poorly argued, and generally incorrect. It would be easy to engage and disprove, but it's better not to give this air. Just say no to kerkour.
joshka··on An AI coding agent, used to write code, needs to reduce your maintenance costs
I think I have a different perspective on this because I've worked in places that do care about that sort of thing on tools that do focus on those sorts of things. I think the long term incentive for these tools to address tech debt as a goal comes from the AI eval benchmarks trending towards being saturated. The advantages of one tool over another will be in the longer context things. This naturally will tend to start to act as a forcing function for training to focus on the longer tail of software development. A good way of thinking about this is GPT 3.5 was good at dealing well with lines of code and functions, 4 was functions, small apps, 5 seems adept at delivering apps and systems, 6 will be systems and whole enterprised programs of work.
joshka··on An AI coding agent, used to write code, needs to reduce your maintenance costs
I feel like AI might let us model some of the things that we initially didn't scope that led to these problems (e.g. "Decided not to fix every bug, or upgrade every dependency") - being able to more easily ask a system that can dig into "how much time are we spending on stuff related to foo"

AI tooling can also be a place where we start building our view of what maintainable software practices look like so we don't make decisions that have these same tail effort profiles. That can be things like building out tooling to handle maintenance updates

I think the real thing that comes out of AI tooling is probably that the tooling needs to be trained (or steered) towards activities that enhance human attention management.

joshka··on All my clients wanted a carousel, now it's an AI chatbot
Is this comment LLM generated?
joshka··on Show HN: Trust – Coding Rust like it's 1989
Ha - I see it's Ratatui based. Nice work there :D
joshka··on Show HN: TRUST – Coding Rust like it's 1989
I recommend VHS generally for these (we use them for all the ratatui screenshots generally). I'm also playing around with doing a rust version of this (https://www.joshka.net/betamax/)
joshka··on Homebridge 2.0 is here, and it speaks Matter
I haven't used homebridge, but have used HA in the past when I had lights and things hooked up. The UX and configuration surface always felt janky to me. So many little paper cut annoyances across every control / window / menu that you touch. The screenshots of homebridge seem much better at a cursory glance - if so, that's a net gain.
joshka··on The text mode lie: why modern TUIs are a nightmare for accessibility
Mitchell Hashimoto has a great response on lobste.rs https://lobste.rs/s/ifbdw1/text_mode_lie_why_modern_tuis_are...

> It isn't fair to blame TUIs.

> The real problem is that pretty much the whole stack has a terrible AX story.

> First, most GPU-rendered terminal emulators don't engage in system-provided accessibility APIs AT ALL. Because text is GPU-rendered, AX tooling can't "read" it, it just shows up as an image. This applies to Kitty, Alacritty, WezTerm. My own terminal Ghostty is AX-readable (on macOS), and so are others like iTerm2 and Terminal.app (which admittedly do it better than me, we have gaps to fill).

> Second, there are no terminal sequences or initiatives at all for TUIs to communicate AX information to the emulator, so the emulator itself can't do much more than display a blob of text to AX tooling. We need the equivalent of ARIA-style annotations but for terminal cells, runs, and regions. No such initiative exists. Even if TUIs do great things with the cursor, this is going to bite a lot of use cases.

> As an example of combining the above, I've been working on something with Ghostty where we integrate semantic prompt (OSC133) and AX APIs so that we can present each shell prompt, input, and command as structurally significant to AX tooling (rather than simply a text box where the cursor is somewhere else). This shows the importance of the relationship between terminal specs (OSC133), TUIs (which must emit OSC133), and terminal emulators (which must both understand OSC133 AND communicate it to AX APIs).

> The whole stack is rotten. And no one is earnestly trying to fix it (including me, I have limited time and I do my best but this is a WHOLE TOPIC that requires a huge amount of time and politicking the ecosystem and I don't have it, sorry).

Bonus: a simultaneously awesome and horrible reality is that AI is really helping to improve AX here. A lot of AI tooling uses/abuses AX APIs to make things happen. How is OpenAI reading your list of windows, typing into them, etc? Accessibility frameworks! So a lot more apps are taking AX integration a lot more seriously since its table stacks for AI using it... Sad it requires that but the glass half full is more software is doing that.

joshka··on Do_not_track
It feels like this should be no_track, for consistency with no_color
joshka··on A Gopher Meets a Crab
A much more charitable reading of the article is "here's some observations I found interesting / different". I met the author at the conf and watched their talk. Their perspective was very much in the camp of exploration, learning, wonder, etc. and not in the camp of criticism of either rust or vibe coding practices.
joshka··on A Gopher Meets a Crab
Probably on topic here - I talk like an LLM sometimes, and parse my points through them sometimes. I’d reasonably use that terminology and think nothing of it as it’s precise and correct. That said, this was partially LLM and my thinking here.
joshka··on A Gopher Meets a Crab
The weird-looking Rust isn’t really Rust being weird, it’s the type telling the truth.

   Result<Option<Result<Message, WsError>>, Elapsed>
That’s three independent “not the happy path” channels: timeout, stream closed, and websocket error.

The nicer version is not a cleverer match. It’s choosing a domain error shape and converting into it one layer at a time:

    let timed = tokio::time::timeout(duration, receiver.next()).await;
    let next = timed.map_err(|_| ReceiveError::Timeout)?;
    let item = next.ok_or(ReceiveError::Closed)?;
    let msg = item.map_err(ReceiveError::WebSocket)?; 
The ugly line is what happens when you have not decided where to normalize the shape yet.
joshka··on If I could make my own GitHub
The author's premise is that these all follow similar models to github and that's the problem they're calling out.
joshka··on If I Could Make My Own GitHub
yeah, you can have github actions setup on arbitrary pushes to your branches, but there's not a good interface for linking actions to bare commits, and then having conversations etc. The place where that happens is usually a PR.
joshka··on If I could make my own GitHub
>it is mostly your build-systems' job to be hermetic, run anywhere, handle cross-builds etc.

yes, and... the idea here is that it would be neat to extend the hermetic builds idea such that this can be run locally / anywhere where there's compute easily. The root problem that's being called out here is that idea of running something until the CI says it's green when there's a change, commit, network call, in the cycle is a pain in the ass. (The best way to avoid this churncycle is to just never write bugs! TFIC ;P)

joshka··on I Got Sick of Remembering Port Numbers
*.localhost works btw

https://datatracker.ietf.org/doc/html/rfc6761#section-6.3

joshka··on Maladaptive Frugality
A similar term (often found as a reaction to Amazon LPs) is frupidity.
joshka··on Who owns the code Claude Code wrote?
If you want to go much deeper, https://www.copyright.gov/ai/ is particularly good at least on the side of comprehensiveness.
joshka··on Could a Claude Code routine watch my finances?
Awesome. Definitely need to highlight this better somewhere on the main page (probably /pricing and in the /docs pages), but https://dashboard.plaid.com/ has it. More vague plans right now.
joshka··on There are only four sensible ways to build a website
I love the phrasing of this line in the article:

> It quietly defines the ceiling of your ambition and the floor of your operational risk.

joshka··on High Performance Git
try `git clone --filter=blob:none` instead

https://github.blog/open-source/git/get-up-to-speed-with-par...

https://gitperf.com/chapter-11.html

joshka··on Could a Claude Code routine watch my finances?
I'm curious how reasonable it would be for a person, rather than a company, to have a plaid sub.
joshka··on Drunk post: Things I've learned as a senior engineer (2021)
> Don’t meet your heroes. I paid 5k to take a course by one of my heroes. He’s a brilliant man, but at the end of it I realized that he’s making it up as he goes along like the rest of us.

Ha yup - I've felt this one before :D

joshka··on Drunk post: Things I've learned as a senior engineer (2021)
> The most underrated skill to learn as an engineer is how to document. Fuck, someone please teach me how to write good documentation. Seriously, if there’s any recommendations, I’d seriously pay for a course (like probably a lot of money, maybe 1k for a course if it guaranteed that I could write good docs.)

Good docs are docs that make it easy to implement the next feature.

From an AI perspective, it's my observation that LLMs often write code with lower quantity / quality docs. At the same time, they are reasonably good at synthesizing / inferring meaning from code that lacks good docs. They often do so internally by forming a chain of thought / reasoning around how the code works. The docs that should be written as part of the code are probably the same things that an LLM would reasonably come to by spending tokens when modifying that code. I believe that this should be trained into model so that future LLM work starts with not having to build up context.

In the absence of that being built in, something I've been experimenting a little with is tuning what I want to see in docs that actually help source control / development. Currently that's at https://github.com/joshka/skills/tree/main/doc-steward - still needs a bunch of work, but it's generally better than nothing. YMMV

joshka··on Jujutsu megamerges for fun and profit
jjk or jjview

I have a PR up for jjk that does the full change as a review changes, and there's another user's PR that allows diffs over arbitrary ranges (i.e. when working out whether the commits that make up a PR are good as a whole rather than individually)

joshka··on Can your AI rewrite your code in assembly?
> An open question is whether the AIs could find optimizations that are not possible if we use a higher-level language like C or C++. It is an intriguing question that I will seek to answer later. For the time being, the AIs can beat my C++ compiler!

Go throw yourself at Stockfish or another chess engine for this. They tend to have good test harness that can give you an idea of whether the speedups are worth the effort.

joshka··on Building a CLI for all of Cloudflare
The rust crate clap which is one of the more well known crates for command line parsing gets about 2M downloads a day and has this convention built in.

This convention existed before clap came into being, but I don't recall when I first saw it. I have been using the command line for just shy of 40 years across various operating systems.

joshka··on jj – the CLI for Jujutsu
> Does JJ really prefer for me to think backwards? It wants me to start with the new and describe command, but with git I first make the changes and name the changeset at the end of the workflow.

A good way to think of it is that jj new is an empty git staging area. There's still a `jj commit` command that allows you to desc then jj new.

> I also often end up with in a dirty repo state with multiple changes belonging to separate features or abstractions. I usually just pick the changes I want to group into a commit and clean up the state.

jj split allows you do to this pretty well.

> Since it's git compatible, it feels like it must work to add files and keep files uncommitted, but just by reading this tutorial I'm unsure.

In jj you always have a commit - it's just sometimes empty, sometimes full, has a stable changeid regardless. jj treats the commit as a calculated value based on the contents of your folder etc, rather than the unit of change.

joshka··on What is jj and why should I care?
The cli and a few concepts have evolved with time past the model's knowledge cutoff dates, so you have to steer things a bit with skills and telling it to use --help a bit more regularly.

I find it reasonably good with lots of tweaking over time. (With any agent - ask it to do a retrospective on the tool use and find ways to avoid pain points when you hit problems and add that to your skill/local agents.md).

I expect git has a lot more historical information about how to fix random problems with source control errors. JJ is better at the actual tasks, but the models don't have as much in their training data.

joshka··on What is jj and why should I care?
The last reviewed sha is generally available on the PR page (not the changes page) when you force push. There should be a changes since review link somewhere near the push.

When reviewing, you can also mark individual files as reviewed (useful in larger reviews where you're incrementally reviewing files). If you do this, only files that are changed will be expanded when you come back to the review.

← PreviousPage 7 of 34Next →