DEV Community: Siraphob Kan

Make Neovim your ultimate code editor

Siraphob Kan — Tue, 21 Dec 2021 15:27:47 +0000

TLDR; My dot-file can be downloaded from this link.

Prologue

Vim was invented around 30 years ago (1991). It is a text editor that runs in a terminal. Programmers at the time use Vim to write their code.

In mordern days, even with new text editor like VSCode, intellij, sublime text, etc; Vim still stand tall among them. This is because Vim has some advantages over those text editors.

Vim is extremely lightweight.
Vim itself is very small and it's likely shipped with most Linux distros. The only dependency it needs is a terminal.
People who use Vim could edit their code faster.
Vim enables full keyboard control. You can navigate, edit, delete, replace, etc. using only your keyboard. You'll seldomly need to touch your mouse when writing code ever again.
Vim is highly customizable.
You can configure Vim to work in your way. Keybindings are not intuitively enough? You can remap it! Want to add Git integration? You can do that too! Add code-completiong and linting for your programming language? I don't need to say that it's achievable too.

Why Neovim?

You may wonder why I was talking about Vim when the title said Neovim. Well, here I am. In this article I'm going to explain why we'll use Neovim instead of Vim.

What is Neovim?

Neovim is a forked version of Vim. It's basically Vim but driven by an open-source community. On the other hand, Vim is maintained by only one person which is its original author, Bram Moolenaar.

Why should you use Neovim instead of Vim?

As I said, Neovim is maintained by the community. And because of that, the tends software evolves faster and more compatible with the modern system. And by that term, I am talking about integration with other third-parties and bug fixes.

Moreover, Neovim's software architecture was redesigned to be more extensible and could process task in multi-thread fashion.

With all that; the traits of its predecessor, blazingly fast software, and powerful plugins; is the reason I recommend you to use Neovim over regular Vim.

Installing Neovim

If you're on Debain-based system, you could run the following command.

sudo apt-get install neovim

For other distributions/system, please refer to this wiki page.

After the installation completed, you could start Neovim by just typing neovim in your terminal.

Configuring Neovim

Before any processes of Vim begins, Vim will read its configuration file first.
So does Neovim. Neovim's configuration file is located at $HOME/.config/nvim/init.vim. If your system doesn't have this directory, you could create one.

The init.vim file allows you to specify how Neovim should behave. The look
and feel, keybindings, and plugins are all configured through this file.

Installing plugins using Vim-Plug

A way to install plugins in Neovim is through a plugin manager. There exists many plugin managers for you to choose. Here is some examples; Vim-Plug, Pathogen, Vundle, etc. In this article, I'm going to use Vim-Plug since it's very easy to use and setup.

To install Vim-Plug for Neovim, please run the following command.

sh -c 'curl -fLo "${XDG_DATA_HOME:-$HOME/.local/share}"/nvim/site/autoload/plug.vim --create-dirs \
       https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim'

Neovim configuration file

After the installation completed, open init.vim and add the following snippet.

call plug#begin('~/.config/nvim/plugged')

" This is where you define your plugins.

call plug#end()

The snippet above make Vim-Plug scans for the defined plugins. Any defined plugins that don't exist in nvim/plugged directory will be download and install. To trigger the Vim-Plug installation, reload Neovim and type :PlugInstall.

Protips: If you're editing init.vim, save the file by running :w and then :source % to source the current file. After that you can call PlugInstall without needing to reload the Neovim process again.

Finding plugins

You can find any plugins for Vim on Vimawesome. When you select a plugin on Vimawesome, it'll show installation instruction for
any plugin manager.

For example, please see Fugitive.

Useful plugins I recommend.

I am going to list all the plugins I use and explain what they do in my Neovim configuration. The list is shown below.

NERDTree - File browsing
Plug 'scrooloose/nerdtree'
NERDTree Git Plugin - Git integration for NERDTree
Plug 'Xuyuanp/nerdtree-git-plugin'
Vim Devicons - Extend Vim to use beatiful icons
Plug 'ryanoasis/vim-devicons'
Syntastic - Syntax Checking
Plug 'scrooloose/syntastic'
Gitgutter - Show git diff in a file
Plug 'airblade/vim-gitgutter'
NERDCommenter - Add comment keybindings support
Plug 'scrooloose/nerdcommenter'
Vim Surround - Brackets wrapping
Plug 'tpope/vim-surround'
CTRL-P - File search
Plug 'ctrlpvim/ctrlp.vim'
Vim-Go - Go programming language support for Vim
Plug 'fatih/vim-go'
COC(Conquer Of Completion) - Syntax completion support
Plug 'neoclide/coc.nvim', {'branch': 'release'}
Colorschemes - Customize Vim colorscheme
Plug 'flazz/vim-colorschemes'
Vim-Javascript - Javascript support
Plug 'pangloss/vim-javascript'
Vim-Graphql - Graphql Sytax highlighting
Plug 'jparise/vim-graphql'
Indentline - Show indentation guide in Vim
Plug 'yggdroot/indentline'
FZF - FuzzyFinder support for Vim
Plug 'junegunn/fzf', { 'do': { -> fzf#install() } }
Plug 'junegunn/fzf.vim'
Fugitive - Git integration
Plug 'tpope/vim-fugitive'
Vim-Airline - Vim status bar customization
Plug 'vim-airline/vim-airline'
Undotree - Undo history
Plug 'mbbill/undotree'

My dot-file

For anyone who's looking for my dot-file. You can download it from this link.

Closing thoughts

In my opinion Neovim is not the thing that every developers should adopt. It is also not something that would instantly replace your current text editor. Honestly, I think the best text editor is not the fastest one or the one with the most plugins. The best text editor is the one that suits your workflow the most.

Neovim is one of those text editor that fits my workflow. It is fast, lightweight, and highly customizable. It is a little bit harder to learn at first because of its steep learning curve. But I assure you that it is worth learning and it will pay off a great prize!

How to persist and backup PostgreSQL Docker container.

Siraphob Kan — Thu, 25 Nov 2021 03:23:07 +0000

Introduction
Persisting database information with a mounted volume
Dumping and restoring database information

Introduction

Have you ever lose database information using a PostgreSQL docker container? We all know that we should never use a docker container to hold database data because when deleted, the data is gone with it, right? right???

OMG YOU DID.

And so did I. There was one time when I started learning how to use Docker containers. Docker containers are very handy and they are operating system independent. The world is covered with sunshine and rainbows. Shit happens when it comes to a database container.

At the time, I forgot to think about where the container holds its information. I was once use a postgresql container as a database instance for my application. Before deploying for production, I thought I should restart this once to refresh it. (Idk why but yea…) I typed docker-compose down followed with docker-compose up.

It was a good 1 minute of thinking that everything was ready for production and Imma leave and watch Netflix. And then, a panic comes in. I opened my application and found out that all my tables, all my configurations were gone into oblivion. The result was I had to reconfigure everything. Took me quite some time to get it working again. Good thing is at least it didn’t happen during production.

In this article, I will show you how to persist data of a postgresql docker container and how to restore them.

Persisting PostgreSQL database information with a mounted volume

We’ll first create our database using docker-compose. Please copy the following script into a docker-compose file then run docker-compose up.

version: '3.1'
services:
  db:
    image: postgres
    restart: always
    environment:
      POSTGRES_USER: myuser
      POSTGRES_PASSWORD: mypassword
      POSTGRES_DB: mydb
    volumes:
       - ./data:/var/lib/postgresql/data

Please notice on the volumes block. You can see that we mounted a volume data/ in the host machine to /var/lib/postgresql/data directory of the postgresql container. This is a necessary step to do in order to persist data on the host machine. Because when the container is deleted, this directory will continue to exist.

After you start the container, you’ll see a data/ directory showed up in your host machine. This directory is where all postgresql information is.

$ ll
total 16
drwxr-xr-x  3 siraphob-wsl-ubuntu siraphob-wsl-ubuntu 4096 Nov 21 16:29 ./
drwxr-xr-x  4 siraphob-wsl-ubuntu siraphob-wsl-ubuntu 4096 Nov 21 16:26 ../
drwx------ 19                 999 root                4096 Nov 21 16:29 data/                <-- HERE
-rw-r--r--  1 siraphob-wsl-ubuntu siraphob-wsl-ubuntu  232 Nov 21 16:28 docker-compose.yml

Let’s test that our theory is correct. Shell into the database container by running the following command.

$ docker exec -it <your-postgres-container-id> bash

Once you’re inside the container, run the following command to connect to the postgresql console.

$ psql -d mydb -U myuser

Let’s create a table and insert some data.

CREATE TABLE IF NOT EXISTS accounts (
    id serial PRIMARY KEY,
    username VARCHAR (255) UNIQUE NOT NULL
);
INSERT INTO accounts(username) VALUES ('rick'), ('morty') RETURNING *;

If you select rows from the table accounts, you’ll see the following result.

mydb=# select * from accounts;
  1 | rick
  2 | morty

After that, exit from the the container. And run docker-compose down to stop the container and remove it. Technically, everything should be gone. But as you can see that the data/ directory still persists.

# stop and remove container
$ docker-compose down
Stopping pg-persist-ex_db_1 ... done
Removing pg-persist-ex_db_1 ... done
Removing network pg-persist-ex_default
# container is gone
$ docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
# data directory still persists
$ ls
data  docker-compose.yml

Next, run docker-compose up again to start the database container. If you shell into the container and log in into the postgresql console. You can see that your table data isn’t lost.

mydb=# \dt
         List of relations
 Schema |   Name   | Type  | Owner
--------+----------+-------+--------
 public | accounts | table | myuser
(1 row)
mydb=# select * from accounts;
 id | username
----+----------
  1 | rick
  2 | morty
(2 rows)

And that’s how you persist database information of a docker-container.

Dumping and restoring PostgreSQL database information
Another way to backup database information is to dump it out. Database dump is an export utility that helps you export database meta-data and data rows into a file. The dump file could later be imported into a new database.

Dumping allows you to export only meta-data (schemas, tables, relationships) or both meta-data and data rows. In this case, I’m going to show you how to export all information from a database.

To backup your postgres database from a docker container, please run the following command.

$ docker exec -t <your-postgres-container-id> pg_dumpall -c -U postgres > dump_`date +%d-%m-%Y"_"%H_%M_%S`.sql

If you open the dump file, scroll down and you’ll see that it has our database information.

# file opened in vim
179 CREATE TABLE public.accounts (
180     id integer NOT NULL,
181     username character varying(255) NOT NULL
182 );
183
184
185 ALTER TABLE public.accounts OWNER TO myuser;
...
216 --
217 -- Data for Name: accounts; Type: TABLE DATA; Schema: public; Owner: myuser
218 --
219
220 COPY public.accounts (id, username) FROM stdin;
221 1   rick
222 2   morty
223 \.

If you want to restore database information from a dump file, please run the following command.

$ cat your_dump.sql | docker exec -i <your-postgres-container-id> psql -U myuser

You could try this on your own on a fresh postgres container to see the effect.

And that’s it for today. Now you’ll never lose your database information again. Happy coding!