More Linux

& after the command is for running it in the background. && lets you do something based on whether the previous command completed successfully || which is the logical or, and also ; which is just a separator which doesn't care what happend to the command before.

$ false || echo "Oops, fail"
Oops, fail

$ true || echo "Will not be printed"
$  

$ true && echo "Things went well"
Things went well

$ false && echo "Will not be printed"
$

$ false ; echo "This will always run"
This will always run

\ allows us to use the next line

$ uname \
> -r
4.4.0-18362-Microsoft

Why do we use ./ to execute a file in Linux?

Because the current directory isn't in your $PATH . This is mainly for security reasons.

Sourcing and Executing

source

source or . (with a space afterwards) will execute the file in the current environment. This explains why we source the ~/.bashrc file, so that it will export variables and alias in the current environment.

source foo.sh

or

. foo.sh

executing

to execute we do the following ./a.out. This is executed as a child process. Therefore when the child terminates the parent doesn't have access to the changes

./a.out

export

The export command provides the ability to update the current shell session about the change you made to the exported variable

export -p view all variables

export name[=value]

$ export -p | grep "EDITOR"
$ export EDITOR=/usr/bin/vim

$ echo $EDITOR
declare -x EDITOR="/usr/bin/vim"

Another cool thing we can do is instead of running each time our compiled program like this ./a.out we can do this (it may be dangerous, dont try this at home)

$ export PATH=$PATH:.
$ a.out
Hello world!

To export a function we use the -f flag like so: export -f foo

foo(){
        if git add *.cpp *.hpp makefile *.md ; then
            printf '\33[1;32mAdd\33[m:      \U00002714 \n'
            if git commit -m "$*"; then
                   printf '\33[1;32mCommit\33[m:    \U00002714 \n'
                   if git push ; then
                       printf '\33[1;32mAdd\33[m:       \U00002714 \n'
                       printf '\33[1;32mCommit\33[m:    \U00002714 \n'
                       printf '\33[1;32mPush\33[m:      \U0001F600 \n'
                else
                    printf 'commit:    \U0000E333 \n'
                fi
            else
                printf 'commit:    \U0000E333 \n'
            fi
        else
            printf 'add:    \U0000E333 \n'
        fi
        return
}

export -f foo

$ source script.sh
$ foo this is a new commit
Add:       ✔
Commit:    ✔
Push:      😀

To remove an exported variable we use unset:

unset variable_name

alias

Aliases are like custom shortcuts used to represent a command. They are only stored in the current shell instance and will not be saved later on. They instruct the shell to replace one string with another string while executing the commands.

Creating an alias

$ alias shortName="your custom command here"

example 1:

$ lh
lh: command not found
$ alias lh="ls -lh"
$ lh
total 0
drwxrwxrwx 1 nissan nissan 4.0K Mar 24 09:47 download_dir

example 2:

$ alias get7z="wget -O nissans_7z.exe https://www.7-zip.org/a/7z1900-x64.exe"
$ get7z && ls
nissans_7z.exe

example 3: start shortcutting everything. Imagine that instead of write git clone or git push we could do something like this

$ alias gc="git clone"
$ alias ga="git add *.cpp *.hpp makefile *.md"
$ alias gs="git status"
$ alias gcd="git checkout develop"
$ alias gcm="git checkout master"
$ alias gfast="git add *.cpp *.hpp makefile *.md && git commit -m \"fast commit\" && git push"

$ gfast
1 file changed, 2 deletions(-)
To https://github.com/NissanGoldberg/teaching_cpp.git

$ alias gfast="git add *.cpp *.hpp makefile *.md \
 && git commit -m \"fast commit\" \
 && git push && \
 echo -e  \
'add:    \U00002714  Pass \n\
commit: \U00002714  Pass \n\
push:   \U0001F600 Pass ' "

 $ gfast
1 file changed, 2 deletions(-)
To https://github.com/NissanGoldberg/teaching_cpp.git
add:    ✔  Pass
commit: ✔  Pass
push:   😀 Pass

Listing aliases

$ alias
...
alias la='ls -A'
alias ll='ls -alF'
alias ls='ls --color=auto'

Removing aliases

$ unalias alias_name

Creating Permanent Aliases and Variables

To permanently save our aliases we need to edit the ~/.bashrc file

Be very careful when editing this file!

Open the file,edit and save the file. Then type to execute the changes

source ~/.bashrc

source is the same as .

Also, If you want to put the environment for system-wide use you can do so with /etc/environment file. There you'll find a PATH variable. But it is more recommended and easy to just edit your .bashrc file.

Here is a list of some environment variables:

• $PATH- list of dirs your system looks for executable files

• $HOME

• $USER

Now if we edit and source our .bashrc file to include in a path lets called my_dir where the program is located and we have a program there called super_cool_program

# .bashrc file 
export PATH=$PATH:my_dir

we can do the following from any directory

$ super_cool_program
Hello world, I am now in control of your terminal, hahaha !!!

export/variables vs alias

One difference between the two is that aliases are only a shell feature, can only be used as the names of programs to run, i.e. as the first word in a command line. Environment variables (export) are inherited by all subprocesses/children (unless deliberately cleared).

foo="mkdir Directory"
echo $foo  # Prints "mkdir Directory"

alias bar="mkdir Directory"
echo bar  # Nothing gets expanded -- just "bar" is printed

cp

cp can copy files or folders. there are mainly 3 cases:

1. Two file names - copies one file to the next file

   $ ls
   a.txt
   
   $ cp Src_file Dest_file && ls
   a.txt b.txt

2. One or more arguments - copy file/s to directory

   $ ls
   a.txt  b.txt  new_dir
   
   $ cp a.txt b.txt new_dir && ls new_dir
   a.txt b.txt

   or

$ cp *.txt new_dir

1. Two directory names - copies all files of the source directory to the destination directory

   $ cp -R Src_directory Dest_directory

   the -R flag is to copy recursively

Flags

• -a : Preserve the specified attributes such as directory an file mode, ownership, timestamps, if possible additional attributes: context, links, xattr, all.

• -v : Verbose output.

• -r : Copy directories recursively.

• -i : Interactive, will ask if to overwrite

Instead of cp you can also use rsync

mv

mv can move files or rename them. there are mainly 2 cases:

Here we rename file

mv [file_name] [new_file_name]

Here we copy files to directory

mv [filename] [dest-dir]

Flags

• -n : prevent overwriting

• -i : Interactive, will ask if to overwrite

• -f : forcefully overwrite

• -u : move only when the file is newer

wget command

The wget command allows us to download files

Syntax: wget url

$ wget https://github.com/cpp-exercises/phonetic-search-a/blob/master/Demo.cpp
$ ls
Demo.cpp

Multiple files

wget url1 url2

flags

• -O (uppercase) : the output name of download. -O new_name

  $ wget -O nissans_7z.exe https://www.7-zip.org/a/7z1900-x64.exe 
  $ ls
  nissans_7z.exe

• -b : download in background. -b log_file_name

curl command

Very good at testing REST api and also downloads.

curl url_name

Will fetch the html page

flags

• -o,--output : the output name of download. -O new_name

  $ curl -o nissans_7z.exe https://www.7-zip.org/a/7z1900-x64.exe 
  $ ls
  nissans_7z.exe

download into specific folder

$ mkdir download_dir
$ curl -o download_dir/my_demo.cpp https://github.com/cpp-exercises/phonetic-search-a/blob/master/Demo.cpp
$ ls download_dir/  
my_demo.cpp

curl vs wget

• wget's major strong side compared to curl is its ability to download recursively.

• curl supports FTP, FTPS, HTTP, HTTPS, SCP, SFTP, TFTP, TELNET, DICT, LDAP, LDAPS, FILE, POP3, IMAP, SMTP, RTMP and RTSP.

• wget supports HTTP, HTTPS and FTP.

• curl builds and runs on more platforms than wget.

• curl offers upload and sending capabilities. wget only offers plain HTTP POST support.

  Credits

Benchmarking

The simple way to benchmark is to use the time command

$ time get7z
real    0m7.472s
user    0m0.031s
sys     0m0.094s

• real (wall clock time) is the time from start to finish of the call. It is the time from the moment you hit the Enter key until the moment the wget command is completed.

• user - amount of CPU time spent in user mode.

• system or sys - amount of CPU time spent in kernel mode

$ time ./a.out

More reliable benchmarking

Lets run a.out which will perfom a for loop 1 billion times

perf stat -r 10 -d <your app and arguments>

The -r 10 will run your app 10 times and do statistics over it. -d outputs some more data, such as cache misses.

Extreme benchmarking

sudo chrt -f 99 perf stat -ddd <benchmark>

sudo chrt -f 99 runs your benchmark in FIFO real-time class with priority 99, which makes your process the top priority process and avoids context switching

Compression and Archiving

• .tar : uncompressed archive file

• .zip : (usually) compressed archive file

• .gz : file (archive or not) compressed using gzip

gzip

Compression: gzip filname

$ gzip my_file.txt && ls
my_file.txt.gz

Decompress:

$ gunzip my_file.txt.gz && ls
my_file.txt

tar

if we have 2 files: file1.txt, file2.txt we can archive them like this

$ tar cvf my_new_archive.tar file1.txt file2.txt

or for all txt files

$ tar cvf my_new_archive.tar *.txt

Explanation: of cvf

c- means create

-v, --verbose - display output in terminal

f - file options

To extract

$ tar xvf my_new_archive.tar && ls
file1.txt
file2.txt

x - extract

Archiving and Compressing

$ tar cvzf files.tar.gz file*.txt
$ ls
file1.txt  file2.txt  file3.txt  files.tar.gz

-z, --gzip, --gunzip : This option tells tar to read or write archives through gzip. This option should be used, for example, when operating on files with the extension .tar.gz.

Decompressing

$ tar xvzf files.tar.gz
file1.txt
file2.txt
file3.txt