DEV Community: Max S-T

How to make your terminal suck less

Max S-T — Fri, 06 Dec 2019 22:46:10 +0000

There comes a point in any Linux user’s life where they have to figure out which terminal emulator to use. Chances are if you are using a desktop environment like GNOME (default with ubuntu) or KDE you’ve stuck with the stock terminal and not given it any thought, right? But doing this leaves a lot out when it comes to having a comfortable experience on Linux.

There are may options for terminal emulators, you could choose the slick-looking Hyper.js or the GPU accelerated alacrity maybe even the utility-focused terminator. Each of these inherently has its pros and cons but ill have to say, in my mind, there is a terminal to rule them all - st.

st, also known as suckless terminal, is a small, lightweight, and fast terminal emulator from the suckless community. Before we talk more about st, we must talk about the driving force behind suckless. The suckless philosophy is to ‘focus on simplicity, clarity, and frugality. To keep things simple, minimal and usable‘ which means a lot for their programs, they are all fast light and efficient but on top of this, they have unrivaled modularity and customizability due to the simple, readable nature of their source code. This means that the members of the community can develop patches and changes independently of the master source code.

So why does this make st so good?
I’m glad you asked because there are a lotta things.

It can run on anything
It’s speedy as
There are no messy config files
It supports UTF-8 out of the box
Clipboard support
True 256 colors

To someone who hasn’t done much research around the topic, this all seems kinda lackluster, but when you find something like even the beloved URXVT has issues with the clipboard every feature you can get is a bonus. What makes this even more impressive is this

Emulator	Lines of code
xterm	65K
urxvt	32K
st	<5K

How do I get started
Now, that’s easy, the steps are:

Clone the source repo
Make any config edits
Run sudo make install

1. Clone source repo

I have a GitHub repo with the patches I use applied e.g.

follow URLs by pressing alt-l
copy URLs in the same way with alt-y
Copy the output of commands with alt-o
Compatibility with Xresources and pywal for dynamic colors.
Default gruvbox colors otherwise.
Transparency/alpha, which is also adjustable from your Xresources.
zoom/change font size
copy text with alt-c, paste is alt-v or shift-insert
and lots more view it here

Download my fork with:

git clone https://github.com/manfromth3m0oN/st.git

2. Config edits

Now st does not have ‘traditional’ config files, this is because you don’t just download a binary and run it, you compile st from source. So to edit the config of st enter into the cloned folder with cd st Now open config.h with your favorite text editor (I recommend nvim). All of the options are commented so I won’t go over them here. There is nothing essential to change, unless you don’t use sh then you need to change the static char *shell = "/bin/sh"; line to your appropriate shell (e.g. ZSHor fish etc)

Compile and install This step is probably the easiest all you have to do is install with sudo make install This works provided you have make and gcc installed if you don’t just use:

    sudo apt-get install make gcc
    OR
    sudo pacman -S make gcc
    OR
    install make & gcc with whatever package manager you have

Now you can start using st
Now just start the st binary however your distro or wm/de does so for i3 edit your i3/config file

# start a terminal
bindsym $mod+Return exec st (or whatever *termname is in config.h)

Closing thoughts

st is not a terminal built for someone who is brand new to the Unix ecosystem, but using it from the beginning can teach you a lot about how your system runs. Use st, and all the other suckless utilities for that matter, to help further your understanding of Linux so that you can be the most efficient user you can. After all, that is what the modern Linux philosophy is.

Thank you all for reading

~ M

Auto-Compiling markdown for a live preview

Max S-T — Fri, 06 Dec 2019 22:38:48 +0000

Now, I really like markdown, but there can be some annoyances when it comes to viewing you'r finished product. In a lot of cases it is nice to see you'r result as you type, so we want:

Auto compilation on save
Refresh our PDF reader

How I thought this would work

Initialy I thought I’d be using the amazing tool entr. entr is great because it monitors a files changes on disk. So the plan was compile with pandoc (as standard for markdown) through a shortcut in [n]vim, be watching for the file change with entr and then send a -HUP signal to my pdf reader (mupdf in this case) with pkill.

How it actually worked

Both fortunately and unfortunately there is no need for entr in this scenario. After a bit of scrolling through :help in nvim I had gathered this info:

Bash commands could be ran through the use of !
autocmd runs ‘automatically when reading or writing a file’ (from :h autocmd)
BufWritePost executes something 'After writing the whole buffer to a file’ (again from :h autocmd)
% are the name of the file
Using *.md after BufWritePost specifies file type From this we can start to piece together what we need to put in out .vimrc (or init.vim in my case) This is what I came up with:

autocmd BufWritePost *.md !pandoc % -o %:r.pdf --pdf-engine=wkhtmltopdf && pkill -HUP mupdf

Lets decompose that line:

autocmd BufWritePost - Run after ! once the entire buffer has been writen to a file
*.md - Only do this for markdown files
!pandoc % -o %:r.pdf --pdf-engine=wkhtmltopdf - Use pandoc to compile the current file (%) to current filename without extention (%:r.pdf) using the wkhtmltopdf PDF engine
pkill -HUP mupdf - Send mupdf a HUP signal (source)

Well that was easy

Yes and no, it took me a while to actually come up with that but its actually a very simple and elegant solution. If it isn't working for you make sure you have wkhtmltopdf (or whatever PDF engine you use) and mupdf installed. Also make sure you’ve put it in the correct file (.vimrc for vim, init.vim for nvim) and reopened any [n]vim instance to make the changes

Thank you all for reading and happy writing,
~ M

Making vim a comfy editor

Max S-T — Fri, 06 Dec 2019 13:23:40 +0000

At first vim can seem somewhat daunting.
Coming from more traditional editors like notepad[++], VSCode or Sublime, the jump to an editor where you can't even just start typing immediately when you open a file can seem frustrating at first.
I understand and am completely sympathetic to this but once you start using vim to its full potential its pretty hard to go back.
I think the first thing that daunts new vim users is the lack of immediate guidance, this is not just a 'feature' of vim but in a large portion of the Linux eco-system overall.
The first big lesson to learn with vim and a lot of other Linux tools is manpages and help dialogues.

`:help`

The :help command is one of the most useful utilities in vim, if you are ever unsure of almost anything the :help command can, in pretty much every case, save you.
At this point you don't even need to open a web browser anymore!
The structure of a help command is very simple type :help and then whatever it is you are questioning. e.g.

:help g

Entering this will bring up a list of command that start with :g.
Now knowing this you're ready to start making vim a little more comfy

`vim-plug`

Back in the day, adding plgins to vim was a somewhat arduous process but now, its as simple as adding a line to your vim config and issuing a command.

So lets install `vim-plug`

Run this command if you are using vim

curl -fLo ~/.vim/autoload/plug.vim --create-dirs \
    https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim

Or this on if you are using neovim

curl -fLo ~/.local/share/nvim/site/autoload/plug.vim --create-dirs \
    https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim

Now enter your vim config which is either in

~/.vimrc if you use standard vim

~/.config/nvim/init.vim if you use neovim

Then add

call plug#begin('~/.vim/plugged')
call plug#end()

Now we can add plugins in between those two lines and run :PlugInstall to install them.

Comfy plugins

Now we need to gather a list of plugins that will will make vim comfy.
For that we need to think about some of the things that we have in other editors that make them more comfy as opposed to stock vim
So the features we want are:

[More and better] Code highlighting
A file Tree
Writing focus mode
A flashy status bar
Auto-closed brackets
A wal based colorscheme
Intellisense/Auto completions

The good news is there are plugins to do all of these things which are as easy as one line in a config to install.

So lets begin:

File tree

For this we are going to use a fan favorite - NERDTree.
To install just put

Plug 'scrooloose/nerdtree'

in between the vim-plug begin and end lines.
Now close and re-open your vim config and issue the :PlugInstall command
Once that is done, to open NERDTree type :NERDTreeToggle to open the tree
Thats a bit of mouthful I think you can see so I like to bind the toggle to a hotkey.
Add

map <C-f> :NERDTreeToggle<CR>

to your config and now once you reopen vim you can open the tree with Ctrl+f
If you want to change the hotkey the anatomy of the binding is <> defines a key/key combo, and anytime you see C it means control then whatever comes after is a key.
So if you wanted Ctrl-e the binding would be <C-e>

Better Code highlighting

The tool for the task in this case seem to be cim-polyglot
Which makes some very bold claims

It won't affect your startup time, as scripts are loaded only on demand.

It installs and updates 120+ times faster than the 146 packages it consists of.

Solid syntax and indentation support (other features skipped). Only the best language packs.

All unnecessary files are ignored (like enormous documentation from php support).

No support for esoteric languages, only most popular ones (modern too, like slim).

Each build is tested by automated vimrunner script on CI. See spec directory.

As well as a very impressive list of supported languages (which can be found here)
And even better, the install is another one line in you config and a :PlugInstall
Just put

Plug 'sheerun/vim-polyglot'

In your Plug section and you're done

Writing focus mode

A great plugin for this is goyo.vim
And as always the install is super simple

vim-plug
1. Add Plug 'junegunn/goyo.vim' to .vimrc
2. Run :PlugInstall

Goyo makes non-coding in vim great.
It removes all the extraneos stuff from your screen so if you just want to sit and write you can.
Despite all this I think having to type :Goyo each time you wanted to switch in and out of focus mode would be a pain.

For this exact reason a wrote a bind to handle it for me:

map <C-g> :Goyo<CR>

So now whenever I hit Ctrl+g I enter focus mode

Auto close brackets

This was one of the first things to get in my way when I started writing code in vim. I'd miss a close bracket and then spend 15 mins looking for the thing. (yes, I know gcc errors show line numbers. I was tired ok?)
So to alleviate the pain or going through something similar use a plugin like auto-pairs

Same drill as usual:

Plug 'jiangmiao/auto-pairs'
:PlugInstall

And now it just works

Status bar

For this task I like vim-airline.
Note for this bar to work you'll need to be running a powerline patched font.

As per usual its a simple install:

Plugin 'vim-airline/vim-airline' Plugin 'vim-airline/vim-airline-themes'
:PlugInstall

Wal based colorscheme

For those who don't know wal is a way of generating and managing colorschemes on linux.
And if your syntx-highlighting colors dont match your system colors, lets be real, what kinda human are you.
So we are going to intergrate wal colors and vim colors with

Plug 'dylanaraps/wal.vim'
:PlugInstall
colorscheme wal

Intellisense and Auto completion

This is achivable with the coc plugin.
To install it put

Plug 'neoclide/coc.nvim', {'branch': 'release'}

In your vim config
Then add

" For COC
20 set hidden
21 set nobackup
22 set nowritebackup
23 set cmdheight=2
24 set updatetime=300
25 set shortmess+=c
26 set signcolumn=yes

as well

Bonus round: Easy tab switching

To really make vim like something like VSCode efficient use of tabs is important.
Usually tabs are controlled with g commands e.g. gt for next tab

So what this next bind does is bind Ctrl+Tab to next tab

map <C-i> gt

I thought this was pretty useful so I'd include it.

Bonus round 2: Line Numbers

Line numbers are pretty important to programming (as expressed earlier) so how do you turn them on?
Well you can either use relatiave line number (rnu) or set line numbers. RNU sets line number relative to your cursor which looks pretty cool as you scroll around a document but set are certainly more useful.
To try either out use the :set numbers or :set rnu commands.
Once you've found which you like just put that respective command in your vim config

Closing remarks

Thank you all for reading and sticking with such a long article.
I'll cya in the next one.
~ M