sheept

It could be more helpful for comparing model performance than just vibes or benchmarks. For example, you could run analyses to compare average line count per change or revert rate by model. Perhaps there will be a paper out in the near future that scrapes AI usage in public repos for a broader dataset.

My pixel font of choice is Sans Nouveaux[0] (requires Flash). It's MIT licensed too.

[0]: https://emehmedovic.com/sans_nouveaux/

Why would there be paranoia when writing blocking code with async?

The downside of goroutines is that you have no control when the goroutine context switches, so naively accessing a global value can lead to race conditions (which the language has no warnings for despite being such a concurrent language), while the same code works fine in JavaScript because context switches don't happen in synchronous code.

Rust unsafe functions aren't a good example of colored functions because it doesn't exhibit the main issue brought up in the article, that one color can call the other but not the other way around.

In Rust, unsafe code can call safe code, and safe code can call unsafe code. Calling unsafe code in safe code requires an explicit unsafe block, but that's fairly normal and not a hack to get around function coloring.

A better example could be Rust async, though unlike JavaScript, you have the option to block the thread on an async function in a sync function.

At least in JavaScript, it's nice to be able to see explicitly where you can expect the function to yield, so it's clear when race conditions can occur, or if you're calling it in a loop, whether you should consider running things in parallel.

Plus, you probably don't want to lock up the whole thread if you're writing anything more than a quick script, like a web server or a GUI.

It could probably be helped a bit by enabling auto hyphenation, but ultimately browsers aren't optimized for typesetting narrow columns of text

In my experience, Rust is only mildly unpleasant to review, if only because the GitHub PR review interface is not an IDE. It can be hard to tell why .as_ref()s and whatnot had to be used without being able to hover over a variable to see its type. This is probably because of the language's preference for type inference, though personally I would rather that than having to skim over explicit types.

Compared to Rust, Go as a language requires a lot more effort to review. You have to be on the lookout for basic gotchas like not checking if a pointer is nil, placing `defer` in the wrong place, using a result when err isn't nil, and so on. Plus, diffs are messier because unused variables are a compilation error, and _, err := can change into _, err = solely due to new lines above.

I'm not sure if that's a great example. What kind of errors could ShouldBindQuery return?

I would assume Axum returns a bad request error for you when query parsing fails, but if you do want more control over how the error is handled, you can change the parameter type to Result<Query<bool>, QueryRejection>, and the type system itself documents precisely what errors you can match against.[0]

[0]: https://docs.rs/axum/latest/axum/extract/rejection/enum.Quer...

A Rust library likely wouldn't be returning an opaque Box<dyn Error> to begin with. Errors are part of a library's API—it's what allows consumers to handle them—so you'd define an enum of possible errors your library could produce and return that, which would be stored on the stack.

Wouldn't it also work just to render the visible text as an image/path, then put invisible text objects over it?

I've heard suggestions like having white/invisible text in resumes for tricking applicant tracking systems,[0] but it's apparently mitigated by showing recruiters the plain text version of the resume.

[0] example: https://news.ycombinator.com/item?id=36857909

It seems like if you wrap both in a record then it should be possible:

    public record Left<T>(T Value);
    public record Right<T>(T Value);
    public union Either<L, R>(Left<L>, Right<R>);

The recent npm supply chain attacks relied on lifecycle scripts, which Deno doesn't run by default, but neither do pnpm or Bun. While Deno, like npm, supports a minimum release age, it doesn't enable it by default.

Deno's goal was to address Node's design weaknesses, while Bun came out with the promise of faster performance. Especially if you're coming from Node or migrating an existing project, it's easier to justify switching to Bun than to Deno.

Since then, all three runtimes have been gradually converging (adopting Web APIs, first class TypeScript support), so there's little reason to move away from Node's vast ecosystem to Deno; most npm packages weren't made with Deno's security model in mind.

Deno's biggest strength is when you want its security model and don't plan on using npm packages, e.g. if you want to let agents write and run quick scripts on your machine without awaiting your permission.

At one point we had UMD[0], which effectively provided runtime-agnostic interface, but ES modules were incompatible with that.

Deno and Bun have decent Node compatibility, so couldn't Node APIs be used as the generic runtime interface?

[0]: https://github.com/umdjs/umd

Deno's LLM contributions have been smaller in scope, so they're more likely to be reviewed by a human, and the codebase remains understood by its contributors. Can the same be said of Bun, which switched to an entirely different language in a single, million-line PR?[0]

[0]: https://github.com/oven-sh/bun/pull/30412

For websites like Gmail when you open an email

It can[0] but I'm not sure if it's using that for the comparison.

[0]: https://developer.mozilla.org/en-US/docs/Web/API/Event/isTru...

Just a quick search through the docs, it's garbage collected and has no means of directly manipulating memory, so it seems to be memory safe

Deno supports import maps, which are the mapping outside of the source files.

But yes, URL imports have a variety of other issues (duplicated dependencies, no resource integrity), though Deno solved them in later versions (npm registry support, lock files).

The only benefit of Deno is its permissions system, which has been great for safely letting agents write and run scripts on my file system.

These examples that you're calling "verbs as a noun" are standard grammar. You can't just invent simplified rules about a language and declare it wrong when the rules fall apart.

Presumably if you block domains, you wouldn't be able to use AI to find a way around the block. So doing so demonstrates at least some human skill

Offline CTFs could also incorporate physical security challenges, like lockpicking

Both are parodies of The Onion's long-running series of articles.[0]

[0]: https://en.wikipedia.org/wiki/%27No_Way_to_Prevent_This,%27_...

Yes, as your parent comment points out, the article centers itself on US transactions, where listed prices seldom include tax and are frequently a cent below a round number. For example, the menu says a dish is $15.00 but the restaurant charges $18.83 after tax and tip. Globally, there's no doubt the US is the exception rather than the norm.

The distinction makes sense, but I wonder if the bill will inadvertently incentivize games to move to subscription based models, which would be ultimately be a worse experience for consumers.

People don't want to read LLM-generated docs though. It'll lack the context to justify why things were designed the way they were, and there's always a risk of hallucination so you still have to verify the documentation's claims, since the person who published it likely did not scrutinize it.

No, they've explicitly denied it.[0] However, they do regularly dig at how much faster their fork is[1][2] that they can't merge because of Zig's AI policy.

[0]: https://x.com/jarredsumner/status/2051600118886138262

[1]: https://x.com/bunjavascript/status/2048427636414923250

[2]: https://x.com/jarredsumner/status/2053050239423312035

your boss will probably prefer the colleague that can now work more, and isn't occasionally absent from their desk

For US undergrad, with all the resources available online, going to university just for education doesn't justify the high tuition. Research is mostly limited to graduate school anyways.

It's still AI. Natural language processing has long been a branch of AI well before LLMs came out.