What if this is as good as software is ever going to be? What if AI stops getting better and what if people stop caring?

Imagine if this is as good as AI gets. If this is where it stops, you'd still have models that can almost code a web browser, almost code a compiler—and can even present a pretty cool demo if allowed to take a few shortcuts. You'd still get models that can kinda-sorta simulate worlds and write kinda-sorta engaging stories. You'd still get self-driving cars that almost work, except when they don't. You get AI that can make you like 90% of a thing!

90% is a lot. Will you care about the last 10%?

I'm terrified that you won't.

I'm terrified of the good enough to ship—and I'm terrified of nobody else caring. I'm less afraid of AI agents writing apps that they will never experience than I am of the AI herders who won't care enough to actually learn what they ship. And I sure as hell am afraid of the people who will experience the slop and will be fine with it.

As a woodworking enthusiast I am slowly making my peace with standing in the middle of an IKEA. But at the rate things are going in this dropshipping hell, IKEA would be the dream. Software temufication stings much more than software commoditization.

I think Claude and friends can help with crafting good software and with learning new technologies and programming languages—though I sure as hell move slower when I stop to learn and understand than the guy playing Dwarf Fortress with 17 agents. But at the same time AI models seem to constantly nudge towards that same median Next-React-Tailwind, good enough app. These things just don't handle going off the beaten path well.

Mind you, it's not like slop is anything new. A lot of human decisions had to happen before your backside ended up in an extremely uncomfortable chair, your search results got polluted by poorly-written SEO-optimized articles, and your brain had to deal with a ticket booking website with a user interface so poorly designed that it made you cry. So it's a people problem. Incentives just don't seem to align to make good software. Move fast and break things, etc, etc. You'll make a little artisan app, and if it's any good, Google will come along with a free clone, kill you, then kill its clone—and the world will be left with net zero new good software. And now, with AI agents, it gets even worse as agent herders can do the same thing much faster.

Developers aside, there's also the users. AI models can't be imaginative, and the developers can't afford to, but surely with AI tools, the gap between users and developers will be bridged, ChatGPT will become the new HyperCard and people will turn their ideas into reality with just a few sentences? There's so many people out there who are coding without knowing it, from Carol in Accounting making insane Excel spreadsheets to all the kids on TikTok automating their phones with Apple Shortcuts and hacking up cool Notion notebooks.

But what if those people are an aberration? What if this state of tech learned helplessness cannot be fixed? What if people really do just want a glorified little TV in their pocket? What if most people truly just don't care about tech problems, about privacy, about Liquid Glass, about Microsoft's upsells, about constantly dealing with apps and features which just don't work? What if there will be nobody left to carry the torch? What if the future of computing belongs not to artisan developers or Carol from Accounting, but to whoever can churn out the most software out the fastest? What if good enough really is good enough for most people?

I'm terrified that our craft will die, and nobody will even care to mourn it.

I wanted to read more. And so I bought a Kindle. It sat in a drawer for a decade.

I wanted to read more. And so I installed the Kindle app on my tablet. The app sat mostly untouched.

I wanted to read more. And so I installed the Kindle app on my phone. And then I started reading a lot.

A bigger screen is nicer than a smaller screen. E-ink is nicer than a typical screen. And real ink is nicer than e-ink. And yet I do most of my reading on my phone. Funny how that works.

I guess the most important reason is that I always have my phone in me. I do make an effort to put my Kindle or a paperback in my bag, and yet I always end up reaching for my phone instead. Perhaps it's a bit too rainy so I don't want to damage the paperback. Or I'm on the train and can't easily fish the Kindle out of my bag. But my phone's right there and so is my personal library. Plus, seeing that reading streak count up does feel pretty nice.

It's not as ✨bookcore✨ and ✨aesthetic✨. I don't feel as comfy reading a book at a coffee shop when I do it on my phone. And it can't be that great for my eyesight either. Yet for some reason it just worked for me.

Maybe that's my problem with a lot of things. I try to get it all nice and perfect, but then getting the details just right is too hard and so I give up entirely. Ultimately, an EPUB read on an LCD screen is better than a paperback left untouched. Maybe I'll grow into reading paperbacks one day. Until then, e-books it is.

I made a little plugin for Obsidian: Note Codes.

It will assign a 4-character code to every note in your Obsidian vault. Those codes let you quickly reference notes in your vault from other places such as hand-written notes.

Click here to try it out.

To make things nicer, there's also a protocol handler, so something like obsidian://note-codes/open?code=XX-XX will open the note with the code XX-XX.

I tried to make these codes look nice even if they are handwritten. They're just four characters and some of the similar-looking ones are removed (though the plugin is smart enough to know that AA-0A is the same as AA-OA.

As usual, it's all open source: https://github.com/SilverEzhik/obsidian-note-codes

What's in a note code?

Note codes are generated based on a note's name and path, meaning that the note code will change if you rename your note.

Each note code consists of 4 alphanumeric characters. For clarity, O, I, L, and U are excluded from the codes, but this plugin will automatically handle these correctly - so OI-LU will automatically be treated as 01-1V when searching. Same with the missing dash or lowercase letters.

Note codes are generated by SHA-256-hashing the note's path in the vault, then taking the first 20 bits of the hash and encoding them using Douglas Crockford's Base32 encoding scheme.

32^4 = 1,048,576, which is hopefully enough.

Hi Hacker News

Looks like this extension made it on the orange website: https://news.ycombinator.com/item?id=45288739

I got some interesting feedback—the first is that probability of note code collisions can be a pretty high due to the birthday paradox and the second is that if you rename a note, its code will change.

Both of these are consequences of how I chose to generate note codes. As said above, note codes are generated based off the note's path relative to the vault root. This means that note codes will be as stable as the note's name and path and won't be tied to Obsidian in any way—generating the note code is as simple as:

import hashlib

def hash_string(s):
    h = hashlib.sha256(s.encode()).digest()
    n = ((h[0] << 16) | (h[1] << 8) | h[2]) % (32**4)
    a = '0123456789ABCDEFGHJKMNPQRSTVWXYZ'
    r = ''.join(a[n // 32**(3-i) % 32] for i in range(4))
    return f"{r[:2]}-{r[2:]}"

But it does come at the cost of the note code changing if the note is renamed.

I don't have a good answer to this. I don't think it's a good idea to tie note codes to Obsidian like that, but at the same time, the renaming problem is quite annoying—after all, Obsidian doesn't (as of me writing this) provide an API to go into the real world and rename every instance of a note name the way it can in the vault. So these note codes are only as stable as a deep link into Obsidian.

So far, I'm contemplating a small improvement on this. I still want to keep note codes as they are, however, I'd like to keep some sort of a vault-specific cache of note codes previously assigned to a note. This way, even if you rename a note, at least within the same vault, you'd still be able to access it via its previous note codes.

As for the birthday paradox, oops. I think ultimately it's not a critical issue. The worst case scenario here is that you'll look up a note code and then see multiple matches in the search panel. I honestly don't think this one can be solved any other way besides tying note codes to the Obsidian vault. Is it worth it? You tell me.

Somewhere along the way, we've lost the "fun" part of "for fun and profit".

I have this temptation to act like a hipster and complain about people just being in it for the money now, but then I'd be making the exact same mistake that gradually drove Silicon Valley's culture insane: treating technology-as-a-craft and technology-as-a-job as one and the same.

Silicon Valley (and the tech industry as a whole) used to have a silly catchphrase about "making the world a better place" with tech. It was all lies, of course, but it was an interesting sign of lingering naive optimism held by a sizable enough portion of technologists still drunk on dreams of cyberspace independence.

Being passionate—being a nerd—used to be an indicator of skill. Skilled programmers used to be in demand. To succeed as a tech company, you needed to sell an idea to the nerds. A "don't be evil" for the altruistic, a Tolkien allusion for those who above all else desired power—"passion" is not equal to "ethics", after all.

And so, passionate, well-fed programmers practiced tech as a craft at the same time as they practiced tech as a means to get paid. From all the open source projects to breaking into Apple offices to work on a graphing calculator, it was an interesting time.

For the majority of programmers out there, though, the noble pursuit of putting food on the table is much more important than tech-as-a-craft.

But passion for the craft never stopped being a signal for skill. And signals get gamed.

Perversion

Imagine getting inspired by a low-tech artist collective to ruin your sleep schedule to... work on a B2B SaaS project? What the fuck?

This is the cursed version of that graphing calculator story, with love for the craft sucked out and replaced with love for getting that MRR.

I seek love for the craft, and find perversion instead.

And that's my real problem—not somebody losing sleep to get paid—but them dressing that up as passion for technology. My problem is going to tech meetups and getting told to just make a web app when I try to talk about learning AppKit on an old PowerBook. My problem is that I have the misfortune of loving tech as a craft and as a hobby.

The hit rage-bait blog post of June 2025 had an entire section about the craft that pissed me off.

Professional software developers are in the business of solving practical problems for people with code. We are not, in our day jobs, artisans. Steve Jobs was wrong: we do not need to carve the unseen feet in the sculpture. Nobody cares if the logic board traces are pleasingly routed. If anything we build endures, it won’t be because the codebase was beautiful.

In our day jobs, we are not artisans. And that's fine! But when work and play bleed into each other so much, when "hacker" is synonymous with "entrepreneur", when the hell do we find the time for art?

Do you like fine Japanese woodworking? All hand tools and sashimono joinery? Me too. Do it on your own time.

When the hell do I get to talk about my Japanese woodworking, if the local crafts circle just fucking talks about leasing out IKEA furniture?

For Fun and Profit

Now that we no longer pretend that technology is a force for good, now that we've struck out the fun from "for fun and profit", can we drop the charade? Can we let people who see technology as a job just do their job in peace? Can we let people who see technology as a craft just do their artisan projects in peace?

I don't want a yet another better computing manifesto. I don't want to claim that real artists starve or that making money is or isn't evil. But can't we have a way to signal that we are doing something for fun or out of love for the craft? Can't we have a space to discuss creating home-cooked software without having to deflect monetization questions? To talk about generative art without getting NFTs involved? To talk about homelabs without getting told to migrate to the cloud?

I mean, it's not like tech communities that prioritize the craft don't exist. The aforementioned low-tech arts collective, Hundred Rabbits, all the incredibly skilled retrocomputing enthusiasts, research laboratories like Ink & Switch, the open source community, all the decentralized protocol hackers. There's tons and tons of interesting people out there.

It's just too bad that their voices get drowned out by an entirely different community with an entirely different set of priorities.

There's a feature request on the Obsidian forum with more details, but the really nice fuzzy search mechanism where you can type something like [[objc and have it match "Objective-C" just no longer works.

Obsidian developers say the limit is there for performance reasons, but I've paid lots of yen for my computer and so I intend to play my note-taking apps with maximum settings.

Here's a cursed little plugin that works around the problem as of Obsidian 1.8.10 using the ✨Monte Carlo method✨:

Download (1.1.0)

Unzip that to your vault's plugin folder (there should be a button to open it in the Community plugins section of the settings), then reload your plugins and enable it.

I've only encountered this problem when inserting links, so not sure if this helps with the quick switcher—please let me know if it doesn't. UPDATE 2025-06-07: There's now a fix for the quick switcher too, using the same mechanism.

Tell me more

I had to do a bit of digging and reverse engineering to figure this one out. Obsidian's all webpacked and stuff so sadly I couldn't easily patch the check itself from a plugin, so instead I patched the function that collects files to only return up to 9,999 items, sampled randomly, with the sample reshuffled once a second or so (check the code out, it's very silly). If you are just a little over the limit, this works pretty well in practice as the list gets reshuffled while you type.

Tell me less

Now your fuzzy searches can be even fuzzier.

Source code (MPL-2.0)

You can play with it above by using f"fancy strings with variable interpolations: {1 + 2 = }" in it and they should work exactly as you'd expect.

f = require("f-string")

local who = "hedgehogs"
print(f"hello {who}!")

Features

You can put any Lua expression into the f-string and it'll hopefully work.

• = endings are supported:

> f"{1 + 1 = }"
1 + 1 = 2

• Formatting specs support everything in string.format and can be used with :%:

> f"{100:%.2f}"
100.00

Caveats

• Upvalue access is kinda broken: Variables from outer scopes of functions (upvalues) are only reliably accessible if they are referenced outside the f-string. For example:

local x = "outer scope"
local function inner()
	-- This reference is needed for the upvalue to be accessible in the f-string
	if x then end
	local result = f"x = {x}"  -- Now works correctly
end

• Uses debug so is probably slow as heck

Making-of

This was fun to make. Writing parsers is always good fun and the little one I hand-rolled here seems to do the job well enough, giving this handling for strings and comments that's a lot better than a regex-based approach. Writing up little parsers comes up a lot for me and previously I'd try to take care of the stack myself and only go character by character, but here I tried to use the function stack as the stack (hence all the parse local functions) for some recursive descent parser action, along with making it easier to take and check multiple characters ahead and it made for a pretty nice experience for me.

I did ask the computer to write test.lua for me, which saved some time but was not as fun. It works though, I guess.

Source code (MPL-2.0)

Source code (MPL-2.0) LuaRocks

You can play with it above by messing with the Promise object and also setTimeout and setInterval which work exactly as you'd expect them to work in JavaScript.

The API

I tried to cover most of the API I saw on MDN:

• Constructor
  • Promise.new(fn) – returns a new Promise. fn is a function which takes in two parameters, resolve and reject, both of which are functions that will either resolve or reject the promise with the given value. If the value given to resolve is a promise or a table that has a next method, it will use the result of that method instead.
• Instance methods
  • :next(onFulfilled, onRejected) – registers callbacks to run when the promise is settled (either fulfilled or rejected). This is called next instead of then as then is a reserved keyword in Lua.
  • :catch(onRejected) – registers a callback to run when the promise is rejected.
  • :finally(onFinally) – registers a callback that will run when the promise is settled. This promise will settle with whatever the original promise's state is.
• Static methods
  • Promise.all(promises) – takes a list of promises and returns a promise that is fulfilled when all input promises are fulfilled or is rejected when any of the promises are rejected.
  • Promise.allSettled(promises) – takes a list of promises and returns a promise that is fulfilled when all input promises are settled with a list of tables in the shape of { status = "fulfilled", value = <...> } or { status = "rejected", reason = <...> }.
  • Promise.any(promises) – takes a list of promises and returns a promise that is fulfilled when any of the input promises are fulfilled or is rejected when all of the input promises are rejected.
  • Promise.race(promises) – takes a list of promises and returns a promise that is settled with the state of the first promise in the list to settle.
  • Promise.reject(reason) – returns a promise that's rejected with the given reason.
  • Promise.resolve(value) – returns a promise that's resolved with the given value.
  • Promise.try(fn) – takes a callback of any kind and wraps its result in a promise.
  • Promise.withResolvers() – returns a promise, its resolve function, and its reject function. I also added a few extra helpers for my own sake:
• Async-await
  • Promise.async(fn) – returns a function that returns a promise that will be resolved or rejected based on the result of executing fn in a coroutine.
  • :await() – if executed from a coroutine, will yield until the promise is settled and return the resolved value or error with the rejection reason.
• Various
  • :ok() – converts rejections of the promise into nil, think Rust's Result.ok().
  • :print() – prints the settled result of the promise without modifying it.

I've kept this async runtime-agnostic. You can override the Promise.schedule(fn) function with your own implementation that will schedule functions for later asynchronous execution. An example implementation for Hammerspoon is provided in the repository.

Making of

I've been suffering from callback hell when automating things with Hammerspoon, so I ended up using zserge/lua-promises (deferred) for a while, but then decided to write my own because reinventing the wheel is a good way to learn how the wheel works.

It was pretty fun to make. The TC39 specification for JavaScript is insanely detailed, so I always could count on it to help me resolve any ambiguities, though I didn't implement it word for word.

I actually get quite a lot of use out of those async-await functions in Hammerspoon, as they let me completely flatten functions that deal with UI automation, which can require waiting for animations to finish and so on.

Source code (MPL-2.0)

So I use a rather nice documentation browser, Kapeli's Dash. With version 7, this app switched to a subscription model, which came with an unfortunate side effect of daily paid upgrade prompts for those staying on their one-time purchase licenses.

Run this in the terminal to disable those update prompts:

defaults write com.kapeli.dashdoc SUFeedURL ""

To restore things back to normal, run:

defaults delete com.kapeli.dashdoc SUFeedURL

This doesn't really seem like a malicious action on the part of the developer – the prompt is just a standard Sparkle update window, used by most artisan Mac software. However, I couldn't find a toggle to disable update checks in the app's settings, so I had to figure out a slightly more manual way.

I tried the NSUserDefaults route next, as Sparkle offers ways to customize itself through Info.plist configuration: https://sparkle-project.org/documentation/customization/ – however, both SUEnableAutomaticChecks and SULastCheckTime keys would get reset whenever I relaunched Dash. So I tried setting the URL that the app polls for new updates to an empty string and that seemed to do the trick.

By the way, it's pretty neat that Sparkle update feeds are just RSS. The more you know!

Here we get to use one of the coolest parts of Lua: metatables. You can set all sorts of properties on objects using this way – what happens when you call or index them, what happens when you assign, what happens when you use operators, and so on.

The special __index metatable method will be called whenever you try to access a non-existent table property – so if I try to do foo.bar when bar doesn't exist, __index will be called, giving me a chance to resolve its value.

Now, Lua has a global table, _G. This table holds all the global variables – think JavaScript's window.

And you can set a metatable on that as well. This means that we can use metatable tricks like __index with global variables.

To make things even cooler, Lua lets you evaluate some code using load(), letting you set that code's environment. This means we can craft our own environment that'll automatically resolve dependencies for us whenever the cell formula tries to access any other cell, all while keeping each cell isolated from one another since they all have their own unique environments.

Pretty neat!

I originally wrote this as a more JavaScript-intensive thing, where each cell got its own Lua interpreter, efficiency be damned. But the more I looked at metatables, the more I started to realize how powerful they are.

Please enjoy a little REPL up above.

https://lua.org

I do like working with Lua, though some things about it mildly annoy me:

• No assignment operators like +=
• No destructuring assignments like [a, b] = tbl
• ~= instead of !=
• No continue in loops
• Inability to have statements after return so I have to do do return end whenever I want to quickly return while testing
• No shorthand for function definitions like JavaScript's arrow functions
• No syntax for coroutines
• No string interpolation

Most of these are syntactic, which is interesting. The common one-based array indexing complaint doesn't really bother me that much in practice.

It'd be nice to have some more batteries, but it's fine, I guess.

Here's what's actually supposed to happen:

The fix

---
--- Monkeypatch for hs.window operations to temporarily
--- disable accessibility while moving/resizing windows
---

do
    local axOnTimers = {}
    local axOriginalState = {}
    local windowMT = hs.getObjectMetatable("hs.window")

    -- clean up when apps are closed
    hs.window.axTimerWatcher = hs.application.watcher.new(function(name, event, app)
        if event == hs.application.watcher.terminated then
            local pid = app:pid()
            if axOnTimers[pid] then
                axOnTimers[pid]:stop()
            end
            axOnTimers[pid] = nil
            axOriginalState[pid] = nil
        end
    end):start()


    local function patch(fn)
        return function(window, ...)
            local app = window:application()
            local pid = app:pid()

            local ax = hs.axuielement.applicationElement(app)
            -- disable accessibility, remembering what the original state was
            pcall(function()
                if not axOriginalState[pid] then
                    axOriginalState[pid] = {
                        AXEnhancedUserInterface = ax.AXEnhancedUserInterface,
                        AXManualAccessibility = ax.AXManualAccessibility
                    }
                end

                ax.AXEnhancedUserInterface = false
                ax.AXManualAccessibility = false
            end)

            local ok, result = pcall(fn, window, ...)

            -- restore accessibility after a short delay
            axOnTimers[pid] = (
                axOnTimers[pid]
                or hs.timer.delayed.new(
                    math.max(0.2, hs.window.animationDuration or 0),
                    function()
                        local orig = axOriginalState[pid] or {}

                        pcall(function()
                            ax.AXEnhancedUserInterface = orig.AXEnhancedUserInterface
                            ax.AXManualAccessibility = orig.AXManualAccessibility
                        end)

                        axOriginalState[pid] = nil
                    end)):start()

            if ok then
                return result
            else
                error(result)
            end
        end
    end

    for _, key in ipairs({
        "setFrame", "setFrameInScreenBounds",
        "setFrameWithWorkarounds", "setTopLeft",
        "setSize", "maximize", "move",
        "moveToUnit", "moveToScreen",
        "moveOneScreenEast", "moveOneScreenNorth",
        "moveOneScreenSouth", "moveOneScreenWest",
    }) do
        windowMT[key] = patch(windowMT[key])
    end
end

-- 🦔🦔🦔

This issue seems to be related to accessibility services – when they are enabled for a specific app, it may misbehave. The Hammerspoon team is tracking the problem as Bug #3224, but this appears to be an application-specific issue.

Unfortunately the application in question is Chrome and in the future, everything is Chrome.

The more you know, the more Chrome you start to notice.

And here it is:

The System

1. Get a note-taking app with links and backlinks, such as Obsidian.
2. Make sure every note is connected via links or backlinks to at least two other notes
3. Go write.

What?

Okay, so. I've sucked at note-taking for most of my life.

Andy Mauschak's working notes. Zettelkasten. Johnny Decimal. Digital gardens. Bullet Journals. All these cool people and cool systems. I've tried to emulate them and I failed.

From piles of Moleskine notebooks to Surfaces and iPad Pros, from Evernote and OneNote to plain old text files and Apple Notes, there is a graveyard of note-taking tech in my drawers, including some attempts of my own like Notegram and IroIro and all the hours wasted trying to comprehend contenteditable. I was always looking for a better bicycle for the mind having never learned to ride a bike to begin with.

I couldn't do analog notes because I'd misplace notebooks.
I couldn't do folders because I'd always want to put one note into multiple folders.
I couldn't do tags because I'd want to write a note about the tag itself.
And so on, and so on, forever distracted by the meta-problem of how to write rather than what to write.

But one day a friend suggested Obsidian, and it just clicked for me – just the right kind of mix between Markdown and What-You-See-Is-What-You-Get, and, of course, the way it displays backlinks very, very prominently.

So I decided to just roll with it. Sick to death of worrying about these systems, I decided to just roll with the three rules above. No tags, no folders, no categories, no inboxes. Only hypertext.

At first, you navigate through weaponized wiki-wandering – dropping into the closest relevant note and clicking through links and backlinks until you find what you need. But eventually, patterns start to emerge. Perhaps you start to use some notes as hubs. And so the organization system emerges organically. Things start to fall into places where your own brain expects them to be, rather than artificial categories made up on the spot. And all that happens without having to think much about it.

That's Hypertext Maximalism.

From zero notes three years ago, to 6,961 as of me writing this, I think this system worked out pretty well for me.

Here's a little enhancement to the website. All the little apps will now have a little link to the source code on the bottom that'll take you to the website repository.

I'm now also including the original TypeScript code for these along with source maps, so if anybody here likes to play with browser developer tools, you'll hopefully have a better time doing it.

Here's Spreadsheet No. 1 enhanced to allow setting properties based on other cells. It's still all nice and reactive.

I might be on to something interesting here...

So, there's a very basic spreadsheet up above. In each cell, you can type a JavaScript expression and it will execute. You can refer to cells by the name that shows up when you hover your mouse cursor over a cell (A1, B1, A2, B2...).

So how do you make a spreadsheet, anyway?

I made a weird React hook that will give you:

• An object mapping cell IDs to formulas (just good old JS)
• An object mapping cell IDs to computed values
• A function to set a cell's value

That hook also has an effect that actually handles cell recalculation. When a formula changes:

• Make a cache that'll store computed outputs
• Convert all formulas to AsyncFunctions
  • Replace each cell reference with a retrieval of its cached result or queuing that cell reference's formula for execution and awaiting that execution's completion
• Execute all the AsyncFunctions and await for them to finish

Spreadsheets are directed graphs and this is just recursive depth-first graph traversal in disguise, I suppose. I honestly thought this part would be harder, but it actually was alright. I think there are better ways to do it than using JavaScript promises as a weird cache, though.

Some food for thought

• Can the computation/caching be done using React somehow, rather than JS?
• The whole spreadsheet gets redrawn on every change which is lame
  • That makes sense given that there is one big blob of all the data that's created at the spreadsheet level rather than at the cell level
• Cycles produce NaN – would love to step through that with a debugger to figure out why
  • Cool that they don't just freeze up or whatever, though
• Do cells really have to just be cells?

On one of those good old days, I wanted to create an identity for myself online. I called myself Ezhik – a hedgehog – and I was building a corner on the internet that was for me. Hence, ezhik.me.

It was a different time. The internet was still young and there was still hope for a brighter future unburdened by all the baggage of history, all the war, all the nations, all the ideologies. The twentieth century was over but the twenty-first did not yet truly begin.

But times have changed. History never ended. And so we are back to the same old mess. Cyberspace never became independent. Worse than that, it was colonized. Little communities, all swept away by waves of corporate interests, propaganda, and psyops.

And so, rather than a cute domain hack, I have to look at .me for what it truly is: the top-level domain (TLD) for the country of Montenegro. And if I'm going to use a country-based TLD, rather than one that just so happened to have a nice ISO 3166 code, I might as well use the TLD for the country that accepted me.

So, ezhik.jp it is.

So this little app will have to do instead.

Select a video by clicking that button above, it'll appear right below it. You can then PiP that.

I don't receive your videos, I don't need them. This is all like 50 lines of JavaScript magic.

This note.com post by Atsu1166 has a fix that worked for me - edit the .epub file's .opf rootfile (This was content.opf in my case) to add the following tag in its <metadata>:

<meta name="primary-writing-mode" content="horizontal-rl"/>

For a bit more context, .epub files are really .zip archives containing all the files the book is made out of. You should be able to either unzip the file and edit that .opf rootfile manually, or, if you use Calibre, edit the epub to update it.

So far I only encountered .opf rootfiles located at the top of the archive, but apparently the EPUB standard specifies that these will be defined in the META-INF/container.xml file in a <rootfile> tag.

The more you know...

I like that approach. The website still works just fine if you don't have JavaScript, but at the same time you can bring in fun bits of interactivity. Make little apps and stuff. So I tried building this for my website too, and the little React hello world is a demonstration of that.

These days, react.dev tries really hard to force you to use stuff like Next.js and whatnot. But if you try, you can figure out how to build some little toy web apps that don't require you to get weird with web servers. Just write some code and just make yourself a little app that'll sit in its own rectangle. It's not a big deal. It's not the next big startup. It's just there for you and whoever else you share it with.

I really do miss Flash.

My Fxtec Pro1 X died a very silly death. It lost so much battery it wouldn't charge anymore. The phone sat dead in my drawer until I came across a very silly fix.

When you hold the power button for like 10 seconds, it'll draw juuust a little bit of power. So if you leave it in that state overnight, it will charge like 6%, which is enough for it to revive and start changing normally.

The more you know!

Here are some little things I fixed though:

• Reduced margins on smaller screens
• Added image previews in <meta> tags
• Made RSS descriptions nicer
• Fixed the external link indicator on Safari
• Made overflows look prettier
• Made the hog resize less
• Removed some weird stuff like old font imports
• Kinda sorta integrated Radical Lookup into this now (it's an <iframe> going to the old page, glitchhog aesthetics and all. Flash embed type vibes.)

I also made a TIL page. Swap the backlinks and the articles and bam, it's now a tag. Neat. To make it even neater, I made a weird ~[[TIL]] syntax that'll exclude that TIL link from its backlinks.

And since this is a blog about my hedgehog stuff, I'll try to post some stuff that's not just about this blog. Blogging about blogging and taking notes about taking notes. I hate getting stuck in metawork. So I made a small post about a gadget I was messing with: Fxtec Pro1 X - The silliest battery fix.

So here we are. I'm still scouring the internet for my various blog posts (I recovered one so far and it's a silly one!). I've also moved most of my existing stuff on the old site over - ping me if anything's missing as I'm sure it's not gone forever and I want to put it all back.

Also... There's now an ✨RSS feed✨. Please follow it.

I've also got ✨backlinks✨. It's all because of my Obsidian addiction. Who needs folders or tags when you have hypertext? Hypertext is all you need. Expect lots of hypertext.

Since it's been a while since I did web stuff and the internet became a very different place during that time, I also now have a Privacy Policy.

Please enjoy.

P.S.
What do you think of that hog? I was kinda winging it with this one and don't know if I like this hog or not.

set clipboard=
noremap ""y ""y
noremap ""yy ""yy
noremap ""p ""p
noremap ""P ""P
noremap <expr> y  (v:register ==# '"' ? '"+' : '') . 'y'
noremap <expr> yy (v:register ==# '"' ? '"+' : '') . 'yy'
noremap <expr> p  (v:register ==# '"' ? '"+' : '') . 'p'
noremap <expr> P  (v:register ==# '"' ? '"+' : '') . 'P'

That's it, post over, go home.

Wait, what?

Okay, so. Vi was originally invented in 1300 BC, before we had GUIs and even the idea of a shared system clipboard. What it had (and what Vim still has today) instead were registers. Registers are basically a bunch of internal Vim clipboards that you can use through the " key — for example, "fy to copy something into the f register, then "fp to paste from it.

By default, anything you yank (Vim's word for copy) goes into the unnamed register (which is actually assigned to the " key, so you can yank something into it explicitly by doing ""y. Then, what Vim's standard way of handling the system clipboard does is simply link up this unnamed register to your global clipboard. Nice and cool, until you overwrite everything you copied with a single character that you just deleted.

See, anything you delete using keys such as x, d, c, and the like, also goes into this unnamed register, overwriting it ("fd would delete something into the f register, by the way). This may have been okay if you were back in Heian Era Japan and all you had was a simple VT100 terminal to write love poems on, as you would have been living inside Vi anyway, using its registers extensively. However, in this day and age, you want to be consistent with the modern OS you're running Vim on (and if you aren't on a modern OS, the Vim on the ancient computer you're configuring is compiled without clipboard support anyway).

Anyone first starting to learn Vim will absolutely not be expecting their clipboard to be wiped every time they delete something, and it will drive them insane. They'll look around the internet for a solution, and they will only find two things.

The first is a bunch of ideology from Unix purists about how you're supposed to just live with that, get used to the Vim way, that poetry declined under the Kamakura shogunate, et cetera. Those people are important and help prevent this world from going completely off the rails drunk on overhyped technology, but listening to them for too long will quickly make the newcomer to Vim start to hate life. To any Vim newcomers reading this, now is also a good time to mention that if you want to have tabs in Vim, search for how to use Vim's buffers. Vim has another feature called tabs, but those are not actually tabs at all. It's complicated and everyone online will be telling you about the Vim way even though you just want to have a little bar on top with two text files that you can quickly switch between.

But anyway. Any newcomer not scared off at this point will keep looking and will find a bunch of solutions that remap the various delete commands to use the "void" (_) register. Those are okay, until you actually do want to use registers the Vim way, plus you'll have to play whack-a-mole with every single command that puts text in the clipboard register.

So what you really want is to just remap the yank (copy) and paste keys to use the system clipboard register. That's exactly what that snippet of code does.

The first line disables any sort of clipboard integration that may have been enabled by default (along with selections automatically getting yanked — change that to set clipboard=autoselect if you're really into that sort of thing and if your Vim supports it).

The last four lines change the main yank and paste keys: if you invoke a yank or paste command with the default unnamed register, it swaps that register out for the system clipboard one instead.

The four lines above those add an exception to the rule: if you explicitly try to use the unnamed register, it will be used instead. Make sure you get the order of the lines right in your Vim configuration file, or who knows what might happen.

So, with the clipboard set up this way, everybody wins! You get to have sane clipboard settings that work the same way as the rest of your OS, while still having the flexibility of proper registers if you need it.

The end!

P.S. If you find out that I made a mistake in my hubris, please email me at i@ezhik.jp, or maybe make an issue on this site's GitHub if it's urgent enough to require public shaming. Thanks!

This is a kanji radical lookup tool with a little twist - it allows you to also decompose a kanji with its radicals. This is useful if you remember a kanji that uses a certain radical, but are not sure how many strokes it actually has (which you'd need to know to use the Jisho radical tool, for example).

This uses KRADFILE for looking things up.

Source (GPL3)

Every single one of those little cars is not just going in a straight line, but is instead behaving similarly to an actual car – accelerating as they move through an empty road, and slowing down before obstacles.

It is based on the Rule 184 CA (hence the name), with enhancements made to add varying speed levels and to make the whole thing work in two dimensions.

Source (GPL2)  Paper

After a hackathon, you are always left with a lot of swag.

Shirts, bags, and, of course stickers.

So many stickers.

So of course, the most logical thing to do, is to put them all to use.

All of them.

Here are the lessons I have learned when torturing my poor laptop with all these stickers.

Google stickers have strong adhesive.

Like, good luck getting those guys off. There’s an upside down SQL sticker somewhere in that mess and it’s never going to get fixed.

I’m pretty sure some of these aren’t even hackathon stickers.

Where did I even get these?

Big red stickers are boring.

Come on man, don’t monopolize my laptop lid.

“Transparent” stickers are the coolest.

Check them out, they’re really neat.

I have a lot of HackingEDU stickers.

Too many, in fact.

Seriously.

Where did I even get so many?

I hope I didn’t take all the stickers or something. Stickers are meant for sharing.

Still, so many stickers.

Like, damn.

Conclusion

I had a big pile of stickers, and now I don’t. Please look forward to the next installment when I try to peel all of these off.

Also, shout-outs to HHCdT and HackingEDU.

It has no installer, no GUI, no options, and uses only a little more than 1 MB of your RAM. Just stick it in your Autorun folder, and you’re ready to go.

It uses Net Framework 4.5, so in theory it should be able to run on jailbroken Windows RT devices.

Download  Source (GPL2)