The internet has officially crossed over from a source of generally good information to a floating island landfill of outdated plastic shrapnel.

Just trying to find “today’s” best-practice for simply fetching data in a React app turns into an exhausting ritual of filtering for hours. Thank goodness for subreddit and stack overflow ratings metadata, and this answer in particular, and tools like npmtrends.

No one can ever say that software development is boring…

In c++, all a sort operation needs is a lessThan function. Complex sorts are EASY:

struct AnalyzerJobs_lessthan
{
    bool operator()(const AnalyzerJob* left, const AnalyzerJob* right) const
    {
        assert(left ->psq_->second && left ->psq_->second->p_shared_aps_ && left ->psq_->second->p_shared_aps_->p_ad_);
        assert(right->psq_->second && right->psq_->second->p_shared_aps_ && right->psq_->second->p_shared_aps_->p_ad_);

        // Primary sort
        // Critical jobs first
        // If only one is critical, it wins.
        if (left ->psq_->second->p_shared_aps_->bCriticalAnalysisNeeded() != right->psq_->second->p_shared_aps_->bCriticalAnalysisNeeded())
            return left ->psq_->second->p_shared_aps_->bCriticalAnalysisNeeded();

        // Secondary sort
        // If only one has never been analyzed, it wins.
        if (left->psq_->second->p_shared_aps_->bAnalyzed() != right->psq_->second->p_shared_aps_->bAnalyzed())
            return right->psq_->second->p_shared_aps_->bAnalyzed();

        // Tertiary sort by reverse timestamp of last analysis.
        double lefttime  = left ->psq_->second->p_shared_aps_->analysis_finished_timestamp_;
        double righttime = right->psq_->second->p_shared_aps_->analysis_finished_timestamp_;
        return (lefttime > righttime);
    }
};

You’d think JavaScript would keep that battle-tested methodology, but they decided it would be better to expect a result from the sort function of [ -1, 0, 1 ]. I’m assuming so they can eek out a bit of performance when sorting arrays that have a large number of “equal” items. Seems an outlier case to optimize for, but it probably puts it on some slightly higher score on some manic benchmark.

So for even the simplest sort, you have to do this stupidity:

myArray.sort(( a, b ) => ( a.value > b.value ? 1 : -1 ));

It seems to work as long as the sign is right, so this is also possible:

myArray.sort(( a, b ) => ( a.value - b.value ));

Also, remember that JavaScript provides all kinds of “helpful” dangerous ugly default conversions. Cest la vie. I have to remember though – I’ve used c++ style comparisons in JavaScript sort functions more than once, and that shit don’t fly. ok byeeeee!

Browsers are here to own our desktops. But they will never deliver the absolute horsepower of a natively-coded world-class desktop app or game.

These days, when you try to run one, you will find it is crippled by the browser’s 100 open tabs (admit it, you have that many open…). And lord knows you don’t want to close them all.

I am the user. I am the king. Not the last 20 sites I happened to browse, each of which is allowed to take a huge chunk of our system resources for whatever task they deem important. Once you’ve rabbit-holed down a few holes, you have given your entire system resources to them.

Don’t put up with this. OWN YOUR OWN SYSTEM.

To really take it back when you need to play a game, work in your DAW, or play a 4k video at high frame rate, you need that browser to give up ALL its resources. And in linux, that is super easy.

• Find the parent browser process pid:

ps ax --forest| grep "[0-9][\_ ]*/usr/lib/firefox/firefox$"

• “STOP” it. This is the magic that tells linux to just stop serving the parent process and all its children, stripping all CPU allocation from the tasks, without actually closing anything (especially your precious tabs scattered across all your virtual desktops). It’s amazing, it will freeze your browser in its tracks in an instant:

kill -STOP #pid-from-previous-step#

• Start your powerhouse desktop app and do your thing.

• When you’re done, you can “CONTINUE” the stopped process, kicking off the CPU to immediately start servicing all that javascript again:

kill -CONT #pid-from-previous-step#

I’ve scripted this up so I can press a media key to “stop” firefox and start up Kodi with beautiful performance. Here’s my javascript “continue” script, which uses my rad-scripts tooling:

#!/usr/bin/env node
import * as rs from 'rad-scripts';
const ffPs = rs.run_command_sync('ps ax --forest| grep "[0-9][\_ ]*/usr/lib/firefox/firefox$"');
const ffProcId = +( ffPs.trim().split(' ')[ 0 ] );
console.log( `Parent firefox pid = ${ffProcId}` );
rs.run_command_sync_to_console(`kill -CONT ${ffProcId}`);

Always do this on EVERY new system. Sigh…

emacs /etc/systemd/journald.conf

[Journal]
# MDM This will run away with your drive if you leave it to the default. FU Poettering.
SystemMaxUse=300M

sudo systemctl restart systemd-journald

Lots of great syntactic sugar goo. But you better study up, it is not something you can work out intuitively. But once you’re boned up, it’s fun stuff.

ESlint kind of brings it all home, obsessively prompting you to use that syntax goo correctly. But it is so obsessive, and there are some very silly rules, so “choose wisely”.