Welcome to the world of making software for random people, almost certainly made worse by she being a woman.

As others pointed out, most people do appreciate it, but they tend to be silent about it, whilst a small minority are demanding little whinny bitches (in a non-gendered way) who think they’re owed service and some are even trolls.

To those reading this, I suggest when you get something you like for free you at least give some feedback that you liked it and, if the person has some kind of sponsoring scheme going on and you really like it, consider contributing, if only to incentivise more of the same.

Those on the other side are people too and they will appreciate it.

If the information never leaves the device then it doesn’t need a policy - privacy is not about what an app does in the device which never leaves the device hence never gets shared, it’s about what it shares with a 3rd party.

A clock doesn’t need to send system time settings information to a server since that serves no purpose for it - managing that is all done at the OS level and the app just uses what’s there - and that’s even more so for location data since things like determining the timezone are done by the user at the OS level, which will handle stuff like prompting the user to update the timezone if, for example, it detects the device is now in a different timezone (for example, after a long trip).

That’s because it’s not a clock, it’s a private information stealing app disguised as a clock.

I’m pretty sure somebody who died because they didn’t made sure to check freely available information beforehand given the very loud and widespread advanced notices that “serious shit might be coming your way” counts as Natural Selection.

The amount of effort I do to try and avoid using double parentesis is trully herculean.

I think that stuff is the product of a completionist/perfectionist mindset - as one is writting, important details/context related to the main train of thought pop-up in one’s mind and as one is writting those, important details/context related to the other details/context pop-up in one’s mind (and the tendency is to keep going down the rabbit hole of details/context on details/context).

You get this very noticeably with people who during a conversation go out on a tangent and often even end up losing the train of thought of the main conversation (a tendecy I definitelly have) since one doesn’t get a chance to go back and re-read, reorganise and correct during a spoken conversation.

Personally I don’t think it’s an actual quality (sorry to all upvoters) as it indicates a disorganised mind. It is however the kind of thing one overcomes with experience and I bet Mr Torvalds himself is mostly beyond it by now.

It was about as prescient as “640k is enough for everybody”, but in a good way.

I got an Orange Pi 5 Plus to play with smallish AIs (because it has an NPU) and I normally access it remotely, so I have to know its IP address to do it.

In order to easilly know the IP address of it, I’ve wired a little 128x64 monochrome OLED screen to it (Orange PIs, like Raspberry PIs have a pin connector giving access to GPIO and interfaces like I2C, Serial and SPI) which talks via I2C.

Turns out those interfactes aren’t active in Linux by default (I.e. no /dev/i2c-x), so I figured out that I had to add a kernel overlay to activate that specific interface (unlike with the Raspberry PI whose Linux version has a neat program for doing it, in the Orange Pi you have to know how the low level details of activating those things), which I did.

To actually render characters on that screen I went with an ARM Linux port of a graphics library for those screens I used before with Arduino, called u8g2)

Then I made a program in C that just scans all network interfaces and prints their names and IP addresses on that screen, and installed it as a Cron job running once a minute.

Now, as it turns out when you shutdown your Linux on that board, if you don’t disconnect it from power there is actually still power flowing through the pin connector to any devices you wire there, so after shutdown my screen would remain ON and showing the last thing I had put there, but because the OS was down it would naturally not get updated.

So the last thing I did was another small C program which just sends to that screen the command for it to go into power saving mode, shutting it down. This program was then installed as a Systemd Service to run when Linux is shutting down.

The result is now that there is a little screen hanging from the box were I put this board with Linux which lists its IP addresses and the info is updated if it connects other interfaces or reconnects and gets a new IP address. Curiously I’ve actually been using that feature because it’s genuinely useful, not just a funny little project.

It’s a new frontier in sourcing material for AI training…

The whole business model of Apple is to force a hardware upgrade cycle on you and force all your devices to be in that same ecosystem.

I mean, I can see the advantages of it on the short term, but on the longer term having stuff that keeps on working even as always even in older hardware (or you just install new hardware under it and it just recognizes it and keeps on working) is a massive benefit versus a $1500+ bill every two five years and having to migrate your stuff.

Having done the transition some months ago, there is still some stupid shit one has to deal with (especially, but not only, for games NOT from Steam) at times, more than in Windows, but it’s all so much better than it was before and by now quite close to the Gaming experience in Windows.

Then on top of that there are all the the longer term peace of mind things versus Windows: upgrading your Linux costs zero, changing your hardware won’t invalidate your Linux “OEM License” (plus it will probably just boot up as normal with if you just move your SSD to a whole new machine rather than throw you into driver nightmare), games that work in today’s Linux will keep on working in tomorrow’s and so on - this is actually massive advantage of Linux versus Windows which is seldom talked about: more often than not, hardware migration with Linux is to just move your SSD to a whole new machine, with all the stuff just the way you like it and all you files, and it just boots with and keeps on working.

(PS: Especially relevant for gamers who have to upgrade due to the increasing demands on hardware from the gaming side of things even though the hardware is fine for everything else they do in that machine, and who would rather that all those other things they’ve installed and kept on using rather than uninstall after “finishing the game”, just carry on configured just the way they like it and working just the way they’ve always did, even when they do upgrade the hardware because of games. People who are fine with hardware dedicated to gaming and with replacing the whole thing - hardware and software - for newer games, just get XBoxes or similar consoles, not PCs)

Linux not only saves you from enshittification, keeps control in your hands and preserves your privacy, it’s also a reliable and functional long term OS layer for your hardware that doesn’t force hardware upgrades on you.

At this rate the Year Of Linux On The Desktop will be 2033!!!

More generally: delegate anything critical to a 3rd party and you’ve just put your business at the mercy of the quality (or lack thereof) of their own business processes which you do not control, which is especially dangerous in the current era of “cheapest as possible” hiring practices.

Having been in IT for almost 3 decades, a lesson I have learned long ago and which I’ve also been applying to my own things (such as having my own domain for my own e-mail address rather than using something like Google) was that you should avoid as much as possible to have your mission critical or hard to replace stuff dependent on a 3rd Party, especially if the dependency is Live (i.e. activelly connected rather than just buying and installing their software).

I’ve managed to avoid quite a lot of the recent enshittification exactly because I’ve been playing it safe in this domain for 2 decades.

Also a lot of people were “on call” to handle any problems when the year changed, so the few problem that had passed unnoticed when doing the fixed and did pop up when the year changed, got solved a lot faster than they normally would.

I was already a dev in a small IT consultancy by the end of the decade, and having ended up as “one of the guys you go to for web-based interfaces”, I did my bit pushing Linux as a solution, though I still had to use IIS on one or two projects (even had to use Oracle Web Application Server once), mainly because clients trusted Microsoft (basically any large software vendor, such as Microsoft, IBM or Oracle) but did not yet trust Linux.

That’s why I noticed the difference that Red Hat with their Enterprise version and Support Plans did on the acceptability of Linux.

Just to add to this, early on there was no such thing as kernel modules, so you had to compile your own kernel with the hardware support you needed for anything beyond basic (if I remember it correctly, it was only basic processor stuff, keyboard and text mode VGA) hardware support.

CRT monitors internally use an electron gun which just fires electrons at the phosporous screen (from, the back, obviously, and the whole assembly is one big vacuum chamber with the phosporous screen at the front and the electron gun at the back) using magnets to twist the eletcron stream left/right and up/down.

In practice the way it was used was to point it to the start of a line were it would start moving to the other side, then after a few clock ticks start sending the line data and then after as many clock ticks as there were points on the line, stop for a few ticks and then swipe it to the start of the next line (and there was a wait period for this too).

Back in those days, when configuring X you actually configured all this in a text file, low level (literally the clock frequency, total lines, total points per line, empty lines before sending data - top of the screen - and after sending data as well as OFF ticks from start of line before sending data and after sending data) for each resolution you wanted to have.

All this let you defined your own resolutions and even shift the whole image horizontally or vertically to your hearts content (well, there were limitations on things like the min and max supported clock frequency of the monitor and such). All that freedom also meant that you could exceed the capabilities of the monitor and even break it.

In the early 90s all the “cool kids” (for a techie definition of “cool”, i.e. hackers) at my University (a Technical one in Portugal with all the best STEM degrees in the country) used Linux - it was actually a common thing for people to install it in the PCs of our shared computer room.

Later in that decade it was already normal for it to be used in professional environments for anything serving web pages (static or dynamic) along with Apache: Windows + IIS already had a lower fraction of that Market than Linux + Apache.

If I remember it correctly in the late 90s RedHat started providing their Enterprise Version with things like Support Contracts - so beloved by the Corporates who wanted guarantees that if their systems broke the supplier would fix them - which did a lot to boost Linux use on the backend for non-Tech but IT heavy industries.

I would say this was the start of the trend that would ultimately result in Linux dominating on the server-side.

Well, if you tip because you care enough about the person on the other side, you might want to try and come up with a way to leave them a tip somehow so that there is no risk it’s taken away from them, assuming that you can. Put $5 under the rug and let them know, or something.

If you can’t, you can’t, and I’m hardly going to criticize you for not wanting to catch an airborne infectious disease.

I was pretty miffed in the UK (years ago) when it came out that lots of companies (there it was mainly restaurants) were just keeping the tip money when people payed by card and filled-in a tip amount, so I very much made an effort to as much as possible make sure the actual people got the tip directly - even if I stood out from the crowd by doing it - as I don’t see the point in tipping the company.

When I tip the driver in a delivery I literally just give them cash when they deliver (and only if they actually arrive with some promptness, not if they come half an hour late with a cold pizza).

It’s a habit I got into when living in the UK because there, like in the US, lots of companies just take the “tip” money and keep it if you tip whilst paying with card.

Granted, I like to pay stuff with cash, both for privacy reasons and because it has actually been shown that people in average spend less if they pay in cash (something to do with the feeling of giving something physical away), so I almost always have some cash to pay and tip.

It’s not about debugging tools.

Different, high level software designs (i.e. architectural designs) which are normally imposed by the game engine, have different probabilities of the developers who are making the code for those to produce bugs, because of lots of factors including things like of how they approach error validation and handling in the engine itself and in which domains does the engine leave the most freedom to coders and which ones does it leave less - some things are pretty safe to leave in the hands of even bad developers, others are not.

The example of multi-threading in Unity should’ve been clear: put a game engine that doesn’t impose a single thread pattern in front of somebody with little or no experience in multi-threaded programming and you will have a huge rate of bugs (mainly critical race conditions) and as it so happens most developers out there have little or no experience in multi-threaded programming. Yet multi-threading can yield far more performance in modern CPU since they’re all multi-core. For that specific game engine a software architectural choice was made to go with a structure that is not as performance but significantly less likely to lead to a higher bug rate when used by the average coder, probably because Unity targets less experienced coders.

Good Senior Designers and Technical Architects don’t design the high level structure of the software for themselves as coders, they do it for the kind of coders that are likely to be coding for it.

Of course the developers themselves also have different capabilities and hence different baseline rates of creating bugs, hence why I said “both”.