HNHacker News
TopNewBestAskShowJobs

tomjakubowski

8,575 karma · joined April 21, 2012

Valued [object Object] at Ralphs.

You can find meanness in the least of creatures, but when God made man the devil was at his elbow. A creature that can do anything. Make a machine. And a machine to make the machine. And evil that can run itself a thousand years, no need to tend it.

submissionscomments
tomjakubowski··on Postgres data stored in Parquet on S3: LTAP architecture explained
Don't know about other systems, but in Ducklake every committed transaction creates a new snapshot.

https://ducklake.select/docs/stable/duckdb/usage/snapshots

tomjakubowski··on Postgres transactions are a distributed systems superpower
I don't think it's true that distributed and decentralized mean the same thing. A hub and spoke rail system is centralized, but it's still a distributed system, if it has multiple trains running concurrently.* A distributed system has to coordinate somehow, and a single central DB is one way of doing it.

*: edit, maybe a better example here is a rail system with a single central dispatcher is centralized but may still be distributed

tomjakubowski··on Vibe Coded X11 Server Written in Rust Adds Xinerama, FreeBSD Support
In the past 20 years there have been enormous gains in tooling and culture, besides the rise of LLM-assisted coding, which make this task easier now. The task was already easier five years ago than twenty. Don't get me wrong, LLMs can speed this process up, and help experts and diligent newbies alike produce software faster, but you are discounting the gains in other parts of our work.

Since 2006, knowledge has become more available on the Internet. There is StackOverflow (for) now, and any number of developer blogs, in addition to the voluminous books published on programming. Hardware setups became more homogenous and the kernel took over handling more of graphics. Compilers, static analyzers, debuggers and testing tooling are all leagues better now. More code is published online, which can be used as learning material. Developers as a class of people have grown in numbers and experience. More mistakes in various open source software projects have been made, and recorded publicly for others to learn from.

tomjakubowski··on Exercise intensity influences body composition in healthy older adults (2025)
And if you're Andrew Skurka, in peak form, you'll get 15 hours in per day.

https://www.keithfoskett.com/the-andrew-skurka-interview/

tomjakubowski··on A way to exclude sensitive files issue still open for OpenAI Codex
The desire not to leak valuable secrets is a strong argument for supporting local-first developer workflows. If an AI agent exfiltrates the credentials to connect to my local dev Postgres database which stores synthetic data, that's pretty low impact.
tomjakubowski··on Zig's new bitCast semantics and LLVM back end improvements
Macintoshes have had mnemonic keyboard shortcuts for inserting en- and em-dashes since forever: option-hyphen and option-shift-hyphen. They've been in my digital repertoire since I first switched to a Mac around 2004.
tomjakubowski··on Extreme Heat conference cancelled due to extreme heat warning
Much of the population of Australia are from those same groups.
tomjakubowski··on The deadly rise of giant trucks and SUVs
In downtown LA I routinely spot on-duty police officers, who are usually cruising in large SUVs, texting while driving.
tomjakubowski··on Codex logging bug may write TBs to local SSDs
The most likely way I think you'd catch this in a test would be by accident, running some kind of long-running integration test for other purposes, and then finding the disk gets filled up in CI (or on a developer machine).
tomjakubowski··on There is minimal downside to switching to open models
You can also edit binary distributions of models with means besides changing their weights. See "LLM Neuroanatomy: How I Topped the LLM Leaderboard Without Changing a Single Weight."

On the spectrum of:

  careful engineering--hacking--mad science
This kind of thing falls far towards the mad science end of the scale, but has proven effective.

https://dnhkng.github.io/posts/rys/

tomjakubowski··on Bun has an open PR adding shared-memory threads to JavaScriptCore
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.
tomjakubowski··on Bun has an open PR adding shared-memory threads to JavaScriptCore
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).
tomjakubowski··on Prefer duplication over the wrong abstraction (2016)
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.
tomjakubowski··on Prefer duplication over the wrong abstraction (2016)
> 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.

tomjakubowski··on Prefer duplication over the wrong abstraction (2016)
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

tomjakubowski··on Bun has an open PR adding shared-memory threads to JavaScriptCore
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.
tomjakubowski··on Bun has an open PR adding shared-memory threads to JavaScriptCore
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.

tomjakubowski··on Bun has an open PR adding shared-memory threads to JavaScriptCore
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

tomjakubowski··on DuckDB Internals: Why Is DuckDB Fast? (Part 1)
You can even use DuckDB to query SQLite :^)
tomjakubowski··on DuckDB Internals Part 1
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).
tomjakubowski··on Zen and the Art of Machine Learning Research
> 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

tomjakubowski··on .gitignore Isn't the only way to ignore files in Git
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.
tomjakubowski··on DuckDB Internals Part 1
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.
tomjakubowski··on Clojure Hosted on Go
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.
tomjakubowski··on Cell-based architecture for resilient payment systems
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.
tomjakubowski··on Anthropic employees accuse Trump administration of targeting them
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.
tomjakubowski··on Anthropic employees accuse Trump administration of targeting them
A separate shell headquarters on some low regulation island country? Like FTX?
tomjakubowski··on Agentic coding deserves more than a chat box bolted onto VS Code
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
tomjakubowski··on Stop Using JWTs
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.
tomjakubowski··on 'Wow, it really worked ': 70s TV show causing worldwide panic today
CNN Lite is still available. It's amazing how much better the experience is. https://lite.cnn.com/
← PreviousPage 4 of 34Next →