HNHacker News
TopNewBestAskShowJobs

forgotpwd16

3,569 karma · joined August 4, 2018

email: [username]@proton.me
submissionscomments
forgotpwd16··on Please just try HTMX
React is an abstraction over UI state, not the platform (ie HTML/CSS). This is by design and non-parallel to C#/CLR case. If you want something akin to this, then Flutter is what you should be looking at.
forgotpwd16··on Jonathan Blow has spent the past decade designing 1,400 puzzles
It may not have a public* release but, over the last decade (starting pre-Zig/Odin), Blow has discussed it extensively in his videos[0], enough that even ~10y was possible for someone to make a toy independent implementation[1].

[0]: https://inductive.no/jai/ [1]: https://github.com/Sharir/jai

*Although there has (always?) been a private alpha/beta release.

forgotpwd16··on How SQLite is tested
SQLite & Fossil* were created by same person (once a member of Tcl Core Team). Fossil few years after SQLite (was on CVS before). A rationale is given in: https://sqlite.org/whynotgit.html. The one other big project using it is Tcl/Tk. (Can say Tcl x SQLite x Fossil form a trinity of sorts with one using the others.)

*The homepage is available in: https://fossil-scm.org/home/doc/trunk/www/index.wiki.

forgotpwd16··on Is Mozilla trying hard to kill itself?
Yeap. It's mentioned in their financial reports that user donations represent more than 99.9% of our annual revenue[0]. Also seems their staff is mainly engineers/developers, and all the expenses are concentrated to their product*. Thunderbird doing what Firefox should.

[0]: https://blog.thunderbird.net/2023/05/thunderbird-is-thriving...

*Though Thunderbird is Gecko-based so can be said in part, perhaps a significant one, they're depending on Firefox development.

forgotpwd16··on Is Mozilla trying hard to kill itself?
Ironically Wikimedia is also throwing money around to side projects, outreach, etc. But luckily for them their products are essentially run by volunteers.
forgotpwd16··on Ruby and Its Neighbors: Perl
Basically Ruby is Perl without the wizardry.

>my favorite piece of random Perl lore – Perligata or Perl in Latin.

I prefer tlhInganHol::yIghun. Or Perl in Klingon.

In series there's also a comparative piece to Smalltalk and Lisp. The Smalltalk post was discussed here recently.

forgotpwd16··on In Defense of Matlab Code
What tools/libraries you miss from Julia? Have you used the language or merely speculating?
forgotpwd16··on In Defense of Matlab Code
This snippet is also cleaner than one in article and more in spirit. Also the image next to whiteboard has a no-commas example.
forgotpwd16··on In Defense of Matlab Code
>I don't think Julia really solves any problems that aren't already solved by Python.

You read the article that compares MATLAB to Python? It's saying MATLAB, although some issues exist, still relevant because it's math-like. GP points out Julia is also math-like without those issues.

forgotpwd16··on An attempt to articulate Forth's practical strengths and eternal usefulness
>The project's README then proceeds into lengthy detail about how to implement >Forth in C.

Seems people have/are more fun/interested implementing Forth interpreters/compilers than actually using Forth. Same with CHIP-8. It's all about making emulators.

forgotpwd16··on Show HN: Generate Passwords from Regex Constraints
Heh, cool concept. Could maybe add some interactive configuration common password gen tools have like choose length, characters used (upper, lower, numbers, symbols) so people not accustomed to regex can play with (and see how for each configuration the regex changes).

Your regex-utils library also interesting, especially the set operations part.

forgotpwd16··on I'm tired of copying auth tokens as vibe coder
>SixXon is the reference MCP-friendly CLI for AI agents. It reduces login friction via OAuth 2.1/Wallet and minimizes cognitive load using the Humility Protocol (3-line output). It features Receipt-Based Evidence (眞) and an AUTO\_RUN safety gate (Trinity Score >= 90). Built as a Strategic Control Point to ensure the Commander's Serenity (孝).

This reads like something a Markov Model will've output in early 2000s.

forgotpwd16··on Programming language speed comparison using Leibniz formula for π
Some seeings:

- C++ unsurpassable king.

- There's a stark jump of times going from ~200ms to ~900ms. (Rust v1.92.0 being an in-between outlier.)

- C# gets massive boost (990->225ms) when using SIMD.

- But C++ somehow gets slower when using SIMD.

- Zig very fast*!

- Rust got big boost (630ms->230ms) upgrading v1.92.0->1.94.0.

- Nim (that compiles to C then native via GCC) somehow faster than GCC-compiled C.

- Julia keeps proving high-level languages can be fast too**.

- Swift gets faster when using SIMD but loses much accuracy.

- Go fastest language with own compiler (ie not dependent to GCC/LLVM).

- V (also compiles to C) expected it (appearing similar) be close to Nim.

- Odin (LLVM) & Ada (GCC) surprisingly slow. (Was expecting them to be close to Zig/Fortran.)

- Crystal slowest LLVM-based language.

- Pure CPython unsurpassable turtle.

Curious how D's reference compiler (DMD) compares to the LLVM/GCC front-ends, how LFortran to gfortran, and QBE to GCC/LLVM. Also would like to see Scala Native (Scala currently being inside the 900~1000ms bunch).

* Note that uses `@setFloatMode(.Optimized)` which according to docs is equivalent to `--fast-math` but only D/Fortran use this flag (C/C++ do not).

** Uses `@fastmath` AND `@simd`. The comparison supposedly is for performance on idiomatic code and for Julia SIMD is a simple annotation applied to the loop (and Julia may even auto do it) but should still be noted because (as seen in C# example) it can be big.

forgotpwd16··on Awesome-Jj: Jujutsu Things
How easier than `git rebase -i`? Running this command, opens your editor of choice with this text & an extensive help commented out at the bottom:

    pick 5340360 # First commit.
    pick 12ccd8a # Second commit.
    pick a2b6a59 # Fourth commit.
    pick 2a648f2 # Commit #4.
    pick 6bb5d98 # Commit #5.
    pick af1f2fe # Commit #6.
    pick 7e99e85 # Commit #7.
    pick 7567b18 # Commit #8.
    pick c23819d # Commit #9.
    pick 50941da # Commit #10.
You edit it to (due to help don't really have to remember a single command):

    pick 5340360 # First commit.
    pick a2b6a59 # Fourth commit.
    pick 2a648f2 # Commit #4.
    reword 12ccd8a # Second commit.
    edit 6bb5d98 # Commit #5.
    squash 7e99e85 # Commit #7.
    pick af1f2fe # Commit #6.
    squash 7567b18 # Commit #8.
    drop c23819d # Commit #9.
    pick 50941da # Commit #10.
And then after letting you reword 12ccd8a, edit 6bb5d98, write new messages for (post-edit) 6bb5d98&7e99e85, and af1f2fe&7567b18, you get:

    pick 5340360 # First commit.
    pick 2448f03 # Fourth commit.
    pick 9cefee3 # Commit #4.
    pick 1259a52 # Second "Hi" commit.
    pick 2ca48d8 # Commit #5.Commit #7.
    pick 4bf7bcd # Commit #6.Commit #8.
    pick dbbb733 # Commit #10.
And if you messed up anything, you can always undo it by using your `git reflog`. No matter what you did, you can always go back a previous state! Each state is stored as new commit.

    dbbb733 (HEAD -> master) HEAD@{18}: rebase (finish): returning to refs/heads/master
    dbbb733 (HEAD -> master) HEAD@{19}: rebase (pick): Commit #10.
    4bf7bcd HEAD@{20}: rebase (squash): Commit #6.Commit #8.
    cdc47c1 HEAD@{21}: rebase (pick): Commit #6.
    2ca48d8 HEAD@{22}: rebase (squash): Commit #5.Commit #7.
    6a6fccc HEAD@{23}: commit (amend): Commit #5.
    86ca5f8 HEAD@{24}: rebase (edit): Commit #5.
    1259a52 HEAD@{25}: rebase (reword): Second "Hi" commit.
    b33f89c HEAD@{26}: rebase (reword): Second commit.
    9cefee3 HEAD@{27}: rebase (pick): Commit #4.
    2448f03 HEAD@{28}: rebase (pick): Fourth commit.
    5340360 HEAD@{29}: rebase: fast-forward
    d1406ed HEAD@{30}: rebase (start): checkout d1406ed8145dc84695eb622bc6b3fc078e8098df
    50941da HEAD@{31}: commit: Commit #10.
    c23819d HEAD@{32}: commit: Commit #9.
    7567b18 HEAD@{33}: commit: Commit #8.
    7e99e85 HEAD@{34}: commit: Commit #7.
    af1f2fe HEAD@{35}: commit: Commit #6.
    6bb5d98 HEAD@{36}: commit: Commit #5.
    2a648f2 HEAD@{37}: commit: Commit #4.
    a2b6a59 HEAD@{38}: commit: Fourth commit.
    12ccd8a HEAD@{39}: commit: Second commit.
    5340360 HEAD@{40}: commit (initial): First commit.
Feel like git has a reputation for being hard even for things they're not that much.
forgotpwd16··on Claude Code's DX is too good. And that's a problem
>"AI is really good until you know what you’re talking about."

Maybe this is a case well represented by the bell curve meme? "AI is great; can do everything" (but you've no domain knowledge so cannot guide it and everything means autonomous creation, so when eventually reaches a roadblock will have no idea what to do), "AI is really good until you know what you’re talking about" (then seemingly doesn't work and is even counterproductive), "AI is great; can do everything" (you've domain knowledge and can guide it and everything means application and assistance).

Essentially rather hope for the LLM to create all by itself as seems to be the current case for many, you should be able utilize your knowledge and have it assist you to both generate an initial code and converge it to where you want.

forgotpwd16··on The Nova Programming Language
Seems to be one of the cases that the academic definition has been simplified in public (quite like theory/hypothesis from science) use and, consequently, adopted by dictionaries making it canonical for many. So your definition is correct from theoretical linguistics perspective but dictionaries also give the broader umbrella definition GP mentions. Ironically dictionaries may've been the reason this distinction was blurred with early lexicographers grouping homographs (logically, spelling in text not relevant) and homophones under an homonym heading.

It's also interesting checking their (Greek originating) etymologies and morphologies. Homo- from omós meaning same, -graph/-phone/-onym from gráphō/phōné/ónoma (ō becoming represented by letter ω in modern Greek) meaning writing/sound/name. And, syn-, equivalent to prefix co-, is from syn (preposition) meaning jointly/together. So respectively, literal meanings, being same writing, same sound, same name, co-named.

Hence about hom/synonym, their difference comes from "name" and "word" being distinct concepts. More specifically, in (Aristotelian) philosophy "name" was tied to essence of things, synonym being "same name, same essence" *, homonym being "same name, different essence". In time "name" and "word" were conflated. Moreover synonym evolved semantically, only retaining the "same essence" as "same meaning", and homonym retained its form. Result being one term being about "many words to same meaning" and the other about "one word to many meanings"**.

*So by ancient philosophy my choice of synonym will've been accurate! But you're right they stand opposite, both then and now.

**And then there's the homonym/polysemy distinction for specifying unrelated/related meanings, essentially reviving Aristotelean essence, and the reason why in dictionaries some words (e.g. bank, see[0]) have multiple entries each with multiple meanings.

[0]: https://www.merriam-webster.com/dictionary/bank

forgotpwd16··on A Lisp Interpreter Implemented in Conway's Game of Life (2021)
Τhat's the reverse, λ->VM/C (also very interesting). Theoretically should be possible to use this code to run @woodrush's λ expressions (the Lisp interpreter, ELVM vCPU, and C compiler).
forgotpwd16··on Linux Sandboxes and Fil-C
Fil-C introduces a garbage collector and can result in significant slowdowns in some cases. Its main existence reason is making non-perf sensitive C/C++ memory safe, not improving the language design. If really want your stack to be C/C++ & Fil-C then your competition includes D/Nim/Go/etc, not (just) Rust/Zig. Even if it magically made C/C++ memory safe, no downsides, your question basically boils down to C vs C++ vs Rust. Don't know about you but prefer somewhat larger binaries and some compiler brawling over programming 70s style.
forgotpwd16··on Defrag.exfat Is Inefficient and Dangerous
Multiple prompts are mandatory for anything non-trivial or/and larger in scope. That said, the exfatprogs repo is ~60k tokens (in 8k LOC) and Linux's exfat driver* is ~40k tokens (in 6k LOC). So directly relevant code is ~100k tokens (in 14k LOC). Not that extensive.

>Not sure if someone can train a model on the kernel code or exfatprogs and generate the code.

They can certainly finetune such a model. Not a crazy idea, just computationally expensive. (But less expensive than training from scratch.)

*Of course Linux driver also uses many includes so if consider those alongside linked code the number goes significantly up.

forgotpwd16··on A Lisp Interpreter Implemented in Conway's Game of Life (2021)
Since although details given, it isn't explicitly stated, ELVM is an infrastructure with an 8cc front-end, a simple IR, and multiple target back-ends which, alongside others, include QFTASM, that article is about, brainfuck, and lambda / binary lambda calculus. Essentially you can write code in C and have it compiled to bunch of weird targets.

Mentioning the last one (same model, different encoding basically) because that guy (@woodrush*) also made a Lisp to λ-calculus expressions compiler which then used to make a Lisp interpreter expressed in λ-calculus (which can evaluate aforementioned compiler and also has an a λ-calculus interpreter implementation available**) and a VM for a Lisp/ELVM-like assembly. The λ ELVM backend was made possible integrating this VM in ELVM. And, of course using his own contributed backend, had an 8cc-based C compiler expressed in λ-calculus.

*If want a drink game to get drunk asap, "take a shot for every λ" in @woodrush Lambda projects is a strong option.

**For extra inception points, can use it to run 2012 Tromp's λ self-interpreter.

forgotpwd16··on Defrag.exfat Is Inefficient and Dangerous
>After reviewing the core defrag logic myself, I've come to a conclusion that it's AI slop.

Will call it a human slop. AI may've given them some code but they certainly haven't use it fully. I uploaded the defrag.c in ChatGPT asking to review on performance/correctness/safety and pointed the sames issues as you (alongside bunch of others but not interested at the moment to review them).

forgotpwd16··on Stoolap: High-performance embedded SQL database in pure Rust
Ah, it was about the usage of rewrite by such third-party efforts. In this case, yes, the original reimplementation (could have also call it alternative) wording is probably better. Was confused at the "happens to have some compatibility" part because the project was started with that intent so it wasn't a coincidence.
forgotpwd16··on Stoolap: High-performance embedded SQL database in pure Rust
From the devs themselves[0]:

>Our goal is to build a reimplementation of SQLite from scratch, fully compatible at the language and file format level, with the same or higher reliability SQLite is known for, but with full memory safety and on a new, modern architecture.

And they call it rewrite in a recent followup post[1].

[0]: https://turso.tech/blog/introducing-limbo-a-complete-rewrite...

[1]: https://turso.tech/blog/we-will-rewrite-sqlite-and-we-are-go...

forgotpwd16··on Stoolap: High-performance embedded SQL database in pure Rust
Can assume they worked on this last few months when they stopped development in the, now archived, Go attempt, but they scrapped the entire git history on publication. Still, even if consider heavy AI use, looks like they put quite the effort in this.
forgotpwd16··on Show HN: Gemini Pro 3 imagines the HN front page 10 years from now
Also, the recently discussed[0], HN Simulator: https://news.ysimulator.run/news. Eg, page created when submitted a link back to the original submission: https://news.ysimulator.run/item/2944.

[0]: https://news.ycombinator.com/item?id=46036908

forgotpwd16··on The Nova Programming Language
True, thanks. Had forgot this term even existed.
forgotpwd16··on The Nova Programming Language
This is an unrelated synonymous language. Besides this and submitted one, there're few others found online, one[0] being 20y+ old (first release 06/2003). There's also a research one on functional parallel programming[1], but no public implementation seems to exist. (Though conceptually Futhark is similar; maybe that Nova even influenced Futhark's creation.)

[0]: http://www.navgen.com/nova/index.html

[1]: https://research.nvidia.com/publication/2013-07_nova-functio...

forgotpwd16··on The Nova Programming Language
So that's why I found the username and language familiar. Was exploring this site few days ago. Besides this page, there's also one on Vera[0], what appears to be Nova's predecessor (at the end there's even link pointing to a defunct wiki under Nova's domain calling it Vera wiki).

[0]: https://wiki.xxiivv.com/site/vera.html

forgotpwd16··on The Nova Programming Language
Some examples are available in the repos of Serpens/Myte[0][1] (Nova in-Python interpreter/to-JS compiler).

[0]: https://forge.nouveau.community/nouveau/serpens/src/branch/m...

[1]: https://forge.nouveau.community/yumaikas/myte/src/branch/mai...

forgotpwd16··on Nook Browser
>there's a good chance an update

Using TST and have tabs hidden few years now. So although there's a chance, it certainly isn't something that happens often.

← PreviousPage 9 of 34Next →