I think there are various idiosyncracies in apt utilities that hinder their use.
I must do work(1) before using one tool or one of the tool options to be sure
if it uses glob or regex and if it tries to substitute the first with the latter
if the first wont be successfull. And of couse in doing that (using
a failed glob as a regex) more idiosyncracies creep in.

Also that is one class of idiosyncracies (argument type handling) .
I had (have) issues with not knowing what is exactly the search
space of a certain argument . Does it search the package name only
or also in other fields ? My experience again warns me to be
cautios and investigate further many times.

I would hope a utility could be more transparent toward
the sysadm about what type of argument it accepts and
what it does with that.
I wonder if such an endeavor would interest anyone. Also
i wonder if the language implementing the utilities hinders
or not a less frictioned use.

(1) And by work i hopped it meant just looking up the man page .
I find my self doing various tests to understand what happens
in each case.

--------- examples ---------
-------------- search space idiosyncracies ------

$ sudo apt-cache -n search  '.*aa$'      / although i used -n  apt-cache give me in the result package names not matching my regex.

-------------- pattern type handling idiosyncracies ------

$ sudo apt-cache  policy  'freeb.*'     / uses regex
$ sudo apt-cache  policy  'freeb*'      / uses glob
$ sudo apt-cache showpkg '*aaa*    /
$ sudo apt-cache showpkg '^aa.*' | grep '^Package'      // regex

$ sudo apt-get install pattern          / will report in its result if it uses the pattern as a glob or as a regex.  Which i found it helpfull.

If i install 10 different linux distros (or devuan only) in 10 different laptops in what level can we achieve the followings :

Each laptop can toggle a communication-collaboration intention state that ranges from : too friendly to too cautious.
That is done accepting that a personal computational device should follow the state(comm wiliingness)  of its owner.
According to that state the laptop calibrates :

• willingness to be part of a local or near adhoc network
    (a participant can at least see the other participants.
     additionaly could see a topology graph and the distances)

• the participants with whow it forms that network

• public announcemt of its presence not

• willingness to share public files according to various private rankings

• willingness to be part of applications that run only with participants
    on that adhoc network.
    (that maybe is sth different. Communication between peers is not the same
    as co-accesing through protocols a shared process.Holding shared state
    allowing realtime concurrent manipulation of that state means i think
    a node capable of supporting that digital state.

I ve learned in the libera#networking  about PirateBox. But it seems as having a computer
that belongs to someone of the participants and we decide to connect to that computer
if we want to share files and collaborate digital. That approach reminds me of the DeadDrops
approach in terms of confidence and trust . Its like demanding a leap of faith big of small.

Can a classic unix mainframe deliver all those requirement ?
With a small difference that all people in a gathering should use terminals to log into the mainframe
and see who is logged in , who shares files , who wants to talk etc?
What if some persons share a computational device ? Imagine four people came to a local cyber gathering
with a sized workstation and four dump terminals? Can say that those four people by having a unix installation
have already achieved - access to the adhoc local network facilities in my initial list? Are we playing with words here?
What could happen also if the 10 laptops were modular and i could take off the computational cores of the 10 laptops , hook them into a mother-board workstation running unix and let the participants access the shared workstation have we again achieved a local adhoc lan ? Or rephrasing: do we have the same facilities offered to the cyber -local- gathering ?

What about  lan parties  ?
In lanparties there is usually a server (a central node) that runs an application (game server) where other connect.
That reminds of a starlike topology , akin to using a piratebox to achieve local e-communication.

The last couple of year bic corps have released tech like Airdrop (ios) , NearbyShare (android and windows).
But perhaps due to the small factor of the smartphone device they focus on simple files exchanges (sharing)
and not on general local adhoc collaboration. And that could align conceptually with the small factor of a personal
computation device(PCD) that is not adequate for productive collaboration.

Also i had a look at KDE connect that seems to approach the issue of communication and integration of one's person's
PCDs

Lastly why it seems that the use case covered by techs like airdrop and nearbyshare seems counterintuitively more difficult than connecting the whole globe via the internet ? What do i miss ? Have we solved the confidence issues in communicating and collaborating in vast wide networks and not in a local one ?  Why it feels that installing a linux distro transform your gear into an isle connected nevertheless  to the internet hyperway  ? Why it feels that the box steers your communication path and not vice versa ? (wow.. that sounds more zen that i intented to :-) )

(ps: if someone read my previous post and find it atleast interesting i apologize for replacing it with that one but i constantly rethink my approach on the matter and i feel that a long philosophical minded post could not help in focusing in the essentials of my  inquiries.)

links:
Bring your own device

Trying to find a vcs perhaps more intuitive and more simple that git i tried lately fossil.

Now suppose i have a certain project tree that i work on.
I'd like to have a command: $ fossil commit project-tree
That command would seems intuitive. We have made some changes and we want to save our project's tree state.But no. In fossil we must do (like in git)
$ fossil add files
and after we have added all the files with changes to our fossil repo THEN
we can make a commit.

(isnt that strange way to explain what a cvs command does? ''Make arrangements' ?..
make arrengement to add a file to the current check-out at the next commit ? Is that explanation or a cvs riddle ? )

So it seems that we have to tell Fossil to construct the Artifacts (Artficats are the equivalenf of blobs in git). But why should  i worry about constructing the artifacts? It seems to me like plumbing that shouldn't bother the end user. The end user is interested in his project.

A project could be various things. Composed of things of various types. But it seems to me that a programmer when using a VCS is interested in the project's state. Not in the project's various subunit's states.

note1: vaguely i remember that in git there is a command to do a commit bypassing all the ''plumbing' steps.

note2: Darcs also handles changes to files by  'addiing' first a file to the vcs's repo. ( ref )

---- UPDATE ---
I stopped the wiki page on virt-manager and instead i started a new one
on using Qemu in CommandLineInterface. Using QEMU from a CLI
---- endupdate ---

I started a wiki page on virt-manager in the https://wiki.devuan.org

It's in the sandbox in https://wiki.devuan.org/Sandbox/Virt-Manager .

I occasionaly use virt-manager and in now as in the past i had again difficulties in setting
it right in devuan. So i think a wiki page could function as focus in order to collect
instructions and tips to smooth things out.

devuan wiki needs i guess some thinking about how to organize things so for
time being i put it in the sandbox.

Also for now i choosed to  use as name the package name that i used for installation.

Any corrections and suggestions are welcomed .

$ sudo apt-cache show stumpwm
Package: stumpwm
Version: 2:22.11-3

/usr/share/doc/stumpwm/NEWS:
* Changes since 0.9.6
** in float mode windows can be resized with the middle mouse button
....

And while StumpWM is running Prefix + v  gives :  1.0.1 compiled at January 2024.

So what is the 2:22.11-3 for ?
Also the version i use has various bugs . If anyone has managed to compile (or wants to) the latest
version please tell me to help each other.

-------------------------------- my compilation effort
$ dpkg -L stumpwm
/usr/bin/stumpwm        // that is the stumpwm binary from the package Version: 2:22.11-3 in Daedalus.

Following the instructions more closely in the github page i managed to compiled.
I think it crucial to install a linux sbcl binary from the sbcl project page as instructed
and follow the instructions from there.

After installing the sbcl binary and loading to it the libraries needed we
compile the stumpwm src :
$ git clone https://github.com/stumpwm/stumpwm.git
$ ./autogen.sh
$ ./configure
$ make
$ sudo make install

'/usr/local/bin/stumpwm'   is the directory that will be installed if we compile the github sources.
We put that path in .xinitrc and we are ok

-----------------------------------------

Of course that leaves a bitter taste in my Devuan admin mouth. The package 'stumpwm' can not work with sblc  devuan package and that result in  an older version running?  And thus instead of 22.11-3 we get 1.0.1 ?

----------------------------------------
StumpWM main page
Debian tracker / StumpWM