It's December Days time again. This year, I have decided that I'm going to talk about skills and applications thereof, if for no other reason than because I am prone to both the fixed mindset and the downplaying of any skills that I might have obtained as not "real" skills because they do not fit some form of ideal.

17: Persistence

As someone who is comfortable with installing and reinstalling and restoring configurations and working my way back to what it was before, just with time and scripting, and exporting and importing, it's not the end of the world when an entity or a corporation pulls a milkshake duck, or decides they, too, are going to chase the snake oil bubble and start cramming LLM-related features into their browsers, or operating systems, or any other piece of software they can control. I will freely admit that it sucks to have to do all of those operations on the regular, or even on the occasion, but it is something that I have become used to, as I've been throwing things around here and there, and making it work better. The hardest part, sometimes, is re-learning where you've stashed all your configuration tweaks and where they get applied to. But the more it gets done, the easier it is to remember where all the pathways are, and what you want to do with them. Perhaps in some future world, I'll remember to save the configuration files first, and back them up, and then retrieve and paste them back in and all will be well.

And, when I make these kinds of decisions, as it turns out, sometimes I learn some new and interesting things, like the way that some apps, even if they don't exist in the package manager, are self-contained enough to run on the system. Therefore, I now have my preferred browser running on a system that doesn't have it in the package repositories. At least, not at the moment, since the new version is built on one version up from where my current distribution wants to be.

This is also a crossover post with the Adventures in Home Automation series, because, for the third time, I have managed to get my television with the attacked Raspberry Pi and the broken IR receiver talking to Home Assistant, and being controllable from there. In the previous incarnations of this situation, I managed to clone some git repositories, recognize that some of the things they wanted to do with containers and running the thing as they would like to wouldn't work, because they were asking for some much older versions of Debian, which were probably the newest versions of Debian at the time, but whose archive pointers had completely fallen off and were no longer available. One promising entity written in go worked for a little while, and then the go language changed versions, and the old script just went "nope" compared to the new version, and I don't program in go, so I couldn't fix it. The second promising entity was written in python, and in a previous version of Debian, I seemed to gather all the right libraries from the system tools and get very close to making things work, before I dropped a piece from a completely different script, meant to make it possible for a remote control to function as a game controller, I believe, into the other script, because it looked like it might work. And it did, to my surprise. So that was version two, running stably and with a systemd service for running on boot, happily working its way along.

Then the Debian version underlying the single-board computer's Linux changed, and that meant not only rebasing, but reinstalling, reconfiguring, re-adding, and otherwise bringing things back into the system I had, and reinstalling and reconfiguring the communication broker so that the SBC could communicate with Home Assistant (and the router, now that it had some Optware installed that would send information about router operations and connected machines over that same protocol, using that SBC as the broker for the messages.)

The last component that needed to work was the bridging script that reported information using HDMI-CEC to read the bus for status and then transmit commands from Home Assistant to turn that screen on and off. In the intervening time, the library that the python program used to communicate had jumped a major version number and changed its entire syntax in the process. Luckily, the error that appeared mentioned that a single flag could be set so that it would use the old version of how it was set up, and that saved me a lot of grief trying to figure out how to re-spec the script to use the new library. The flag may deprecate at some point, and then I will have to walk the script up from the previous version to the current version. Hopefully, when that's necessary, there will be a nice conversion guide posted somewhere that explains what the equivalent commands are, and where to put the components of the previous command in the new syntax. For now, however, the scripts themselves are sorted, thanks to adding one piece of code at the right place to the thing itself.

What's not working is that in this new version based on Debian Trixie, the library I had installed from the earlier version was no longer present. And that meant a significant amount of looking around to see if there was something suitable that would serve in its place. The testing repository, the one that would be in the next release (Forky), had the library I thought I had installed on the previous version. So, I did something that is recommended against, and added the testing repository and pulled the version of the item from there, expecting it all to set up and go.

No dice. So I uninstalled that particular set of libraries, because pulling from different releases is a good way to break it. Option two: since it's a python script, I can potentially set up a virtual environment for Python, separated from the system-managed Python installation, then install the necessary libraries through the pip package manager to the virtual environment, and run the script out of that, so long as said script can communicate out and have Home assistant pick up what it's laying down. That's easier to manage with some software packages like pipx to handle the creation and management of the virtual environment. I get the environment set up, and the library that I think will work installed, and the script bombs again with the same error as it had before, So the virtual environment approach isn't going to work, either.

All this time, I'm using my search engine skills to try and figure out what the error is, but there aren't a whole lot of posts on the subject, and most of the time, it keeps coming back to a couple of places, including a GitHub issue that seems like it's exactly about the problem that I'm having, and that somehow the problem was fixed in a subsequent release of the software, but I don't see how they got from point a to point b, as I read and reread the information and keep trying to figure out where the library is that I need to install from the package manager to get the functionality I had before.

This is one of those things where sometimes you need to let your brain background solve a task. Humans are, after all, persistence predators, and while flashes of insight are often cool, they often come more after you have been chewing on a problem for a while, letting it background-process while you work your way toward greater understanding. There was a study, I believe it was in one of my graduate school texts, where a professor gave students a list of riddles to try and solve over the course of a day. At the lunch break, the professor collected the tests and had the students do their lunch break activities, but at places along the way in the building, the professor had placed representations of riddle solutions, and the thing that was being tested was whether the presence of those solution prompts helped the students solve more riddles. I can't find the study, and so I may not be representing it accurately, but sometimes you go through an entire something and as your brain twists and turns on it, and eventually, you do some up with something that actually qualifies as a solution to the problem. It's the idea of "distracting" your conscious processes so that some other process can take over the solving of things, or the integration of information. Sometimes sleeping on it is the right answer to the situation.

In my case, the actual solution came when I finally realized that I was making an assumption that one of the forum posts explicitly denied was a good one to make, and that instead of installing a package from a repository with a similar name, but not actually containing what was needed to succeed, what I instead needed to do was follow the instructions that were given in the right place and compile the damn library myself. Which there was definitely a recipe for, and for the specific architecture and device that I was using. Download source, pass appropriate flags to the compiler, make, make install, all of the things that are involved in compiling a library from source, and guess what? As soon as I had compiled the correct library, the script worked perfectly as I ran it, with the "use the old version please" flag set for the library that did some of the work.

I felt very stupid afterward, because everything kept funneling back to these posts that said "no, that package is not the library you need, you have to compile the library from scratch, and this is the way to do so." I didn't want to do that because I'd rather use the package manager to produce the thing that I needed, instead of compiling something from source. Actually doing what the thing said only took a few minutes and would have avoided many months of grief and not understanding why things weren't working, even with the ability to search up the specific error message and find the post that described it accurately and said what the solution was. Once I managed to read the post correctly and drop the preconception I had, things went much more smoothly.

So this is about the persistence of solving problems, of trying to get to a solution that works for me, and sometimes the disappointment that comes when someone is satisficing rather than looking for a full solution. It's about persistence, because apparently I keep wanting to tweak and shuffle and suggest and do things until they're exactly right, instead of mostly right. It's also about how that persistence sometimes means it's hard to let go of the situation if it's not perfect and optimized and works in all cases. And how it can be annoying to have to deal with people who deliberately want to keep introducing nonsensical edge cases into your perfectly working system, or who believe that if you don't debate them on their nonsensical edge cases or absurd questions, they have somehow "won" and proven themselves smarter than you, because you refused to engage with bad faith tactics. As the somewhat ineffectual advice given would tell us, we can only control ourselves, we cannot control other people. (In pursuit of perfection, we seek control, and sometimes the control that would produce perfection is the control of others, and therefore, perfection will always be beyond us. In theory, this realization is supposed to help us not seek that level of control. In practice, there's still a lot of frustration that comes from not being able to do the things flawlessly and well, and sometimes even more aggravation when things are going out of our control and we don't even know why.) Given how often I end up having to engage with the absurd and the nonsensical, I'd like to believe I have a greater tolerance for other people being Wrong on the Internet (or in my workplace), but there's still sometimes that bit where I want to believe that with enough persistence, I will be able to prevail over the things that bother me, or the people that bother me.

It's also, though, about persistence, the concept that we first learn about when object permanence makes it into our head, that the world is not, in fact, limited to what we are experiencing with our senses, and that our senses (and our minds, if you want to get Zen about it) are misleading us about the nature of our reality. Just because the ball disappears behind the paper doesn't mean it winks out of existence entirely, only to return into reality when the paper is raised. (At least, at the Newtonian mechanics level. Quanta and their friends behave very differently, and we are finding more and more that the act of observation collapses all the possibilities into an observed real, such that whatever organ we are using to perceive the possibilities with inscribes what the result will be onto those possibilities.) The past and the future are constructions, only Now is reality, and only for the now that we experience Now. Many of those constructions are useful, and society rests on our ability to construct things about past, future, and pattern so that we can attempt to impose some amount of order upon the chaos, so as to make it livable and manageable. (That's karma, baby.) We persist in things all the time. Error. its opposite. The horrors persist, and so do I (or but so do I.) Nevertheless, she persisted. He's baaaack! So many things that we have in our history and our lives are about the application of human-sized amounts of influence and force until the desired result is achieved, sometimes even with a great array of things standing athwart, sabotaging, or attempting to cause failure in the way. Because we are not the kinds of beings that let go easily, or give up, and we do much greater work when there are more of us, so we can each take a turn at persistence while someone else rests up for their next turn. The idea about the arc bending toward justice is not a thing that happens by itself, it happens because there are people bending the arc into the desired shape. We will not complete the work in our lifetime, but neither are we excused from doing the work during our lifetimes. And through the ages, thanks to our persistence, we build and sustain things that are greater than any one person and one lifetime. (It's frustrating not to see when it finally clicks into place, but ours is not to know the day or the hour, apparently.)

Only a little while longer, and some of the decisions that I made in the past, decisions that were absolutely correct, will finally have discharged their consequences. It always seems impossible until it is done. Keep at it.