dahlia

This piece appears to be a response to [my recent essay on craft, alienation, and LLMs][1], so let me engage with it directly.

The argument collapses every social and structural explanation into a single move: the individual chose it. This is the classic libertarian reduction, and it has a well-known failure mode. Under this framework, there is no coherent distinction between a choice made under duress and a choice made freely. If a developer uses LLM coding assistants because their livelihood depends on keeping pace with colleagues who do, and the author's response is that no one forced them, well, no one forces a person at gunpoint to hand over their wallet either. The gun is still there.

The author acknowledges, mid-essay, that the system “can change incentives and tradeoffs.” But this is precisely what a structural analysis is. Once you admit that incentives can be arranged such that a person has no viable path except the one the system rewards, you have already conceded the core Marxian point. Calling it “alienation” or not is just terminology.

What the alienation framework actually claims is not that individuals don't choose. It's that the conditions under which those choices are made matter morally and analytically. My own essay is careful about this: I noted explicitly that the tension between craft and efficiency doesn't vanish under different political arrangements. The question survives capitalism; capitalism just answers it harshly. Dismissing this as a “denial of the craftsman” misreads the argument.

On LLM capabilities: the claim that none of these problems can be solved by LLMs (understanding systems, architecture decisions, debugging) reads as confident as of roughly two years ago. The frontier has moved. Coding agents are already handling non-trivial architectural reasoning in constrained domains, and the trajectory is visible. Anchoring the argument to current limitations, stated as permanent ones, is a move that ages badly.

[1] https://writings.hongminhee.org/2026/03/craft-alienation-llm...

Sure! Here's what I wrote about the story: https://writings.hongminhee.org/2025/10/stf-fedify/

That's fair, and I don't really blame anyone for taking the startup route. It's often the only realistic path to working full-time on something you care about. My point is more that it shouldn't have to be. The more public funding flows into open source infrastructure, the less that tradeoff becomes necessary in the first place. Korea being almost entirely absent from that picture is part of why I feel this so keenly.

What strikes me most about this acquisition isn't the AI angle. It's the question of why so many open source tools get built by startup teams in the first place.

I maintain an open source project funded by the Sovereign Tech Fund. Getting there wasn't easy: the application process is long, the amounts are modest compared to a VC round, and you have to build community trust before any of that becomes possible. But the result is a project that isn't on anyone's exit timeline.

I'm not saying the startup path is without its own difficulties. But structurally, it offloads the costs onto the community that eventually comes to depend on you. By the time those costs come due, the founders have either cashed out or the company is circling the drain, and the users are left holding the bag. What's happening to Astral fits that pattern almost too neatly.

The healthier model, I think, is to build community first and then seek public or nonprofit funding: NLnet, STF, or similar. It's slower and harder, but it doesn't have a built-in betrayal baked into the structure.

Part of what makes this difficult is that public funding for open source infrastructure is still very uneven geographically. I'm based in Korea, and there's essentially nothing here comparable to what European developers can access. I had no choice but to turn to European funds, because there was simply no domestic equivalent. That's a structural problem worth taking seriously. The more countries that leave this entirely to the private sector, the more we end up watching exactly this kind of thing play out.

Better Solution: Combine things that do their own jobs.

It actually is what Flask does.

The one of the biggest advantages of PostgreSQL is GiST (Generalized Search Tree) which is based on the theory of indexability.

> One advantage of GiST is that it allows the development of custom data types with the appropriate access methods, by an expert in the domain of the data type, rather than a database expert.

http://www.postgresql.org/docs/9.1/static/gist-intro.html

> Traditionally, implementing a new index access method meant a lot of difficult work. It was necessary to understand the inner workings of the database, such as the lock manager and Write-Ahead Log. The GiST interface has a high level of abstraction, requiring the access method implementer only to implement the semantics of the data type being accessed. The GiST layer itself takes care of concurrency, logging and searching the tree structure.

> [...]

> So if you index, say, an image collection with a PostgreSQL B-tree, you can only issue queries such as "is imagex equal to imagey", "is imagex less than imagey" and "is imagex greater than imagey". Depending on how you define "equals", "less than" and "greater than" in this context, this could be useful. However, by using a GiST based index, you could create ways to ask domain-specific questions, perhaps "find all images of horses" or "find all over-exposed images".

http://www.postgresql.org/docs/9.1/static/gist-extensibility...

If you are already using PostgreSQL though have not known about this fact, I highly recommend you to learn about GiST. It is the most powerful feature of PostgreSQL as I know.

http://www.pythonmeme.com/about

> I’m a 11 years programer, and I’m a python new guy.

I am impressed.

It reminds me of the truth that speed is the best user experience.

> Node sucks for general web apps because you have to program everything asynchronously.

To be fair, the exact problem is not async itself, but forcing CPS (continuation-passing style) for serial routines. For example, gevent and eventlet use greenlets (coroutines for Python) to avoid unnecessary callbacks in serial routines.

No. What Katz really needs is not blocks, but RAII. See Python’s with statement or C#’s using statement.

It reminds me again that Dropbox is hard to beat.

It’s an evil thing originated from JavaScript. PHP always has borrowed evil things from other languages. As a result, PHP keeps getting more evil by the version.

I really love Bitbucket (over GitHub!), but it seems too late for me.

The most strange (but interesting) static site generator I’ve ever seen is: http://mearie.org/about/mearie#technical-detail . It uses Apache’s mod_negotiation very well to support internationalized contents. (That site provides English, Korean and Japanese version for most contents.) You can read the source code from here: http://hg.mearie.org/mearie.org/current

According to his profile page (http://sorah.cosmio.net/), he’s just 14 years old yet.

Only I missed is that it invented a new markup language poor than well-known existing ones e.g. Markdown, reStructuredText.

http://j.mearie.org/post/3212514215/object-oriented-css

Someone wrote a post I agree about this.

Lisphp's map/filter/reduce functions are implemented in the same manner that Parentscript does.

This is map: http://github.com/dahlia/lisphp/blob/81849070ac7ff13948786b5...

This is filter: http://github.com/dahlia/lisphp/blob/81849070ac7ff13948786b5...

This is fold: http://github.com/dahlia/lisphp/blob/81849070ac7ff13948786b5...

Lisphp respect the iterator protocol of PHP instead of Lisp tradition in the practical reason.

I made the mailing list (Google Groups) which is the place for discussion about Lisphp:

lisphp@googlegroups.com

http://groups.google.com/group/lisphp

Join us if you are interested in this project!

Try this:

  $env['echo'] = new Lisphp_Runtime_PHPFunction(create_function('', '
      $args = func_get_args();
      foreach ($args as $arg) echo $arg;
  '));

  $env = Lisphp_Environment::full();

I implemented cdr just to respect a Lisp tradition. Lisphp's Lisphp_List type isn't a linked list but a subtype of ArrayObject, which supports random access. So instead of doing:

  (car (cdr (cdr (cdr list))))

  (at list 3)

I'm the author of this, I made the web REPL also.

http://dahlia.ruree.net/try-lisphp/

Well, of course, it uses a sandbox environment.