Notices by Adrian Cochrane (alcinnz@floss.social), page 68

@crybaby I like my takes cold!

People are chattering are how bad it's going to be as #ChatGPT starts ingesting it's own AI-generated output as "truth".

But we are already living in AI feedback loops, like when we listen to #Spotify's recommended tracks, and it uses that new listening behavior to make the next recommendation.

It doesn't get better and better over time, it gets narrower and narrower. And to the extent it mixes in "what's popular", some flukes are getting highly recommended while some good music is missed.

Hmmm, I don't think I'll bother typechecking calc() formulas in CatTrap, I'll just let the rare poorly-written formula give weird results...

If I'm not implementing any formal concept of CSS property types...

Chaos Theory has this term "basins of attraction", destinations where seemingly random inputs keep ending up, like a movie with many beginnings but only one ending.

Today I finally listened to enough music from different genres that my Spotify recommendations are finally landing in a different basin of attraction instead of continuing to spiral me back down the drain of the same pop music.

Once you start listening to music in a #spotify basin of attraction it's hard to climb out of the well!

P.S. I don't personally feel any need for it & my plate's too full for such a project, I just think this would be a useful thing to exist advocacy-wise.

@fosserytech @tilvids @simon.caine_channel They sell a lot of it!

There's a tiny probability that any particular datapoint is interesting to the buyer, but sell enough of it & the buyer can bet some fraction of it is interesting.

@lanodan Several!

Mozilla DeepSpeech (is it still around?)
PocketSphinx
Kaldi
Julius

So great to see this: https://github.com/dani-garcia/vaultwarden/discussions/2450 A #FOSS project working as a well oiled dev community should! Contributors to the VaultWarden project so engaged, and giving their express permission to the lead dev to relicense the project under the (very appropriate!) AGPLv3 license. Many thanks to you all! A superb initiative.

eSpeak NG is a handwritten multilingual text-to-speech engine! Voice2JSON parses speech-to-text voice commands without involving the internet!

nginx is the HTTP server I like using.

Maddy & Snikket/Prosody are email & XMPP servers. Very easy to setup, & I like those communication protocols!

SourceHut is a lightweight, flexible, & capable suite of software-project management services!

3/3

What are these libraries?

FontConfig, Harfbuzz, & FreeType all handles fonts.
FriBidi & LibICU handles unicode text. Together these all allow me to excel at internationalization!

Haskell is a safe & elegant language I've come to love.

XML Conduit is an XML parser, Haskell CSS Syntax is a CSS lexer. http-client-tls is self-explanatory, using Cryptonite for crypto.

Rasterific SVG renders SVG, JuicyPixels other image formats.

Mesa3D are linux's userspace GPU drivers, our OpenGL implementation.

There's numerous projects I am grateful for, but here's a few:

* FontConfig
* FriBidi
* Harfbuzz
* LibICU
* Haskell
* XML Conduit
* http-client-tls
* Haskell CSS Syntax
* Rasterific SVG
* Juicy Pixels
* Mesa3D
* Cryptonite
* eSpeak NG
* nginx
* Maddy
* Snikket/Prosody
* SourceHut
* Voice2JSON

Without these it'd be a lot harder to develop the #ArgonautStack !

#iLoveFreeSoftware

Apart from some support functions (a few of which are only called from outside), that pretty well covers the bulk of the Expect-specific commands! I'll go over a few more tomorrow...

6.1/6.1!

`log_user` also sets a global, as per `log_file`. `send`, `send_error`, `send_tty`, & `send_user` all parses their arguments, retrieves the property to send, & with logging writes it in the appropriate format to the channel before cleaning up. `send_log` wraps the Diag subsystem. `sleep` wraps some system/event-loop specific code. `getpid` wraps the corresponding syscall. `exp_pid` retrieves a channel property. `spawn` operates on channels & its implementation heavily depends on build flags.
6/7

`wait` parses args looking up the channel, checks its atomic state looking up a pid to `waitpid` on or spinlocks as appropriate, converts results to TCL data, & cleans up. `close` wraps the corresponding syscall with argument parsing & channel lookup. `exp_configure` wraps TCL's typesystem. `exit` runs exit handlers, some cleanup TCL code, & closes the interpreter. `exp_internal` wraps the TCL datamodel & the "diag" channels. `debug`, if supported, reconfigures some globals.

5/6 for now!

Continuing on...

`overlay` with parsed arguments gathers a subcommand multistring with default SIGINT & SIGQUIT handlers `execvp`s it before cleaning up & outputting the error. `disconnect` with validation & ignoring SIGHUP configures terminal I/O specially & reconnects the standard filedescriptors to /dev/null before forking and/or configuring cgroups & exitting. `fork` wraps the corresponding syscall with bookkeeping. `strace` creates & possibly destroys Trace objects.

4/?

✨ GStreamer Rust bindings 0.20 and Rust plugins 0.10 release is out

This release features the addition of a few convenience APIs, the addition of bindings for some minor APIs and a lot of internal changes to improve performance and code generation.

https://gstreamer.freedesktop.org/news/#2023-02-13T10:00:00Z

#GStreamer #Rust #RustLang

There's also a few utilities in that file for configuring the terminal called by initialization & other modules.

---

Another file defines the bulk of APIs exposed to TCL testscripts. `exp_open` parses its arguments, opens the TCL channel in 1 of 2 ways, attaching a PID & wrapping in a "file channel".`inter_return` defers to `return` with adjusted exit codes.`exp_continue` determines an appropriate exit code to return. `interpreter` parses flags then recurses back to entrypoint.

3/?

Expect provides a couple teletype TCL commands. `stty` redirects the standard filedescriptors parsing redirected input then its options then the output. Finally this gets rewritten into an `exec` command to evaluate.

And the `system` command parses its commandline flags running a `tcsetattr` syscall or equivalent IOCTL reporting any errors, concatenates remaining args into a buffer, calls `system` ignoring SIGCHLD signals, calls `tcgetattr` with error reporting, outputs results, & cleans up.

2

Expect consists mostly of a relatively-small API exposed to the TCL interpreter it runs. Today I'll study how these APIs work.

There's an `interact` TCL command, which with extensive state evaluates some expression & parses commandline flags + keywords before outputting a prompt, reading from a TCL channel into a linkedlist, & evaluates them. Followed by richer timestamped-input mainloops & cleanup. Including a filedescriptor hashtable & subprocesses.

Glossing over a lot...

1/?

@urusan @sotolf I'm loving Julia for teaching the mechanics of computer graphics!

At which point I end up reimplementing some of its standard API.

That said, occasionally the multiple dispatch might not behave the way you expect coming from an OO language. Planning to switch to dictionaries for dynamic dispatch to Pratt-parse GLSL...