Um multiplexador de terminal tem algum benefício quando usado com um gerenciador de janelas lado a lado?

Os multiplexadores de terminal (screen, tmux) e os gerenciadores de janelas lado a lado acionados por teclado (ratpoison, dwm, xmonad) fornecem funcionalidade semelhante. Existe algum benefício em usar os dois ao mesmo tempo? E os problemas que podem surgir?

Eu uso dwm e tmux. Antes de aprender a usar o tmux, eu teria vários terminais abertos para coisas diferentes e tê-los em tags diferentes. Agora eu posso executar tudo dentro de uma sessão do tmux, sob uma única tag, e posso desanexar e reconectar sem perder o estado se precisar reiniciar o X.

O benefício adicional dos multiplexadores de terminal é que suas sessões de multiplexador ainda estarão ativas e você poderá reconectá-las mesmo que o X (sua sessão da área de trabalho) travar ou que você tenha desconectado o X.

Use os dois: Um gerenciador de janelas lado a lado e um multiplexador de terminal.

Combine suas capacidades e vantagens para obter uma sinergia ainda melhor. Na minha configuração do i3, eu mostro regularmente vários terminais ao mesmo tempo, mas todos conectados à mesma sessão do tmux , para que eu possa exibir todas as janelas do tmux em qualquer um dos terminais .

Na verdade, eu uso os recursos de lado a lado i3para substituir / aumentar a funcionalidade de divisão / movimentação de janelas do multiplexador de terminal para (imho) obter o melhor dos dois mundos.

O script abaixo é usado aqui para gerenciar a conexão / detecção de sessão e limpeza na inicialização do terminal:

#!/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

Não. Nos raros casos em que a tela dentro da tela ou o tmux dentro do tmux é útil, ambos os programas fornecem um meio simples de passar o controle para a instância aninhada.

A tela oferece recursos de console serial, mas eu apenas uso um aplicativo dedicado (miniterm.py distribuído com python) quando preciso. Caso contrário, não consigo pensar em nada de improviso que um possa fazer e o outro não, mas um pode fazê-lo mais simples que o outro.

Gostaria de aprender um ou outro e, se você estiver curioso ou insatisfeito com o que escolheu, tente o outro. Eu prefiro o tmux, pessoalmente.

Outro aspecto útil de um multiplexador de terminal nesse cenário é após a conexão com servidores remotos. Um caso de uso típico que eu acho é

1. Abra uma janela de terminal no meu PC local.
2. ssh em um servidor remoto.
3. O tmux / screen agora oferece multiplexação no servidor remoto, permitindo fácil abertura de novos terminais / shells no servidor remoto. Comparado a abrir um segundo terminal no PC local e reconectar-se com um segundo ssh, este é um passo a menos.