MyOutfitIsVague

In an ideal future (read: fantasy), utf-16 gets formally deprecated and trashed, freeing the surrogate sequences and full range for utf-8.

Or utf-16 is officially considered a second class citizen, and some code points are simply out of its reach.

The way I envision this working is with something like git filters. Checking out from version control converts it all into text in your preferred formatting, which you then work with as expected. Staging it converts it into the stored representation. In git, this would be done with smudge and clean filters, like how git LFS works. You'd also have viewers for forges and the like that are built to interpret all the stored representations as needed.

You still work with text, the text just isn't the canonical stored representation. You get diffs to resolve only when structure is changed.

You get most of the same benefit with a pre-commit linter hook, though.

That wasn't the argument at all.

If I wrote a card game in 3 months, then cloned the repository and used that as a base to implement a different card game, it would be significantly faster with or without LLMs.

The argument is that it's not really an apples-to-apples comparison. "I wrote a game in 3 months and then used an LLM in 3 days to fork it and make some changes" is not the same thing as "I spent 3 months doing something that I could do in 3 days with LLMs".

I believe LLM-driven development is powerful (though I hate seeing "10x" everywhere, and have hated it long before LLM coding was big, when it was talking about supposedly superhuman coders), but this is not a good comparison, and the argument is sound.

It's not just subsidies, it's also permitting and any other roadblocks they can manage. This isn't just economic or political, it's a weird personal crusade.

You're somewhat mistaken, in that "UTF-32, or UTF-8 for that matter, is perfectly capable of representing [U+D83D U+DE00] as a sequence distinct from [U+1F600]." You're right that the encoding on a raw level is technically capable of this, but it is actually forbidden in Unicode. Those are invalid codepoints.

Using those codepoints makes for invalid Unicode, not just invalid UTF-16. Rust, which uses utf-8 for its String type, also forbids unpaired surrogates. `let illegal: char = 0xDEADu32.try_into().unwrap();` panics.

It's not that these languages emulate the UTF-16 worldview, it's that UTF-16 has infected and shaped all of Unicode. No code points are allowed that can't be unambiguously represented in UTF-16.

edit: This cousin comment has some really good detail on Python in particular: https://news.ycombinator.com/item?id=44997146

Mostly just zombies and signal handlers.

And your software can do it, if it's written with the assumption that it will be pid1, but most non-init software isn't. And rather than write your software to do so, it's easier to just reach for something like tini that does it already with very little overhead.

I'd recommend reading the tini readme[0] and its linked discussion for full detail.

[0]: https://github.com/krallin/tini

That's needlessly rude. I just found the sequence of events confusing. If I promise you a cash gift, then some months later demand you to give me something in return for the promised gift, it would be silly to say that I paid absolutely nothing. I don't consider that pedantic.

I had seen that, but I don't consider that "paying nothing". That's paying something. I'm also confused how it's a "grant" if it's completely transactional. That's not a string attached, that's just a purchase. So I guess it's just political spin on all sides.

> the government made an $8.9 billion investment in Intel common stock, purchasing 433.3 million shares at a price of $20.47 per share, giving it a 10% stake in the company

> The United States paid nothing for these Shares, and the Shares are now valued at approximately $11 Billion Dollars

I don't understand. Can somebody explain to me how the government made an investement, bought shares, but paid nothing?

I never have more than one account at a time. I can get addicted to social media, like everybody else, and sometimes I find that I'm wasting way too much time talking on HN (and sometimes having arguments). I also dislike a permanent backlog of everything that I've ever said being attached to me. When I feel this way, and when I feel like noprocrast isn't doing a good enough job modulating my addictive tendencies, I retire my account (locking myself out of it intentionally) and take a few months away, usually eventually making another account.

You're being needlessly aggressive and making some uncalled-for assumptions.

Been here for years (across many different accounts), and this is the first time I've heard of these terms. I am here for programming content, not business.

We're in that era. BitWarden supports them natively, and you can even self-host.

Presumably the tax would be based on some estimated value of the property, and affordability would therefore scale.

Ruby on Rails has a databases.yml that is preprocessed by ERB. I often do something like:

    field: <%= File.read('/foo/bar').to_json %>

Though I have myriad criticisms of YAML, this article's arguments are not a concern at all if you can ensure that your YAML parser always uses 1.2 regardless of any %YAML directive.

I don't think they are missing the point, because they're pointing out that the tools are still the most useful for patterns that are extremely widely known and repeated. I use Gemini 2.5 Pro every day for coding, and even that one still falls over on tasks that aren't well known to it (which is why I break the problem down into small parts that I know it'll be able to handle properly).

It's kind of funny, because sometimes these tools are magical and incredible, and sometimes they are extremely stupid in obvious ways.

Yes, these are impressive, and especially so for local models that you can run yourself, but there is a gap between "absolutely magical" and "pretty cool, but needs heavy guiding" depending on how heavily the ground you're treading has been walked upon.

For a heavily explored space, it's like being impressed that you're 2.5 year old M2 with 64 GB RAM can extract some source code from a zip file. It's worth being impressed and excited about the space and the pace of improvement, but it's also worth stepping back and thinking rationally about the specific benchmark at hand.

Blender doesn't say "start with a cube". Its default "General" scene has a cube. You can add whatever mesh, text, curves, metaballs, grease pencil, volumes, etc you want.

As far as workflows go, there are far too many to list, and most artists use multiple, but common ones are:

* Sculpt from a base mesh, increasing resolution as you go with remeshing, subdivision, dyntopo, etc. * Constructively model with primitives and boolean modifiers. * Constructively model with metaballs. * Do everything via extrusion and joining, as well as other basic face and edge-oriented operators. * Use geometry nodes and/or shaders to programmatically end up with the result you want.

Very many of us are quite critical of all authoritarianism, and don't feel like we've been represented by any presidential administration for our entire lives. Centrist liberalism isn't flashy or popular, though, and it doesn't spawn many angry rallying cries or outrage that goes viral, so you'd think that we don't exist.

The current flavor of authoritarianism is quite bad, though, and does distastefully wear its hypocrisy on its sleeves.

The median wage for programmers is about 5x the average minimum wage. You're paid significantly higher than the average programmer.

There's no block scope in Python. The smallest scope is function. Comprehension variables don't leak out, though, which causes some weird situations:

    >>> s = "abc"
    >>> [x:=y for y in s]
    ['a', 'b', 'c']
    
    >>> x
    'c'
    
    >>> y
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    NameError: name 'y' is not defined

Comprehensions have their own local scope for their local variables, but the walrus operator reaches up to the innermost "assignable" scope.

> Compare with the if statement, where the variable in the expression being tested will necessarily be defined.

    if False:
        x = 7
    print(x)

    print(x)
          ^
    NameError: name 'x' is not defined

Ruby does this sort of stuff, where a variable is defined more or less lexically (nil by default). Python doesn't do this. You can have local variables that only maybe exist in Python.

Nope, it's more complicated than that:

    e = 'before'
    try:
        x = int('cat')
    except Exception as e:
        e2 = e
        print(e)
    print(e2) # <- This works!
    print(e)  # <- NameError: name 'e' is not defined

It's not a scoping thing, the bound exception variable is actually deleted after the exception block, even if it was already bound before!

> psychophancy

Sycophancy. I don't usually correct misspellings, but this one is pretty unique.

The library should serve the entire community, not a loud minority or even exclusively the majority. If 20% of the community wants LGBTQ books, 30% don't, and 50% don't care, why should the 30% be able to decide that the other 20% shouldn't have access to these books? The majority should not be able to strip rights that the minority should have access to. Tyranny of the majority is a real thing.

I find it hard to believe that even a plurality wants these books banned. Do we have proportions, or is it just a number of complaints?

Public parks don't turn profits. Public roads don't turn a profit. Food stamp programs and housing assistance don't generate a profit.

Public goods can increase efficiency and well-being in a way that indirectly translates into increased economic efficiency, but no, profit is not a good direct long term goal of most public goods and services.

I don't think your understanding is accurate. Their positions are overwhelmingly in support of freedom of information, freedom of speech, privacy, and the public domain. They're opposed to anything that locks down and restricts information, generally oppose unnecessary copyright extension and overbearing copyright laws and rules (including the DMCA and DRM). They have a wide array of positions that are both frequently aligned with and opposed by both major American political parties.

People distort the ALA's position as pushing LGBTQ books on children, but that's just the most in the limelight right now because those are the books that are being challenged the most, and the ALA is generally against book banning.

The ALA is aligned largely with classical liberalism, not modern progressivism, and most American conservatives I knew before 2016 would have agreed with their positions on freedom of information and personal privacy.

I don't care for the current admin nor RFK Jr, but this is a bit disingenuous. Floride toothpaste and floridated drinking water are different things, and RFK hasn't said anything about attacking the former. This jab doesn't have anything to do with the discussion at hand.

Rust's compilation is slow, but the tooling is just about the best that any programming language has.

I dislike framing art as something unimportant. Art is a vital part of being a human and part of a culture. We've grown accustomed to our culture being commoditized and rented back to us, but that doesn't mean the culture is unimportant, or such a state of affairs is acceptable.

> The HN crowd dislikes brick-and-mortar landlords but often sides with charging rent for certain bits. Which side will prevail?

I don't think that's exactly the case. A lot of the HN crowd is very much against the current iterations of copyright law, but is much more against rules that they see as being unfairly applied. For most of us, we want copyright reform, but short of that, we want it to at least pretend to be used for what it is usually claimed to be for: protecting small artists from large, predatory companies.

nushell does that out of the box:

    > history | get 82076
    ╭─────────────────┬──────────────────╮
    │ start_timestamp │ 2025-06-24 16:46 │
    │ command         │ mpc play         │
    │ cwd             │ /home/work       │
    │ duration        │ 1ms              │
    │ exit_status     │ 0                │
    ╰─────────────────┴──────────────────╯

It's really nice, because it doesn't just tell you time between command executions (or rather time between commands finishing), but the actual runtime duration of the command.