Dpkg Primer(Using Basic commands of dpkg)

Debian is one of the earliest Linux distribution around. It caught the public's fancy because of the ease of installing and uninstalling applications on it. When many other linux distributions were bogged down in dependency hell, Debian users were shielded from these problems owing to Debian's superior package handling capablities using apt-get.

All Linux distributions which claim their roots in the Debian distribution use this versatile package manager. For the uninitiated, Debian uses the deb package format for bundling together files belonging to an application. You can look at it as something like a setup installer (Eg: Installshield) in windows counterpart.

Here I will explain how to go about using this package handling utility to get the results that you desire.

The first step needed to use apt-get to your advantage is including the necessary repositories. Repositories are merely collections of softwares which are stored in a public location on the internet. By including the web address of these repositories, you are directing apt-get to search these locations for the desired software. You use the /etc/apt/sources.list file to list the addresses of the repositories. It takes the following format:

deb  [web address] [distribution name][maincontribnon-free]

For example, in Ubuntu a debian based distribution, it could be something like this:

deb http://in.archive.ubuntu.com/ubuntu breezy main restrcted

You can add any repository you like. apt-get.org contains an excellent collection of repositories to suite all tastes.

Once you have set the repositories, the next step is to sync the local software database with the database on the repositories. This will cache a copy of the list of all the remotely available softwares to your machine. This is achieved by running the following command:

# apt-get update

An advantage of this is you now have the power to search for a particular program to see if it is available for your version of distribution using the apt-cache command. And you don't need a net connection to do this. For example,

# apt-cache search baseutils

... will tell me if the package baseutils is available in the repository or not by searching the locally cached copy of the database.

Once you have figured that the package (in our case baseutils) is available, then installing it is as simple as running the following command:

# apt-get install baseutils

The real power of apt-get is realised now. If the baseutils package depends on the availability of a version of the library say, "xyz1.5.6.so". Then apt-get will download the library (or package containing the library) from the net and install it before installing baseutils package. This is known as automatic dependency resolution.

And removing a package is as simple as running the command:

# apt-get remove baseutils

Get statistics about the packages available in the repositories by running the command :

# apt-cache stats
Total package names : 22502 (900k)
Normal packages: 17632
Pure virtual packages: 281
Single virtual packages: 1048
Mixed virtual packages: 172
Missing: 3369
...

To upgrade all the softwares on your system to the latest versions, do the following:

# apt-get upgrade

And finally the king of them all - upgrading the whole distribution to a new version can be done with the command:

# apt-get dist-upgrade

Saving valuable hard disk space

Each time you install an application using apt-get, the package is actually cached in a location on your hard disk. It is usually stored in the location /var/cache/apt/archives/ . Over a period of time, all the cached packages will eat up your valuable hard disk space. You can clear the cache and release hard disk space by using the following command:

# apt-get clean

You could also use autoclean where in, only those packages in the cache which are found useless or partially complete are deleted.

# apt-get autoclean

dpkg - The low level Package management utility

As I said earlier, Debian based distributions use the Deb package format. Usually normal users like you and me are shielded from handling individual deb packages. But if you fall into a situation where you have to install a deb package you use the dpkg utility.

Lets assume I have a deb package called gedit-2.12.1.deb and I want to install it on my machine. I do it using the following command:

# dpkg -i gedit-2.12.1.deb

To remove an installed package, run the command:

# dpkg -r gedit

The main thing to note above is I have used only the name of the program and not the version number while removing the software.

You may also use the --purge (-P) flag for removing software.

# dpkg -P gedit

This will remove gedit along with all its configuration files. Where as -r (--remove) does not delete the configuration files.

Now lets say I do not want to actually install a package but want to see the contents of a Deb package. This can be achieved using the -c flag:

# dpkg -c gedit-2.12.1.deb

To get more information about a package like the authors name,the year in which it was compiled and a short description of its use, you use the -I flag:

# dpkg -I gedit-2.12.1.deb

You can even use wild cards to list the packages on your machine. For example, to see all the gcc packages on your machine, do the following:

# dpkg -l gcc*

Desired=Unknown/Install/Remove/Purge/Hold
Status=Not/Installed/Config-files/Unpacked/Failed-config/.
/ Err?=(none)/Hold/Reinst-required/X=both-problems
/ Name            Version        Description
+++-===============-==============-========================
ii  gcc             4.0.1-3        The GNU C compiler
ii  gcc-3.3-base    3.3.6-8ubuntu1 The GNU Compiler Colletio
un  gcc-3.5         none          (no description available)
un  gcc-3.5-base    none          (no description available)
un  gcc-3.5-doc     none          (no description available)
ii  gcc-4.0         4.0.1-4ubuntu9 The GNU C compiler
...

In the above listing, the first 'i' denotes desired state which is install. The second 'i' denotes the actual state ie gcc is installed. The third column gives the error problems if any. The fourth, fifth and sixth column gives the name, version and description of the packages respectively. And gcc-3.5 is not installed on my machine. So the status is given as 'un' which is unknown not-installed.

To check if an individual package is installed, you use the status -s flag:

# dpkg -s gedit

Two days back, I installed beagle (a real time search tool based on Mono) on my machine. But I didn't have a clue about the location of the files as well as what files were installed along with beagle. That was when I used the -L option to get a list of all the files installed by the beagle package.

# dpkg -L beagle

Even better, you can combine the above command with grep to get a listing of all the html documentation of beagle.

# dpkg -L beagle | grep html$

These are just a small sample of the options you can use with dpkg utility. To know more about this tool, check its man page.

If you are alergic to excessive command line activities, then you may also use dselect which is a curses based menu driven front-end to the low level dpkg utility.

dpkg -S | --search filename-search-pattern ...
Search for a filename from installed packages. All standard shell wildchars can be used in the pattern.


dpkg -p|--print-avail package
Display details about package, as found in /var/lib/dpkg/available.


dpkg --update-avail | --merge-avail Packages-file
Update dpkg's and dselect's idea of which packages are available. With action --merge-avail, old information is combined with information from Packages-file. With action --update-avail, old information is replaced with the information in the Packages-file. The Packages-file distributed with Debian GNU/Linux is simply named Packages. dpkg keeps its record of available packages in /var/lib/dpkg/available.


dpkg -A | --record-avail package_file ...
Update dpkg and dselect's idea of which packages are available with information from the package package_file. If --recursive or -R option is specified, package_file must refer to a directory instead.


dpkg -l | --list package-name-pattern ...
List packages matching given pattern. If no package-name-pattern is given, list all packages in /var/lib/dpkg/available. Normal shell wildchars are allowed in package-name-pattern. (You will probably have to quote package-name-pattern to prevent the shell from performing filename expansion. For example, dpkg -l 'libc5*' will list all the package names starting with "libc5".)


dpkg -s | --status package-name ...
Report status of specified package. This just displays the entry in the installed package status database.


Get a list of everything you've installed?
dpkg -l '*'


List each available package whose name matches thunderbird.
# apt-cache pkgnames | grep thunderbird


"dpkg --force-help" is your friend.

Get to Know /etc/init.d Directory -- /etc/init.d/command {start|stop|restart|force-reload}

If you use Linux you most likely have heard of the init.d directory. But what exactly does this directory do? It ultimately does one thing but it does that one thing for your entire system, so init.d is very important. The init.d directory contains a number of start/stop scripts for various services on your system. Everything from acpid to x11-common is controlled from this directory. Of course it’s not exactly that simple.

If you look at the /etc directory you will find directories that are in the form rc#.d (Where # is a number reflects a specific initialization level – from 0 to 6). Within each of these directories is a number of other scripts that control processes. These scripts will either begin with a “K” or an “S”. All “K” scripts are run before “S” scripts. And depending upon where the scripts are located will determine when the scripts initiate. Between the directories the system services work together like a well-oiled machine. But there are times when you need to start or stop a process cleanly and without using the kill or killall commands. That is where the /etc/init.d directory comes in handy.

Now if you are using a distribution like Fedora you might find this directory in /etc/rc.d/init.d. Regardless of location, it serves the same purpose.

In order to control any of the scripts in init.d manually you have to have root (or sudo) access. Each script will be run as a command and the structure of the command will look like:

/etc/initi.d/command OPTION  --- [OPTION = {start|stop|restart|force-reload]

Where command is the actual command to run and OPTION can be one of the following:

start

stop

reload

restart

force-reload

Most often you will use either start, stop, or restart. So if you want to stop your network you can issue the command:

/etc/init.d/networking stop

Or if you make a change to your network and need to restart it, you could do so with the following command:

/etc/init.d/networking restart

Some of the more common init scripts in this directory are:

networking

samba

apache2

ftpd

sshd

dovecot

mysql

Of course there may be more often-used scripts in your directory – it depends upon what you have installed. The above list was taken from a Ubuntu Server 8.10 installation so a standard desktop installation would have a few less networking-type scripts.

But what about /etc/rc.local

There is a third option that I used to use quite a bit. This option is the /etc/rc.local script. This file runs after all other init level scripts have run, so it’s safe to put various commands that you want to have issued upon startup. Many times I will place mounting instructions for things like nfs in this script. This is also a good place to place “troubleshooting” scripts in. For instance, once I had a machine that, for some reason, samba seemed to not want to start. Even afer checking to make sure the Samba daemon was setup to initialize at boot up. So instead of spending all of my time up front with this I simply placed the line:

/etc/init.d/samba start

in the /etc/rc.local script and Samba worked like a charm. Eventually I would come back and trouble shoot this issue.

Linux is flexible. Linux is so flexible there is almost, inevitably, numerous ways to solve a single problem. Starting a system service is one such issue. With the help of the /etc/init.d system (as well as /etc/rc.local) you can pretty much rest assured your service will start.

chkconfig --  chkconfig  allows the checking of the startup level of services and gives the ability to set the service. Running ‘chkconfig’ will setup the scripts in the needed “rcX.d” directory.

/sbin/service “stop|start|restart|etc”

this command is the equiv of typing “/etc/init.d/ command   “stop|start|restart|etc”

In order to whether a particular process is running or not type  ps -fu root | grep daemonname

ps -fu root | grep cupsd

sudo /etc/init.d/cups stop

If cups  daemon is not running you'll get the appropriate message from this command.

Indian Railways Reservation Against Cancellation(RAC), Wait List(WL), Confirm(CNF) what does these words mean??

WL = Waitlist
RAC = Reservation against cancellation
CNF  = Confirmed Reservation.

An RAC ticket gets you on the train but a  WL ticket doesn’t,

but there’s a chance you could end up with just a seat for RAC

A berth is split into 2 seats for 2 RAC ticket holders, if there are any last minute cancellations then an RAC ticket holder is given the empty berth.

the other RAC ticket holder can then convert the 2 seats into a berth.

RAC tickets are only issued for 

2-tier air condn (4 seats per carriage),

 3-tier air condn (6 seats per carriage), 

on air condn First Class (4 seats per carriage), 

and non air con Sleeper Class (up to 12 seats per carriage).

Lets assume you have reserved a ticket at a WL 10.

Tickets will be sold in the following order....(4 RAC places in this example)

1. Available 02
2. Available 01
3. RAC 01
4. RAC 02
5. RAC 03
6. RAC 04
7. WL 01
8. WL 02

WL 10/WL 4 means that you join the waitlist at position 10, but due to cancellations (before you bought the ticket) you have already moved to waitlist position 4

If there are still another 3 cancellations then your new waiting position would be WL 10/WL 1.

If there are another 3 cancellations  then your status would be WL 10/RAC 2, 

further 2 more cancellations would take you to WL 10/CNF (confirmed reservation).

Note:-

WL 10/WL 4 = is still a waitlisted ticket, you can’t board the train with a waitlisted ticket.

WL 10/RAC 2 = is an RAC ticket, you can board the train with an RAC ticket but you may only get a seat instead of a berth. (more later)

WL 10/CNF = is a confirmed ticket, you can board the train with a confirmed ticket and find your berth.

Stop,Start,Restarting CUPS after any changes in UBUNTU and DEBIAN Based Systems

hp-setup

sudo apt-get install hplip-cups

Printing

1. Restart the cups system to see the new hpoj service by running

sudo /etc/init.d/cupsys restart

sudo /etc/init.d/cupsys stop
sudo /etc/init.d/cupsys start

Git Essestials

Git Commands

------------

git clone

  clone the repository specified by ; this is similar to "checkout" in

  some other version control systems such as Subversion and CVS

Add colors to your ~/.gitconfig file:

  [color]

    ui = auto

  [color "branch"]

    current = yellow reverse

    local = yellow

    remote = green

  [color "diff"]

    meta = yellow bold

    frag = magenta bold

    old = red bold

    new = green bold

  [color "status"]

    added = yellow

    changed = green

    untracked = cyan

Highlight whitespace in diffs

  [color]

    ui = true

  [color "diff"]

    whitespace = red reverse

  [core]

    whitespace=fix,-indent-with-non-tab,trailing-space,cr-at-eol

Add aliases to your ~/.gitconfig file:

  [alias]

    st = status

    ci = commit

    br = branch

    co = checkout

    df = diff

    lg = log -p

    lol = log --graph --decorate --pretty=oneline --abbrev-commit

    lola = log --graph --decorate --pretty=oneline --abbrev-commit --all

    ls = ls-files

Configuration

-------------

git config -e [--global]

  edit the .git/config [or ~/.gitconfig] file in your $EDITOR

git config --global user.name 'John Doe'

git config --global user.email johndoe@example.com

  sets your name and email for commit messages

git config branch.autosetupmerge true

  tells git-branch and git-checkout to setup new branches so that git-pull(1)

  will appropriately merge from that remote branch.  Recommended.  Without this,

  you will have to add --track to your branch command or manually merge remote

  tracking branches with "fetch" and then "merge".

git config core.autocrlf true

  This setting tells git to convert the newlines to the system’s standard

  when checking out files, and to LF newlines when committing in

You can add "--global" after "git config" to any of these commands to make it

apply to all git repos (writes to ~/.gitconfig).

Info

----

git reflog 

  Use this to recover from *major* fuck ups! It's basically a log of the

  last few actions and you might have luck and find old commits that

  have been lost by doing a complex merge.

git diff

  show a diff of the changes made since your last commit

  to diff one file: "git diff -- "

  to show a diff between staging area and HEAD: `git diff --cached`

git status

  show files added to the staging area, files with changes, and untracked files

git log

  show recent commits, most recent on top. Useful options:

  --color       with color

  --graph       with an ASCII-art commit graph on the left

  --decorate    with branch and tag names on appropriate commits

  --stat        with stats (files changed, insertions, and deletions)

  -p            with full diffs

  --author=foo  only by a certain author

  --after="MMM DD YYYY" ex. ("Jun 20 2008") only commits after a certain date

  --before="MMM DD YYYY" only commits that occur before a certain date

  --merge       only the commits involved in the current merge conflicts

git log ..

  show commits between the specified range. Useful for seeing changes from

  remotes:

  git log HEAD..origin/master # after git remote update

git show

  show the changeset (diff) of a commit specified by , which can be any

  SHA1 commit ID, branch name, or tag (shows the last commit (HEAD) by default)

git show --name-only

  show only the names of the files that changed, no diff information.

git blame

  show who authored each line in

git blame

  show who authored each line in as of (allows blame to go back in

  time)

git gui blame

  really nice GUI interface to git blame

git whatchanged

  show only the commits which affected listing the most recent first

  E.g. view all changes made to a file on a branch:

    git whatchanged  | grep commit | \

         colrm 1 7 | xargs -I % git show %

  this could be combined with git remote show to find all changes on

  all branches to a particular file.

git diff head path/to/fubar

  show the diff between a file on the current branch and potentially another

  branch

git diff head --

  use this form when doing git diff on cherry-pick'ed (but not committed)

  changes

  somehow changes are not shown when using just git diff.

git ls-files

  list all files in the index and under version control.

git ls-remote [HEAD]

  show the current version on the remote repo. This can be used to check whether

  a local is required by comparing the local head revision.

Adding / Deleting

-----------------

git add ...

  add , , etc... to the project

git add

  add all files under directory

to the project, including subdirectories

git add .

  add all files under the current directory to the project

  *WARNING*: including untracked files.

git rm ...

  remove , , etc... from the project

git rm $(git ls-files --deleted)

  remove all deleted files from the project

git rm --cached ...

  commits absence of , , etc... from the project

Ignoring

---------

Option 1:

Edit $GIT_DIR/info/exclude. See Environment Variables below for explanation on

$GIT_DIR.

Option 2:

Add a file .gitignore to the root of your project. This file will be checked in.

Either way you need to add patterns to exclude to these files.

Staging

-------

git add ...

git stage ...

  add changes in , ... to the staging area (to be included in

  the next commit

git add -p

git stage --patch

  interactively walk through the current changes (hunks) in the working

  tree, and decide which changes to add to the staging area.

git add -i

git stage --interactive

  interactively add files/changes to the staging area. For a simpler

  mode (no menu), try `git add --patch` (above)

Unstaging

---------

git reset HEAD ...

  remove the specified files from the next commit

Committing

----------

git commit ... [-m ]

  commit , , etc..., optionally using commit message ,

  otherwise opening your editor to let you type a commit message

git commit -a

  commit all files changed since your last commit

  (does not include new (untracked) files)

git commit -v

  commit verbosely, i.e. includes the diff of the contents being committed in

  the commit message screen

git commit --amend

  edit the commit message of the most recent commit

git commit --amend ...

  redo previous commit, including changes made to , , etc...

Branching

---------

git branch

  list all local branches

git branch -r

  list all remote branches

git branch -a

  list all local and remote branches

git branch

  create a new branch named , referencing the same point in history as

  the current branch

git branch

  create a new branch named , referencing , which may be

  specified any way you like, including using a branch name or a tag name

git push :refs/heads/

  create a new remote branch named , referencing on the

  remote.

  Example: git push origin origin:refs/heads/branch-1

  Example: git push origin origin/branch-1:refs/heads/branch-2

git branch --track

  create a tracking branch. Will push/pull changes to/from another repository.

  Example: git branch --track experimental origin/experimental

git branch -d

  delete the branch ; if the branch you are deleting points to a 

  commit which is not reachable from the current branch, this command 

  will fail with a warning.

git branch -r -d

  delete a remote-tracking branch.

  Example: git branch -r -d wycats/master

git branch -D

  even if the branch points to a commit not reachable from the current branch,

  you may know that that commit is still reachable from some other branch or

  tag. In that case it is safe to use this command to force git to delete the

  branch.

git checkout

  make the current branch , updating the working directory to reflect

  the version referenced by

git checkout -b

  create a new branch referencing , and check it out.

git push :

  removes a branch from a remote repository.

  Example: git push origin :old_branch_to_be_deleted

git co

  Checkout a file from another branch and add it to this branch. File

  will still need to be added to the git branch, but it's present.

  Eg. git co remote_at_origin__tick702_antifraud_blocking

  ..../...nt_elements_for_iframe_blocked_page.rb

git show --

  Eg. git show remote_tick702 -- path/to/fubar.txt

  show the contents of a file that was created on another branch and that 

  does not exist on the current branch.

git show :

  Show the contents of a file at the specific revision. Note: path has to be

  absolute within the repo.

Merging

-------

git merge

  merge branch into the current branch; this command is idempotent

  and can be run as many times as needed to keep the current branch 

  up-to-date with changes in

git merge --no-commit

  merge branch into the current branch, but do not autocommit the

  result; allows you to make further tweaks

git merge -s ours

  merge branch into the current branch, but drops any changes in

  , using the current tree as the new tree

Cherry-Picking

--------------

git cherry-pick [--edit] [-n] [-m parent-number] [-s] [-x]

  selectively merge a single commit from another local branch

  Example: git cherry-pick 7300a6130d9447e18a931e898b64eefedea19544

Squashing

---------

WARNING: "git rebase" changes history. Be careful. Google it.

git rebase --interactive HEAD~10

  (then change all but the first "pick" to "squash")

  squash the last 10 commits into one big commit

Conflicts

---------

git mergetool

  work through conflicted files by opening them in your mergetool (opendiff,

  kdiff3, etc.) and choosing left/right chunks. The merged result is staged for

  commit.

For binary files or if mergetool won't do, resolve the conflict(s) manually 

and then do:

  git add [ ...]

Once all conflicts are resolved and staged, commit the pending merge with:

  git commit

Sharing

-------

git fetch

  update the remote-tracking branches for (defaults to "origin").

  Does not initiate a merge into the current branch (see "git pull" below).

git pull

  fetch changes from the server, and merge them into the current branch.

  Note: .git/config must have a [branch "some_name"] section for the current

  branch, to know which remote-tracking branch to merge into the current

  branch.  Git 1.5.3 and above adds this automatically.

git push

  update the server with your commits across all branches that are *COMMON*

  between your local copy and the server.  Local branches that were never 

  pushed to the server in the first place are not shared.

git push origin

  update the server with your commits made to since your last push.

  This is always *required* for new branches that you wish to share. After 

  the first explicit push, "git push" by itself is sufficient.

git push origin :refs/heads/

  E.g. git push origin twitter-experiment:refs/heads/twitter-experiment

  Which, in fact, is the same as git push origin but a little

  more obvious what is happening.

  

Reverting

---------

git revert

  reverse commit specified by and commit the result.  This does *not* do

  the same thing as similarly named commands in other VCS's such as "svn 

  revert" or "bzr revert", see below

git checkout

  re-checkout , overwriting any local changes

git checkout .

  re-checkout all files, overwriting any local changes.  This is most similar 

  to "svn revert" if you're used to Subversion commands

Fix mistakes / Undo

-------------------

git reset --hard

  abandon everything since your last commit; this command can be DANGEROUS.

  If merging has resulted in conflicts and you'd like to just forget about

  the merge, this command will do that.

git reset --hard ORIG_HEAD

  undo your most recent *successful* merge *and* any changes that occurred

  after.  Useful for forgetting about the merge you just did.  If there are

  conflicts (the merge was not successful), use "git reset --hard" (above)

  instead.

git reset --soft HEAD^

  forgot something in your last commit? That's easy to fix. Undo your last

  commit, but keep the changes in the staging area for editing.

git commit --amend

  redo previous commit, including changes you've staged in the meantime.

  Also used to edit commit message of previous commit.

Plumbing

--------

test = $(git merge-base )

  determine if merging sha1-B into sha1-A is achievable as a fast forward;

  non-zero exit status is false.

Stashing

--------

git stash

git stash save

  save your local modifications to a new stash (so you can for example

  "git svn rebase" or "git pull")

git stash apply

  restore the changes recorded in the stash on top of the current working tree

  state

git stash pop

  restore the changes from the most recent stash, and remove it from the stack

  of stashed changes

git stash list

  list all current stashes

git stash show -p

  show the contents of a stash - accepts all diff args

git stash drop []

  delete the stash

git stash clear

  delete all current stashes

Remotes

-------

git remote add

  adds a remote repository to your git config.  Can be then fetched locally.

  Example:

    git remote add coreteam git://github.com/wycats/merb-plugins.git

    git fetch coreteam

git push :refs/heads/

  delete a branch in a remote repository

git push :refs/heads/

  create a branch on a remote repository

  Example: git push origin origin:refs/heads/new_feature_name

git push +:

  replace a branch with

  think twice before do this

  Example: git push origin +master:my_branch

git remote prune

  prune deleted remote-tracking branches from "git branch -r" listing

git remote add -t master -m master origin git://example.com/git.git/

  add a remote and track its master

git remote show

  show information about the remote server.

git checkout -b /

  Eg git checkout -b myfeature origin/myfeature

  Track a remote branch as a local branch.

  

git pull

git push

  For branches that are remotely tracked (via git push) but

  that complain about non-fast forward commits when doing a 

  git push. The pull synchronizes local and remote, and if 

  all goes well, the result is pushable.

Submodules

----------

git submodule add

  add the given repository at the given path. The addition will be part of the

  next commit.

git submodule update [--init]

  Update the registered submodules (clone missing submodules, and checkout

  the commit specified by the super-repo). --init is needed the first time.

git submodule foreach

  Executes the given command within each checked out submodule.

Remove submodules

   1. Delete the relevant line from the .gitmodules file.

   2. Delete the relevant section from .git/config.

   3. Run git rm --cached path_to_submodule (no trailing slash).

   4. Commit and delete the now untracked submodule files. 

Patches

-------

git format-patch HEAD^

  Generate the last commit as a patch that can be applied on another

  clone (or branch) using 'git am'. Format patch can also generate a

  patch for all commits using 'git format-patch HEAD^ HEAD'

  All page files will be enumerated with a prefix, e.g. 0001 is the

  first patch.

git am

  Applies the patch file generated by format-patch.

git diff --no-prefix > patchfile

  Generates a patch file that can be applied using patch:

    patch -p0 < patchfile

  Useful for sharing changes without generating a git commit.

Git Instaweb

------------

git instaweb --httpd=webrick [--start | --stop | --restart]

Environment Variables

---------------------

GIT_AUTHOR_NAME, GIT_COMMITTER_NAME

  Your full name to be recorded in any newly created commits.  Overrides

  user.name in .git/config

GIT_AUTHOR_EMAIL, GIT_COMMITTER_EMAIL

  Your email address to be recorded in any newly created commits.  Overrides

  user.email in .git/config

GIT_DIR

  Location of the repository to use (for out of working directory repositories)

GIT_WORKING_TREE

  Location of the Working Directory - use with GIT_DIR to specifiy the working

  directory root

  or to work without being in the working directory at all.

Linking with the library: cc -o executable-name prog.c libctest.a cc -o executable-name prog.c -L/path/to/library-directory -lctest

Linking with a library in Qt


  LIBS+=  -L/path/to/library-directory -lnameoflibrary

installing gparted(Gnome Partition Editor) and formatting USB on Ubuntu

 launch a terminal and type

sudo apt-get install gparted


(Above step requires Administrator privileges)



open terminal and type gparted or go to  System->Administration->Partition Editor


Right-click on the device in the GParted window.


then click "Unmount." 


Right-click on the device (after it is unmounted) and then hover over "Format to."


Select the desired file system type (RiserFS, linux-swap, Ext 2/3 or FAT16/32).


click "Apply".


Flash drive is formatted. 


To mount the flash drive, unplug it and then plug it back in.