TachyonicBytes

It's the usual way to make changes to a privileged file in Emacs; ssh to localhost with root.

The DuckDB API I was talking above seem to already meet your use-cases?

- Does this[1] solve the group by wish?

- Depending on what you mean by projection, maybe this[2] or this[3]?

[1] https://duckdb.org/docs/api/python/relational_api#aggregatee...

[2] https://duckdb.org/docs/api/python/relational_api#projectexp...

[3] https://duckdb.org/docs/api/python/expression#column-express...

Something akin to this is available[1] in DuckDB, itself started as a "shell" over SQLite. Using Python, you can compose your SQL plans as you like.

I recall a previous discussion about the SQLite bytecode and potential alternatives, where the main idea was that, if SQLite had gone the other way, you could have a much more general engine, where you could achieve something like DuckDB itself just as a set of extensions.

Reading the draft, it doesn't seem that extensibility of SQLite was a main factor in deciding. Maybe this trade-off also covers extensions somehow, which would be nice to see in the final document.

[1] https://duckdb.org/docs/api/python/expression

Not many, but I discovered projects, that I use daily, through GitHub's seemingly new "Trending" section.

Congrats on doing the podcast! Definitely looking forward to it.

I wanted to complain about the audio, but the YouTube comments on the topic made it clear what the problem was. This means that audio is going to be better in the future.

At first I thought you posted the Tuesday's printer bug

https://beza1e1.tuxen.de/lore/print_on_tuesday.html

My use-case would be exactly the one described in the README, for example I would like to add one-off events to my calendar by writing an unstructured note.

For production stuff like servers I wouldn't even think about it.

I have been searching[0] for something like this, so thank you! It doesn't quite parse my original example, `14 december 11:20`. but it parses `14 december 2024 11:20`.

I was not aware GNU date could do this as well, but that also doesn't parse my original example.

A small configuration of adding your preferred timezone or reading the system timezone would be nice. The code seems simple enough that I may try to add it myself.

[0] https://emacs.stackexchange.com/questions/79703

Isn't the urban legend around this that it mimics the "EAT ME" and "DRINK ME" messages from Alice in Wonderland by Lewis Carroll?

The missing space is probably from UNIX preferences.

You may joke, but Stallman actually tried to convince them in 2017 to modify gcc to make one out of it

https://lists.gnu.org/archive/html/emacs-devel/2017-04/msg00...

I still feel that llamafiles[1] are the easiest way to do this, on most architectures. It's basically just running a binary with a few command-line options, seems pretty close to what you describe you want.

[1] https://github.com/Mozilla-Ocho/llamafile

How hard would it be to implement commands other than git in this client? Something like "Transient outside of Emacs", not just "Magit outside of Emacs"?

Why wouldn't an abstract `Graph` type and specific implementations of that work? Like Java has for `Set` and various implementations?

They seem to have added "Download PDF" buttons to every issue at the usual link https://cacm.acm.org/issues. There's also the digital library https://dl.acm.org/

Yes, would love to see a wasm runtime comparison

I guess it could be a good test. Maybe comparing very similar medium-sized projects, like wasmtime and wasmer, can give insight into what works better

Also, how does it "know" which parts are the important parts? Example, from the React repo, we have this:

    The key components of React's implementation include:

    The reconciler, implemented in …/react-reconciler, which contains the ReactFiberReconciler class and algorithms for recursively diffing virtual DOM trees and scheduling rendering work. The beginWork and completeWork phases drive the reconciliation process.

But the reconciler seems to be an experimental, not core, recent package, not a key one.

As long as this is happening, might as well try some of my favorites: https://github.com/wasm3/wasm3, https://github.com/WebAssembly/wabt, https://github.com/bytecodealliance/wasmtime

Would this[1] library help you? It's a Rust vector similarity search engine, written to be compiled to Wasm. I discovered it through articles like these[2].

    [1] https://github.com/tantaraio/voy
    [2] https://dawchihliou.github.io/articles/share-rust-types-with-typescript-for-webassembly-in-30-seconds

One of the challenges of quantum computing is getting the useful results back into "classical" mode, where you can use them. Theoretically that's one of the hurdles of getting better theoretical performance than a classical computer. What you describe is more akin to how a GPU works, but in this case, you can't "just get" the result from the GPU.

Do you have links to some of the more non-trivial ones?

Offtopic: Does anybody know if the WebAssembly runtime inside deno (which is actually the runtime inside v8) is exposed by any of the deno crates? A cursory search seems to indicate that it isn't. You can access it from `deno_core` through javascript, of course.

Do you use an extension other than just `rust-analyzer` in order to get compile-time errors for SQL with sqlx?

Late to the party, but I didn't see anyone mentioning this: Shopify seems to be curiously extremely involved in sponsoring WebAssembly-related projects. It's a gold sponsor on AssemblyScript[1], it used to develop javy[2] which compiles JavaScript to WebAssembly, a member of the BytecodeAlliance[3].

I wouldn't think they sponsor LadyBird just for LibWasm[4], as that doesn't make any sense, but technically, they add that to their wasm sponsorships now.

Honestly, it looks like a really nice place to work if you like WebAssembly, I wouldn't mind a collaboration or to work with them.

[1] https://www.assemblyscript.org/

[2] https://github.com/Shopify/javy

[3] https://bytecodealliance.org/

[4] https://github.com/SerenityOS/serenity/tree/master/Userland/...

Maybe add WebSockets and WebWorkers?

There doesn't seem to be much discussion here. The interesting thing for me is actually that this paper is a part of the larger "Readings in Databse Systems"[1], a book composed of thin chapters discussing certain "mandatory" papers that you must read, if you want to have a deeper understanding of database systems.

It has been posted a lot on HN[2], but never quite got attention.

  [1] http://www.redbook.io/ch1-background.html
  [2] https://news.ycombinator.com/item?id=15436647

This is great! I have been meaning to get more into WebGPU!

One question: Does anyone know more details about the Firefox WebGPU story? Even on this site's homepage, if you access it from Chromium with WebGPU enabled, you get nice floating rotating triangles, if you access it from Firefox stable, you get, understandably, static triangles. But if you access from Firefox nightly, with WebGPU enabled, you get a dark background and the error:

    TypeError: navigator.gpu.getPreferredCanvasFormat is not a function

TinyGo does indeed have problems with the reflect package, as well as many others, one which I've managed to help with [1]. The developers have been very helpful, but the reflect package is still a big missing piece.

Your framework sounds interesting. Do you develop it in the open?

[1] https://github.com/tinygo-org/tinygo/issues/3274

In her wasm summit presentation [1], Ashley Williams had a slide that showed a different picture. AssemblyScript came out with the smallest footprint, while Rust and C (through Emscripten) had bigger footprints--the slide is qualitative.

An article posted last week on HN [2] also seems to support this hypothesis, this time with some numbers. The AssemblyScript program had 6% the filesize of the Rust program.

So it seems like, if you want small wasm libraries, AssemblyScript may be your best shot.

  [1] https://youtu.be/J5Rs9oG3FdI?t=2133
  [2] https://news.ycombinator.com/item?id=33761756