olooney

However, the real value is in complex, non-trivial, and above all novel code. This has been true for a long time, and it's just as true in open source as it is in industry or academia. Here, agents are far less useful. In fact, the only people I've seen have any kind of success using agents on these kinds of "serious" projects are people who are already serious programmers. They already know how to design and test stuff, they already know how to supervise junior developers, they already have an intuition for which aspects of the project the can safely delegate to a less experienced developer. So they're able to use agents as a "better autocomplete" in their own code, or use it to flesh out the non-essential and more routine aspects of the project, or even just delegate the agents to the role of code reviewer.

Here's the thing though. The less experienced ones, the people who don't already have those skills, they do get burned when they "stick the fork in the socket," as you put it, or in other words when they try to use agents to take on projects they don't fully understand... but they don't learn anything! The ones I've seen, anyway. Relying on agents insulates you from the code, which also prevents you from building a mental model of what's going on under the hood, which in turn makes it impossible to learn anything at all. They just keep yelling at the agents, telling them to fix stuff even though each fix introduces yet another regression in an endless loop... they don't know how to dig themselves out of the hole they've dug. And after all, what is the solution? To spend five years down in the code mines, paying your dues as a junior dev, reading and typing and thinking about mere code for the requisite 10,000 hours? Nobody has the time or inclination for that.

Agents, in other words, break the learning loop. You can't learn to program, and therefore can't learn to design or architect software, not really, if you're using agents. I am unfortunately coming to the sad conclusion that the last programmer has already been born; if you didn't have 5+ years of experience and a pretty good handle on the more advanced aspects of programming (such as software architecture, design patterns, optimization, debugging, etc.) before agentic programming became a thing, then I don't see how you ever will.

It'll be like COBOL programmers - the industry will shrink from the top-down, with the first to go being the new college graduates looking to enter the workforce. Inexperienced devs have always been given less interesting projects, but they stuck it out because they were learning valuable skills, building experience, making the economically rational decision to invest in their own career. But anyone entering the market today will never get out of that trench - anyone that actually needs a real programmer for a serious project will hire someone with decades of experience - there will be plenty of supply. And the projects on offer for junior devs won't teach them how to program, only to supervise agents. As a knock-on effect, smart young people already see the writing on the wall and are pivoting to other majors, which just reinforces the trend. This might cause problems in a few decades when all the real programmers start to retire, but when has the market ever considered long term consequences?

Or use a graphical language like LabVIEW. I'd like to see an LLM drag connectors around using Playwright MCP if it doesn't have a DOM and has to script mouse movements and take screenshots. They can probably do it but it would be unbelievably slow and token heavy.

The character counting is interesting but I predict frontier models are going to give up on tokens and just traim end-to-end on characters soon, just as voice models have largely moved past phonemes and for pretty much the same reasons.

https://www.oranlooney.com/docs/jev_eudemonia2.png

Also relevant: https://news.ycombinator.com/item?id=49812769#49824215

https://x.com/oranlooney/status/2102927869974303071

A standard drop of water is 0.05 ml. A standard household bucket is about 3 gallons. So the proverbial "drop in the bucket" is 0.0004%.

So, for all you naysayers out there saying this is just a drop in the bucket, it's literally x10 that.

Why, if they could get this up to a repeatable process and ban 13,000 accounts per day, that would be 1.5% every year. After a couple of years of work, that might even be perceptible to the average user. Sounds like the problem is well in hand.

Given that, all the study found was that harnesses do work when the benchmark is not saturated. It does not provide any evidence one way or the other about the effect harnesses have on frontier model performance. Therefore, the recommendations in the "what this means in practice" section are unsupported.

But I'm probably never going to write that article because, as your comment correctly points out, the tenor of the discourse isn't very healthy. Everyone is either "clowning on" Jev (as the kids say), or gulping down industrial quantities of Kool-Aid, or talking about the hype and branding instead of the math. I'll have to find a less contentious example if I want talk about calibration.

Edit: I just found something interesting: there already is a preprint case study[4] along the same lines as the one I outlined, posted just 2 days ago!

Unsurprisingly, they found that recalibration helps enormously, as you'd expect. I guess I could still talk about the Dutch book stuff if I gave a gambling/investing example, but that's pretty well-trodden territory. So now I have even less interest in writing that blog post.

[1]: https://en.wikipedia.org/wiki/Brier_score#Decompositions

[2]: https://en.wikipedia.org/wiki/Dutch_book_arguments

[3]: https://scikit-learn.org/stable/modules/calibration.html

[4]: https://arxiv.org/abs/2609.24052

https://www.oranlooney.com/post/playfair/#known-plaintext-at...

Slightly more complicated than the toy examples shown in the documentation above, and hints at one of the real world use cases for Z3 - red teaming cryptography.

That said, I'm not sure the documentation linked above is really doing it any favors in terms of helping popularizing it.

Yes:

https://en.wikipedia.org/wiki/Landauer%27s_principle

But modern computers are nowhere near this theoretical limit, nor any of the other limits I mentioned above. Nevertheless, most of heat generated from modern CPUs does come from bits turning on and off. Each transistor is a tiny capacitor, that holds a charge when its ON. When it switches OFF, it dumps that charge down the drain, creating waste heat. This is a limitation of our technolgy, not a fundamental limit of physics.

Could be worse, though; early chips would disipate heat even when they weren't doing anything. CMOS improved this enormously by pairing up "complementary" transistors so current only flows when something changes.

Still, from the universe's point of view, what we consider a super advanced computer is a lot closer to a space heater than anything that pushes up against its computational limits. Consider, for example, that quarks operate on time scales of 10^23 Hz, and the universe is happy to run three of those in every proton in every star in the universe. In fact, it runs 10^24 of them for one CPU, and that same CPU can't even simulate the quarks of one proton in real time.

Let's face it: we're like kids in Minecraft who think it's cool watch a calculation of 2+2 trickle through a redstone computer in a minute, while the GPU is rendering a billion triangles every second to give them that view.

    main::before { 
        background: 
            linear-gradient(rgba(18, 16, 16, 0) 50%, rgba(0, 0, 0, 0.25) 50%),
            linear-gradient( 90deg, rgba(255, 0, 0, 0.06), rgba(0, 255, 0, 0.02), rgba(0, 0, 255, 0.06) );
    }

    :root { 
        --text-shadow: 2px 0px red, -2px 0px var(--glitch-color-2);
    }

        <span>explorator.dev</span>        
        <span>єӿƿłøгⱥʈøг.ᑻ</span>

Computer scientists are in denial about it, but CS is a branch of theoretical physics, not mathematics. You can point to this or that model of computation, such as lambda calculus or mu-recursive functions and try to claim its abstracted well beyond the particular laws of physics for some specific universe, but they all have some kind of rate limit built into them... and where does the motivation for this idea, that it takes something (time, space, work) to compute something ultimately come from? That's right - from underlying physics itself[1] - from the Bekenstein bound or Bremermann's limit or the like.

Even apparently non-physically-realizable models of computation like non-deterministic Turing machines are ultimately informed by and motivated by concepts in physics... otherwise they would just be examples of chmess[2] and of no interest to anyone. Computer science is of course somewhat abstracted from the details, but no more so than, say, thermodynamics, where concepts like entropy or Gibbs free energy can be studied in the abstract without reference to whether we are talking about a gas of non-interacting molecules or the spins of a bunch of electrons trapped in a lattice.

So, it's of no surprise whatsoever that the fundamental problems of distributed computing are ultimately the same as those found in the relativity of simultaneity[3]. You've all been studying the same things all along, just with different tools and at different levels of abstraction.

[1]: https://en.wikipedia.org/wiki/Limits_of_computation

[2]: https://link.springer.com/article/10.1007/s11245-006-0005-2

[3]: https://en.wikipedia.org/wiki/Relativity_of_simultaneity

Other aspects of strategy, like shortening decision loops[1], forming alliances, or the exploration/exploitation tradeoff[3], are simply not represented by chess because it is a turn-based, zero-sum game with perfect information. That makes chess a poor model of real-world strategy.

Still, the things it does teach are real and useful, so as long as you don't think its the end-all, be-all of strategic thinking you can get something out of it.

[1]: https://en.wikipedia.org/wiki/OODA_loop

[2]: https://en.wikipedia.org/wiki/Cooperative_game_theory

[3]: https://en.wikipedia.org/wiki/Exploration%E2%80%93exploitati...

https://www.oranlooney.com/post/rose-petals/#language-models

It’s popular to dismiss LLMs as “just next token predictors.” This is technically true, but also kind of misses the point. Markov chains, RNNs, and transformers are all language models that can be described as “next token predictors,” but they don’t all work equally well. A better question to ask is: “What is this model’s inductive bias?”

A Markov chain (an -gram model) assumes the next word depends on the previous words, and that each possible combination of words has a completely independent parameter. (Andrey Markov proposed using this language model over a century ago, making it the granddaddy of modern LLMs.) So, for a vocabulary of size , there are parameters to learn. For even a smallish like 5, that already explodes the hypothesis space beyond what can be learned from even a huge text corpus like the entire internet. And, simultaneously, having a context window of only the previous 5 words is grossly inadequate for modeling real-world language. Like our FCNN above, this model suffers from having an inductive bias which is too weak.

RNNs tried to fix this problem by compressing the entire history into a single fixed-size state vector, updated one token at a time. But that compression is itself a brutal assumption: everything worth remembering about the past must survive being squeezed through a tiny bottleneck at every step. In practice, RNN models quickly lose the plot after a handful of sentences. Locally, the text they generate looks grammatically correct and meaningful, but zoom out a little and they’re basically nonsense generators. Like our naïve linear model, this model suffers from having an inductive bias which is too strong.

Transformers manage to hit a sweet spot: by keeping the recent history around as a working memory, and attending to different parts of it at different times, the transformer’s bias matches real structure in language: the referent of a pronoun, the subject of a verb, the parenthesis waiting to be closed. Not only that, but the particular structure of the transformer, basically a weighted sum of semantic vectors from the context window, has empirically been shown to somehow be a “good enough” match for the structure of real-world language found in the wild.

Transformers aren’t “smarter” than other possible language models, they just happen to land in that Goldilocks zone where their inductive bias is just right.

The same book contains an extraordinary number of nascent mathematical ideas. For example, he talks about "circular numbers," which today we would call modulo arithmetic. He gives a method of multiplication involving a cross that gives rise to our modern "X" symbol for multiplication, but was the first to use algebraic juxtaposition (simply putting two letters next to each other to denote multiplication) and the concept of an "exponent:" `E = mc^2` would look a lot different without Stifel's work!

The most amazing thing in the book, in my opinion, is the extraordinary connection between arithmetic progression and geometric progression he mentions in an almost offhand way[1] (link goes to the Internet Archive version of the book.)

    | -3  | -2  | -1  | 0 | 1 | 2 | 3 | 4  | 5  | 6  |
    |-----|-----|-----|---|---|---|---|----|----|----|
    | 1/8 | 1/4 | 1/2 | 1 | 2 | 4 | 8 | 16 | 32 | 64 |

[1]: https://archive.org/details/bub_gb_ywkW9hDd7IIC/page/n539/mo...

https://en.wikipedia.org/wiki/The_American_Scholar

https://andrewmbailey.com/papers/Higher-order%20truths%20abo...

For text files, I always have one generic TODO.md file that uses the `[ ]` todo and `[X]` done notation, and a couple of more generic text files like "work.md" or "solace.md" for more free form writing. There are also folders and text files for specific topics, like quotes, poems, etc. It's very important to have a scratchpad that you can just open up and start typing without thinking about how to categorize it, because you might lose the precious thread of the thought while debating which category to use, and you can always shelve it later if it's worth keeping. Zero friction to start typing is crucial.

On paper, I use a simple loose leaf and folder system. I used to use bound journals, but since 80% of what I write down is thrown away, loose leaf works better. Have a pile of about 10-20 pages. You fill up a page, and if it's destined for the circular file, dog-ear it; otherwise give it a title and date and move it to the bottom of the pile. When you run out of blank pages, go through and either discard or file each page in an appropriate manila folder. This works better than index cards (which are too small to contain a complete thought) or journals (where it's too hard to discard pages.) Lots of people use ring or disc bound journals for that, but I find that fiddly and not any easier to work with than loose-leaf, probably because I just keep everything at my desk and don't have to carry it around anywhere.

Paper has a massive advantage when it comes to diagrams, design thinking, and mathematical equations. I love LaTeX, and use MathJax on my personal site quite heavily, but its so much slower and less fluent than just writing equations on paper. I've tried tablets, and am really good at using draw.io (now app.diagrams.net) but when you're thinking freeform you want flexibility and fluency above all else and never want to be fighting a UI, which takes you out of the flow state. Ideas are fragile things, especially when newborn; any distraction is an unacceptable risk.

I used to use a custom Tesseract pipeline to OCR the pages I wanted to be searchable, but lately I've just been using ChatGPT, which seems to do just fine with my handwriting. As OCR got better over the years, I actually moved more towards paper, because what's the downside?

So, getting back to the point of the article: PKM tools are stuck in the unenviable position of competing with both paper and ordinary text files, and for me they just don't offer enough advantages.

* Characteristica universalis, Leibniz (c. 1679) - https://en.wikipedia.org/wiki/Characteristica_universalis

* As We May Think, Vannevar Bush (1945) - https://www.theatlantic.com/magazine/archive/1945/07/as-we-m...

* Cybernetics: Or Control and Communication in the Animal and the Machine, Norbert Wiener (1948) - https://direct.mit.edu/books/oa-monograph-pdf/2254528/book_9...

* An Introduction to Cybernetics, Ashby (1956) - https://ashby.info/Ashby-Introduction-to-Cybernetics.pdf

* Man-Computer Symbiosis, J. C. R. Licklider, (1960) - https://groups.csail.mit.edu/medg/people/psz/Licklider.html

* Augmenting Human Intellect: A Conceptual Framework, by Douglas Engelbart (1962) - https://www.dougengelbart.org/pubs/augment-3906.html

* Man and the Computer, John G. Kemeny - https://archive.org/details/mancomputerbyjoh0000john

* The Extended Mind Thesis, Andy Clark and David Chalmers (1998) - https://www.alice.id.tue.nl/references/clark-chalmers-1998.p...

* The Dream Machine (2002) - https://www.amazon.com/Dream-Machine-M-Mitchell-Waldrop/dp/1...

See also the Wikipedia article on "Intelligence Amplification", which gives a subset of the above list but also provides a great deal of context.

https://en.wikipedia.org/wiki/Intelligence_amplification

I have these notes to hand because I've written about it in the context of the deep history of computer science:

https://www.oranlooney.com/post/history-of-computing-2/#appe...

Right now, I'm using a bunch of vibe-coded scripts[3] to help me out; for example, here is a gallery wall of ~500 vintage sci-fi book covers[4] that I generated with it. But I think I've taken the CLI approach as far as it can go and would need a real app to make things any easier; and digiKam might be it.

[1]: https://www.refern.app/

[2]: https://www.digikam.org/

[3]: https://github.com/olooney/image-tagger

[4]: https://www.oranlooney.com/books/

[1]: https://store.steampowered.com/app/570940/DARK_SOULS_REMASTE...

[2]: https://en.wikipedia.org/wiki/Cooperative_principle

> I don’t know. Maybe a little.

is not the right way to interpret the null result (insufficient evidence to reject null hypothesis that it has no effect) because the prior for supplements that people are trying to sell you is so low. In the absence of clear, strong evidence, you should assume the the whole thing is just an example of motivated reasoning. People want nootropics to be real, and other people really want to sell you readily available powders by claiming they have nootropic properties. In that environment, they were always going to trying to concoct a similar narrative about some supplement, and it just happened to be creatine. Those efforts were always going to result in a handful of "positive" studies that turn out to be non-reproducible, maybe because of p-hacking, maybe because of publication bias, maybe because of outright fraud. This is what the literature always looks like for stuff that just doesn't work. If it did work - if the effect size was large enough that you could personally detect it in your own life - then the papers would be trying to put error bars around the effect size, not trying (and failing) to barely distinguish it from a placebo.

“If your experiment needs statistics, you ought to have done a better experiment.” - Ernest Rutherford

https://www.oranlooney.com/demos/soma-forest/

One of them used constraint solving with Z3, which was indeed reasonably fast. However, by far the fastest was a simple backtracking solver written in Rust which used bit twiddling to quickly test for intersections. For polyomino's in particular, this represents between 10x and 100x constant speed boost, depending on the size of board. There's no way to get that back with a smarter solver.

If you randomly sample from only 60 quotes, then after 10 refreshes there will be a greater than 50% chance of at least one repeat, and by 20 refreshes it's up to 95%. This is an example of the birthday paradox[1].

On the flip side, if someone wants to see all 60 quotes, they will have to refresh the page an average of 281 times, mostly (~80%) seeing quotes they've already seen before. This is an example of the coupon collector's problem[2].

The way to avoid both these problems is to shuffle the quotes into a random order, just once, and remember that order. The first time a user comes to the page, start at a random index in that shuffled list, and from then on, simply move to the next item in the list. Every user will get a unique set of random quotes, but will see no repeats until the list is exhausted, and will be guaranteed to be able to see all available content in just 60 refreshes.

[1]: https://en.wikipedia.org/wiki/Birthday_problem

[2]: https://en.wikipedia.org/wiki/Coupon_collector%27s_problem

https://www.oranlooney.com/quotes/

I've did something similar to your 3D viewer once, but for all possible solutions to the Soma cube:

https://www.oranlooney.com/demos/soma-forest/

The way that works is it uses t-SNE to embed the solutions in a 2D manifold based on similarity. This is completely different than John Conway's SOMAP solution.

In theory I could do something similar for quotes, passing each through an embedding model, computing the n^2 semantic distances, and using t-SNE to flatten that to 3D manifold, and using the resulting point to select the row, book, and shelf in a library.

Are you planning to make your 3D library code open source?