The £200 Windows 10 laptop wasn't powerful enough, it was too laggy. Even on Wifi.
I love the idea of the X11 protocol. And I still love the idea of a web desktop. Something that is supremely well integrated and allows me to move workloads between client and server seamlessly. This idea I really like. The ability to outsource computation and storage seamlessly. A process can be moved between machines seamlessly.
This could be modelled in Javascript and promises that can be sent around. Microservices in the desktop environment.
I looked at tools that would bring up tmux sessions with everything preloaded. (https://github.com/tmuxinator/tmuxinator)
ScrapScript has very good ideas in this area of distributing dependencies and storage. (https://scrapscript.org/) There is also val town.
I never use KDE Plasma widgets or the sidebar widgets that Mac provided.
There is so many exciting ideas that could be tried out but I worry they're all too big ideas to be implemented.
https://stackoverflow.com/questions/5447278/bash-scripts-wit...
This looks like the best solution to your question https://github.com/tmuxinator/tmuxinator
Lets you predefine layouts and what will run in each pane.
https://github.com/tmuxinator/tmuxinator
There are other solutions but I used this one for a while and liked it. Then stopped doing as much development at home (work is Windows) and haven't used it in a while. It's easy(ish) to create different configs for different needs. I basically had a Common Lisp IDE or a C++ IDE or whatever set of things I commonly used.
I work with a few different hosts on SSH and having an active connection for each as a labelled window (tab) in the terminal itself that I can just open up a terminal anywhere to come back to is great.
Personally I use the `tmuxinator` helper tool[^1] that allows you to create configurations as json files to be launched/attached to with short aliases (eg `mux s myconfig`)
I've started this as a hobby project for practicing my Golang skills. Before it, I've been using tmuxinator[0], but I missed some features(like starting only some windows), so I decided to create my own utility. I would appreciate any feedback/code review.
I know the numbers off by heart so can switch without looking.
Just a command away from it setting up the Tmux panes with the right sizes and processes running.
Someone mentioned it a few months back and it greatly simplified my life. You specify your layouts (and tmux will give you the information to copy a current layout). You can then tell it what programs to run in each window of the layout.
So I have a window broken into 5 panes (as an example). The top left runs emacs (via emacsclient) and opens my ledger.org file. The other 4 show various reports I want to see: Current cleared balance, current uncleared balance, current uncleared transactions, future transactions (out to a month), and a running balance sheet across the past several months.
In another two windows I just have a shell and an emacsclient instance (because I live in emacs). Then as I come up with other things I want to see (weather information, summaries of my todos, email inbox (tally at least) I can add new window and pane configurations to my tmuxinator configuration. When I restart it, everything is back as I had it (if I put them in the config).
I haven't done as much coding at home as I'd like lately (and it's all Windows at the office). But I have a couple other tmuxinator configs that will layout several windows and panes for development. Like launch an editor, and have spaces laid out like I want for debuggers and test monitoring scripts. As appropriate to the language and task.
https://github.com/tmuxinator/tmuxinator
For the constantly refreshed display, it's mostly `watch -t ` (modifying the refresh rate if necessary. `-t` removes the title text from the top of watch so it only shows the command outputs. Which is something it took me way too many years to realize.
Copy mode allows you to select and copy text using vi or emacs ( whatever you choose ) key bindings. This way, you can go completely mouse free in the terminal. This is also present in screen.
Then scriptability: tmux exposes lots of commands so you can interact with it from a script. There are quite a few plugins out there. https://github.com/tmux-plugins/
My personal favourites:
- https://github.com/morantron/tmux-fingers/ copy pasting using vimium-like hints, so you don't even have to enter copy mode ( this one I did it myself )
- https://github.com/tmuxinator/tmuxinator/ predefined user sessions. Solves repetitively opening the same services/commands every time you start a coding session.
tmux[1] is oriented toward commandline users on posix-like systems. libtmux is a python library to help you script and automate tmux. it abstracts the concept of the server, its sessions, their windows and panes [2] into a herarchy you can easily navigate, even with a live tmux session.
I don't know if you use cli, tmux, or a tmux session manager (tmuxinator, teamocil, tmuxp) already, so its hard to tailor this answer specifically.
command line
a good deal of programmers, sysadmins, etc. use the terminal routinely throughout their day. some even go so far as to swear off a graphical IDE all together, and use screen or tmux with a combination of an editor like vim, emacs and others.
if you primarily use windows and don't use linux/bsd/os x terminal often, if you ever do, i highly recommend giving screen[3] or tmux a shot.
tmux
the benefit to using the terminal means tmux lets you do a couple things:
- split your terminal into multiple PTY's (panes) and windows, copy and paste between them. No GUI required - "detach" the tmux sesssion, sending it (and any shells/applications running in the panes) to the background, and come back later to reattach - it is also seamless to SSH into a server and work from there, since there's no GUI involved, you can use the same workflow on OS X, Linux or BSD machines.
I write in detail about tmux here: http://tmuxp.readthedocs.io/en/latest/about_tmux.html
tmux configuration
a good amount of developers use screen or tmux on a regular basis. over time, a variety of plugins have popped up. tmuxinator[4], teamocil[5] and tmuxp[6] (my own, written in python) being ways to load pre-configured sessions from a YAML file.
scripting / automating tmux with libtmux
so here is where libtmux comes in, it can be used to control tmux via python objects, which can be very handy in situations where you want to interface with tmux at a low level expressively.
it is possible to script things via shell, but there's no way to know the state or easily traverse through the tree of Server -> Sessions -> Windows -> Panes.
tmuxp uses libtmux under the hood a way to build sessions[7]. other developers have used tmuxp[8]* for scripting tmux to the workflow of their projects.
* note: I link to `import tmuxp` because the API would formerly be in that project for the past few years. libtmux decouples the core into its own library.
[1] https://tmux.github.io/ [2] http://libtmux.readthedocs.io/api.html [3] https://www.gnu.org/software/screen/ [4] https://github.com/tmuxinator/tmuxinator [5] https://github.com/remiprev/teamocil [6] https://github.com/tony/tmuxp [7] https://github.com/tony/tmuxp/blob/master/tmuxp/workspacebui... [8] https://github.com/search?utf8=%E2%9C%93&q=%22import+tmuxp%2...