3,569 karma · joined August 4, 2018
[0]: https://inductive.no/jai/ [1]: https://github.com/Sharir/jai
*Although there has (always?) been a private alpha/beta release.
*The homepage is available in: https://fossil-scm.org/home/doc/trunk/www/index.wiki.
[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.
>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.
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.
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.
Your regex-utils library also interesting, especially the set operations part.
This reads like something a Markov Model will've output in early 2000s.
- 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.
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.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.
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.
>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.
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.
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).
>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...
[0]: http://www.navgen.com/nova/index.html
[1]: https://research.nvidia.com/publication/2013-07_nova-functio...
[0]: https://forge.nouveau.community/nouveau/serpens/src/branch/m...
[1]: https://forge.nouveau.community/yumaikas/myte/src/branch/mai...
Using TST and have tabs hidden few years now. So although there's a chance, it certainly isn't something that happens often.