omoikane

> Masthead set in Manufacturing Consent

I like the description for Manufacturing Consent font:

https://fonts.google.com/specimen/Manufacturing+Consent/abou...

https://github.com/google/fonts/blob/main/ofl/manufacturingc...

That looks like the brainfuck mandelbrot set by Erik Bosman, but the example is missing the header line with the credit. The one I saw came from here:

https://github.com/thaliaarchi/bfcorpus/blob/main/ebosman/ma...

Be sure to check out other files in that directory for how the program is assembled.

(Erik Bosman's mandelbrot set is a personal favorite of mine, very useful for benchmarking brainfuck interpreters)

See also:

https://news.ycombinator.com/item?id=47625366 - United States Code (federal laws) in Git (2026-04-03, 15 comments)

https://news.ycombinator.com/item?id=47621591 - Every Law a Commit – US Law in GitHub (2026-04-02, 32 comments)

I think it's parsing this data:

https://uscode.house.gov/download.html

Which was discussed here:

https://news.ycombinator.com/item?id=6135504 - The entire US Code is now online in XML (2013-07-31, 237 comments)

Current UI text looks blurry in Chrome and Firefox, probably because it's using a font that's optimized for 11px but font-size is scaled to 13.75px.

The first example should have changed the heading to "C++ code" as opposed to "C code" due to the use of `std::unreachable()`. This matches the godbolt link.

Another alternative is to use `__builtin_unreachable()` (not standard, but available in GCC and Clang).

It sounds like the same algorithm described here:

https://www.roguebasin.com/index.php/Cellular_Automata_Metho...

Lesson here is that the subdomain names can be queried due to passive DNS records, and putting stuff that is not supposed to be guessable in subdomain names is a bad idea.

Interesting how 9.99 GBP (about 13.36 USD) will allow for "more than 2 links" in 2025, but 14.99 USD now will still only allow for 2 links. Users will need to pay for "advanced plan" at 49.99 USD per month just for 8 links.

https://www.facebook.com/help/1929252614431792/

Maybe the pull from a string/leash would affect how the thing flies, kind of like kites.

I like how he built a test stand near 7:22, which solves the motor flying off problem and is probably easier to iterate on. It reminds me of how rockets are tested.

I like how for この先生きのこるには, it has この先生(せんせい) as opposed この先(さき)生(い)きのこる. Maybe it's learning from memes.

https://dic.pixiv.net/a/%E3%81%93%E3%81%AE%E5%85%88%E7%94%9F...

I tried D after attending this talk:

https://www.youtube.com/watch?v=RlVpPstLPEc

My impression was that it strives to be a better C++ by fixing many of the annoyances and providing some well thought out convenience features, and it did a pretty good job. I thought the multiple version features and being able to write unit tests inline was especially nice.

But D came about before C++11 was a thing, and C++11 was a great ergonomic improvement over C++98. Since C++ got better, I haven't been keeping up with D.

It says the folders are evaluated in alphabetical order, but actually it's evaluating them in natural sort[1][2]. This makes sense since Windows also displays folders in natural sort order.

[1] https://github.com/rottytooth/Folders/blob/015cf65c15ab681f5...

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

Going for paid membership is a bold move. It's also not obvious who is handling payment information, the terms of service only says payment will be processed by a third party.

GCC still not implementing the standard pragmas reminds me of the old GCC pragma easter egg. This is in cccp.c from gcc 0.9:

    /*
     * the behavior of the #pragma directive is implementation defined.
     * this implementation defines it as follows.
     */
    do_pragma ()
    {
      close (0);
      if (open ("/dev/tty", O_RDONLY) != 0)
        goto nope;
      close (1);
      if (open ("/dev/tty", O_WRONLY) != 1)
        goto nope;
      execl ("/usr/games/hack", "#pragma", 0);
      execl ("/usr/games/rogue", "#pragma", 0);
      execl ("/usr/new/emacs", "-f", "hanoi", "9", "-kill", 0);
      execl ("/usr/local/emacs", "-f", "hanoi", "9", "-kill", 0);
    nope:
      fatal ("You are in a maze of twisty compiler features, all different");
    }

It's gone by gcc 1.21:

    #if 0
    /* This was a fun hack, but #pragma seems to start to be useful.
       By failing to recognize it, we pass it through unchanged to cc1.  */
    ...
    #endif

The examples seem to lean toward "code as means to an end", e.g. making random tools. There is also recreational programming where the code itself is the goal. Examples include IOCCC[1] and a lot of stuff by Yusuke Endoh[2]. I also have a few[3].

[1] https://www.ioccc.org/years.html

[2] https://news.ycombinator.com/from?site=github.com/mame

[3] https://uguu.org/sources.html

> people are going to try and install Chrome at all costs

Mozilla might have anticipated this when they wrote "Diversify your browser engine" as one of the selling points.

https://www.firefox.com/en-US/enterprise/firefox-enterprise/...

Diversification is a good idea, personally I use both Chrome and Firefox every day (and sometimes Lynx).

> This new OpenAI result is thus less a mathematical breakthrough and more an oddity of computer scientists being bad at formalizing their design specifications.

Related, another article about proofs that may depend on bad formalizations:

https://news.ycombinator.com/item?id=49994145 - Navier-Stokes Lost in Translation (5 days ago, 237 comments)

AI seems to be very good at getting answers, but not always answers to the correct questions. These remind me of Deep Thought from The Hitchhiker's Guide to the Galaxy, where they got an answer to the ultimate question before actually knowing what the ultimate question is.

This article saying DDR4 is making a comeback, and all the comments here saying DDR4 never went away, reminds me of the submarine ("Suits make a corporate comeback").

https://paulgraham.com/submarine.html

> People still play chess and go and StarCraft

Those are activities where repeating the same experience yourself is still enjoyable, kind of like you might eat today even though you already ate yesterday.

Finding mathematical proofs is probably more like seeing the ending to a mystery novel. Once the ending has been spoiled for you, it's really hard for you to enjoy it the same way, and it might be more fun to move on to a different mystery.

> increase in speed of new features

But who will maintain those features going forward?

> I also see a lot of Devs simply trusting that the code is correct, they are losing touch with the code.

My worry is that developers can't outsource their understanding to AI forever. It's a lot of risk for companies to be accumulating code faster than developers can understand them.

> rand() Itself has only 32767 possible values

For MingW maybe (due to MSVCRT). I think most libraries such as glibc have RAND_MAX at 2147483647.

Did you mean this one?

https://github.com/openai/math/tree/main/preprints/The-Quasi...

I thought it was interesting that it said "This paper was written with human assistance", unlike this other Quasi-Riemann Hypothesis preprint that didn't have the same disclaimer.

https://github.com/openai/math/tree/main/preprints/The-Quasi...

These optimizations are part of what makes Playdate development fun, since they are more rewarding on the Playdate than on other platforms with higher specs.

(If you are the kind of person that finds optimizations fun, of course. There is a puzzle solving element of optimizing code that I really enjoy.)

I believe it works like this:

    Initial setup:
    0100 c5 30  lds si,[bx+si]   ; Initialize SI
    0102 04 ad  add al,ad
    0104 e6 61  out 61,al
    0106 eb f9  jmp 0101

    After first jump:
    0101 30 04  xor [si],al      ; Modify color part of text buffer.
    0103 ad     lodsw            ; Read [si] into AX and increment SI by 2.
    0104 e6 61  out 61,al
    0106 eb f9  jmp 0101

So the XOR sort of randomizes memory, LODSW reads that memory back (with wraparound), and then writing to port 61h may or may not play a sound depending on bit 0 of AL.

The part I am not sure about is how SI conveniently ends up pointing at video memory. I thought text memory is at b800:0000, and I am not sure how that's derived from [bx+si]?

I am not sure what's the current status of Wuffs-based WebP decoder, but that would be another implementation worth comparing since it shares the same goals of safety and speed.

https://github.com/google/wuffs/tree/main/std/webp

Every HN post regarding security exploits inevitably results in some comment saying the bounty is too low. I find it helpful to read previous comments by tptacek regarding bug bounties and market values:

https://hn.algolia.com/?dateRange=all&page=0&prefix=true&que...

This one probably has the best summary:

https://news.ycombinator.com/item?id=43025038

The instructions seem rather sparse, like the Archimedean solids only have folding nets, and not the folding instructions that produce the cool looking pictures with the holes in the faces.

Even for the intersecting tetrahedra where instructions are available, I see that it's basically constructing the edges from 30 pieces of paper and then assembling them together. I wish they have more things that were built from a single square piece of paper.

Godot comes with a lot of tools in addition to the runtime. Maybe they are using the IDE to do layouts for the menu dialogues, for example.

Also, I am not sure about how easy it is to build binaries using SFML for various platforms (such as WASM), but with Godot you just have to download the right template.

The article mentions it's a halt-on-error pattern:

https://www.sandordargo.com/blog/2026/09/16/cpp26-trivial-in...

Edit: sorry, missed the UB bit.

> The loop must be a trivially empty iteration statement -- meaning its body is literally empty

This seems to say that the loop body can not be "continue". Indeed, I just tried -std=c++26 with ";" and got an infinite loop as promised, but "continue" restores the undefined behavior:

- "while(true);" -> https://godbolt.org/z/T65o51crx

- "while(true) continue;" -> https://godbolt.org/z/Pj9raEcnP

This is unfortunate since I know of one style guide that prefers "continue" over single semicolons. I guess all those code will be doing "while(true) {}" from now on.

https://google.github.io/styleguide/cppguide.html#Formatting...