Things are quite different. While Trump was in office, he did multiple things that were worse than what Nixon did, and was never forced to leave office. I think our institutions were stronger back then. We didn’t have a very good democracy when Hoover was president, and it took many decades for the Voting Rights Act to get passed (which has recently been weakened by SCOTUS, and will probably be weakened much more). I think we’ll regress quite a bit. Republicans obviously want more of an autocracy/oligarchy. I think it’s a very real possibility we have Russia-style “elections” in the future, and I don’t even know how you come back from that. Assuming democracy isn’t completely destroyed, it may take many decades of fighting and changing the minds of the people who aren’t disenfranchised to get back to where we were. Hell, even civil war is on the table if Trump follows through on some of his more egregious promises (i.e. if he deems Democratic state governments as the “enemy within” and tries to use the military to depose them).

Yeah, I agree. I do use Flatpaks, Snaps, and Appimages sometimes if I can’t find a suitable deb repo/package. Flatpak is the best out of the three because they do try to avoid too much duplication through runtimes. I also use Docker quite a bit, which has similar issues (and benefits).

I assume the “kill it” comment was a little tongue-in-cheek. On small SBCs, like a Pi, or old hardware, it could be a problem. I’ve seen people with flatpaks taking up 30GB of space, which is significant. I’m not sure how much RAM it wastes. I assume running 6 different applications that have loaded 6 different versions of Qt libraries would also use significantly more RAM than just loading the system’s shared Qt libraries once.

Wastes RAM and disk space (compared to package-manager installed applications) by storing more libraries on disk and loading them into RAM rather than just using the libraries already installed on the distro. It’s probably better than Snap and Appimage though.

GPL’d clients. Everything is encrypted/decrypted on the client before sending/receiving to/from the server. I may later switch to a self-hosted solution, but don’t want to set one up right now (was using BitWarden’s cloud before).

I just exported my data from BitWarden and imported into ProtonPass. Was pretty easy. Hate the color palette of the app and browser extension though, lol.

I have. My bank did a chargeback like they would if it was a credit card. I was told it would’ve been a lot harder to get my money back if my PIN was used. But, I’ve only seen that option available for in-person purchaees.

Every manufacturer is pretty bad on this front: https://foundation.mozilla.org/en/privacynotincluded/articles/its-official-cars-are-the-worst-product-category-we-have-ever-reviewed-for-privacy/

Best bet is probably buying an older used car. I’ve heard of some people disconnecting their antennas; not sure how hard that is.

And most major U.S. media outlets are highly biased toward Israel for some reason. I don’t know if I’ve ever seen the U.S. media this biased on an issue; I have to resort to small outlets like The Intercept or foreign media like Al Jazeera (which are biased in their own way), to stay informed. The only things comparable I can think of is the Iraq-WMD thing, and their perpetual bias against labor rights/for capital.

https://spinscore.io/?url=https%3A%2F%2Fwww.jta.org%2Farchive%2Fnazis-execute-52000-jews-in-kiev-smaller-pogroms-in-other-cities

Code should be self-documenting. That way it is never outdated. Here’s an example of this similar to what you can expect to see in practice:

def nabla_descent(X, y, theta, alpha, delta, nabla):
    m = len(y)
    for _ in range(delta):
        h = X.dot(theta)
        nabla = (1/m) * X.T.dot(h - y)
        theta = theta - alpha * nabla
    return theta

I (probably unreasonably) despise using web front-ends for desktop applications.

GTK is OK. QT is very feature rich, but that adds complexity. Both can be cross-compiled to most systems and shipped with all the required libraries pretty easily.

I haven’t used it in a long while, but I remember liking Java Swing for some reason. Java should be “write once, run anywhere.” But, cross-compiling isn’t usually too hard, so not sure how much that matters. There’s more modern frameworks for JVM-based languages now, but I haven’t tried them.

I’ve noticed Gradio is popular in the ML community (web-tech based, and mostly used for quick demos/prototypes).

Edit: For web applications, I prefer Angular’s more traditional architecture over React’s hook architecture.

Haven’t tried Gemini; may work. But, in my experience with other LLMs, even if text doesn’t exceed the token limit, LLMs start making more mistakes and sometimes behave strangely more often as the size of context grows.

This is more complicated than some corporate infrastructures I’ve worked on, lol.

I usually just use VS Code to do full-text searches, and write down notes in a note taking app. That, and browse the documentation.

Nah, LLMs have severe context window limitations. It starts to get wackier after ~1000 LOC.

Python is quite slow, so will use more CPU cycles than many other languages. If you’re doing data-heavy stuff, it’ll probably also use more RAM than, say C, where you can control types and memory layout of structs.

That being said, for services, I typically use FastAPI, because it’s just so quick to develop stuff in Python. I don’t do heavy stuff in Python; that’s done by packages that wrap binaries complied from C, C++, Fortran, or CUDA. If I need tight-loops, I either entirely switch to a different language (Rust, lately), or I write a library and interact with it with ctypes.

There’s plenty of open source projects that distribute executables (i.e. all that use compiled languages). The projects just provide checksums, ensure their builds are reproducible, or provide some other method to verify.

In practice, you’re going to wind up in dependency hell before pypi stops hosting the package. E.g. you need to use package A and package B, but package A depends on v1 of package C, and package B depends on v2 of package C.

And you don’t need to use pypi or pip at all. You could just download the code and directly from tbe repo, import it into your project (possibly needing to build if it has binary components). However, if it was on pypi before, then the source repo likely had all the code pip needs to install it (i.e. contains setup.py and any related files).

C# is actually pretty nice. Ecosystem, not so much, but D doesn’t really have one anyways :)