m0xEE @m0xee@librem.one

@splitshockvirus @eric @theorytoe
Astrologers proclaim the era of Wayland, frame rate of all Wayland compositors doubles 🧙

@wx1g @yurnidiot
That is one enviable job! 😹

@gemlog
As for Rust — I'm only testing waters myself, I'm still far from being
comfortable with the language, but I was pleasantly surprised that a lot
of things build out of the box even on such a rare platform — others require minimal porting, I touch this bit in the next thread.
Most crates support PowerPC now, even ring the popular TLS crate — basically it's Rust bindings for Google's fork of OpenSSL. Not having it used to be a big problem as even the newer rustls relies on it.

@gemlog
Every now and then I give this machine a "maintenance day" when I build new software from upstream Void and fix things that break — luckily, I don't have to do much as xbps-src facilitates most mundane tasks.
Yesterday was such a day, that's how I ended up having the latest-greatest.

@gemlog
Oh, don't worry — I suppose I can thank my anxiety for running (nearly) bleeding edge software on this machine: I worry a lot about support for 32-bit PowerPC architecture waning from mainstream software, so I build new versions just to make sure things still work: I have Python 3.12 there, LLVM 17, GCC 13 and so on. I even have linux 6.9, which mostly works, but has certain hard to reproduce issues, so I'm sticking with 6.1 😁

@romin
This is the thing I meant: https://github.com/NicolasLM/feedsubs
It looks nice, but it has so many moving parts (Django, Postgres, Redis 🤪) and as I'm not using Dorker, I'm not ready to invest time into hosting it myself yet. I'm using like 4 different machines and a couple of phones more or less daily so having a centralised reader for RSS and not updating the feeds on every machine individually looks like a good idea.

@romin
For me it's more about experimenting with Rust and seeing how well it works on marginal architectures (so far so good) than about making the RSS reader work. It's not even that good TBH — very basic, I don't think I'll keep using it even 😂
For me installing that web-based behemoth in Python would make more sense, can't recall its name — it has accounts and uses PostgreSQL DB for its data. I really like TUI, but I want images in my feeds to easily tell the articles apart 🤷

In Go this wouldn't have been a problem as HTTP client in the standard library honors the environment variables for proxies, but in Rust standard library is very limited — there are plenty of widely used and good crates to make up for it. ureq, which is used in this project, doesn't do it, to me it looks a very similar to Python's great requests module, in which you have to construct the session object (Agent in ureq) and to configure it to use proxies and which is then used to execute requests.

Now I have to figure out how to make ureq in this RSS reader use the proxy set with environmental variables. It looks trivial to accomplish: a matter of implementing the Default trait, which is now derived, for the structure (which would be an object in classic object oriented language) that is used as HTTP client.

@beckermatic
Well, it IS virtue signalling, no one is even attempting to lie to you about it, look at the comment above:
"so it’s more a statement than anything that could be really enforced"
I find this useless too, as it won't harm Russia the state in any way and is likely to only inconvenience individual people, but I'm in no position to tell others what to do with their stuff.
@deb

@newt
In a way, original one also was: a pretty much privileged dude, who never knew scarcity, and who at some point started acting on a whim, realised some things and started teaching them to everyone, even to those, in context of whose lives his teachings might be out of place. A lot like many woketites of today😏

@sj_zero
Rapid progress is often followed by a reactionary phase soon after — French aren't special here.
It might seem like that dialectic thing, but it's not it, it's something we can indeed observe quite often.
…but yeah, that particular case always struck me as something overly silly 😅

@newt
🤔
…now I'm interested in your synopsis of the book of Job 😂

Some problems arise from software relying on atomics (thread-safe types) from the standard library, which aren't portable — luckily, there is portable-atomic crate: https://github.com/taiki-e/portable-atomic
Replacing atomics from standard library with the ones from portable-atomic IS straightforward, but in my case it was a dependency of a dependency using it, so building the RSS reader involved adding a [patch.crates-io] section to Cargo.toml to use a local patched version of crate.

In case some of the crates use C code and build something themselves, like ring crate does, you have to point cargo to the right tools using the environment variables, but in a lot of cases it figures everything out on its own.
Also rust crate version 0.16 didn't support 32-bit PowerPC properly so to port TUI RSS reader here https://github.com/veeso/tuifeed I had to update a few dependencies to use newer ring 0.17

It appears that cross-compiling with Rust is rather straightforward: just install the target you're… hmm, targeting with "rutsup target add <target>", and use "cargo build --target <target> --release" — not much harder than it is with Go.
Considering that your target is available via rustup — mine, PowerPC MUSL system wasn't and I had to build natively, I'll figure out how to add my own targets later. But building for my old ARM machine went without a hitch — and, surprisingly, the binary works😂

I have sussexfully updated rust (and cargo) to 1.79 on my PowerPC MUSL machine running Void.
xbps-src makes cross-building software so easy, in absolute most cases you only have to specify the target architecture and here we go — although it fails to produce a working dynamically-linked Python for PowerPC, but it looks like a bug in libffi. In any case you only have to worry about platform-specific workarounds, most of other stuff is done for you — and it just works!

@jk
Nowadays problems with -O3 are way more rare than they used to be, but not completely out of the question.
-O3 is most often used by those who think architectures less common than x86_64 don't exist, in Void, which supports plenty of architectures, everything is built with -O2, which is a reasonable choice, I build stuff with -O3 when I do it myself, so I do notice when things start breaking 😅