DEV Community: Stephan Bakkelund Valois

How Algorithms and Big O Notation Works. In An Understandable Manner.

Stephan Bakkelund Valois — Tue, 21 Jul 2020 11:35:20 +0000

Such scary words. It oozes math all over them…
This is probably what you’re thinking if you’re new to computer science and programming. But really, they aren’t that hard to grasp, once you understand the basics of them.

the Big-O is a way of figuring out how efficient an algorithm is. When you’re working on a big project with a huge database, making your code run as efficient as possible can save huge costs in the long run. You may ask — What is an algorithm?

Algorithms

You can think of an algorithm as a recipe. A set of instructions on how to complete a task. Imagine getting a glass of milk. The algorithm for doing such a task might look something like this:

Open cupboard
Get a glass from the cupboard
Close cupboard
Open fridge
Take the milk carton out of the fridge
Open milk carton
Pour milk into the glass
Close milk carton
Put milk carton back into the fridge
Close fridge

This is an algorithm. It explains every step of getting a glass of milk, assuming there are glasses in the cupboard, and milk in the fridge.

You might have heard about different search algorithms and such. They are also just instructions on how to search for something, within some data.

A very popular search algorithm is the binary search. It sounds very computery, but it’s actually an algorithm you’ve used many times throughout your life. The binary search basically splits the data in half, checks which side of the split the data you’re searching for is, and repeating the cycle until you found what you’re looking for.

Imagine you’re looking for Todd Jefferson’s phone number in the phone book. The phone book is going to be in alphabetical order, ordered by the last name. You wouldn’t look for Jefferson at page 1, where the last names begin with an A. You could turn to the next page, and repeat until you got to J. But you probably wouldn’t. Because it’s very ineffective, and this is something you just know unconsciously.

What you probably would be doing, is to go to somewhere in the middle. Maybe you end up at a page which shows last names beginning with M. Since you know J is before M, anything after M is useless information in this context. Now, you might try to split the phone book again. Maybe you’ll end up at F. And again, everything before F is useless information, since J is after F. We’ll loosely repeat this process until we find Tod Jeffersons phone number.

I say loosely, because your subconsciousness is incredible efficient in solving these types of math problems, and you might find it more efficient to turn the page to Tods phone number, if you know that would be more efficient than splitting the data again.

A computer doesn’t have subconsciousness. Nor does it have conscious. The computer is a loyal servant. It does exactly what you tell it to. No more, no less.

There are many pre-made algorithms, created by very smart people. These include ways of sorting data, moving data, manipulating strings and more. Very high-level languages (Python, Ruby, JavaScript etc) often come with predefined functions, or “wrappers” of these efficient algorithms, so that you don’t have to write them yourself.

Example in Python

list_of_numbers = [2, 1, 3, 5, 4]
list_of_numbers.sort()
print(list_of_numbers)

output: [1, 2, 3, 4, 5]

The sort function in python is actually a sorting algorithm called Timsort which you can read more about here: https://en.wikipedia.org/wiki/Timsort

The point in this example is to show you that this simple, short little function you append to your data, is actually an advanced sorting algorithm behind the scenes. Python takes all the hard stuff and puts it in a built in function for you to use.

Example in JavaScript
JavaScript comes with a prebuilt sorting function, which you append to a set of data. Consider this example:

let listOfNumbers = [2, 1, 3, 5, 4];
listOfNumbers.sort();
console.log(listOfNumbers);

output: [1, 2, 3, 4, 5]

JavaScript has the same built in sorting function as Python has. Which algorithm does JavaScript use? It actually depends on where you run your JavaScript code. Each browser is free to implement their own sorting algorithm. For instance, Google’s V8 JavaScript engine (Chrome, Node.js etc) also uses Timsort, while Mozilla Firefox uses merge sort.

In a lower level programming language like C, you wouldn’t have any of these high level functions. Everything has to be coded manually. If you want to sort data in C, you need to figure out how you want to sort the data. In other words — which algorithm you’d use to sort the data, and implement it programmatically.
To recap algorithms, it’s not a scary word. It’s just a recipe — a set of instructions on how to do a task. We are using algorithms consciously and subconsciously many times every day.

Big O Notation

The reason I included some info about algorithms, is because the Big O and algorithms go hand in hand. As noted earlier, Big O Notation is all about the efficiency of the algorithm.

You can put it this way:

How long does it take the computer to do a certain task
How much memory will the computer use while doing a certain task

The Big O always describes the worst case scenario of the efficiency of an algorithm. Let’s have a look at some common orders of growth.

O(1)
O(1) means constant. We use the number 1, to signalize a constant value. The number 1 will never change. 1 will always be 1.
It will always take the same amount of time to execute an O(1) operation.

Example, O(1):

myArray = [1, 2, 3]
myArray[1]

output: 2

In this example, we’re getting the value of the array at index 1. Since computers know the index of the arrays, searching up an index would be constant. It doesn’t matter how big the array is. It will take the same amount of time to look up an index whether the array consists of 3 elements, or 5000 elements.

O(n)
O(n) means linear time. You can think of the n as number of data. The time it takes to execute a O(n) operation depends on how much data we have. Let’s look at another example:

# PYTHON 
my_list = [1, 2, 3, 4, 5]
for number in my_list:
  print(number)

# JS 
const myArray = [1, 2, 3, 4, 5];
for(let i = 0; i < myArray.length; i++) {
  console.log(myArray[i]);
}

Both these snippets of code will produce the same outcome. It will spit out the content of the array. When we iterate over data like this. the size of the data will determine how long it will take to iterate over it.

An operation we do a lot of times, is to search through data. Let’s look at an example where we do a linear search through an array. How would this algorithm look like?

Loop over the array
Check value
Is the value the value I’m looking for?
If it is — perfect, we found our number. Exit program.
If not — go to next value and repeat stage 2.

In code:

# PYTHON
arr = [1, 2, 3, 4]
def search(arr, number):
  for i in range(len(arr)):
    if arr[i] == number:
      return print("Number is in array")
  return print("Number is not in array")
search(arr, 4)

output: Number is in array

# JS
const arr = [1, 2, 3, 4, 5];
const search = (arr, item) => {
  for(let i = 0; i < arr.length; i++) {
    if (arr[i] === item){
      return "Number is in array";
    }
  }
  return "Number is not in array";
}
search(arr, 6)

output: Number is not in array

In the best case, this algorithm is O(1). if the value we’re looking for is the first value in the array. But it might not be. And the array could be huge, with hundreds of values. In the worst case scenario, we would have to iterate through the whole array to find the value we’re looking for. This makes it O(n).

If you run two loops right after each other in the same scope, we’ll get a complexity O(2n), because we get n two times. In Big O Notation, we remove the constant. Which means, O(2n), O(3n) and on is still written as O(n)

O(n²)
What is this scary looking thing? It sure starting to look mathy now! That’s what I thought when I first saw this.

This complexity is close to O(n), but it’s a pretty bad operation. Which means, the computer will need to do a lot of calculations in an operation with big O of O(n²). Is this always bad? Should you never use algorithms with this order of growth? The short answer is — yes, you should not. You should figure out a different way of solving whatever you’re working on. The long answer is — it depends. There are times where these algorithms are the only ones that will work. And that’s ok. Just be aware of it, and try to come up with better ways of solving things.

Let’s look at an example, and figure out why O(n²) is so slow:

# PYTHON 
num_list = [1, 2, 3]
letter_list = ['a', 'b', 'c']

for number in num_list:
    print(number)
    for letter in letter_list:
        print(letter)

output: 1, a, b, c, 2, a, b, c, 3, a, b, c

# JS 
const numArr = [1, 2, 3];
const letterArr = ['a', 'b', 'c'];
for(let i = 0; i < numArr.length; i++){
  console.log(numArr[i]);
  for (let j = 0; j < letterArr.length; j++){
    console.log(letterArr[j]);
  };
};

output: 1, a, b, c, 2, a, b, c, 3, a, b, c

Here is a program that consists of two nested loops. At the outer loop first iteration, the whole inner loop runs. Looking at the example above, when the outer loop goes to 1, the inner loop has to do a complete iteration before the outer loop moves over to 2. This operation runs in quadratic time. If the array has 10 items, we have to print 100 times. If it has 1000 items, we have to print 1000000 times.

O(n²) might work for smaller programs and operations, but you can see how inefficient it would be when working on huge datasets.

O(log n)
This is probably the scariest of all the complexities. The O(log n) follows the logarithmic scale. It will perform better the more data it runs. On large datasets, this is the second best complexity, only beaten by O(1).

For example, when we perform a binary search, we will divide the data in two, and only work with the part where the data we search for probably is. We will continue to do this until we find, or don’t find our value

Let’s take a look at this chart. All the graphs should start to make sense, and they clearly visualize how efficient the different time complexities are. We are lucky to have such higher languages, that hides all this complicated stuff from us so that we can concentrate on building cool apps. However it’s still important to understand how it works under the hood.

Until next time
Stephan Bakkelund Valois

Beginning Vim (and using Vim in other text editors)

Stephan Bakkelund Valois — Sat, 04 Jul 2020 09:32:33 +0000

Today, I want to write a bit about Vim, using Vim keybindings. and why you should use switch to Vim keybindings if you’re not already using them.

Me, as well as many others started hearing about this arcane text editor when we first started learning programming. What is it with this 30 years old editor, that makes it so intriguing?

First of all, about all Linux servers have Vim installed. This means if you were to SSH into a server, you would probably use Vim to open and edit files containing text, be it regular text files, source code, or what have you.

A lot of people like the Vim editor because it’s very hackable. You can build a customized fully-fledged IDE just by installing a few Vim-addons.

Now, I don’t use Vim as my main text editor anymore. Like so many others, I made a switch to Visual Studio Code. And I can tell you, I would’ve never made the switch if it wasn’t for Vim keybindings.

That’s one of the dangers by learning Vim keybindings. They’re just so good, you never want to go back to the wrong way of editing text.

Now, you’ve probably heard that Vim is incredible hard. That’s a lie. You can do some pretty amazing, very advanced editing in Vim. This isn’t something you usually need to use all the time. The regular coding, day to day work doesn’t require incredible advanced Vim-skills. It will just be a bit different than what you’re used to.

If you are running Linux or Mac OS, you can fire up Vim by typing Vim in the terminal. If you’re on Windows, I recommend you install gVim from www.vim.org

Vim modes
Vim: Create new file, write , save, and close
Moving around in Vim
Let’s edit something
Visual Mode
Vim MISC
Vim in other text editors?
Closing thoughts

Vim Modes

Doing a quick google search shows us what we need to go over first. There are plenty of memes about quitting a Vim session out there. If you’re unfamiliar about how Vim works, it’s understandable. If you are familiar with it, you wouldn’t want it any other way. (Looking at you, Google Docs!)

Let’s try opening Vim. Open up a terminal window, and enter vim

~ % vim

The famous Vim start-page.

One of the main reasons people are actually googling how to exit Vim, is because they’re not familiar to Vim’s modular approach.
When you first start up Vim, you are in Normal Mode. Vim has multiple different modes, where the most important ones are Normal Mode, Insert Mode and Visual Mode.

Normal Mode overview

Normal Mode is used for navigating through the file and doing edits. If you try to enter text in Normal Mode, nothing will be printed out.
When programming, most of the time you spend in the text editor is spent editing and looking trough the code, not actually writing code. This is one of the reasons it makes perfect sense to have Normal Mode as Vim’s default mode.
You return to Normal Mode by pressing Esc on your keyboard.

Insert Mode overview

Insert Mode is used for inserting text into the document. It will behave as a regular text program. Which means you are also able to use backspace to delete text. If you have to delete more than a couple of characters, you should probably do that in Normal Mode. We’ll get back to that shortly!
You enter Insert Mode by pressing i on your keyboard.

Visual Mode overview

Visual Mode is used to highlight text, the same way you would do when you drag your mouse over a piece of text to copy it.
You enter Visual Mode by pressing shift+v or v on your keyboard.

Vim: Create new file, write , save, and close

Let’s see whats going on here.
From the terminal, I’m first opening Vim. I’m appending a -clean. This is just so that I’m able to show you Vim without any addons. My Vim has quite a few addons, which may take the focus off of the actual editor.

We can change from Normal Mode to Insert Mode by pressing the i key. Once pressed, Vim shows us that we’re currently in Insert Mode by displaying INSERT in the lower left corner.

Once we’re in Insert Mode, we can write text as usual. When we’re done writing text, we exit Insert Mode by pressing the ESC-key on our keyboard. Vim shows us that we’re currently in Normal Mode, by not displaying anything in the lower left corner.

Now comes an interesting part. To save the text as a new file, we use the write command. We type :w followed by whatever we want our file to be named. Once saved, we may exit Vim by using the quit command, :q

Note that if you try to exit Vim without saving your file, you’ll run into an error:

If you don’t want to save your work, just follow the instructions, and add a ! to override Vim’s safety net. :q!
Note that you can save and exit Vim by concatenating the commands:

:qw <filename>

or omit the filename if you’ve edited an already existing file

Moving around in Vim

You might think — What’s so special about this? We’re just using the arrow keys to move around. Well, not quite.

When using Vim, we should not use the arrow keys. We use the keys h, j, k and l instead.

h to move left
j to move down
k to move up
l to move right

Now, these are some weird keybindings! And I totally agree. This is probably one of the weirdest things about Vim. These keybindings are actually quite common in the terminal world. If you were to use less or more to look inside a file, you could use the same keybindings to scroll through it.

Here, we can see a couple of other commands for moving around. Let’s go through them:

e
When pressing the e key, we move to the end of the word, or the end of the next word, depending on where the cursor is.

b
When pressing the b key, we move to the start of the word, or the start of the previous word, depending on where the cursor is.

$
A dollar sign will move you all the way to the end of the line.

0
A zero will move you back, to the start of the line.

Number before a move command
If you write a number before the move command, Vim will execute the command the number of times you’ve entered.
If you type 10e, Vim will move 10 words ahead. If you type 3j, Vim will move down 3 lines.

gg
This command will move you to the start of the document.

Shift+g
This command will move you to the last line of the document.

Number + shift+G
Do you know which line number you’re moving to? Say you need to do some work at line 56. just type out 56, and press shift+G. Easy!

Let’s edit something

Editing is done in Normal Mode. We only enter Insert Mode to do small bursts of text insertions. There are an incredible amount of different commands for different edits. This topic goes so deep, entire books have been written on this subject. Let’s go through the ones I use the most throughout the day.

u
I wanted to show you this command first. This is equivalent to ctrl+z on Linux and Windows, and cmd+z on mac. Why it’s important is pretty self explanatory.

i
To enter Insert Mode, and start writing, we press i.

ctrl+r
Redo. Goes hand in hand with undo, or u.

daw
Stands for ‘delete a word’, and will delete the entire word.

ciw / caw
Stands for ‘change word’. the command deletes the word, and put you directly in Insert Mode. The difference between these commands, is that ciw will leave a space, while caw will will jump to the first character of the next word.

Try it yourself. Write out two words. Jump back to the first word, and try out both commands. Which one do you like best? If you ask me, ciw is the way to go. It might be one of the most useful commands in Vim.

cw
This command deletes a word from the cursor, which means everything before the cursor will be left alone.

CONSIDER THIS TEXT:
const newNumber;
CURSOR ON N:
const newNumber;
         ^
USE cw:
const new

As we can see from the example, the text got deleted at the cursor, and Vim put us in Insert Mode. as you may see, this makes for very quick text edits.

dd
This command will delete an entire line of text.

d$
This command will delete from the cursor, and to the end of the line.

d0
This command will delete from the cursor, and to the beginning of the line.

x
x will delete the character underneath the cursor.

di} di) di] di” di’
And so on, and so forth. These commands are very, very useful if you’re editing code. Think of it like this: ‘delete inside bracket’, ‘delete inside quotes’.

CONSIDER THIS MOCK VARIABLE
const variable = {...something, id: newId};
MOVE CURSOR SOMEWHERE INSIDE THE BRACKETS 
const variable = {...something, id: newIid};
                    ^
TYPE ci} 
const variable = {};

The example above works with all types of brackets, single and double quotes. It is an amazing way to delete inside, and makes for very efficient text editing.

yy
y stands for yank. This command will duplicate a whole line.

p
paste (put). If you use it after yy, you paste the line you just duplicated. This command also works with deletion of words. So if you need to delete a word and paste it in another place, you delete it, move the cursor to where you want to paste it in, and press p.

yw / yiw
Works the same as deleting words, except these commands will copy them. You may use p to paste them again.

o
o will enter Insert Mode on a new line, underneath the cursor.

O
O will enter Insert Mode on a new line, above the cursor.

r
replaces the character underneath the cursor.

.
This command will repeat the last change you’ve made.
Remember, you can always add numbers to a command, to make Vim repeat it.

Visual Mode

Visual Mode will let you highlight text, the same way you often do with your mouse. What’s nice about Visual Mode, is that it can very easily copy or delete big sections of text.
As far as I’m concerned, there are two main ways of entering Visual Mode, and they work a bit different:

v
v will enter Visual Mode from where the cursor is, and let you highlight text relative to the cursors position when you entered Visual Mode.

Note that it says ‘Visual’ instead of ‘Insert’, while in Visual Mode.

Shift + v
This will highlight line by line. This is a command I’m using all the time.
It makes it very easy to select chunks of text.

Vim MISC

We are getting near the end of this little Vim keybinding tutorial. There are a couple of other commands that I use frequently, that doesn’t belong in any of the sections above.

Search for text
In Normal Mode, there is a search function pretty similar to the one you you’re used to from web browsers, and such. By using a slash followed by the word you’re looking for, you’re able to search through the entire document, jumping from a matched word, to the next matched word.
/word-to-find

Replace all characters
Say you did a mistake. You’ve created a bad variable name, and you need to change it. However, you’ve used the variable name in 10 different places. It could potentially take some time to replace them all. Or, maybe there was an easy way to do this? Well, this is Vim. Of course there is an easy, yet arcane way to do it.

:s stands for substitute.

:s/old-word/new-word
This command will replace the old word, with the new word, on the line which the cursor is currently on.

:%s/old-word/new-word/g
Note the percent character. This command will replace every old word with the new word, throughout the entire document.

Vim in other text editors?

As I wrote a bit earlier in this post, I don’t use Vim text editor at the moment. I use Visual Studio Code. Before that, I used Atom. I’m lazy, and it’s a lot easier to use one of these big, new shiny toys than building and customizing my own. I can guarantee that if it wasn’t for Vim bindings, I wouldn’t have touched any of the new text editors. You see, after using Vim and Vim keybindings for a while, you will get so used to them, to a point where it’s nearly impossible not to use them.

You don’t need to set up Vim, if you don’t want to. Just enable Vim Mode in the text editor you’re currently using. All the commands I’ve showed you so far, works in all of them.

Closing thoughts

If you’ve read all the way to here, I’m pretty sure you will give these amazing keybindings a try. Or even have a shot at the real thing. There are so many plugins for Vim, you wouldn’t believe it. The text editor itself is also actively maintained. Not bad for a 30 years old piece of software!

If you’re touch typing (as you should!), you’ll notice that many of the commands are laid out very conveniently. This means you don't have to move your hands that much while editing text. You don’t need to use your mouse either. You can keep your fingers at the correct position. This can shave off some time you would have spent on moving your arm to your mouse, and moving your hand over to the arrow keys.

If you are serious about learning Vim, but find the standard commands hard to remember, why not learn it by playing a game? There is a game called Vim adventures, where.. Well, I won’t spoil anything. It’s pretty amazing. It does cost money for a premium version, but you can pick up quite a bit if you only want to do the free one. Check out https://vim-adventures.com/

There are an incredible amount of commands, and ways of combining commands. A lot more than what I’ve written about. Entire books have been written on the subject. This blog post barely scratches the surface of what’s possible with Vim commands. But to be honest, these are the commands I use the most, and I like to think about my self as a fairly efficient Vim user. If I need to create a special macro for some weird and clunky editing task, I can always google it.

I hope this have been informative and that you find it helpful
Until next time

Stephan Bakkelund Valois

Beginning Linux and Mac terminal

Stephan Bakkelund Valois — Mon, 22 Jun 2020 12:14:05 +0000

For the complete beginner, and for those who just need a quick refresh. If you use Linux as your primary OS, this blog post is probably not for you.

If you’re thinking about doing any sorts of computer programming, development, or working with servers, you probably should get used to working with in a terminal window. Even if you’re just tired of Windows, switching to Linux could be very good for you.

Now, if you want to work with Microsoft products, that might be a different story. I’m not too familiar with the .NET platform, so this post won’t touch on any of that.

There are an incredible amount of software out there, created to help programmers build cool stuff. Most of them are Command Line Applications. You do have some programs that comes with a GUI, but most of them started out, or also have a Command Line version of the application.

Most of the things you do in a GUI environment, you can do in a terminal. Be it working with files, downloading from the internet, writing, and so forth. This blog post focuses on the basic terminal commands. It won’t make you an expert, but it will allow you to navigate, and work in the terminal with confidence.

PS: If you don’t have access to a linux terminal, you can find many online terminals to play around with for free. For example https://cocalc.com/doc/terminal.html

ls

Short for list, this command lists all files and folders in a directory.

~ $ ls file.py ingredients.txt secret_folder

As we can see, our current directory consists of 3 items — 2 files and a super secret folder. we can have a peak into the folder from our current directory. Since the secret_folder is inside our current directory, we can use the ls command, followed by the folder name

~ $ ls secret_folder/ nintendo_cheat_codes.txt

Cool. the secret_folder contains a file. Now, how can we navigate into the folder?

cd

This command is short for change directory. At a basic level, you can use it the same way as ls. You enter cd, followed by the directory you want to navigate to

~ $ cd secret_folder/ ~/secret_folder $ ls nintendo_cheat_codes.txt

So we cd into the secret_folder directory, and run the command ls to list the files inside of the directory. What if we want to go back to the previous directory?

‘..’ and ‘.’

Dots? Well, yeah. Those dots have a special meaning in a terminal window. one dot means this current directory, while two dots means the parent directory, or the directory your current directory sits in. The two dots will help us navigating to the previous directory

~/secret_folder $ cd .. ~/ $ ls file.py ingredients.txt secret_folder

So now we know how to change directories, and how to list the files and folders inside of them. If you ask me, running these commands are a lot less work than physically moving your hand over to your computer mouse and clicking stuff!

pwd

So, how can we keep track on where we are, relative to the root? The pwd command is short for Print Working Directory and will show you exactly where you are.

~ $ pwd /home/myuser

mkdir

How can we create new folders? We can use the mkdir command, which stands for Make Directory. We type in the command, followed by the name of our new directory

~/ $ mkdir not_so_secret_folder ~/ $ ls file.py ingredients.txt not_so_secret_folder secret_folder

As we can see by listing the items in our current directory, our newly added directory got created.

touch

This command is probably the easiest way to create any file you want. You type in the command, followed by the filename WITH the file extension.

~/ $ touch new_file.txt ~/ $ ls new_file.txt

rm

If you want to remove files or folders, there are a couple of commands you can use. The easiest one is probably the command rm, which stands for Remove.

~/ $ ls new_file.txt ~/ $ rm new_file.txt ~/ $ ls

So if we list our files, we can see the file we just created with touch. By using rm, followed by the filename, we’ll delete the file. What about folders?

~/ $ mkdir to_be_deleted ~/ $ ls to_be_deleted ~/ $ rm to_be_deleted/ rm: cannot remove ‘to_be_deleted/’: Is a directory

We get an error. In linux, we are not able to delete directories! Well, that’s a lie. We just need to use a flag! What is a flag? A flag is a special command we put alongside the main command, to alter the way the main command executes. We won’t go through every type of flags in this post, but let's take a look at the flags we need to delete a directory

~/ $ ls to_be_deleted ~/ $ rm -r to_be_deleted/ ~/ $ ls ~/t $

The -r flag tells the rm command to delete the folder and all its content. It works like a little safety net. Deleted files are usually not recoverable. Sometimes, you might have problems deleting files because of file permissions and such. There is another flag you can use, but must always be used with extreme caution

rm -rf

This command works the same as the previous command, except it will delete everything, no questions asked. If you were to write rm -rf *, you could, in a worst case scenario, do extreme damage to your system. I wanted to put this in a separate section because of this. Don’t be afraid to use the command, however. I use it all the time. Just be sure you know what you’re deleting, you probably won’t be able to recover the files.

cp

Sometimes, you want to copy stuff from one place, to another. The command cp, short for copy will do just that!

~/ $ ls file.py ingredients.txt not_so_secret_folder secret_folder ~/ $ cp ingredients.txt not_so_secret_folder/ ~/ $ ls not_so_secret_folder/ ingredients.txt

So, we list our files, and decide to move the ingredient.txt file into our not so secret folder. we do this by using the cp command, followed by the path, or folder we want to move the file to.

mv

Now, we copied the file to the wrong directory! Do we have to delete it, and copy the file to the proper directory? That sounds like a lot of work! Well, we could use the mv command, short for Move. The way mv is used, is pretty similar to the cp command. we use mv, followed by the file that we’re moving, and its destination.

~/ $ mv not_so_secret_folder/ingredients.txt secret_folder/ ~/ $ ls not_so_secret_folder/ ~/ $ ls secret_folder/ ingredients.txt nintendo_cheat_codes.txt

So we gave the command two paths. The first path is to where the file is. The second path is where we want to put the file.

Rename files and folders?

Would you believe me if I told you that there are no command for renaming files and folders? It’s actually true. There is an easy way of doing it, however it does not have its own command. We need to use the previous command, the mv. What the command actually does, is delete the file, and recreate it at the chosen path. We can take advantage of this, and use it to give the file a new name.

~/ $ touch filr.txt ~/ $ ls filr.txt ~/ $ mv filr.txt file.txt ~/$ ls file.txt ~/ $

In this example, we created a new file, but made a nasty typo. No problem! We just used the mv command to rename the file to its proper name!

Tab button in the terminal

To save time, the tab button is amazing. It can work as an auto complete, and also as a lightweight ls, when used with other commands. Say you want to copy a file to a new directory, but you suddenly forgot the exact name of the directory. Let’s discuss two ways of using the tab button

~/ $ cp file.py ingredients.txt not_so_secret_folder/ secret_folder/

By writing cp followed by a space, and pressing tab twice, all the files in my current directory gets listed. Say we want to copy file.py into not_so_secret_folder. It was quite a long name, so we used the cp command to list the directory, and we start writing the name of the directory

~/ $ cp file.py no

We press tab once

~/ $ cp file.py not_so_secret_folder/

and the rest of the directory name gets autocompleted. The tab button is super useful for quick navigation through the file system.

cat

Not the cat as in the purring kitty, but short for concatenate. This command can do multiple operations. One of the most useful ones, is printing a file content to the terminal, in one quick motion.

~/ $ cat ingredients.txt 1 tbsp of something 2 cups of something else

we type cat, followed by the filename. The content of the filename gets printed to the terminal. This is a very quick way to peak inside the content of a file, without opening it up in any kind of software or text editor. (This is a side effect of the cat command. We won’t go over the concatenating part of the command in this blog post)

Text editors in terminal?

For editing text, there are a couple of editors that are pretty standard in every terminal you come across. Nano/Pico, and Vim/Vi. Nano is a simple text editor for manipulating and editing text. Vim is a workhorse (and my personal favorite) which, with some modifications, can do pretty much whatever you want it to do.

If you’ve never used Vim before, Nano is a whole lot easier. It will show you its commands in the lower part of the program, and you can navigate the text by using the arrow keys.

For Vim, it’s a whole different story. It comes with its own key bindings, it own way of doing.. Pretty much everything. I would definitely recommend learning it. However, once you learn how to use it, you will be annoyed that other writing softwares don’t use the same key bindings. I might write a beginner tutorial for Vim if anyone wants, however you’ll find tons of tutorials if you google it. Leave a comment if it sounds interesting.

Last words

These commands should get you up and running. There are a ton of other commands to pick up, but it should not be a problem once you learn the ones listed above.

If you don’t use any special Windows software, or play high end games, you might just migrate over to a more secure, and stable OS. Not to mention, most of the Linux distros are free. And most of the software that runs on Linux is free.

PS: If you like playing games, Steam supports a huge amount of games on Linux!

In dire need of Microsoft Office suite? You can use Google Suite or Libre Office. You need Photoshop? What about the free photo editor Gimp! You’ll most likely find a free, amazing replacement for all your Windows software.

Best Regards
Stephan Bakkelund Valois