Prologue: edit, save and exit!

Edit a file with Vim:
1. vim <filename>
2. Press i
3. Make your changes

Saving in Vim:
1. Press ESC
2. Press :
3. Type w

Exit Vim:
1. Press ESC
2. Press :
3. Type q!

Introduction

When using Vim I often find myself trying to remember how to do various things: how do you comment on multiple lines of code? what’s the shortcut for undo? what was the command for setting line numbers? With this post, I’m trying to gather all this information in one place so I can easily find it at a later date and hope that it will be useful to you too.

Vim is a clone of Vi and stands for Vi IMproved. It was written by Bram Moolenaar and released to the public in 1991. Vi itself was written as a visual editor for the ex line editor which in turn was inspired by ed. Ed was the line editor on the Unix operating system.

You might be wondering what is a line editor and how is it different from a text editor?
A line editor is a limited text editor; limited in the sense that you edit the text but you don’t see the result immediately because there’s no monitor to output the text. It was used especially on teletypes (which are printers with keyboards) that had no video display and therefore no ability to interactively move a cursor or see the result of your editing, unlike a screen-based text editor.

Modes

Vim has several modes, in which characters that you type have different meanings.

• Normal

  • this is the default mode

  • can be accessed by pressing ESC or CTRL-[

  • characters typed in this mode have special meaning and are used for manipulating, searching and navigating within the text

• Insert

  • can be accessed by:

    • pressing i enters insert mode before the cursor

    • pressing I enters insert mode at the start of the current line

    • pressing a enters insert mode after the cursor

    • pressing A enters insert mode at the end of the current line

  • characters don’t have a special meaning in this mode; they appear as you type them

• Visual

  • can be accessed by pressing v and will also mark a selection start point

  • used for making text selections

  • useful for copy, paste, delete, replace operations

• Command

  • can be accessed by typing :

  • a prompt appears at the bottom of the window where you can input your commands

  • useful for things which can’t be done easily in the normal mode

• Replace

  • easily replace text by writing over it

  • from normal mode, position your cursor over the first character that you want to replace; press R and start typing your text; when done, press ESC

Navigation

Editing

Search

Useful commands

Find and replace
:%s/foo/bar/g
: enter command mode
% search across all lines (optional)
/foo search for “foo”
/bar replace with “bar”
/g global otherwise will execute only once per line

Show line number
:set number
: enter command mode
set builtin command
number option to be configured
There are a lot of options that can be configured. Please see https://www.shortcutfoo.com/blog/top-50-vim-configuration-options/ for a more complete list.

Comment / uncomment multiple lines
Comment:
Go to the first line you want to comment. Press CTRL-v and use the arrow key to select until the last line you want to comment. Press SHIFT-i and then write your comment character (# for Python, // for C, C++, etc.). Press ESC to exit visual mode.

Uncomment:
Go to the first line you want to uncomment. Press CTRL-v and use the arrow keys to select all the lines you want to uncomment. Press d to delete characters and then press ESC.

Customization

You can create a .vimrc file in your home directory and add various configuration options which will be applied to Vim.
For an example of what a vimrc file looks like, please see https://vim.fandom.com/wiki/Example_vimrc

Conclusion

Vim can be confusing if you’re used to text editors like nano, joe, notepad. I think it’s confusing because it has different modes which are specialized for different things. This is Vim’s greatest power and also its weakness because if you don’t take the time to get comfortable with this modes, you’ll be lost and frustrated.

I tried to summarize the most useful commands and shortcuts for making it easier to edit text in Vim. However, there’s a lot more power to Vim and several books have been written to show this like “Practical Vim” by Drew Neil, “Pro Vim” by Mark McDonnell, and others.

If you have any favorite shortcuts or snippets please let me know in the comments.
Thank you!

After searching all over the Internet and trying different solutions I finally found one that worked and I wanted to share it with you in case you find yourself in the same situation.

Note: before running the following command, please make sure you have a backup of your data!

Run this command in a terminal:

rm ~/.config/pulse/*

And restart your computer.

You should now have a working sound in Firefox.

ps aux | grep [process name]  # to get the process ID
cat /proc/[process ID]/environ | tr '\0' '\n'

What the above commands do, is:

• Get the id of a process by name

• print the contents of the “environ” file for that process

• print each environment variable on a new line; tr stands for “translate”

It starts with the SQL fundamentals and builds up all the way to window functions, views and query performance optimizations.

Although it isn’t free, I’ve learned a lot from finishing this course and I consider it is well worth the money.

Swave uses Web Audio APIs for visualizations, HTMLAudioElement for audio streaming and a Canvas element to draw the sound bars.

Live Demo: https://bogdan-cornianu.github.io/swave/examples/
Source code https://github.com/bogdan-cornianu/swave
NPM package https://www.npmjs.com/package/swave

When it comes to game design, there aren’t as many resources. In my opinion, one of the best book to learn about game design is “Level Up! The Guide to Great Video Game Design, 2nd Edition” by Scott Rogers.

The chapters in the book are called levels and as you progress through the book you level up, just like in a game. There are 18 levels and some bonus material. The bonus material contains, among others, a game design template, a list of mechanics and hazards, a list of game genres, a list of possible game environments.

You will learn why story is important for the gameplay, and how too much will ruin it. The game design document is an important part of the game design process and should be the first thing you do. You will learn about the three Cs: Character, Camera, Controls and how to best use each one of them to make a great game experience. For example, the way your hero looks, and everything he does is shaped by his personality. If your hero is funny, then his looks should reflect that. A very important advice in the book being, “Form follows function”.

Designing a game level is easy once you know how to create enemies, where to place them and how to guide the player. Power-ups will spice your gameplay, but you should use them wisely, they are more of a balancing act.

I recommend this book to anyone interested in creating video games or anyone who is curious about what goes into making a game. It is not a technical book, there are no code samples. The books isn’t meant for a specific game genre, it has a general approach and you’ll have to customize the solutions to your specific needs.

In my opinion the easiest way to start is by using “systemd-analyze” which is part of systemd.
Since version 15.04, Ubuntu has switched from upstart to systemd as the default system and service manager. Systemd is not something specific to Ubuntu, but rather an industry standard that other major distributions have adopted as well: Debian, Fedora and CentOS to name a few.
“systemd-analyze” gives us information about what programs are run on startup and how much time they need to start.

There are around a dozen options that we can use from systemd-analyze to see where the startup bottleneck is. But from a time perspective we’re only interested in a few of them (to see the rest of the options available you can run “man systemd-analyze” in a terminal):

The options that we are interested in are:

• plot

• time

• blame

• critical-chain

plot 

Outputs the svg code with all the started services, their dependencies and how long it took for them to start.

For a better visualization you can pipe the output to an svg file and then open it with an image viewer:

$ systemd-analyze plot > init.svg

You should be looking for long red bars. These bars represent the time it took for that process to start.

When opening the generated svg, you should see something similiar to

time

Shows the amount of time spent after the bootloader has given control to the kernel up until the userspace finished initialization.

$ systemd-analyze time
Startup finished in 7.541s (firmware) + 5.696s (loader) + 4.053s (kernel) + 8.206s (userspace) = 25.498sgraphical.target reached after 8.068s in userspace

The values in this example are for my laptop which has an i7 processor, 16GB of RAM and a 512GB SSD.
If you use an older system, you may not see the firmware data as this is available only for EFI/UEFI systems.
If a lot of time is spent in firmware, there might be an hardware issue.
Time in loader is the time needed by your bootloader, typically Grub. If a considerable amount of time is spent here it might mean that the bootloader can’t find some disks or maybe some kernel boot parameters are wrong.
Kernel time is used for loading drivers and other initializations. After the kernel finished its startup it will launch the init process (which usually has the id 1).
The init process, in our case is systemd and represents time spent in userspace.

blame

Displays an ordered list of services, from slowest to fastest.

$ systemd-analyze blame
6.272s NetworkManager-wait-online.service
          2.998s plymouth-quit-wait.service
           930ms dev-sda6.device
           795ms fwupd.service
           632ms snapd.service
           547ms motd-news.service
           449ms plymouth-start.service
           396ms NetworkManager.service
           325ms upower.service
           274ms systemd-logind.service

critical-chain

Similar to blame, but it takes into account dependencies between services. The slow starting services will be highlighted in red.

$ systemd-analyze critical-chain
The time after the unit is active or started is printed after the "@" character.
The time the unit takes to start is printed after the "+" character.

graphical.target @8.068s
└─multi-user.target @8.068s
  └─kerneloops.service @8.058s +10ms
    └─network-online.target @8.056s
      └─NetworkManager-wait-online.service @1.783s +6.272s
        └─NetworkManager.service @1.385s +396ms
          └─dbus.service @1.359s
            └─basic.target @1.356s
              └─sockets.target @1.356s
                └─snapd.socket @1.354s +2ms
                  └─sysinit.target @1.354s
                    └─systemd-timesyncd.service @1.137s +215ms
                      └─systemd-tmpfiles-setup.service @1.125s +9ms
                        └─local-fs.target @1.123s
                          └─run-snapd-ns-docker.mnt.mount @2.093s
                            └─run-snapd-ns.mount @1.818s
                              └─swap.target @262ms
                                └─swapfile.swap @157ms +104ms
                                  └─systemd-remount-fs.service @147ms +7ms
                                    └─systemd-journald.socket @140ms
                                      └─system.slice @139ms
                                        └─-.slice @137ms

By using all this information from systemd-analyze we can find out what is slowing the startup process. Once we know that, we can dig deeper and get to the root of the problem.

Swap is a special area on your computer, which the operating system can use as additional RAM.
Starting with Ubuntu 17.04, the swap partition was replaced by a swap file. The main advantage of the swap file is easy resizing.

Note: before running the following commands, please make sure you have a backup of your data!

In the following example, we’ll extend the swap space available in the /swapfile from 4 GB to 8 GB.

1. Turn off all swap processes

sudo swapoff -a

2. Resize the swap

sudo dd if=/dev/zero of=/swapfile bs=1G count=8

if = input file
of = output file
bs = block size
count = multiplier of blocks

3. Change permission

sudo chmod 600 /swapfile

4. Make the file usable as swap

sudo mkswap /swapfile

5. Activate the swap file

sudo swapon /swapfile

6. Edit /etc/fstab and add the new swapfile if it isn’t already there

/swapfile none swap sw 0 0

7. Check the amount of swap available

grep SwapTotal /proc/meminfo