Un multiplexer terminale ha qualche vantaggio se usato con un gestore di finestre di piastrellatura?

Entrambi i multiplexer terminali (schermo, tmux) e i gestori di finestre di piastrellatura guidati da tastiera (ratpoison, dwm, xmonad) offrono funzionalità simili. Ci sono dei vantaggi nell'usarli entrambi contemporaneamente? Che dire dei problemi che possono sorgere?

Uso dwm e tmux. Prima di imparare ad usare tmux, avrei più terminali aperti per cose diverse e li avrei in tag diversi. Ora posso eseguire tutto all'interno di una sessione di tmux, sotto un singolo tag, e posso staccare e ricollegare senza perdere stato se devo riavviare X.

Il vantaggio aggiuntivo dei multiplexer terminali è che le sessioni multiplexer saranno ancora attive e potrai riconnetterti anche se X (la tua sessione desktop) si arresta in modo anomalo o sei disconnesso da X.

Utilizzare entrambi: un gestore di finestre di affiancamento e un multiplexer terminale.

Combina sia le loro capacità che i vantaggi per ottenere una sinergia ancora migliore. Nella mia configurazione i3 visualizzo regolarmente più terminali contemporaneamente, ma tutti collegati alla stessa sessione tmux , quindi posso visualizzare tutte le finestre tmux in uno qualsiasi dei terminali .

In effetti, utilizzo le funzionalità di piastrellatura di i3sostituire / aumentare la funzionalità di suddivisione / spostamento della finestra del multiplexer terminale per (imho) ottenere il meglio da entrambi i mondi.

Lo script seguente viene utilizzato qui per gestire la connessione sessione / rilevamento e la pulizia all'avvio del terminale:

#!/bin/bash
# This script attaches the terminal to a common session, where all
# terminals can show any window of the main tmux session independently
# This script also cleans up "old" sessions
# Todo: Cosmetic fix-ups. Make less verbose.

DEBUG="y"
showRun(){ echo Will run: $@;test -z $DEBUG||read -n1 -p"Press ENTER";$@; }

SNAME=${1:-XyZ}

if ! tmux has -t $SNAME; then
    echo -n "Session $SNAME not found, creating it: "
    showRun exec tmux new-session -s $SNAME;
else
    echo -n "Session $SNAME found: "
    MySESSION=$(tmux ls | grep -E "^$SNAME:.*\(attached\)$")
    echo $MySESSION;
    if [ -z "$MySESSION" ] ; then
        echo "Session $SNAME unattached, seizing it:"
        showRun exec tmux attach -t $SNAME \; new-window
    else
        echo "Session $SNAME already attached, finding grouped Sessions:"
        REGEX="group ([^)]*)"
        [[ $MySESSION =~ $REGEX ]]
        GNAME=${BASH_REMATCH[1]}
        GSESSIONS=$(tmux ls | grep "group $GNAME)" | grep -v $SNAME:)
        echo "$GSESSIONS"
        if [ -z "$GSESSIONS" ]; then
            echo "No sessions in group with $SNAME found, creating new one:"
            showRun exec tmux new-session -t $SNAME \; new-window
        else
            FGSESSIONS=$(echo "$GSESSIONS" | grep -v attached )
            if [ -z "$FGSESSIONS" ]; then
                echo "No free sessions in group $GNAME found, creating new one:"
                showRun exec tmux new-session -t $SNAME \; new-window
            else
                echo -e "Free grouped Sessions:\n $FGSESSIONS";
                if echo "$FGSESSIONS" | tail -n +2 | grep . > /dev/null; then
                    echo "Several detached Sessions found, cleaning up:"
                    echo "$FGSESSIONS" | while read SID x ; do
                        if [ -z $KEEPSID ]; then
                            KEEPSID=${SID%:*};
                            echo "Keeping session $KEEPSID for takeover after cleanup"
                        else
                            echo "Cleaning up old detached session $SID"
                            tmux kill-session -t ${SID%:}
                        fi;
                    done
                    KEEPSID=$(tmux ls|grep "group $GNAME)" | grep -v attached);
                    KEEPSID=${KEEPSID%: *}
                    echo "Attaching to session $KEEPSID:"
                    showRun exec tmux attach -t $KEEPSID \; new-window
                else
                    echo "Free session ( ${FGSESSIONS%: *} ) found, seizing it:"
                    showRun exec tmux attach -t ${FGSESSIONS%: *} \; new-window
                fi ;
            fi ;
        fi ;
    fi ;
fi

No. Nei rari casi in cui lo schermo all'interno dello schermo o tmux all'interno di tmux è utile, entrambi i programmi forniscono un semplice mezzo per passare il controllo all'istanza nidificata.

Lo schermo offre funzionalità di console seriale, ma quando ne ho bisogno uso solo un'app dedicata (miniterm.py distribuita con Python). Altrimenti non riesco a pensare a niente di strano che uno può fare e l'altro no, ma uno potrebbe farlo in modo più semplice dell'altro.

Imparerei l'uno o l'altro e, se sei curioso o insoddisfatto di ciò che hai scelto, prova l'altro. Preferisco il tmux, personalmente.

Un altro aspetto utile di un multiplexer terminale in questo scenario è dopo la connessione a server remoti. Un caso d'uso tipico che trovo è

1. Apri una finestra terminale sul mio pc locale.
2. ssh in un server remoto.
3. tmux / screen ora fornisce il multiplexing sul server remoto, consentendo una facile apertura di nuovi terminali / shell sul server remoto. Rispetto all'apertura di un secondo terminale sul PC locale e al ricollegamento con un secondo SSH, questo è un passo in meno.