How to ignore files already added in your git repository without using .gitignore file

We will see how to ignore files that are already added previously to your git repository without using the .gitignore file. Use the following commands to achieve the same.

git rm --cached file_name_here
git commit -m "Your commit message here"

Now update your .git/info/exclude file to not show the changes in your file_name_here file.

Open .git/info/exclude and add file_name_here entry there to start ignoring the file.

Have a good day! ūüôā

How to ignore new files or folders without .gitignore

There’s a simple way to ignore files/folders to stop showing up in your git status. Please remember these are the “new” files and folders that we will ignore from git and not the files/folders that have already been added and are existing in your git repo.

Add them in the .git/info/exclude file.

Let’s exclude a file random.txt which is in your root folder where you have the .git file, without using .gitignore.

Open .git/info/exclude and enter random.txt

Now, let’s exclude a sub_folder.

Open .git/info/exclude and enter sub_folder_name.

And that’s how we can use .git/info/exclude file for ignoring in git.

That’s all for today!

Happy Git-ing!

Rename Local and Remote Git branch

Today we’ll go through a few of the very simple steps to rename Git branches which maybe present locally or on a remote server.

We will use the below command to rename branches:

git branch

Rename Local git branch

To rename the currently active (the one on which you are currently on, and the one which HEAD ref is pointing to) local branch.

git branch -m <new_name_for_current_branch>

To rename another branch than your current one

git branch -m <old_branch_name> <new_branch_name>

Now, if you have pushed the branch to remote server. You can do the following:

// Delete the old branch from remote server
git push origin :<old_branch_name>
// Push new branch to remote server
git push -u <remote> <new_branch_name>

And, that’s it!

Happy Git-ing! ūüôā

Working with .screenrc file for a better screen experience

The .screenrc file resides in your home folder which is /home/<your_username>/.screenrc 

Opening multiple default screen windows when `screen` starts:

In this case 2 default windows with the first one at the bash prompt and the second one starting the python prompt.

Enter the following one after the other in your ~/.screenrc  

screen -t Shell 1 bash
screen -t Python 2 python

Selecting the 0th window on screen launch, if multiple windows open:

select 0

Go to the screen number mapped with that character:

Bind a character to the index of the screen window pane.

In this case bind character j to window index number 1 and so on. Use it by typing <Ctrl-a> j to go to Window pane 1.

bind j select 1
bind k select 2
bind l select 3

Bind v to vertical split of window and h to horizontal split of the window.

bind v split -v
bind h split -h

The above creates regions on your main window splitting it vertically like below.

And then the right half of the window further split horizontally like below.

If you wish to delete of kill the regions created by the vertical and horizontal split just type your main Command character and Shift+x like so. In this case the screen command character key is Ctrl-a and upper case x.

Ctrl-a X

Thanks for reading up until here. We’ll come back with more interesting stuff soon.

Happy screening…!

8 helpful uses of the netcat command on Linux

Netcat (nc) is often called the Swiss army knife of networking on Linux. Let us see a few important things that we can achieve with the nc command when we are tasked with networking on Linux.

Scan a local port number

Scanning a single port (In this case Port:80) on localhost with nc.

nc -vw1 80

Scan local port range

Scanning multiple ports (Ports:75-85) on localhost with nc.

nc -vw1 75-85

Scan a remote port

Scanning a particular port on a remote host with nc. For instance if you want to scan Port 80 of our website.

nc -vw1 80

Scan a remote port range

Scanning multiple ports on localhost with nc. For instance if you want to scan Port 75 to 85 of our website.

nc -vw1 75-85

Start a Server to listen on a local port

nc -l 4545

Simple one to one chat(data sending) client and server model

Create a Server and listen to a port on 1 computer

nc -l 4545

Connect to the port of that computer from a different computer/machine which acts as a Client (Or in this case, using my [same] machine but from another terminal instead)

nc 4545

Now you can start typing and press Enter in any of the 2 terminals, and see the data being sent to the other side.

Never end listening on a port as a Server

nc -kl 4545

Transfer Data

Start by using nc to listen on a specific port, with output captured into a file:

nc -l 4545 > icon_copied.png

Use a second machine (Or in this case, using my [same] machine but from another terminal), connect to the ip and port of the machine where the listening nc process is started, giving it the file to be sent:

nc 4545 < icon.png

Thanks for reading! Please do let us know if you have anything to share with us in the comment box section.

Happy Linux-ing! (Is that even a word? :wondering: )

Working with Python Virtual environment on Ubuntu

Virtual environment (virtualenv) helps us have different python versions & different python libraries and their versions installed on our system in isolated environment (environment in this case is basically a folder/directory) without affecting our global system python version & its libraries.

Installing python virtual environment is not too difficult on your system.
Just open the terminal ( Press ctrl+alt+t in Ubuntu. You may have to check the key combination for your distro) and fire the command

pip install virtualenv
this will install virtual environment on your system, and provide you with a virtualenv command
Now we can create a folder for your python projects,
which will give you an environment to work on,
isolated from the system.
Type this on your terminal
virtualenv my_virtual_env_folder_name
You can also provide a python version to use in your project like this:
virtualenv -p /usr/bin/python2.7 my_virtual_env_folder_name
If you check this folder, it should have a few directories like these:
(Note: `my_virtual_env_folder_name` in my case is `test`)
ls -lsh my_virtual_env_folder_name/
Enter into the folder,
cd my_virtual_env_folder_name
And activate the virtual environment.
source bin/activate
This will change your current python environment & set it to this folder `my_virtual_env_folder_name`
So now that we have activated the virtual environment, we can see it on the terminal.
This shows you that a virtual environment has been activated in the terminal,
by showing the name of the virtual environment, like this:
And now everything you install with `pip` or `easy_install` should be installed, in the
my_virtual_env_folder_name/lib/pythonX.X/site-packages folder
{X.X denotes a version of python, like, 2.7, 3.4 etc}
For eg.
pip install requests
pip install lxml
Those above 2 packges “requests” and “lxml” will be installed in the local environment and not the global site-packages and dist-packages folder, which can be found at these locations
So that’s how you work on isolated python environments.
To come out of the virtual environment, you can type deactivate on the terminal and exit it, like this
This will deactivate your python environment & set terminal to global default values.

Git aliases: Shortening Git commands

So today we’ll see, how we can shorten the long git commands,
which can help programmers save time and a few keystrokes while working with git.

So lets work with git a bit. (Git a bit. Lol :p, a rhyming scheme. Does that help me qualify to be a poet, song writer?, umm… a rapper maybe? Maybe i should write a rap on this, yo mayne…! )

We’ll see 2 ways of adding aliases to our git commands.

How to add aliases to git commands:

Way 1: Using the `git config` command

Use the git config command to do the same.

So lets add an alias to the status command of git as s

git config --global alias.s status

Lets add another for add

git config --global alias.a add

Another for  commit

git config --global commit

And another

git config --global alias.cim "commit -m"

Now, we can just fire the short commands instead of the long ones and see the result of the command
for eg. git status, we can write,

git s

Lets break down the above command & take a look at the options we passed:

config: This option tells git, that everything following should be treated as the configuration for git, and can be added in the .gitconfig (or .git/config file depending on other options) file.

–global: The `–global` option tells git to add the alias in your ‘.gitconfig’ which is in your home folder,
which will be treated as your global settings for all git repos on your system,
unless you have another .git/config file inside a particular repo, overriding the global .gitconfig.
Try using the `–global` option since it will help you keep the same aliases across all repositories on your system, if you have a number of them.
Without the `–global` option git will consider the local repository by default.
Caveat: If you already have the <short_name> as an alias to some other previsouly added command in the config,¬†the –global option will replace that previous one.

alias.<short_name> <git_command_name>: Tells git that <git_command_name> particular command will have <short_name> as its alias form.

Way 2: Using the .gitconfig file directly

If you see in the ~/.gitconfig (~ = your_home_folder which is, /home/<your_login_name>/.gitconfig ) file,
you will notice that the shortened commands have gotten added under the [alias] section
Like this:

So instead of firing a `git config` command, lets try adding, the aliases directly into this file.

Lets open the file,

vim ~/.gitconfig

go under the [alias] section & type

rl = reflog

& save it & the file now looks like this.

And now we can check the `reflog` command too, by typing

git rl

So, there we have it.
Let us know, if the above post was of any help to you.
Until later.

Oh ya! The complimentary rap i mentioned.

Rap starts…

Hey yo! Let me tell you a few things about git,
but i’ll teach you them, uh! bit by bit.
aye! but, bit by bit, is a 1 bit. (Suddenly, the rapper gets into Math/CS/Binary mode & talks about, Division/Binary division, as, bit by bit, bit_divided_by_bit, is 1bit/1bit is 0b0001/0b0001 = 0b0001 = 1),
oh my gosh!!! what is this sh*t??? (And.. the audience go…).


Working with Postgresql helper commands

Hi Friends,

So today we’ll try to learn a few things on PostgreSql and
see what exactly PostgreSql ‘Helper commands’ are.

Apart from the good old sql queries that you can certainly use,
PostgreSql also provides us with Helper commands which you can use
to fetch information from the PostgreSql DB.

You can fire the PostgreSql Helper commands from the PostgreSql command prompt.

So lets login into the PostgreSql command prompt.
psql is the command line utility you would need for this, so lets begin.

Open Terminal (`ctrl+alt+t` in Ubuntu, check for you particular distro)

psql -h <host_name> -p <port_number> -d <database_name> -U <db_user_name> -W

Type in your <db_password> in the password prompt.

So now since we have connected to out database, lets see a few commands.

Check for All the Databases on the server


Check for size and access privileges of a particular Database

\l+ <database_name>

List Tables in a DB


List Tables in a DB with Size


Details about a particular table

\dt+ <table_name>

Describe a Table in a DB

\d+ <table_name>

Describe table with size and description (with pg_catalog schema)

\dtS+ <table_name>

Change/connect/move to a different Database.

\c <new_database_name>

Will try to come up with more blog post where we can share our information with each other.

Please let us know if you have any comments about the blog in the comments section below or if there are any corrections you may have spotted and you would like us to make those corrections.

Thanks a lot for taking your time & stopping over at the blogpost.
Have a good day!

10 Simple ways to work with the `ls` command in Linux

So, today we’ll work with the `ls` command in Linux
& see how it can help us to know about directories & files on our system.

`ls` helps us list the contents of the directory/folder that we are currently in, or that we specify as a parameter to `ls`, and lets us understand about other details of the files/directories like, the permissions on them, owners/groups they belong to,
last modified times on them, their size with some other functionalities.

Listing names of the contents in the current folder


1.txt  b.b  bench  bench_apache  bench_nginx

Listing contents with summary (Name and size in Kilobytes)

  ls -s
  total 20
  0 1.txt  4 b.b  4 bench  4 bench_apache  4 bench_nginx  4

Listing contents with long list format (Name and size in Kilobytes)

ls -l

total 20
-rw-rw-r-- 1 ash ash    0 May 22 19:04 1.txt
drwxrwxr-x 2 ash ash 4096 May 29 00:03 b.b
drwxrwxr-x 3 ash ash 4096 May 22 19:30 bench
-rw-r--r-- 1 ash ash 1401 Mar 10  2014 bench_apache
-rw-r--r-- 1 ash ash 1401 Mar 10  2014 bench_nginx
-rwx------ 2 ash ash  243 Mar 10  2014

Listing in long listing & human readable format

ls -lh

-rw-rw-r-- 1 ash ash    0 May 22 19:04 1.txt
drwxrwxr-x 2 ash ash 4.0K May 29 00:03 b.b
drwxrwxr-x 3 ash ash 4.0K May 22 19:30 bench
-rw-r--r-- 1 ash ash 1.4K Mar 10  2014 bench_apache
-rw-r--r-- 1 ash ash 1.4K Mar 10  2014 bench_nginx
-rwx------ 2 ash ash  243 Mar 10  2014

Listing in long listing & human readable format

ls -lsh

total 20K
 0 -rw-rw-r-- 1 ash ash    0 May 22 19:04 1.txt
 4.0K drwxrwxr-x 2 ash ash 4.0K May 29 00:03 b.b
 4.0K drwxrwxr-x 3 ash ash 4.0K May 22 19:30 bench
 4.0K -rw-r--r-- 1 ash ash 1.4K Mar 10  2014 bench_apache
 4.0K -rw-r--r-- 1 ash ash 1.4K Mar 10  2014 bench_nginx
 4.0K -rwx------ 2 ash ash  243 Mar 10  2014

Ignoring files & only listing directories

ls -lI "*.*"

drwxrwxr-x 3 ash ash 4096 May 22 19:30 bench
-rw-r--r-- 1 ash ash 1401 Mar 10  2014 bench_apache
-rw-r--r-- 1 ash ash 1401 Mar 10  2014 bench_nginx

(Caveat: This will ignore any file/directory which contains a .(dot) in its name. Sometime, directories contain a dot in their name so they might get ignored as well so watch out, and sometimes, files do not contain a dot in their name).

Listing files and folders in the current directory {Having a dot (.) in their names}

ls *.*



List the files & folders in the current directory’s, & further files/folders inside the folders in current directory (to Depth 1)

ls *

1.txt  bench_apache  bench_nginx


 b  b.txt

List all files along with hidden files

ls -a

.  ..  1.txt  b.b  bench  bench_apache  bench_nginx  .hidden

List Files & Folder contents starting with a Name/Pattern/Alphabet

Eg. List all the files starting with the alphabet ‘b’ & folder contents starting with the alphabet ‘b’

ls b*

bench_apache  bench_nginx


 b  b.txt


A few things to do with screen command and screen session in Linux

Today we’ll try to see a few things we can do with the screen command.
If you wish to have multiple bash terminals running in the same terminal window
without creating multiple terminal windows or terminal tabs,
screen is the command you would want to aim at.

So let’s see what options does screen command gives us:

screen --help

And, we get the following details about the screen command.

Currently running screen sessions

screen -ls

Attaching a Detached screen sessions

If a screen session was detached from a bash terminal window,
and you wish your current bash window, to attach the that screen session process,
you can just type the following.

screen -r <process_id.your_screen_session_name>

You could also use only the your_screen_session_name without the process_id if the multiple screen sessions are named differently, like this:

screen -r <your_screen_session_name>

Detaching & Attaching an attached screen sessions

If you were disconnected from a screen session somehow, and the screen session never got detached,
you can detach it from the bash terminal where it is attached to, & attach it to your current bash terminal window,
and start working with it.

screen -D -r <process_id.your_screen_session_name>

Killing the whole screen session

To kill the whole screen session, type:

Ctrl-a \

To Kill a window in a screen session

Let’s start a screen session with total 3 windows created

screen -S Local_Server -t my_local_server_1

Type the following 2 times, to create 2 more screen windows:

Ctrl-a c

Now to kill a window in screen,  go to that window
Since you created 2 more screen window in the same bash terminal, by typing the above command 2 times.
You will now have total 3 windows listed, starting from the number 0 to 2, inside screen type:

Ctrl-a Shift-"

We can see 3 Windows like this

Press Enter to select the window with id 1.

Now fire this command to kill the window.

Ctrl-a k

Press y if asked for confirmation like, Really kill this window?

And your window id 1 should be gone from the list now.

To scroll up the window in screen

If a lot of output has been printed on your terminal while in a screen session,
and you would want to scroll up & see what got printed, you can type:

Ctrl-a Esc k

Ctrl-a: The escape character
Esc: The Escape key, to enter into scroll mode
k: To scroll up
Others you can use:
j: Scroll up
h: Move cursor towards left
l: Move cursor towards right
You could also use the arrow keys instead of, j,k,h,l.
Type Esc key once to exit scrolling.

Changing the escape character in screen from Ctrl-a to other

Open the ~/.screenrc file that you should be having in your home folder (/home/your_username/.screenrc), if you don’t then you can just create it.
Let’s change the escape character from Ctrl-a to Ctrl-z
Enter the following in your ~/.screenrc and save it.

escape ^zz

Now start screen & your escape key has been changed from Ctrl-a to Ctrl-z.