My favorite font of the time was ISO 9x16: https://int10h.org/oldschool-pc-fonts/fontlist/font?ibm_dos_...

My current frustration with Markdown is that Gemini is very bad at producing them.

Just because gemini.google.com uses Markdown for its output, it doesn't seem to be able to properly output Markdown from Markdown: always corrupted.

Just yesterday I asked gemini.google.com to write a README.md for a software project: the Markdown was broken from the closing first code block "```bash" and the rest of the doc was in the output like if it wasn't the doc anymore. An escaping issue. So I asked it to give me the same README.md encoded as Base64: once decoded the content was broken from the same point, but after that that wasn't Markdown anymore but binary data. It looks like Gemini leaked raw binary tokens in the Base64.

Very reliable tech. Is is too much to expect reliable Markdown escaping? Shouldn't this be a solved problem long ago?

I remember fondly of a raster talk at FOSDEM about 20 years ago: playing videos inside a terminal. Amazing!

Wow, I think I remember that talk, too. And I remember thinking, "why would anyone want to run a video inside a terminal?!" I still don't want to do that, but it was cool that enabling that feature only required a few lines of code, since EFL(?) already supported it, was already linked in, and the code to start it was minimal.

i found this one from 2012:

https://video.fosdem.org/2012/maintracks/k.1.105/EFL.webm or https://youtu.be/HfcFbHQWqu8?list=PL31210579EDD785E7

in an interview from that time he says the previous time he was at fosdem was 10 or 11 years earlier. there seem to be no recordings from that time.

I would question the framework design: the method is called "UpdateUser", so it should be executed in a transaction, so it should be a parameter of the service, and the transaction logic handled by the framework.

  func (s \*Service) UpdateUser(ctx context.Context, tx models.Repo, userID string) error {
        user, err := tx.GetUser(ctx, userID)
        if err != nil {
            return err
        }
        user.Name = "Updated"
        return tx.SaveUser(ctx, user)
  }

In that instance, you are right, but there are often cases where you need to do multiple queries / updates spanning multiple tables in a single transaction, then you do need a generic transaction wrapper.

zmosh is zmx+mosh

https://github.com/mmonad/zmosh

Anyway, when I first saw the VeraCrypt thing this morning my initial reaction was “I wonder if Iran uses VeraCrypt”

On a GitHub project, agents must just be considered untrusted external contributors.

Or ask the agent to write a Dockerfile (to abstract the build environment) that builds CUPS and all your stuff around it directl in WASM, instead of targeting x86 and then emulating x86 with WASM.

Is there a Docker-to-WASM pipeline, and how does it do anything differently from emulating x86?

Also: goeval https://github.com/dolmen-go/goeval

There is a 8 months old open ticket, with an official answer, here: https://gitlab.opencode.de/bmi/eudi-wallet/wallet-developmen...

Yes, hence me saying duplicate above