Some commands

$ tmux attach -t NAME
$ tmux detach

Get the session name

Get them all:

$ tmux ls

Get the current one:

$ tmux display-message -p '#S'

Rename session

$ tmux rename-session -t OLD NEW

Links

• tmux cheatsheet
• tmux in iTerm2
• Chris Scheller’s tmux config

I also put this in Reddit

A few other places:

• perlfaq5: How do I change, delete, or insert a line in a file, or append to the beginning of a file?
• Respect the global state of the flip flop operator
• Make exclusive flip-flop operators

Here’s some text that has a mix of written (“first”) and numeric (“4th”) ordinals, and our task is to change them all to the written form except for the first line:

$ cat > file.txt
first line has the numeric ordinal 4th
second line
third is before 4th
4th
next to last
last line is not 4th

Let’s start with a program that simply adds line numbers to the input:

$ perl -n -e 'print "$. $_"' file.txt
1 first line has the numeric ordinal 4th
2 second line
3 third is before 4th
4 4th
5 next to last
6 last line is not 4th

We can skip the first line, which means that we only get lines that have a line before it. The $. is the input line number:

$ perl -n -e 'print "$. $_" unless $. == 1' file.txt
2 second line
3 third is before 4th
4 4th
5 next to last
6 last line is not 4th

But we don’t want to skip the first line. We simply don’t want to change it. We can use the same $. comparison for the part that changes the line. Notice the first line does not change but the fifth line does:

$ perl -n -e 's/4th/fourth/ unless $. == 1; print "$. $_"' file.txt
1 first line has the numeric ordinal 4th
2 second line
3 third is before fourth
4 fourth
5 next to last
6 last line is not fourth

The -p switch is different than -n because it outputs the value of the line at the end of the loop (if you change it or not):

$ perl -pe 's/4th/fourth/ unless $. == 1' file.txt
first line has the numeric ordinal 4th
second line
third is before fourth
fourth
next to last
last line is not fourth

Once you know about $., you can select lines however you like, such as every other line:

$ perl -pe '$_ = uc($_) unless $. % 2' file.txt
first line has the numeric ordinal 4th
SECOND LINE
third is before 4th
4TH
next to last
LAST LINE IS NOT 4TH

Or, even a range (window) of lines:

$ perl -pe '$_ = uc($_) unless( $. < 2 or $. > 5)' file.txt
SECOND LINE
THIRD IS BEFORE 4TH
4TH
NEXT TO LAST
last line is not 4th

There’s a special, and sometimes mind-bending, operator that handles this. The .. range operator in scalar context, as it would be in a condition, doesn’t produce a list. It’s the “flip-flop” variant. That returns false until the lefthand argument is true, and then keeps returning true until the righthand argument is true, after which it returns false. It takes many people a few minutes to unravel that if they haven’t used it before:

$ perl -pe '$_ = uc($_) if $. == 2 .. $. == 5' file.txt
first line has the numeric ordinal 4th
SECOND LINE
THIRD IS BEFORE 4TH
4TH
NEXT TO LAST
last line is not 4th

Perl, being the language that it is, has special cases for the common cases. You can leave off the explicit comparison because comparing the number to $. is the default:

$ perl -pe '$_ = uc($_) if 2 .. 5' file.txt
first line is not 4th
SECOND LINE
THIRD IS BEFORE 4TH
4TH
NEXT TO LAST
last line is not 4th

As an aside, compare this to sed’s 2,5 ... syntax for a line range.

I tried this task a long time ago, in some place I don’t remember, looking at the presence of properties and other things, but I don’t want to create a long chain of things to query to rule out versions. That’s just too much work if I can cheat.

First, the Unicode data files are embedded in the Perl distribution. Look for them in the *lib//unicore/* directory inside the perl installation, for example, *lib/5.42.0/unicore/*.

The version is in *lib//unicore/version*, but you don't need to look in that file and it's a bit annoying to construct the path. There is a module in that directory, but you can't use `perldoc -l` to get its path since it contains no pod:

$ perldoc -l unicore::Name
No documentation found for "unicore::Name".

Getting the right path is a bit weird because the path might be a symlink, so I need to get the final path:

$ which perl
/Users/brian/bin/perl
$ readlink -f $(which perl)
/usr/local/perls/perl-5.42.0/bin/perl5.42.0
$ readlink -f $(which perl) | xargs perl -e '$ARGV[0] =~ s|bin/perl([^/]+)\z|lib/$1/unicore/version|; print scalar <<>>'
16.0.0

That works, but is a bit annoying. There’s another way that took me a minute to discover; buried in Unicode::UCD is the UnicodeVersion function, all the way back to v5.8:

$ perl -MUnicode::UCD -E 'say Unicode::UCD::UnicodeVersion()'
16.0.0
$ perl5.8.9 -MUnicode::UCD -e 'print Unicode::UCD::UnicodeVersion()'
5.1.0

Finally, if you screw around with the stuff in unicore/, perhaps in an attempt to upgrade the UCD version in a perl installation, that’s on you. Don’t do that.

Now here’s the same thing for other languages:

$ python3 --version
Python 3.10.6
$ python3 -c 'import unicodedata; print(unicodedata.unidata_version)'
13.0.0

$ ruby --version
ruby 3.2.2 (2023-03-30 revision e51014f9c0) [arm64-darwin22]
$ ruby -e 'require "rbconfig"; puts RbConfig::CONFIG["UNICODE_VERSION"]'
15.0.0

Further reading

• tchrist’s answer to “How to identify programmatically in Java which Unicode version supported?”

These ideas apply to any software, but the particulars are for Perl. The question was specifically about the POE module.

Consider what I typically look at when I’m evaluating a module. Although we are looking at POE, this is the same sort of evaluation you might go through with a distro, judging based on your context how much these matter to you.

Is there a more alive alternative?

Is there any other way to do this that’s current and maintained? For example, I “maintain” Net::SSH::Perl, which I paid another contractor (who paid yet another contractor) to write for one of my clients. But, people should use Net::OpenSSH.

Part of this is to not be fooled by release dates, since minor things, such as a LICENSE or SECURITY.md file to bring the distro up to current standards, doesn’t make the code any more recent. Have the releases included substantive changes or bugfixes?

My goal is that all of my distros pass the same basic checks so I can maintain them in bulk. If one gets a new file, like SECURITY.md, they all get that file (as appropriate).

How old is the current release, and what’s the velocity?

The last release of POE was at the end of 2022. Some things are just done and don’t need new releases; Dominus’s remarks on his Template module are interesting. I don’t think POE is in that bucket.

The most recent merged pull request is from 2019, and that’s a Pod fix. The last substantive merged pull request is from 2015. (closed pull requests)

What are the open issues?

On MetaCPAN, you can look at the number of open issues in the left menu. POE still uses the sunsetted rt.cpan.org (red flag), and there hasn’t been a maintainer reply to an opened issue since Dec 2022 there (and even later in the GitHub pull requests).

Likewise, the “Testers” link to CPAN Testers is helpful. Even if a module is maintained and has repeated failures on your platform across several versions, it’s not really “maintained” for your purposes.

The GitHub repo, rcaputo/poe has open pull requests, most of which are simple usability fixes for the distro.

Who is involved?

Some of the people involved with POE are the sort to adopt modules merely to keep the lights on. If you see my name (on a module I didn’t invent myself), Todd Rinaldo, and a few others, it’s a sign that the module has reached the point where no one is interested in fixing it.

Indeed, I have more than a few modules that I keep alive (usually at the request of clients) but have never used, never substantially edited, and have no idea how they work. I will apply fixes if they work and make sense, so I’m really just a janitor.

Are those people active?

Along with that, you can look at the activity of any of the comaintainers of a module. In this case, that’s BERGMAN, APOCAL, BINGOS, BSMITH, CFEDDE, HACHI, MARTIJN, and XANTUS. But, I only know that because I am a CPAN author, looked into PAUSE, and used “View Permissions”. (a comaintainer is merely a person who is allowed to upload a new release). Without a PAUSE account, you can use cpanmeta.grinnz.com.

Beware, though, that their most recently uploaded release in the PAUSE data files might not be their most recent activity. Say BINGOS released a new POE yesterday, and CFEDDE then did that again today, you wouldn’t immediately see BINGO’s activity. However, MetaCPAN shows you prior versions, the uploader, and the date in the “Jump to version” pull-down. RCAPUTO made a release in 2015, BINGOS revived it in 2020, and then there’s the 2022 release.

First, some modules don’t compile. Notably, HTML::TagSet changed its minimal version to v5.10, although LWP, which aims for v5.8.1, depends on it. Then Test::Fatal updated its minimum version to v5.12, although URI, which LWP also needs. Neither of these changes were necessary.

Fixing the modules was easy enough by installing old versions before I start anything else:

cpanm PETDANCE/HTML-TagSet-3.20.tar.gz RJBS/Test-Fatal-0.017.tar.gz

The parent module had some trouble which I didn’t bother to figure out. v5.8 didn’t like something in the tests, so I installed it without running the tests:

cpanm --notest parent

Then I got weird errors trying to install IO::Socket::SSL. This one was really weird. The docker build died with a suspicious error:

#9 42.94 DIED. FAILED tests 1-15
#9 42.94    Failed 15/15 tests, 0.00% okay
#9 42.94 t/alpn............................FAILED tests 1-5
#9 43.00    Failed 5/5 tests, 0.00% okay
#9 43.00 t/auto_verify_hostname............$!=No such file or directory, $@=IO::Socket::SSL: Bad protocol 'tcp', S$SSL_ERROR=IO::Socket::INET configuration failed at t/auto_verify_hostname.t line 34.

This one was a bit tricky, and the change between v5.8 and v5.10 does not show up in the perldelta. After trying lots of different things, I search for Bad protocol 'tcp'. That’s a result of the slim version of a base image that does not distribute /etc/protocols. That file defines the numeric constants for the Internet protocols, including TCP and UDP. If that file is not there, getprotobynam can’t resolve the names to their constants.

This wasn’t a problem in v5.10 because Socket defined those constants itself and didn’t need getprotobynam. I solved this by creating the file myself:

printf "tcp 6 TCP\nudp 17 UDP\n" >> /etc/protocols

I could also get these by installing the data package that has the files:

apt-get install netbase

Sometimes I need a simple web server to do something in a test. Most often this web server needs to simulate some error condition, such as a timeout or other server error.

In this test program I fork. In the child, I start a Mojolicious server where the / path has a 10 second delay. This will be longer than the time-out I set for the user-agent in the parent. The magic is the Mojo::IOLoop->start that keeps the server going at the end of the program.

In the parent I do whatever I want to test, which is usually something much more complicated. When I’m done, I shut down the server and get on in life.

#!perl
use v5.40;

use Mojolicious::Lite;
use Mojo::Server::Daemon;
use Mojo::UserAgent;

my $port = 3000;

my $pid = fork;

if( $pid == 0 ) {
    local $SIG{INT} = sub {exit};
    local $SIG{TERM} = sub {exit};
    local $SIG{__WARN__} = sub {1};

    get '/' => sub ($c) {
      sleep 10;
      $c->render(text => 'Hello from inside the program!');
    };

    local *STDOUT;
    open STDOUT, '>>', '/dev/null';
    my $app = app->log( Mojo::Log->new(path => '/dev/null') );
    my $daemon = Mojo::Server::Daemon->new(app => $app, listen => ["http://127.0.0.1:$port"]);
    $daemon->start;
    Mojo::IOLoop->start;
    }
else {
    sleep 2; # let server start
    my $ua = Mojo::UserAgent->new->inactivity_timeout(3);
    my $tx = $ua->get( "http://127.0.0.1:$port/" );

    if( eval {$tx->result} ) {
        say "BODY: " . $tx->res->body;
        }
    else {
        say "ERROR: $@";
        }

    kill 9, $pid;
    waitpid $pid, 0;
    }

Previously, I also used HTTP::Daemon, which was fine too, but I often am dealing with Mojolicious so it’s already there.

This is normally not a problem, but the album rating is somehow lumped into the song rating for smart playlists. And, there’s no longer a way to make or remove album ratings. Yet, those ancient data are still tracked and there’s a listing column for album ratings.

The trick is to set the album rating to something that is the same as zero stars. The album rating is actually a number between 1 and 100 that is mapped onto five stars. Give it something that maps to zero stars; 1 is good:

tell application "Music"
	repeat with theTrack in selection
		set album rating of theTrack to 1
	end repeat
end tell

Think about how beavers chew away at a tree—they chew away at tree until the top portion of the tree either falls over or is connected by a dull point of the connected fibers of the heartwood. These beavers aren’t directing the fall at all; they are merely taking what comes to them.

Along with this claim was that beavers have some sort of special hearing that allows them to hear the tree fibers cracking so they know when it’s going to fall, and they can escape safely. Anyone who has been in this situation knows that you don’t need special hearing, and you don’t even need to be particularly close. The fibers snapping is loud.

So, I went to look for the research, and I found the distressing article The Orientation of Beavers (Castor canadensis) when Cutting Trees (OHIO J SCI 103 (5):143-146, 2003).

This entry isn’t about beavers; it’s about the idea that you can have an idea of beaver behavior without ever looking at one, or putting forth a way to predict what would happen.

Again, science is the art of prediction. Can I observe the world, detect patterns, and make correct predictions? In this case, given a tree, can I predict to a high degree where a beaver will stand?

I suspect you can’t. I suspect the beaver stands wherever he was when he encountered the tree, and the direction of travel is much more predictive than anything else. I also expect that beavers don’t really have a plan; they act compulsively and randomly. But it’s up to someone else to prove through a mountain of evidence that that’s not true.

Beavers die

One of this group’s assertions was that beavers had a special power to avoid being hurt by trees. Of course, that’s stupid and false:

The idea that beavers can control the direction of a tree’s fall is now out of favor based on two types of observations: 1) many trees get caught in the foliage of other trees, and 2) falling trees sometimes kill beavers

But this statement is similarly stupid. That a tree gets caught up doesn’t mean that the beaver didn’t control the direction. In a dense forest, any direction is likely to cause a hang-up. And, that falling trees sometimes kill beavers doesn’t mean beavers didn’t control the direction. That can be “shit happens”, that there are stupid beavers (choosing a bad direction is still choosing), or nothing at all.

There’s nothing here that comes from actual observations of beavers, and as such, saying anything about how beavers orient themselves to the trees is just the bunk.

The elephant and the three blind men

In the parable of the three blind men and the elephant, three different people feel different, select parts of an elephant then tell others what an elephant looks like, having never touched all of an elephant. And, as the parable’s situation forces, having never seen an elephant.

So, let’s suppose that we want to discover if beavers employ a plan and execute it with skill to repeatedly and consistently succeed. What’s the first thing we’d want to do?

If I were designing this experiment, I’d want a bunch of graduate students, volunteers, and field workers to observe beavers and record what they do. I’d interview as many people as I could about beaver behavior. If I could, I’d ask beavers what they are up to.

This paper goes in a different direction. It ignores the beavers and looks at the tree stumps.

Wait, what? How is a tree stump going to tell them anything? Here’s the glaring red flag that shows that the authors not only don’t know anything about beavers, they don’t know anything about trees.

Directional felling

In the world of forestry, “directional” felling refers specifically to making the tree lay over in a direction against its prevailing forces. For example, suppose the tree in front of me leans to the left. Can I fall it to the right instead?

To accomplish that, you can’t do what beavers do: chew away the tree until the remaining fibers fail. Most forestry directional felling is going to maintain some of the tree’s fibers and use those fibers to constrain the tree from falling in the disfavored directions. This is the “hinge”, and typically it’s about 80% of the diameter of the tree and slightly in front of the center of the tree.

Even during the fall, the hinge is intact until the face-cut aspects meet, stopping the free fall of the tree and causing the momentum of the falling weight to rip the hinge apart. This typically happens when the angle of the bole (the main part of the tree) is around 45 degrees to 30 degrees to the ground, in which case the direction of fall is a fait accompli. Indeed, in some falls, these fibers never completely fail because the tree’s branches hold the bole off the ground.

But, I don’t think the people involved in this paper have ever had to cut down a tree, or at least one large enough they might lose their life if they did it incorrectly.

The stump is not the tree

Earlier, I wrote about indirect measures and that most science is not actually a serious attempt to add to human knowledge. That is the case here as well. There is nothing in this paper that increases our understanding of beavers. We already know the paper did not observe any beavers. They also didn’t observe any trees that were still standing.

Instead, their indirect measure was the disconnected stump left over and the orientation of surrounding trees. From that, and only that, they try to work backward to what the beaver was thinking and what the beaver did. They use a plumb line to measure the angle of the trunk compared to straight up, and assume that they know something based on that. If you’ve ever worked in a forest, you know this is complete bullshit. Trees do all sorts of crazy things, and knowing what the stump looks like doesn’t tell you about the bole. The angle at knee height is useless. But it is something that you can measure.

Consider, for example, how the weight is distributed in the canopy. A tree leaning to the right might have its center of gravity to the left because there are more or heavier branches on the left. These things matter, but aren’t part of the data.

One curious thing about this paper is that it doesn’t mention the tree type. But why would you if a tree is just a tree? Some trees, like birch, are thin and tall without branching, so canopy asymmetry doesn’t matter as much as it does with a pine. The Ohio Department of Natural Resources says the forest is a mix of beech and maple.

With all of this, the paper lacks any science (predictive power) and any investigation of the beaver’s intent. If all the trees are leaning toward that marshland or pond, the beavers might not have any agency at all in the direction that the tree falls.

But there’s this nonsense:

Far from the shore, the trees tend to be fairly symmetrical and vertical (Loehle 1986). Thus, trees should fall in the direction from which they are cut.

This is stupidly beyond belief; it’s unsupported, has no observational evidence, and is a completely broken syllogism.

It is there only to lead to the next statement:

Therefore, beavers trying to control the direction trees fall should cut from the side nearest the water to minimize the distance the trunk or branches need to be dragged.

How they could have done

They could have recorded beavers chewing on trees and watching them fall. They wouldn’t have to measure 452 stumps, make large unsupported logical leaps,

But the acknowledgments give it away:

This research was funded by the Howard Hughes Medical Institute Undergraduate Biological Sciences Education Program grant to Ohio Wesleyan University.

This is a vanity project to keep students, who are short-term workers, busy. They didn’t care to get to the truth; they cared about a short-term project that could satisfy a grant and be completed by temporary workers.

As an aside, hash keys are not SVs; they are simple strings. This is why a hash key cannot be tainted and one way to get around taint checking is to send the SV through a hash key, losing all its SV flags, and pull it back out. I write about this in Mastering Perl.

Maybe you have enough memory to do all of this, but in the environment where I do this, I do not. That’s simply because the owners of the hardware aren’t going to give me several hundred Gigs of RAM. So, I need to come up with another way.

Since I only needed to know if a particular IPv4 address was part of the data, I don’t really care about which address that was (but I will be able to). I just need the count of unique IPv4 addresses. Perl has a way that I can map them onto a much smaller data structure: the bit vector.

But IP numbers are just just, well, numbers (sometimes represented as strings), so let’s simplify this with a smaller set of numbers. I’ll use one bit for each IP address, and it’s position is its integer value. For example, the address 192.168.1.1 is really the positive whole number 3,232,235,777, which I know because I have a bash shell alias to convert it:

$ alias ip_aton
alias ip_aton='perl -MSocket=inet_aton -le '\''print unpack q(N), inet_aton(shift)'\'''

$ ip_aton 192.168.1.1
3232235777

I won’t go through a long vec tutorial here, especially since our field width is one bit which makes it straightforward. Here’s a small demonstration where I start with nothing in $bitmap, and when I see a number, I set a bit at that position. Perl takes care of extending the bitmap as needed. I use numbers up to 13:

#!perl
use v5.36;
use strict;
use warnings;

my $bitmap;
foreach my $i ( random_numbers(10, 4) ) {
	say "Saw $i";
	vec( $bitmap, $i, 1 ) = 1;
	say show_vec($bitmap);
	}

sub random_numbers ($max = 13, $n = 10) {
	my @a = map { int rand $max } 1 .. $n;
	}

sub show_vec ($b) {
	my $bits = 8 * length $b;
	my $s =
		join '',
		map { vec($b, $_, 1) ? '+' : '.' }
		0 .. $bits - 1;
	}

Here’s one run. In the bitvector, I show “not set” as . and “set” as +. Notice that Perl grows the size of the bitvector as needed:

 2: ..+.....
 9: ..+......+......
 2: ..+......+......
 8: ..+.....++......

Now I want to know haw many of the unique numbers I saw, so I add a function to count the bits:

sub count_unpack ($b) {
	unpack("%32b*", $b);
	}

Now honestly, raise your hand if you’ve ever seen something like that before. I think I’ve only seen it because I handled the pack section of the latest Programming Perl.

The % in the unpack indicates that I want a checksum of the values, taking 32 thingys at a time. This is effectively the count of set bits.

Now, if instead of random numbers I do this for IP addresses, I get the count of IPv4 addresses, and do it for something under 600 MB (counting all the other stuff going on). That’s pocket change for some applications.

As a side note, unpack has a nybble order. It doesn’t matter for this task because it does not change the count, but I could play games with where the bits show up. This is endianness at the octet level:

$ perl -le 'print unpack q(B8), shift' p
01110000

$ perl -le 'print unpack q(b8), shift' p
00001110

So, let’s summarize the book. It’s really easy because most of the text is the sort of fluff that has taken over these sorts of non-fiction books where the author is a major part of the story. It’s entertaining when Hunter Thompson does it, but no one is Hunter Thompson, so stop it.

There are different ways to organize objects and information about objects. In the physical world, objects take up space and thus exclude other objects from that space (and give me a moment to say the same about the “digital” world), The author calls that the First Order. After that, a large enough collection benefits from a way to find that part of physical space that holds the object I want. That’s Second Order, and might be a card catalog, for example. Beyond that, there’s an exciting new Third Order that the digital world gives us where we “tag” things.

This book was published in 2007, so it was likely written a year or two earlier. For comparison, Gmail launched in April 2004 with the idea that there should be no folders because search makes that useless. Later, in 2010, Gmail had to essentially add folders through a kludge with nested labels. It’s easy to see why this had to happen:

• searching all of your email for a common term returns too many results
• people have one or two major concepts of an email, such as “Duck Project” and “Mallard”, and don’t want all emails that match “duck”, “project”, or “mallard”
• tags are folders

Let’s go back to the difference between physical and digital objects. Each takes up space somehow. Each needs some way to look up the space it takes. Each of those “Second Order” organizations can list as many ways as they like to lead the searcher to that address. There is really no third order, digital-only technique. Tagging objects is just another card catalog.

Librarians already know this. There can be a card catalog for the subject, author, or title. These fulfill different starting points in increasing order of specificity:

• I don’t know what object I want, but I know its subject
• I know the author and want to find their books
• I know the title I want

The mistake that people make about “digital” is that it is something new. It’s not. We can do all of these things in physical space with 3x5 cards. It would be a lot of work and require a lot of people and many, many index cards, but you can do it. It would take up a lot of space.

All of that space disappears inside the computer because the representation of an index card doesn’t exist until I ask for it, and it doesn’t even really exist then. The physical dimensions disappear.

In the computer world, each time someone tags an object, the virtual card catalogs can immediately update. Instead of a couple of tags, we can have two hundred, two thousand, or two million.

This is especially advantageous when the tags are automatic, which might allow many more tags than we’d ever imagine. Consider an image recognition step that can recognize a bridge over a river next to a mountain. The cataloging system can remember all things and allow for things like vector databases that remember multiple attributes, and we can look for all the images with bridges and mountains, even if there is no river.

This is a different sort of searching, though, and it’s mildly interesting. Given even small to moderate scale, looking for an image with particular elements will return too many results. Again, we’re back at the Gmail problem. With too many objects, random searching will fail. For example, choose your favorite photo and imagine you tag it with everything in it. Now, how many of those tags do you have to specify to find that photo among all the others that have the same tags? And how many hours are you going to devote to adding enough tags that there is some unique way to find it?

But we have another way, and the book goes off the rails about this when the author claims that a digital object cannot be in more than one folder. Of course it can. That some systems don’t do it is not a statement of possibility. In Unix, for instance, there’s the hard link, named “hard” because it’s literally just another name for the same data on disk. You can have as many of these as you like.

But let’s back up a moment. A folder isn’t really a folder in the sense of a file cabinet, but rather a skeuomorphic thing that tries to represent a familiar concept in meatspace. Files don’t exist in folders. Instead, pointers to data exist in “folders”, and there’s no requirement that there can’t be multiple pointers to the same data. The computer does not care. The author misunderstands this and uses his misunderstanding to make his case for tagging. Folders are just tags that have a list of files with that tag, just like Gmail had to admit.

This is a completely different topic from people being confused about folders and labels. “Folders” are typically displayed with icons that look like physical file folders in the graphical UI, and people navigate through them. Each folder can have more folders, and this roughly creates a tree for an organization that the person chooses based on what is important to them. See johnnydecimal for example.

But, it’s not really a tree; it’s more like a graph because a folder can contain links to folders in other trees outside of it, and even above it. Consider for example, I have a folder in my macOS Desktop named “Good Things”, under which I have another folder named “mac Things”, and in that folder I put a link to Desktop again. I follow that interior “Desktop” and see the folder “Good Things” again, and click through the folders infinitely without ever getting to the end.

Some random notes

• The Dewey Decimal system isn’t bad because it’s Western. The particular categories might not reflect social needs today, but the categories aren’t the system.
• Any classification system, including tags, will have social problems. Some group is not going to like it. There is no balanced tree that will satisfy the world and the diversity of values.
• Some of the confusion is that an assigned number, no matter the system, corresponds to physical space. That’s one way to do it, but imagine a completely different system now where every object is easily discovered by RFID and is randomly shelved. When that book is requested, the RFID system locates it and presents it. Consider the difference in grocery stores before and after Piggly Wiggly let shoppers collect their own groceries directly off the shelves. In the before times, the shopper didn’t need to know how to find the item, and in the after times, they did.