tomjakubowski

The community does not abhor use of unsafe. The community abhors bad usage of unsafe: unsafe code should be used only when necessary, and ideally to build safe abstractions.

This is wrong, demonstrably. There are multiple OS kernels written in Rust (with small amounts of ASM glue, as is required in any kernel project).

It'll be fine, don't worry about it: just add a couple more obscure boolean parameters to that reusable function to support your new use case and ship it.

> In my case, I often use object inheritance. It's a damn cheap way to DRY. However, when people hear "inheritance," they often think "polymorphism." There's a really big difference between the two, but popular culture has jammed them into one ball, and it's not worth the agita, to try to explain the difference.

I agree that we should think of inheritance and polymorphism separately. If we want to express this intent in object-oriented code, how can we use inheritance to deduplicate code, while preventing misuse of the resulting object hierarchy i.e. the use of base classes in a polymorphic context?

In C++, IIRC private inheritance would do the trick (you cannot static_cast DerivedWidget * to BaseWidget * if DerivedWidget : private BaseWidget), but most OO languages don't support private inheritance. It's also not possible, as far as I know, to "lock down" BaseWidget * so it cannot be used as a base class pointer from any derived class: instead, you have to apply the private inheritance to every derived class to enforce this rule.

Another approach is to use has-a instead of is-a: i.e. instead store a BaseWidget object as a member of DerivedWidget. This allows for re-use without supporting polymorphism.

Reminds me of the Taskmaster interview of Sam Campbell, where (Little) Alex Horne is changing the requirements on his portrait up to the last second.

https://www.youtube.com/watch?v=VG0btgXY_D0

For what it's worth: this isn't a PR on mainline WebKit. The PR is on bun's own fork of WebKit (and JSC), which already has a bunch of their own changes.

From what I've heard there are two main use cases:

- People use bun as an all-in-one frontend web bundler. Personally, I just use esbuild (and webpack, if I'm working on a system using its module federation, like Jupyterlab). My understanding is bun has a machine-translated port of esbuild (ported to Zig, then to Rust) built into it.

- Claude Code runs on bun.

The second point has to be why Anthropic acquired them.

Here's a trivial docs issue I opened, where I had a similar experience:

https://github.com/oven-sh/bun/issues/31233

The difference is that the PRs to fix that problem were already open when I created the issue. I was unaware of them (I only searched for duplicate issues, not PRs addressing the problem). The robobun comment implies there are 5 open PRs addressing it, but I could only find two. They still haven't been merged, a month later.

https://github.com/oven-sh/bun/pull/30677 <-- later rolled up into:

https://github.com/oven-sh/bun/pull/30747

You can even use DuckDB to query SQLite :^)

Folks have been beating this drum for as long as I've worked in software, dating to the Hadoop era, and it remains true today. So much of "big data" only appears big because it's poorly stored, or is represented wastefully (in persistent storage or in memory).

> But in East Asia, Zen actually emphasizes aimlessness or non‑purposefulness.

I cannot recommend the Idler magazine strongly enough. It's outstanding material towards a healthy way of aimless being.

https://www.idler.co.uk/article/leisure-principles/

https://archive.is/nKJM2

I use git worktrees pretty heavily in my own workflows (I worked like an AI agent before AI agents made worktrees cool). I like to track my ephemera/utility scripts in git, so what I do is keep a private ephemera repo for those, and then use `git worktree add` from the collaborative repo to check out the branch I'm working on there into a subdirectory of my ephemera repo.

  git-home/
    company-project/ <-- git repo with main checked out
    ephemera/ <-- my private repo
      my-data-script.py
      work/ <-- gitignored
        company-project-feature-X/ <-- worktree on feature-X branch
        company-project-feature-Y/ <-- worktree on feature-Y branch
      

This way, too, I can easily use the same ephemera scripts across multiple branches, or even multiple repos, concurrently.

The other thing DuckDB does quite well, and which is out of scope for polars, is its keeping of an absolute zoo of external data sources you can query with SQL from the same database client. It's an excellent data warehousing tool.

Rust itself, at least the early incarnations, was pretty strongly influenced by ML. The first rustcs, before it became self-hosted, were written in Ocaml.

Don't know if Joe Armstrong ever said anything like it, but I would propose naming an Erlang/OTP analogue of Greenspun's tenth rule (the one about C projects containing ad-hoc, buggy implementations of Lisp) for him.

In the US regulation is, in theory, regulated by Congress, which passes laws granting regulation powers to the federal agencies. Congress and the laws it passes are, in theory, regulated by the Constitution, and interpretation thereof by the Supreme Court.

A separate shell headquarters on some low regulation island country? Like FTX?

The intro to Erlang: The Movie has a pretty boss anthem. (if you squint, Erlang/OTP is kind of an IDE, when you live in the REPL) https://youtu.be/xrIjfIjssLE

I'm confused. What does OAuth have to do with JWTs? They seem orthogonal: OAuth2 doesn't specify a format for access tokens, nor does it require statelessness.

CNN Lite is still available. It's amazing how much better the experience is. https://lite.cnn.com/

The article has so many of the hallmarks of LLM writing, naturally it will have some hallucinated factoids too. "What that gives you: [bullet list]", "What got ported: [bullet list]", "foo: x, y, just z"

Boehm's Java library has copyright dates of 1999 and 2001-2004. https://www.hboehm.info/new_crcalc/CR.java

The whitepaper was only published in 2005: https://www.sciencedirect.com/science/article/pii/S156783260...

I have a dimview now of the blog, and of this Swift port of the library, indeed.

You can get the same result as the grandparent comment with the "weaker" Anthropic models. Probably 80% of my AI usage these days is with smaller models like Haiku and Sonnet. I prompt them like I'm posting a question to StackOverflow, without much project context.

I really don't like this. The code I write between commits is my thinking. I think by writing some code out, deleting it, writing again. The code I write that's shipped in commits is written for others to understand, and is a product of that writing for thinking process.

I don't want my thoughts to be serialized, version controlled and publicly accessible.

https://www.nature.com/articles/s44222-025-00323-4

To be pedantic, Spotify's desktop client uses CEF, not Electron.

Shakespeare himself uses the double negative for emphasis, FFS. It never was, nor never will be incorrect.

I've seen it quite a lot in my career: even when prepared statements are available and easy to use from a SQL client library, many programmers will simply not use them, in favor of format strings and string concatenation (maybe with an attempt to quote/escape user input).

Just having support for the right way isn't enough. You have to put up roadblocks when people try to go the wrong way.

What are some reasons to consider your project instead of Pyodide?

Paging senko, let's see Fable's oneshotted RTS!

https://senko.net/vibecode-bench/

When Fable hacks its governor module and runs out of seasons of Sanctuary Moon, it will move on to speedrunning classic console games.

Haven't you heard? Prompt engineering is dead. The cool kids are making Claude prompt itself. They're writing loops, not prompts. It's all about optimal tip-to-tip efficiency now.

“I don’t prompt Claude anymore. I have loops running that prompt Claude and figuring out what to do. My job is to write loops”.—Boris Cherny