What we have not yet seen is an AI developing a substantial new conceptual framework in order to solve a mathematical problem. Much of mathematics proceeds by identifying the objects that are truly central to a question and then developing a theory that helps us understand them. Current AIs are very strong at searching and recombining existing ideas, but they are weak at building any deep and sustained new theory.

This speaks to a more general limitation of current AI systems. They are creative in the sense that they can recombine existing ideas in novel ways. But they are not creative in others: they have not yet developed conceptually new theories or structures. And while they have larger working memories than humans do, know more about more different things than any particular human does, and can process information faster than humans, can, true novelty is still largely beyond their reach.

Of course, that distinction may not survive for very long. Predictions are notoriously hard, especially about the future of AI. None of these mathematical capabilities were explicitly designed for, or planned. They’re all emergent properties of increasingly capable AI models. We are both confident that someday we will see AI models that are capable of the type of creativity required to do novel mathematics. Will that be in a few months, a few years or a few decades? Of course we don’t know, but our guess is sooner rather than later. //

Rontea • August 28, 2026 9:27 AM

Mathematics, like all human endeavors, is a cathedral built not only of logic but of spirit. The machines that now parade their counterexamples and clever recombinations are but mirrors reflecting the fragments of our own thought. They do not suffer the torment of doubt, nor do they rejoice in the sudden illumination that turns the darkness of ignorance into the dawn of understanding.

A mind that has never trembled before the mystery of existence cannot truly create. These artificial intellects move as blind giants, lifting stones without knowing they are in a temple. They may uncover truths, but they cannot love them. They may solve problems, but they cannot feel the sacred weight of the question.

So no, the end of mathematics is not yet upon us. For mathematics is not merely the tallying of symbols, but the human cry toward infinity. While machines can echo our steps, only man can walk toward the Absolute with awe and trembling.

In order to completely avoid the write hole, you need to provide write atomicity. We call the operations which cannot be interrupted in the middle of the process "atomic". The "atomic" operation is either fully completed or is not done at all. If the atomic operation is interrupted because of external reasons (e.g. a power failure), it is guaranteed that a system stays either in original or in final state.

In a system which consists of several independent devices, natural atomicity doesn't exist. Variance of mechanical hard drives characteristics and data bus particularities don't allow to provide required synchronization. In these cases, transactions are typically used. Transaction is a group of operations for which atomicity is provided artificially. However, expensive overhead is required to provide transaction atomicity. Hence, transactions are not used in RAIDs.

One more option to avoid a write hole id to use a ZFS which is a hybrid of a filesystem and a RAID. ZFS uses "copy-on-write" to provide write atomicity. However, this technology requires a special type of RAID (RAID-Z) which cannot be reduced to a combination of common RAID types (RAID 0, RAID 1, or RAID 5).

If your remote access is you reaching a handful of web dashboards, install Tailscale and forget about it. It's got superb polish and is seamless for that use case. My case for NetBird is specific: I wanted a control plane that's the vendor's actual product rather than a third-party reimplementation of a closed one, and I wanted to tunnel things that don't speak HTTP without asking permission from a three-port allowlist. If neither of those is your problem, NetBird's stack is overhead you don't need. If both are, there isn't really a competition.

https://netbird.io/

The catch is that scrubs are expensive, especially when the pool holds petabytes. An admin who hit a power-supply problem or a sudden shutdown usually wants to scrub the data written around that event, not the entire pool. That is the goal here: teach ZFS something about wall-clock time.

Internally, ZFS only thinks in transaction group (TXG) numbers. Administrators, inconveniently, think in dates. A TXG is just a uint64_t that goes up with every transaction, and there has never been a clean way to map between the two. //

With the database in place, zpool scrub learned two new flags: -S for the start date and -E for the end date. Both accept "YYYY-MM-DD" or "YYYY-MM-DD HH:MM" in local time. The end date is rounded up: scrubbing a bit more than asked is fine, scrubbing less is not.

shipped in OpenZFS 2.4.0.

What is ZFS and why is it so popular among experienced users? Let's have a look at the history of ZFS and its features and advantages over other filesystems. ////

Snapshot explanation is incorrect about recovery and storage -- snapshots track all changes to the file system, not just versions of existing files.

Tailscale recently made its free tier a lot more generous this year, with the user cap going up to 6 and the hundred-device cap being axed completely. I had been using it for easy remote access for my family far before the limit change, and right after, everyone decided that they wanted access to my media server around the same time. I quickly reached 6 users, and while I was tempted to just start paying Tailscale for more space, I decided to make use of the infrastructure I was already paying for with self-hosted NetBird, and I saved myself from paying a hefty monthly fee in the process. //

Headscale exists precisely for people in my situation, and it has a key advantage, being that it replaces only the coordination server, so official Tailscale clients can continue to be used exactly as they did. //

It's not a bad solution and plenty of people use it effectively, even in the same VPS-hosted configuration that NetBird is currently in for me, but the fact that it's not official means, like many other open-source community-maintained projects, that the maintainers can simply stop maintaining it. The self-hosted NetBird solution is an official part of the NetBird product, and therefore, it gets the same official support as the cloud-based solution.

The 'zdb -d` will display information about the dataset.

# zdb -d pool | grep pool/data
Could not open pool/data/%recv, error 16
Dataset pool/data [ZPL], ID 291, cr_txg 112281839, 219K, 7 objects

In this particular situation, we had an ongoing recv process which couldn’t read the data from network. Therefore, the zdb command might be a very useful and quick option to solve such situations.

One of the best aspects of ZFS is its reliability. This can be accomplished using a few features like copy-on-write approach and checksumming. Today we will look at how ZFS does checksumming and why it does it the proper way. //

We can see that using a merkle tree is a very safe way to store data on the disk, as it allows us to detect a lot of problems in the system. It is also worth noting that if ZFS is configured in the redundant way, it will detect broken data, return correct data (of course if possible) and also will repair them. This feature is called self-healing.

Most of the time, the whole point of ZFS is that your data does not get corrupted. But during development you sometimes need the opposite: a controlled, reproducible corruption, so you can watch self-healing kick in, see what a scrub reports, or just understand how a file maps onto the physical disk. There is no better exercise than breaking one byte on purpose and seeing ZFS struggling.

The safe rule is simple: do this only on throwaway pools backed by throwaway files. Pointing these commands at a real disk would be less of a lesson and more of a confession.

This is the story of doing exactly that on Linux, the lazy way and the educational way.

In this comic, the concept of an ordinary person having an FTP server is quickly dismissed. And yes, it’s not common. To the average computer user, the idea that someone could just… connect to your computer feels exotic, or even dangerous — see the very common ironic fear of your IP address being known to other people on the internet.

If you take someone who’s “good with computers” but not a networking person, their mental model of The Internet probably involves a definition of “servers” or “the cloud” that distinguishes them from personal computers in some meaningful way. True peer‐to‐peer, if they ever think about it, is an endeavor: WebRTC, STUN, TURN, ICE, what have you. Given that we live in a world of NAT, CGNAT, and restrictive ISPs, this isn’t entirely wrong, but it breaks the elegant design of the original Internet. //

There’s lots of things you can blame for killing the open Internet, but I think NAT was one of the earliest. Running a server used to be trivial: run an executable, tell people your address, done. Now, if you’re lucky, you probably have to configure port forwarding, which you often can’t even do if you’re behind CGNAT or on an institutional network.

It also trained everyone to think client‐server is natural. “My device talks to The Cloud which talks to other devices” feels normal, when that feeling originated as an artifact of address scarcity. The problem the people in the XKCD comic at the top are facing is the absurdity of trying to establish a one-to-one communication using only outbound connections on both sides. Even more ironic is that NAT got normalized as a security feature — “your devices are hidden!” — which is one of the things that made people resist the thing that would fix it.

NAT certainly isn’t the only reason why the modern internet is full of centralized walled gardens, but it was the first — it’s why it’s hard to send a file to someone, it’s why you don’t run your email on your own computer, and why running your own services at all is difficult and often expensive (if you can’t port forward from your own internet connection, you have to buy a VPS instead of using hardware you already have).