bellsDoSing

Just checked it on three different accounts (germany) and each one had those two options turned on.

Somewhat recently I caused a failed kernel update by accident:

Ran system update in tmux session (local session on desktop). But problem was that tmux itself got also updated, which crashed the tmux session and as a result crashed the kernel update. Only realized it upon the following reboot (which no longer worked).

Your described solution re "live ISO, chroot, run system update once more, reboot" was also what got me out of that situation. So certainly something worth learning for "general troubleshooting" purposes re system updates.

Have you ever learned about the following in VIM:

• H, M, L, 22H, ...,: vertical cursor placement
• zt, z0, zb: vertical scroll positioning
• 0, $, gm, gM: horizontal cursor placement
• w, e, b: word based cursor movement

Simply holding j or k at times also works, even more so with a decently high key repeat rate.

Of course there's a lot more: https://vimhelp.org/motion.txt.html

The trick is to only learn a couple new movement mappings at a time and use them during one's workflow for a while, up until they feel ingrained. Then repeat, iteratively building up one's movement skills in VIM.

One can say many things about VIM, but not that learning it's movement mappings will make your required APM (let alone mouse clicks) go up to "get stuff done". Honestly, once a basic set of these movements has been learned, any other editor without them will feel like a drag.

Have a ZOWIE EC2 for quite a while now:

• gaming mouse, 5 buttons
• USB compliant
• no special vendor drivers needed to use all mouse features (has buttons on bottom side for settings)

Works well on all OS.

I started using git-secret 2 years ago. It's nice for making secrets part of the repo, while not being readable by anyone that isn't explicitely allowed to do so (using GPG).

I went through setting up netdata for a sraging (in progression for a production) server not too long ago.

The netdata docs were quite clear on that fact that the default configuration is a "showcase configuration", not a "production ready configuration"!

It's really meant to show off all features to new users, who then can pick what they actually want. Great thing about disabling unimportant things is that one gets a lot more "history" for the same amount of storage need, cause there are simply less data points to track. Similar with adjusting the rate which it takes data points. For instance, going down from default 1s internal to 2s basically halfs the CPU requirement, even more so if one also disables the machine learning stuff.

The one thing I have to admit though is that "optimizing netdata configs" really isn't that quickly done. There's just a lot of stuff it provides, lots of docs reading to be done until one roughly gets a feel for configuring it (i.e. knowing what all could be disabled and how much of a difference it actually makes). Of course, there's always a potential need for optimizations later on when one sees the actual server load in prod.

Same here! Been using manjaro for more than 5 years by now on all my dev machines and I really like not being overrun by updates.

Once you form the habit of checking latest "stable update" forum thread (the eqivalent of checking the arch frontpage before an upgrade) and check for potential "manual interventions" (if any), then it gives you suprisingly good stability. But it's still rolling release and "pretty current".

And stability simply becomes more of a factor once your metaphorical "plate" becomes choke full and the last thing you want from your underlying OS is to act up on its own due to an update.

Coincidentally, I happen to have been reading into SEO more in depth this week. Specifically official SEO docs by google:

https://developers.google.com/search/docs/fundamentals/seo-starter-guide

To be clear, SEO isn't about tricking search engines per se. First and foremost it's about optimizing a given website so that the crawling and indexing of the website's content is working well.

It's just that various websites have tried various "tricks" over time to mislead the crawling, indexing and ultimately the search engine ranking, just so their website comes up higher and more often than it should based on its content's quality and relevancy.

Tricks like:

• keyword stuffing
• hidden content just visible to crawlers
• ...

Those docs linked above (that link is just part of much more docs) even mention many of those "tricks" and explicitely advise against them, as it will cause websites to be penalized in their ranking.

Well, at least that's what the docs say. In the end it's an "arms race" between search engines and trickery using websites.

IMO (neo)VIM is great for writing text as well, when all you need is markdown level formatting. Personally I use vimwiki a lot (many years by now).

Just looked it up a bit: https://microsoft.github.io/monaco-editor/

AFAIU, monaco is just about the editor part. So if an electron application doesn't need an editor, this won't really help to improve performance.

Having gone through learning and developing with electron myself, this (and the referenced links) was a very helpful resource: https://www.electronjs.org/docs/latest/tutorial/performance

In essence: "measure, measure, measure".

Then optimize what actually needs optimizing. There's no easy, generic answer on how to get a given electron app to "appear performant". I say "appear", because even vscode leverages various strategies to appear more performant than it might actually be in certain scenarios. I'm not saying this to bash vscode, but because techniques like "lazy loading" are simply a tool in the toolbox called "performance tuning".

BTW: Not even using C++ will guarantee a performant application in the end, if the application topic itself is complex enough (e.g. video editors, DAWs, etc.) and one doesn't pay attention to performance during development.

All it takes is to let a bunch of somewhat CPU intensive procedures pile up in an application and at some point it will feel sluggish in certain scenarios. Only way out of that is to measure where the actual bottlenecks are and then think about how one could get away with doing less (or doing less while a bunch of other things are going on and then do it when there's more of an "idle" time), then make resp. changes to the codebase.