Introduction to VIM Editor macros

Have you ever come across a situation where you have to type redundantly into files? For example, type a text repeatedly with changes related to numbers only (that increase sequentially). Definitely, it would be a highly mundane and unattractive task if we have to do it manually. So, there is an easy and interesting way out with the help of vim macros.

Recording

The concept is basically recording our single individual operation and repeat it as many times as we can, therefore automating the redundant ones. Here is how we do the recording in vim:

• Start the recording by pressing key ‘q’ followed by a character name register, the recording to be saved to, let us say ‘x’.
• Do the individual operation which has to be done within the loop.
• Stop the recording by again pressing ‘q’
• Run the recording ‘i’ number of times by typing in the format

                               i@x

where,

i => A number representing how many times to run the recording

x => Run the recording identified by this register

Coming back to our example, let us get our hands on to it.

We have a requirement to list down all addresses in a particular area, where all addresses are same except the house numbers which are sequentially increasing.

So, create a new file using Vim editor using following command

$vim addr

Now, follow these steps :

• Enter the insert mode(press i) and type the first address of the area,

                 house no. 300 santa clara, ca

• Come out of the insert mode (press escape key), and then start the recording. Press q following by a.
• Next, copy the current line and paste it to next line by pressing yy and then p.
• Navigate the cursor to the number on second line and press ctrl + a (ie hold ctrl and press a)to increment the number.
• Stop the recording by pressing q.
• Run the newly created recording 12 times by typing 12@a.

It is amazing to see how we see 12 lines of text addresses with sequential house numbers.

house no. 300 santa clara, ca

house no. 301 santa clara, ca

house no. 302 santa clara, ca

house no. 303 santa clara, ca

house no. 304 santa clara, ca

house no. 305 santa clara, ca

house no. 306 santa clara, ca

house no. 307 santa clara, ca

house no. 308 santa clara, ca

house no. 309 santa clara, ca

house no. 310 santa clara, ca

house no. 311 santa clara, ca

house no. 312 santa clara, ca

house no. 313 santa clara, ca

Similarly, we can do various similar tasks like typing redundant lines of text through the same way.

Further moving on to a next level, let’s say we have 1000 files and we want to convert the third line of every file with a text

I love macros

then on line number 5 type

Its awesome

Here are the steps to do this using our smart chap Vim “macro”.

• Open all files at once by vim * if all files are in the same directory OR vim <path of each file>.
• Press q and then x to start recording the macro in letter x.
• Go to line number 3. (ie Type :3 and press enter).
• To replace the text on this line press c + $. This is for changing everything from current cursor position till end of line.
• Now type I love macros and press escape to switch off the insert mode.
• To go to 5th line press the down arrow key twice. Remember you were at line number 3 at that time.
• Now again press c + $, type Its awesome and press escape to switch off insert mode.
• Now save these changes in current file and go to next file by typing :wn and press enter.
• These are the steps you want to perform so now save the macro by pressing “q”.
• If 1000 files were opened initially type 999 @x

This is superb, isn’t it? The usage of macros and creativity to use them are unlimited and extends with your imagination. You can automate your mundane tasks, make your life easier and proud to be lazy by automating operations.

Macros in buffer

We have set a macro, and if we want to see what it contains, type

:enew

This will create a new file.

Now type :

 "ap

Here a is the register in which our macro is stored. This will print the macro. Note that here the macro can also be edited.

This is what I get in my case

yyp^A

As expected, we see key combinations

yy – yanked

p – paste

^A – increment the number

The screen looks like :

You can edit it, say delete ^A and save it to the buffer using following key combination

^”ay$

Re-open our ‘addr’ file and now again run the macro in register a using following

3@a

Notice the difference. The house number is no more incrementing.

house no. 300 santa clara, ca

house no. 301 santa clara, ca

house no. 302 santa clara, ca

house no. 303 santa clara, ca

house no. 304 santa clara, ca

house no. 305 santa clara, ca

house no. 306 santa clara, ca

house no. 307 santa clara, ca

house no. 308 santa clara, ca

house no. 309 santa clara, ca

house no. 310 santa clara, ca

house no. 311 santa clara, ca

house no. 312 santa clara, ca

house no. 313 santa clara, ca

house no. 313 santa clara, ca

house no. 313 santa clara, ca

house no. 313 santa clara, ca

The post Linux Vim Editor Tips and Tricks – Save Time Through Macros and Bookmarks appeared first on MyLinuxBook.

Have a look at these 12 awesome devices that are powered by Linux.

1. Linux Powered Rifle

Developed by an Austin based start-up (TrackingPoint), it is a Linux powered Rifle that boasts of auto-aim feature. This rifle is worth about $17000. Read more about it here.

Image Courtesy ArsTechnica

2. Linux Powered MotorBike

Priced at around $41000, TTX02 from Maziven is not like any other Motor Bike. This beast comes along with Linux OS, USB based system bus, WiFi connectivity and a web server.  Read more about it here.

Image Courtesy Engadget

3. Large Hadron Collider

Considered as one of the greatest engineering milestones of mankind, LHC is world’s largest and highest-energy particle accelerator. It was build by European Organization for Nuclear research to prove theories of particle physics, high energy physics and particularly to test the existence of Higgs Boson. Read more about it here.

Image Courtesy NASA

4. Linux Powered Smart Fridge

With Linux at it’s display heart, make way for Smart Refrigerators. Now, get to know complete inventory of your fridge, get warned if any item is nearing it’s expiry, see the stock that is nearing it’s limit and even get recipe suggestions — all of this and more, right at the face of your fridge. Read more about it here.

Image Courtesy SmartApplianceNews

The post Linux Is Everywhere – 12 Awesome Devices Powered By Linux appeared first on MyLinuxBook.

Linux Command Line vs GUI

As the saying goes, “we learn it best when we do it ourselves”, therefore after switching to Linux I personally felt the efficiency and quickness of tasks getting done through command line verses through graphical user interface (CLI vs GUI). And the major reason being, even a mouse click generates an action which will trigger the execution of the same executable as we do through the command directly. Hence, running the same task through GUI involves an extra overhead of calculating the mouse pointer coordinates, raising a click action etc. In case, there are input options required, it adds on to the overhead. All this handling of the overhead takes some time at the cost of impressive visuals and to avoid typing.

Well, to talk about deep driven merits of using command line as compared to GUI, here is a synopsis of abstract points:

Agile and Time-saving

Since through command line we are just triggering the executable which makes it faster than any GUI operation which involves parsing actions, inputs and displaying outputs. As a simple comparison exercise, install VLC player using its installer, which is GUI download/installation, and through the command line by running the following command.

$sudo apt-get update

$sudo apt-get install vlc

Feel the difference in the amount of time one needs for the installation in both the cases.

Mouse Disability

A Linux command line user will rarely need a mouse device. From my own experience, just using keyboard is much convenient and as we develop the skill, its way more faster than using mouse. Believe it or not, but just using keyboard and typing every damn command sharpens our memory too.

Better Understanding

Running commands offer a better understanding of how system works than any GUI alternative. Moreover, as we use commands, we implicitly memorize many and we give ourselves an opportunity to learn more.

Scripts

Many of the redundant group tasks can be easily scripted and performed using those scripts. For example, if we have a huge set of files that needs to be renamed and then moved to another destination. With the GUI, it might be a tedious one for each one of the file, but with scripts its just about one logic in the script and running the script.

Typing

Do you think typing is a hassle with command line, especially with the long directory paths? There are some interesting conducive ways to avoid that. We shall learn more in the later sections.

Powerful

Commands are any way more powerful in terms of options from any GUI alternative. To conclude, the efficiency and several micro-seconds of time saved in each command, really makes tremendous and precious value addition in the life of Linux users.

Remember for every small task we want out of the operating system, there exist a command or a key combination. Here in further sections we shall learn about certain Linux command line utilities which are not popular but are still a good alternative to GUI for some common tasks.

Assumption All the commands discussed have been tested with bash shell on Ubuntu 12.04.

Shutdown and reboot the system

When we click on the “shutdown..” action menu or button, it actually calls a command internally.

Linux gives us a simple command with the simplest name to remember

$shutdown [TIME]

Here is its man page. The user needs root privileges to run this command.

Now we will discuss what all it has to offer.

1. We can even schedule a shutdown using one of its argument specifying time. The time can be specified in a phrase like ‘now’ or in minutes, minutes or hh:mm where ‘hh’ specifies the hours and ‘mm’ specifies the minutes in the time.

Therefore after/at specified time, the shutdown is initiated.

As an example, try

$shutdown now

2. One can even restart the system through

$shutdown -r 3

It informs and alerts us about the reboot as

Broadcast message from rupali@home-OptiPlex-745

    (/dev/pts/0) at 10:16 ...

The system is going down for reboot in 3 minutes!

Broadcast message from rupali@home-OptiPlex-745

    (/dev/pts/0) at 10:17 ...

The system is going down for reboot in 2 minutes!

Broadcast message from rupali@home-OptiPlex-745

    (/dev/pts/0) at 10:18 ...

The system is going down for reboot in 1 minute!

Broadcast message from rupali@home-OptiPlex-745

    (/dev/pts/0) at 10:18 …

The system is going to reboot now!

There is another way to reboot the system, and that is through the ‘reboot’ command.

Here is how it looks like when we run the command

Broadcast message from rupali@home-OptiPlex-745

    (/dev/pts/0) at 10:18 …

The system is going to reboot now!

Web Browsing

Not one, but there are many text-based command line web browsers available for Linux. Such kind of command line web browsers may not be as fancy as our usual browsers. As a user, we all know fancy stuff comes with a compromise on efficiency. However, such simplistic command line browsers are pretty suitable for normal browsing and study.

One of such web browser is Lynx. The first and foremost step is to install it

$sudo apt-get install lynx-cur

After the installation is complete, launch the web browser by

$lynx

And we get the following screen

(Click to Enlarge)

We need to know following basic help information to starting using the ‘lynx’ text based browser

Commands: Use arrow keys to move, '?' for help, 'q' to quit, '<-' to go back.

 Arrow keys: Up and Down to move.  Right to follow a link; Left to go back.

H)elp O)ptions P)rint G)o M)ain screen Q)uit /=search [delete]=history list

To enter a URL, press ‘g’. Type the website URL one wishes to open. Lets type and enter mylinuxbook.com
Check out the following snapshot with our input URL

(Click to Enlarge)

We get the website opened in our browser which looks like:

(Click to Enlarge)

Navigate through the website by using up and down arrows. As we move up/down, the selected link gets highlighted. And we click a particular link by pressing ‘enter’.

For me, I select the ‘commands’ link from the menu available

After selecting ‘commands’ menu item, I press ‘enter’, which leads me to the relevant web-page.

(Click to Enlarge)

Note that, the top header menu remains the same for all the web pages of this website.

To go back, use left arrow key. Any time, we need to open a different URL, press ‘g’ and enter the URL. Lynx comes with a man page for its usage information.

However, we shall not go much in the details of the usage of web browsers as every text based web browser would have its own different ways to use.

A few known browsers are:

• Links
• w3m
• ELinks

I don’t recommend any specific browser, feel free to explore the available ones and set your preference.

Email Client

In this connected world, are we too addicted email clients? In our CLI Linux world, we can’t afford not to have a command line based email clients on Linux. Command line email client tools are powerful in terms of performance, and very easy to configure and use. However, to be candid, for someone who needs an interaction-impressive email client, command line based email client tools are not for them.

First of all, let us go ahead installing ‘mutt’ on our linux system, which can be done by following command

sudo apt-get install mutt

While we run this command, on my ubuntu 12.04 system, it asks

Need to get 2,682 kB of archives.

After this operation, 7,523 kB of additional disk space will be used.

Do you want to continue [Y/n]?

Type ‘y’ and press enter to the above prompt. And then it asks for certain basic configurations with a text based in-terminal screen. Following is a snapshot

(Click to Enlarge)

Since it is purely text based, mouse won’t work here. To select ‘OK’, press right arrow and then press ‘enter’. Further we get following screen, where we need to select a general type of mail configuration

(Click to Enlarge)

Since, in this article we aim to configure our ‘www.gmail.com’ account email to this email client, hence we need to select “Internet Site”. Here is a link to know more about postfix configurations.

Similarly select ‘OK’ by right arrow and pressing enter.

Next it asks us the system mail name. The information on the screen also explains

│ Thus, if a mail address on the local host is foo@example.org, the         │  

│ correct value for this option would be example.org.

Therefore, in case I, type ‘gmail.com’. After typing, select ‘OK’ and press enter, which completes the ‘mutt’ installation and basic configuration.

However, we are still one step away from using the mutt email client. What is that one step? It is the client configuration and customization. Creating the directories for caching headers and bodies along with certificates

$ mkdir -p ~/.mutt/cache/headers

$ mkdir ~/.mutt/cache/bodies

$ touch ~/.mutt/certificates

Thereafter, creating a ‘.muttrc’ file in the home directory having the following customised settings

Notes (Before you proceed further)

• We are connecting it to the Gmail mail, which is an IMAP mail server

• Replace all ‘rupali.s@gmail.com’ with your email account

• One can also configure it with our password, but I won’t recommend the password to be mentioned in any clear form in any file on our system. Hence, leaving it to be prompted for whenever required.

# The gmail account details. Please change it to suit you.

set imap_user = "rupali.s@gmail.com"

set smtp_url = "smtp://rupali.s@smtp.gmail.com:587/"

set from = "rupali.s@gmail.com"

set realname = "Rupali"

# Set your favourite editor here

set editor = "vi"

# Certain configurations

set folder = "imaps://imap.gmail.com:993"

set spoolfile = "+INBOX"

set imap_check_subscribed

set hostname = gmail.com

set mail_check = 120

set timeout = 300

set imap_keepalive = 300

set postponed = "+[GMail]/Drafts"

set record = "+[GMail]/Sent Mail"

set header_cache=~/.mutt/cache/headers

set message_cachedir=~/.mutt/cache/bodies

set certificate_file=~/.mutt/certificates

set move = no

set include

set sort = 'threads'

set sort_aux = 'reverse-last-date-received'

set auto_tag = yes

ignore "Authentication-Results:"

ignore "DomainKey-Signature:"

ignore "DKIM-Signature:"

hdr_order Date From To Cc

alternative_order text/plain text/html *

auto_view text/html

bind editor  complete-query

bind editor ^T complete

bind editor  noop

# Gmail-style keyboard shortcuts

macro index,pager y "unset trash\n " "Gmail archive message"

macro index,pager d "set trash=\"imaps://imap.googlemail.com/[GMail]/Bin\"\n " "Gmail delete message"

macro index,pager gi "=INBOX" "Go to inbox"

macro index,pager ga "=[Gmail]/All Mail" "Go to all mail"

macro index,pager gs "=[Gmail]/Starred" "Go to starred messages"

macro index,pager gd "=[Gmail]/Drafts" "Go to drafts"

Now we are all set to use the email client ‘mutt’. Run it by running following command

$mutt

A blank screen turns up, which prompts for the password at its bottom-most list

Password for rupali.s@gmail.com@imap.gmail.com:

Enter your password and it will start loading your mails for you to access. Here is how it showcases your mails.

Check out the top highlighted line which is a basic help segment always available, intimating basic key options. Here are the commonly used ones

Up/Down Arrow:    Navigate the messages

Enter:            Select the message

q:             To Quit the tool or return to the message list view

d:            Delete a message

u:            To Undelete a mail

s:            To Save a mail  

m:            Initiate composing a mail

r:            To Reply

g:            A group reply

?:            Need a Help

While composing a mail/reply, your favourite editor shall be opened as mentioned in the ‘.muttrc’ by us.

Well, mutt client agent has a lot more options and customisations as we start using it. This article shall not delve into all those usage information details which can be referred here.

However, there are other such command line email clients also available, such as

Pine

Alpine

mailx

Imagemagick

Editing images is no longer a professional’s effort in this era of social networking websites, most of us are living in. Of course, GUI has enhanced certain editing features as for example, say cropping. No doubt about that. However, think of cropping like hundreds of images to the same size. I am pretty sure, it wouldn’t be a pleasant experience with GUI applications any more. Besides, still most of the other image editing features are efficiently done through command line, without depending on any GUI application functionalities. Moreover, if the image editing is to be done on a number of images, command line tools is the most convenient rescue.

Linux gives us one such superb image format converter and editor which is imagemagick.

It is installed with the package ‘imagemagick’

$sudo apt-get install imagemagick

Imagemaick is like a suite of command line utilities for image operations. Here is a list of all the utilities which come within, descriptions taken from the man page.

Note: As an example image for all the illustrated example usage, we have taken following image called ‘orig.png’

display

displays an image or image sequence on any X server.

So, lets ask it to display the image, which can be done by

$display orig.png

And here is what we get, A dialog window with the image displayed.

convert

convert between image formats as well as resize an image, blur, crop, despeckle, dither, draw on, flip, join, re-sample, and much more. The umbrella of benefits also includes the scenario where a thumbnail picture can be dexterously created in an autoscript of any application by just resizing any picture. Now we know, how might facebook has the thumbnail ready as soon as we upload our profile picture.

convert -resize 30x30 orig.png resized.png

The resulting thumbnail is:

To check out an example of the image effects it can do, try

convert -monochrome orig.png m.png

Here it edits the image to convert into a black and white monochrome effect, and save it to a separate ourput file m.png. Here is how the output file looks like

‘convert’ is also capable of converting from one image file format to another. Here is how that works specifying the compression level of the converted format JPEG.

$ convert -quality orig.png converted.jpg

Using ‘convet’ tool, the linux users have the capability to do image effects, resize and even rotate the image. Checkout this interesting set of effects of our image.

$ convert orig.png -rotate 180 -emboss 1 -quality 90  new.jpg

Our output image is, the penguin looks beautiful to me

More effects and options of ‘convert’ can be referred to from its man page.

identify

describes the format and characteristics of one or more image files.

Trying it out on our original image,

$ identify orig.png

What I get is,

orig.png PNG 198x264 198x264+0+0 8-bit DirectClass 62.5KB 0.000u 0:00.000

If one doesn’t understand, what the output means, verbose output is obtained by

$ identify -verbose orig.png

A detailed output looks like,

Image: orig.png

 Format: PNG (Portable Network Graphics)

 Class: DirectClass

 Geometry: 198x264+0+0

 Resolution: 72x72

 Print size: 2.75x3.66667

 Units: Undefined

 Type: TrueColorMatte

 Endianess: Undefined

 Colorspace: RGB

 Depth: 8-bit

 Channel depth:

   red: 8-bit

   green: 8-bit

   blue: 8-bit

   alpha: 1-bit

 Channel statistics:

   Red:

     min: 0 (0)

     max: 255 (1)

     mean: 141.496 (0.554886)

     standard deviation: 61.8626 (0.242598)

     kurtosis: 0.0347628

     skewness: -0.547966

   Green:

     min: 0 (0)

     max: 255 (1)

     mean: 147.828 (0.579719)

     standard deviation: 60.3165 (0.236535)

     kurtosis: 0.504549

     skewness: -0.947011

   Blue:

     min: 0 (0)

     max: 255 (1)

     mean: 140.783 (0.552089)

     standard deviation: 66.8083 (0.261993)

     kurtosis: -0.311562

     skewness: -0.855471

   Alpha:

     min: 255 (1)

     max: 255 (1)

     mean: 255 (1)

     standard deviation: 0 (0)

     kurtosis: 0

     skewness: 0

 Image statistics:

   Overall:

     min: 0 (0)

     max: 255 (1)

     mean: 107.527 (0.421673)

     standard deviation: 82.7262 (0.324416)

     kurtosis: -1.45325

     skewness: -0.185137

 Rendering intent: Undefined

 Interlace: None

 Background color: white

 Border color: rgba(223,223,223,1)

 Matte color: grey74

 Transparent color: none

 Compose: Over

 Page geometry: 198x264+0+0

 Dispose: Undefined

 Iterations: 0

 Compression: Zip

 Orientation: Undefined

 Properties:

   date:create: 2013-05-10T22:14:27-07:00

   date:modify: 2013-05-10T22:14:27-07:00

   signature: 4fa517adcf20cdc524027ac621ba437e38635f21443781678830f3e75d890f15

 Artifacts:

   verbose: true

 Tainted: False

 Filesize: 62.5KB

 Number pixels: 52.3K

 Pixels per second: 5.227M

 User time: 0.010u

 Elapsed time: 0:01.009

 Version: ImageMagick 6.6.2-6 2011-03-16 Q16 http://www.imagemagick.org

mogrify

resize an image, blur, crop, despeckle, dither, draw on, flip, join, re-sample, and much more. Mogrify overwrites the original image file, whereas, convert writes to a different image file.

To see how it works differently as compared to ‘convert’, do the following :

First of all, because we are expecting the original image to be overwritten, lets create a copy of our original one, as we need to use the original one for other imagemagick tools too.

$cp orig.png oimg.png

$mogrify -monochrome oimg.png

$display oimg.png

As a result of ‘display’ command, we get

Most of the mogrify options are similar to the ‘convert’ ones.

composite

overlaps one image over another.

This is going to be really amazing. It takes a lot of mouse click efforts to overlap two images in any image editor, here it just takes the following command

$composite thumbnail.png new.jpg overlapped.png

The output image ‘overlapped.png’ is

montage

Create a composite image by combining several separate images. The images are tiled on the composite image optionall adorned with a border, frame, image name, and more.

With ‘montage’, it creates a collage kind of collection of images in a geometrical way. The generic syntax to use ‘montage’ is

      montage input-file [options] output-file

Note, the input file in above can be a set of files separated by spaces

For example, we shall be creating a composite image with all the effects and editing on our original image. Initially lets create several images with different effects using following simple ‘convert’ command

$ convert -implode 1 orig.png implode.png

$ convert -monochrome orig.png mono.png

$ convert -charcoal 3 orig.png charc.png

$ convert -emboss 6 orig.png emboss.png

$ convert -resize 60x60 orig.png resized.png

With each of the above five commands, we get five differently edited images, and including the original, we have total six images in total to create a composite image.

Now, we use the ‘montage’ tool to create a collage as follows:

$montage *.png montage.png

The figure below is how our output image looks like

Note, the way the images have been composited to create the final output image. It offers various options, including to change the geometry of the images, more details of which can be referred through its man page.

compare

Mathematically and visually annotate the difference between an image and its reconstruction.. This is a very useful tool, especially for image processing professionals who need to monitor every pixel variation. As an example, let us compare two different formats of same image.

$compare orig.png converted.jpg diff.png

The way it illustrates a comparison visually is in the form of a diff image,

Mathematically, it compares two images as

$compare -metric AE  orig.png converted.jpg diff.png

We use the option -metric which needs a metric type. In this example, we use ‘AE’ which corresponds to Absolute Error. More information regarding metric and metric types is here

For the metric type = AE, we get difference output as,

6707

animate

Animates an image sequence on any X server.

I am pretty sure you would love this tool. Remember the earlier days, where animations were created by drawing several and several drawings depicting a change in the overall movement. Similarly, this tool works on the same concept of principle. As a simplest example, lets create certain images of varying sizes in a separate directory.

$mkdir animation

$cp orig.png animation/0.png

$cd animation

$convert -resize 10x10 0.png 1.png

$convert -resize 20x20 0.png 2.png

$convert -resize 30x30 0.png 3.png

$convert -resize 40x40 0.png 4.png

$convert -resize 50x50 0.png 5.png

$convert -resize 60x60 0.png 6.png

$convert -resize 70x70 0.png 7.png

$convert -resize 80x80 0.png 8.png

$convert -resize 90x90 0.png 9.png

$convert -resize 100x100 0.png 91.png

$convert -resize 110x110 0.png 92.png

$convert -resize 120x120 0.png 93.png

Now, run the animation as

$animate *.png

Use your creativity cells to create such animations and we would love to hear about them.

Command Line Terminal Shortcuts

In the initial section above, we discussed that for using command line for all kinds of tasks will result in a lot of typing. I never denied that a lot of typing can be cumbersome, especially when it comes to long file names, at times re-typing commands, etc. Although, we cannot completely avoid typing but Linux does come with a way to minimize certain difficulties. In this section we shall be discussing a few fantastic key combination short cuts which can be used while working on Linux terminal.

CTRL + r

This is an exciting short cut to search through the list of commands we’ve run in a terminal. We can even edit the already run command and then run it with the modification. As in, suppose we once copied a file ‘f1’ from a directory path to another destination path. Now we would like to copy file ‘f2’ from the same source path to the same directory path.

We can re-use are earlier used command as

1. Press key combination ‘Ctrl + r’

We get following just below command prompt

$

(reverse-i-search)`':

2. Type cp.

Basically, type the initial matching characters of the relevant command. More the relevant characters we type, quicker we’ll encounter the matching needed command from the already run commands.

3. Keep pressing ‘Ctrl + r’ until it displays our needed ‘cp’ command from the list of earlier used commands.

$

(reverse-i-search)`cp': cp /home/rupali/programs/cstatic/f1 /home/rupali/out/dest/

4. Once it shows our relevant command, press right arrow key (or left arrow key) to come out.

5. Make modification to change the filename from ‘f1’ to ‘f2’ and then run the new modified command.

cp /home/rupali/programs/cstatic/f2 /home/rupali/out/dest/

Therefore, it helped us to avoid re-writing the complete ‘cp’ command. It is an immensely useful key combination in Linux.

Up Arrow

To check and run the recently run commands in a terminal. As an example, we are debugging an application and every time we make a change in the source, we have to run our ‘make’ command. We don’t need to type ‘make target’ again and again as it is the one of the most recent command in the command history. Just use up arrow to browse through recently run commands and run it from there.

The same can also be done using key combination ‘CTRL + p’.

To see how that works, run command ‘ls’ on your command prompt. After the command output, press up arrow key. You’ll find ‘ls’ command, which is the recent command which we just ran.

CTRL + a and CTRL + e

At times, we are typing our command and then notice we need to add ‘sudo’ in front of the command. We can use the key combination ‘Ctrl + a’ to reach the beginning of the command. The same can be achieved by ‘home’ key.

Similarly, we can use the key combination ‘Ctrl + e’ to reach the end of the command. Again, the same can also be done by ‘end’ key.

Tab key

Tab key is the most used among the Linux users. When we are typing a file/directory path, ‘tab’ key assists in auto-complete as we move along with the path.

The way how it works is, type the initial characters identifying the directory name in the path of the filename, and press ‘tab’ key. It will be auto-completed in case the initial few typed characters uniquely identify it. Otherwise, it will suggest the possible names.

For example, try

$gedit /h

and then press tab key. It will be be auto-completed to

$ls/home

In this way, we can easily type and auto-complete a long path as well conveniently.

CTRL + l

One can clear the terminal using ‘ctrl + l’ key combination. It has the same effect as the clear command. So, no need to type ‘clear’ command again and again.

CTRL + u

Clears all the text to the left of the current cursor on the command prompt.
For example,

On pressing Ctrl + u, we get

CTRL + k

Similar to the above discussed key combination, ‘ctrl + k’ removes all the text to the right of the current cursor on the command prompt

On pressing ‘ctrl + k’, we get

ALT + d

This key combination clears the word from the command prompt. Though the cursor should be at the beginning of the word before pressing ‘alt +d’.
As in,

On pressing ‘Alt + d’, we get

Note, this involves ‘Alt’ key and not the ‘Ctrl’.

Other keyboard shortcuts

The other keyboard shortcuts like opening a terminal, searching in the filesystem, etc can depend upon the distribution of the linux used. However, they are even changeable from the system preferences.

As in, in case of ubuntu, we the keyboard shortcuts can be found under

System > Preferences >Keyboard Shortcuts
Following is the snapshot depicting the same.

Well, from the above key shortcuts, we see Linux really values our typing and helps us in all ways in saving our effort of typing something which has been typed once.

NOTE – To learn some amazing Linux command line tricks, read our article on 20 interesting and extremely helpful Linux command line tricks

Conclusion

This article is an effort to widen the scope of using more and more Linux command line which is much faster and effective along with aiding self learning. Believe me, there are plethora of command line Linux utilities and tricks available for each and everything that can be done on an operating system. So, it is an endless topic. Would love to hear about more command line Linux powerful tools.

The post Linux Command Line Alternatives – Leave The Mouse To Rest! appeared first on MyLinuxBook.

The news broke out around April fools day and took technology enthusiasts by surprise. While some of them appreciated the arrival of Google glass competitor, others slammed it as yet another attempt by a Chinese company to copy technology developed by an American company.

Due to the timing, there was a whole lot of confusion related to authenticity of the news. Some of the news outlets like Techcrunch made a full circle by first confirming that ‘eye’ definitely exists and is under rapid development but then an update to the same article said that though it seems like one of the best April fool’s joke but still has a ‘kernel of truth’.

Initial reports related to ‘eye’ also made several huge claims including that the company is working with Qualcomm to develop a technology that can extend the battery life of this wearable technology product to more than 12 hours. But, seems like this ‘Qualcomm story’ , that was making rounds on internet, prompted Baidu to make an official public statement to clear the confusion around ‘eye’.

According to Engadget, here is what Baidu’s director of international communications, Kaiser Kuo, said about ‘eye’ :

“We really are developing something similar in its basic functionality to what was described in the Sina Tech report and other sources in the Chinese press; the reports were correct in their essentials though they got some of the details wrong (and those inaccuracies may have its origins in an April Fool’s prank gone awry!). The project’s internal name is Baidu Eye. Not sure whether that’s going to be its final name. We’re doing some internal testing on it now on a small scale, and evaluating where this goes from here. That’s why we didn’t make any public official announcement on this.”

Mr Kuo also confirmed that the ‘Qualcomm story’ is not true to the best of his knowledge.

Baidu Eye – Features

‘Tit for tat’ or ‘eye for an eye’ ? Whatever you call it but one thing is for sure that ‘eye’ is not fundamentally different from ‘glass’ as Mr Kuo also confirmed that just like ‘glass’, ‘eye’ is also an ‘ocular wearable interface’.

As reported, It boasts of features like :

• Voice search
• Image search
• Facial recognition
• Bone conduction
• etc

Besides, ‘eye’ can also be used as standard pair of eyeglasses.

Business

As of now, Baidu, the company, doesn’t seem to have an aggressive plan to launch ‘eye’ in the market. The company claims that ‘eye’ is an internal project which may or may not hit the market but doing research on any technology related to internet search falls in line with company’s vision.

Linux powered Google glass (download kernel code here) is scheduled to arrive in market later this year with an initial price tag of $1500. This price could act as a deterrent for consumers in growing Asian economies like India and China which have huge consumer and enterprise base. If ‘eye’ can strike the right chord with a balanced combination of ‘timely release’ + ‘affordable price’ + ‘decent quality’ then it can prove to be a good competitor for Google glass at least in Asia region.

Besides end consumers, products like ‘eye’ or ‘glass’ can even help small enterprises to improve productivity as one can do things on the go which otherwise would require a hand-held device like a tablet, Laptop or a mobile phone.

If a device like ‘glass’ or ‘eye’ comes with an affordable price tag then we can imagine a technology revolution similar to the one brought by Mobile phones. Sectors like education, defence, health can gain a lot from these kind of devices but there could be areas like cinemas, casinos etc where this technology can be misused.

So, yes, like any other breakthrough in technology, the wearable technology is also facing concerns. But, how deep these concerns can dent the business, this is yet to be seen.

Meanwhile, you can read this great article on what businesses can expect from Wearable technology.

Future of wearable technology

Wearable technology is the latest trend in which accessories or clothing incorporates computer as well as other advanced electronic technologies. Apart from Baidu and Google, many other companies are experimenting on this technology for example Apple is researching on a wristwatch device that would be able to show messages and e-mails that users receive on their iPhone. Similarly, Samsumg and LG are also exploring possibilities of a similar kind of smart watch devices.

Conclusion

Samuel Johnson – The Rambler said that Almost all absurdity of conduct arises from the imitation of those whom we cannot resemble. Let us wait to see what kind of imitation will Baidu Eye produce.

The post Is Baidu Eye A Real Competition To Linux Powered Google Glass? appeared first on MyLinuxBook.

NOTE – All the examples in this article are tested on bash shell.

Linux command line tricks

1. How to switch between directories efficiently?

Working on Linux command line means switching between lot of directories. You are in a directory ‘A’, then you move to directory ‘B’. Now you want to come back to directory ‘A’. Typing the complete directory path for ‘A’ can be cumbersome sometimes. For this you can use ‘cd -’ short cut.

Here is an example :

$ pwd
/home/himanshu

$ cd /usr/local/bin/

$ cd -
/home/himanshu

So we see that it’s easy to switch between two directories using cd- .

But, ‘cd -’ resolves only a partial problem. It can only switch you back to last directory only. What if you switch between multiple directories and then want to come back to the first or some other desired directory? I mean, suppose you are in a directory ‘A’, then you switch to directories ‘B’ -> ‘C’ -> ‘D’ -> ‘E’ and then you want to again go back to directory ‘A’.

Well, for this, you can use the combination of ‘pushd’ and ‘popd’.

Here is an example :

$ pwd
/home/himanshu

$ pushd /home/himanshu
~ ~

$ cd /usr
$ cd /tmp
$ cd /proc

$ popd
~

$ pwd
/home/himanshu

As you can see, first you pass the desired directory (to which you want to come back eventually) as argument to ‘pushd’ and then through ‘popd’ you can actually trigger a directory switch to that directory from anywhere on the command prompt.

2. How to make efficient use of Linux command line history using !! and ! ?

Double exclamation ie ‘!!’ represents the last run command on the shell. Here is an example :

$ uname -a
Linux himanshu-Inspiron-1525 3.2.0-36-generic-pae #57-Ubuntu SMP Tue Jan 8 22:01:06 UTC 2013 i686 i686 i386 GNU/Linux

$ !!
uname -a
Linux himanshu-Inspiron-1525 3.2.0-36-generic-pae #57-Ubuntu SMP Tue Jan 8 22:01:06 UTC 2013 i686 i686 i386 GNU/Linux

So what best can we do with !! ?

Well, firstly, you can extend the command easily. Here is an example :

$ !! | grep Linux
uname -a | grep Linux
Linux himanshu-Inspiron-1525 3.2.0-36-generic-pae #57-Ubuntu SMP Tue Jan 8 22:01:06 UTC 2013 i686 i686 i386 GNU/Linux

Also, it so happens many times that you run a command and you get an error that the command requires root privileges. Then you press the ‘up arrow’ key + home key + write ‘sudo’ . Well all this can be avoided using !!.

Here is an example :

$ touch new_binary
touch: cannot touch `new_binary': Permission denied

$ sudo !!
sudo touch new_binary
[sudo] password for himanshu:

$ ls new_binary 
new_binary

Sometimes you would like to append a command to existing shell script or would like to create a new shell script, then you can use ‘!!’ to the task easily. Here is an example :

$ ls -lart /home/himanshu/practice/*.py

-rw-rw-r-- 1 himanshu himanshu 50 Mar  1 00:23 /home/himanshu/practice/firstPYProgram.py

$ echo !! > script.sh 
echo ls -lart /home/himanshu/practice/*.py > script.sh

$ cat script.sh 
ls -lart /home/himanshu/practice/firstPYProgram.py

So we see that this way !! proves to be easy and time saving.

Now, lets come to single exclamation ie ‘!’ . Unlike double exclamation ie ‘!!’, through single exclamation ‘!’, we can access any previously run command that exists in command line history. Here are some examples :

Use serial number from output of history command to run a particular command

$ history
...
...
...
2039  uname -a | grep Linux
 2040  dmesg
 2041  clear
 2042  cd bin
 2043  clear
 2044  pwd
 2045  touch new_binary
 2046  sudo touch new_binary
 2047  ls new_binary 
 2048  history

$ !2039
uname -a | grep Linux
Linux himanshu-Inspiron-1525 3.2.0-36-generic-pae #57-Ubuntu SMP Tue Jan 8 22:01:06 UTC 2013 i686 i686 i386 GNU/Linux

So we see that command number 2039 was run through single exclamation ‘!’ without having to type or copy paste the command again.

You can use negative integer values with ‘!’ to run second last command, third last command, fourth last command…and so on.

Here is an example :

 $history
...
...
...
 2049  ! 2039
 2050  uname -a | grep Linux
 2051  history

$ !-2
uname -a | grep Linux
Linux himanshu-Inspiron-1525 3.2.0-36-generic-pae #57-Ubuntu SMP Tue Jan 8 22:01:06 UTC 2013 i686 i686 i386 GNU/Linux

Run a new command with argument of previous command

Here is an example :

$ ls /home/himanshu/practice/*.py
/home/himanshu/practice/firstPYProgram.py

$ ls -lart !$
ls -lart /home/himanshu/practice/*.py
-rw-rw-r-- 1 himanshu himanshu 50 Mar  1 00:23 /home/himanshu/practice/firstPYProgram.py

So we see that ‘!$’ can be used to fetch argument from previous command and use it with the current command.

In case of two arguments, use carrot ‘!^’ to access first argument

Here is an example :

$ ls /home/himanshu/practice/*.py /home/himanshu/practice/*.txt
/home/himanshu/practice/file.txt           /home/himanshu/practice/output.txt  /home/himanshu/practice/sort.txt
/home/himanshu/practice/firstPYProgram.py  /home/himanshu/practice/sort1.txt   /home/himanshu/practice/test.txt
/home/himanshu/practice/input.txt          /home/himanshu/practice/sort2.txt

$ ls -lart !^
ls -lart /home/himanshu/practice/*.py
-rw-rw-r-- 1 himanshu himanshu 50 Mar  1 00:23 /home/himanshu/practice/firstPYProgram.py

So we see that through ‘!^’ we can access the first argument of the previous run command.

To access the any other argument (of previous run command) in current command, ‘![prev command name]:[argument number]‘ can be used.

Here is an example :

$ ls !ls:2
ls /home/himanshu/practice/*.txt
/home/himanshu/practice/file.txt    /home/himanshu/practice/sort1.txt  /home/himanshu/practice/test.txt
/home/himanshu/practice/input.txt   /home/himanshu/practice/sort2.txt
/home/himanshu/practice/output.txt  /home/himanshu/practice/sort.txt

So this way, the second argument (of the previous command) was accessed.

To access all the arguments of a previously run command, use ‘!*’

Here is an example :

$ ls -lart !*
ls -lart /home/himanshu/practice/*.py /home/himanshu/practice/*.txt
-r--r--r-- 1 himanshu himanshu 50 Oct 24  2012 /home/himanshu/practice/output.txt
-r--r--r-- 1 himanshu himanshu  7 Nov 10 13:46 /home/himanshu/practice/input.txt
-r--r--r-- 1 himanshu himanshu  8 Dec  7 20:38 /home/himanshu/practice/sort1.txt
-r--r--r-- 1 himanshu himanshu  8 Dec  7 20:39 /home/himanshu/practice/sort2.txt
-r--r--r-- 1 himanshu himanshu 14 Dec 14 20:45 /home/himanshu/practice/file.txt
-r--r--r-- 1 himanshu himanshu 41 Jan 23 20:42 /home/himanshu/practice/sort.txt
-rw-rw-r-- 1 himanshu himanshu 50 Mar  1 00:23 /home/himanshu/practice/firstPYProgram.py
-rw-rw-r-- 1 himanshu himanshu  0 Mar 10 15:31 /home/himanshu/practice/test.txt

Use ‘![keyword]‘ to run the last command starting with [keyword]

Here is an example :

$ !ls
ls -lart /home/himanshu/practice/*.py
-rw-rw-r-- 1 himanshu himanshu 50 Mar  1 00:23 /home/himanshu/practice/firstPYProgram.py

So we see that the last ls command was executed. This way you can just write the first keyword of the command (which is command name usually) and you do not need to write the complete command. Single exclamation ‘!’ will do it for you.

3. Use comma ‘,’ operator wherever it makes life easy

As already said, the comma operator can make life easy for you on Linux command line. Here are some examples :

Convert to lower case

Comma operator can be used to convert the whole string or only the first letter to lower case.

Here is an example :

$ words="Example of comma OPERATOR"

$ echo ${words,}
example of comma OPERATOR

${words,,}
example of comma operator

So we see that through a single comma only the first letter was converted to lower case while through double comma, complete string was converted to lower case.

Use comma with file names

Comma operator can be used with file names. A couple of examples are shown below.

$ touch new_file{1,2,3}
himanshu@himanshu-Inspiron-1525:~/practice$ ls new_file*
new_file1  new_file2  new_file3

So we see that comma operator helped in creating three files easily.

Similarly, for one of the very popular work people do on command line is to rename files by adding .old or .new temporarily. You can save the time by doing something like :

mv my_filename.{old,new}

This will rename my_filename.old to myfilename.new.

4. How to delete files with leading or trailing spaces?

You might find yourself struggling with deleting files with leading or trailing spaces through ‘rm’ command on Linux command line.

For example :

$ rm tempFile
rm: cannot remove `tempFile': No such file or directory

So we see that rm command says that this file does not exist. But you are pretty confident that file with such name exists. Then the only thing could be that this file name would be having leading or trailing spaces.

You can use double quotes to avoid this problem :

$ rm "tempFile "

The above command worked in my case.

Note that if you do not want to use double quotes then ‘\ ‘ can be used. Here is an example :

$ rm tempFile\

Remember to add a space after back slash.

5. How to delete files with names beginning with hyphen (-) ?

Sometimes you may find yourself stuck with a situation like this :

You have to delete a file named -1mpFile.out

$ ls
-1mpFile.out                          CPPfile.o             libCfile.so      mylinuxbook_new  prog          split

But, when you try using rm command, following error is produced :

$ rm -1mpFile.out
rm: invalid option -- '1'
Try `rm ./-1mpFile.out' to remove the file `-1mpFile.out'.
Try `rm --help' for more information.

Even if you use double quotes, you get the following error :

$ rm "-1mpFile.out"
rm: invalid option -- '1'
Try `rm ./-1mpFile.out' to remove the file `-1mpFile.out'.
Try `rm --help' for more information.

So, rm command considers the hyphen ‘-’ as an indicator that some command line option will follow and so it treats ’1mpFile.out’ as an option. Hence the error.

Now, to tell ‘rm’ that the word beginning with hyphen is file name, you need to pass double hyphen (–) first. Here is an example :

$ rm -- -1mpFile.out

So this should remove the file successfully.

Since this problem is generic ie you will observe this problem even while creating this file using ‘touch’ command etc. Double hyphen can be used with other commands too for the same purpose.

Here is another example of double hyphen but this time with touch and ls commands :

$ touch -1mpFile.out
touch: invalid option -- '1'
Try `touch --help' for more information.

$ touch -- -1mpFile.out

$ ls — -1mpFile.out -1mpFile.out

So we can safely use double hyphen (–) in a generic sense with different Linux commands.

6. How to delete all files in a directory except some (with particular extensions) ?

Suppose you have a directory with lot of files and you want to delete all the files except some of them (with particular file extensions). This can be done in following way :

Here is a directory containing lot of files :

$ ls
a.out         Cfile.c  file.c             macro.c     my_printf.c   orig_file.orig  stacksmash.c
bfrovrflw.c   cmd.c    firstPYProgram.py  main.c      new_printf.c  orig_file.rej   test_strace.c
bufrovrflw.c  env.c    helloworld.c       my_fopen.c  new.txt       prog.c          virtual_func.c

Now, you want to delete all the files except .c and .py files.

Here is what you can do :

$ rm !(*.c|*.py)

$ ls
bfrovrflw.c   Cfile.c  env.c   firstPYProgram.py  macro.c  my_fopen.c   new_printf.c  stacksmash.c   virtual_func.c
bufrovrflw.c  cmd.c    file.c  helloworld.c       main.c   my_printf.c  prog.c        test_strace.c

So you can see that files with all other extensions got deleted.

7. How to create customized backup using touch and find commands?

Touch command in association with find command can be used to create customized backups.

Suppose you want to create a backup of files that you created or changed in a directory between 9am and 5pm. For this, the very first step is to create two files temp1 and temp2 with timestamps as 9am and 5pm respectively.

$ touch -d "9am" temp1
$ touch -d "5pm" temp2

These commands will create two files temp1 and temp2 with access and modification timestamps as 9am and 5pm respectively.

Let’s cross check these by using stat command:

$ stat temp1
 File: `temp1'
 Size: 0 Blocks: 0 IO Block: 4096 regular empty file
 Device: 806h/2054d Inode: 528534 Links: 1
 Access: (0664/-rw-rw-r--) Uid: ( 1000/himanshu) Gid: ( 1000/himanshu)
 Access: 2013-04-28 09:00:00.000000000 +0530
 Modify: 2013-04-28 09:00:00.000000000 +0530
 Change: 2013-04-28 19:06:05.982909491 +0530
 Birth: -

$ stat temp2
 File: `temp2'
 Size: 0 Blocks: 0 IO Block: 4096 regular empty file
 Device: 806h/2054d Inode: 529476 Links: 1
 Access: (0664/-rw-rw-r--) Uid: ( 1000/himanshu) Gid: ( 1000/himanshu)
 Access: 2013-04-28 17:00:00.000000000 +0530
 Modify: 2013-04-28 17:00:00.000000000 +0530
 Change: 2013-04-28 19:06:12.090939793 +0530
 Birth: -

So we see that timestamps was as expected. Now move to the directory where you want to create the backup of files. Here are the contents of the directory in my case :

$ ls
bfrovrflw.c   Cfile.c  env.c   firstPYProgram.py  macro.c  my_fopen.c   new_printf.c  stacksmash.c   virtual_func.c
bufrovrflw.c  cmd.c    file.c  helloworld.c       main.c   my_printf.c  prog.c        test_strace.c

Now, I create a directory named ‘bkup’ and run the following command :

$ find . -newer ../temp1 ! -newer ../temp2 -exec cp '{}' ./bkup/ ';'

The -newer and ! -newer options in command above will first find all the files with modification time between 9am and 5pm. Then the -exec option makes sure that the cp command is run for every result (‘{}’) of find command and the file is copied to ./bkup/ folder. The terminating ‘;‘ is the indication that cp command terminates here.

Now, if you see the ‘bkup’ directroy, you’ll find all the backed up files there. Here is what I saw in my case :

$ cd bkup/

$ ls
bfrovrflw.c   Cfile.c  env.c   firstPYProgram.py  macro.c  my_fopen.c   new_printf.c  stacksmash.c   virtual_func.c
bufrovrflw.c  cmd.c    file.c  helloworld.c       main.c   my_printf.c  prog.c        test_strace.c

As all the files were created between 9am and 5pm so all of them were backed up.

8. Why rm command fails with error ‘Argument list too long’?

This usually happens when you have a directory containing huge number of files. When you do a rm -rf over it, you get something like :

-bash: /bin/rm: Argument list too long

This issue can be resolved using following command (please switch over to the desired directory before running this command):

find * -xdev -exec rm -f '{}' ';'

The find command above will supply input to rm command in batches that it can process. This is one of the fastest method to delete files.

9. How to search for all the files in a directory containing a particular string?

This can be easily achieved using grep command.

Here are a couple of examples :

$ grep -l "printf" *.c
bfrovrflw.c
bufrovrflw.c
Cfile.c
cmd.c
env.c
file.c
helloworld.c
macro.c
main.c
my_fopen.c
my_printf.c
new_printf.c
prog.c
stacksmash.c
test_strace.c

$ grep -l "buff" *.c
bfrovrflw.c

If it is desired to view the lines where the string is used in the file, then ‘find’ command can be used with ‘xargs’ and ‘grep’ command in the following way :

$ find ./ -name "*.c" | xargs grep "buff"
./bfrovrflw.c:    char buff[15];
./bfrovrflw.c:    gets(buff);
./bfrovrflw.c:    if(strcmp(buff, "MyLinuxBook"))

So we see that even the lines containing the string “buff” were displayed in the output.

10. How to Empty a file using ‘>’ operator ?

Suppose you want to empty a file from command line.

Here is how easily you can do it :

$ > [complete file path]

For example :

$ > ./logfile

This will delete all the contents of the file ‘logfile’ and empty it.

11. How to search man pages for a particular string?

You might have used Linux man pages to understand more about a command, function etc. But, what if you want to know which man pages discuss about a particular topic. For example, what if I want to know that which man pages discuss about ‘login’?

Well, there exists an option -k through which you can do this. Here is an example :

$ man -k login
access.conf (5)      - the login access control table file
add-shell (8)        - add shells to the list of valid login shells
chsh (1)             - change login shell
faillog (5)          - login failure logging file
faillog (8)          - display faillog records or set login failure limits
getlogin (3)         - get username
getlogin_r (3)       - get username
gnome-session-properties (1) - Configure applications to start on login
hotot (7)            - lightweight & opensource microbloging client
issue (5)            - prelogin message and identification file
lastlog (8)          - reports the most recent login of all users or of a given user
login (1)            - begin session on the system
login (3)            - write utmp and wtmp entries
login.defs (5)       - shadow password suite configuration
login_tty (3)        - tty utility functions
logname (1)          - print user's login name
...
...
...

So we see that all the man pages that discuss about ‘login’ were displayed in the output.

12. How to redirect stderr output messages to a file?

It so happens mostly that standard commands/programs/services stream normal log messages to stdout while error log messages to stderr stream. Now, if you just do something like :

$ [some-command] > logfile

Then only the messages that were directed to stdout would be redirected to the file ‘logfile’ but no message that was directed to stderr would be redirected to the file.

Here is an example :

$ touch new > /home/himanshu/practice/logfile 
touch: cannot touch `new': Permission denied

$ cat /home/himanshu/practice/logfile 
$

So we see that error was not redirected to the log file.

Now, to correct this, do something like :

$ touch new > /home/himanshu/practice/logfile 2>&1

$ cat /home/himanshu/practice/logfile 
touch: cannot touch `new': Permission denied

So we see that this time the error was redirected to the file successfully. Please note that 2>&1 combines both stdout and stderr streams to stdout stream only.

13. How to follow multiple log files on the go?

If it is required to follow multiple log files as they are being updated then this can be done through tail command.

Suppose I want to monitor two log files ‘logfile’ and ‘logfile1′ simultaneously then I will use the tail command as follows :

$ tail -f logfile logfile1
==> logfile <==

==> logfile1 <==

==> logfile <==
hi

==> logfile1 <==
hello

So you can see that dynamic updates to these log files can easily be monitored through tail command.

14. How to make a command not to show up in the output of ‘history’ command?

Well, sometimes you would want to run a command but do not want it to appear in the output of Linux history command.

You can achieve this by inserting a space before you type the command on prompt.

Here is an example :

$  df
Filesystem     1K-blocks    Used Available Use% Mounted on
/dev/sda6       29640780 6174904  21960188  22% /
udev             1536752       4   1536748   1% /dev
tmpfs             617620     892    616728   1% /run
none                5120       0      5120   0% /run/lock
none             1544040     156   1543884   1% /run/shm

Note that there is a space between ‘$’ and ‘df’.

Now, let’s confirm whether this command appears in the output of ‘history’ :

$ history | grep df
 1633  ls *.pdf
 1634  mv LinuxCommandsPart1.pdf LinuxCommandsPart1
 2245  history | grep df

The df command was not captured in the output of history command.

15. How to simulate on-screen typing just like you see in movies?

Well, to simulate typing just like you see in movies, use ‘pv’ command.

Try this out :

 echo "You can simulate on-screen typing just like in the movies" | pv -qL 10

Check the output for yourself.

16. How to escape the aliased version of a command?

The alias command, as we all know is used to create aliases of the commands that act as short cuts and save time.

For example, I have created alias of ls command such that whenever I execute ls, its ‘ls -lart’ that gets executed.

$ alias ls='ls -lart'

Now, if I ever intend to escape the alias and want to execute only ls, then I can do this by beginning the command with a backslash ie ‘\’.

Here is an example :

$ \ls
1                      CPPfile.o            libCPPfile.so    mylinuxbook_new  prog.c        stacksmash.c

So we see that the original ls command was executed.

NOTE – If you want to suppress an alias for a whole login session, you can use ‘unalias’ command for that.

17. How to get rid of that unknown process that forbids you to delete a file?

There are situations where you want to delete a file but you get an error like ‘file is already in use’. You try to find which process in using this file but all your effort goes in vain. What would you do in this case?

Well, you can use the ‘fuser’ command. It tell you the process that is using a particular file. You can use ‘fuser -k [filename]‘ command to kill that process.

Read our article on fuser command to know more about it.

18. How to monitor and redirect logs to file simultaneously?

If you want to redirect logs to a file but also want to monitor them in parallel, you can use the Linux ‘tee’ command.

Here is an example :

./program | tee logfile

The command above will execute the ‘program’. All the logs will be redirected to ‘logfile’ while you can simultaneously view them on stdout (command line in most of the cases) also.

19. How to check if a command succeeded or failed?

Well this can be done through ‘$?‘ environment variable. It holds 0 if last run command was success else it holds a non zero value in case of failure.

Here is an example :

$ touch abc
touch: cannot touch `abc': Permission denied

$ echo $?
1

As the last command failed, so the output was ’1′.

20. How to copy paste on command line through keyboard?

You can copy the text by selecting it first and then by pressing :

CTRL + SHIFT + C

and paste it using :

CTRL + SHIFT + V

Well, that was all from my side. I would really appreciate if you can drop in your comments related to these tricks. Also, it would be great if you can provide any useful Linux command line trick that is not listed here.

WANT TO READ MORE? Read best of MyLinuxBook on FunnyLinuxCommands, Linux netcat command, Bash scripting Part-I, Bash scripting Part-II and Linux strace command.

The post 20 interesting and extremely helpful Linux command line tricks appeared first on MyLinuxBook.

Diffidently, I tried my hands over Linux and acclaimed it. After I started using Linux, I found that it is a must have OS on your machine and realized that what crap was I using for years. Undoubtedly during its initial years Linux had “Gurus Only” image because of its high difficulty level but these days, those gurus or geeks have simplified it nicely for everyone. Believe me that it is not at all difficult to use, it’s just that you are new to it. Once you develop a habit of working on Linux, you will get addicted to this robust and versatile OS.

10 reasons why I won’t miss Windows

Here are 10 reasons why I love Linux :

1. Open Source with Zero Cost

Linux is a free and open source Operating System which means that anyone is allowed to copy the software, check its source code and redistribute it for free under GPL.

2. Terminates the Need of an Expensive Machine

Linux is such a sound OS that it works equally good on an obsolete redundant machine and give away new life to that PC. You don’t need to buy an expensive machine to run Linux.

3. High on Security

With Windows, I was always struggling to get viruses out of my system. Sometimes the system used to get dead slow because of all this crap. But, Linux is designed in such a manner that it protects your PC against viruses, malware and other intruders and I have personally experienced that my Linux machine always works smoothly.

4. Highly Stable

Yes, No blue screen of death here. With Linux, you need not to fear about loosing your important data as it never crashes down. It keeps your computer stable.

5. No Need to Install Drivers and Other Important Stuff

Linux comes with inbuilt drivers and other required stuff like web browser, movie player, image editor etc. So it definitely aborts the need of installing important stuff separately.

6. Strong Community Support

A very commendable word about Linux users and developers is that they are always there and happy to help you. There is no dearth of Linux admirers who keep helping people through web forums, emails etc.

7. Blow the Terms like “Reboot” and “De-fragmentation”

Unlike Windows, Linux never slows down because it is far beyond fragmentation and registry problems. It is a fast and efficient OS which will rarely generate the need of rebooting your machine over a very long period of time.

8. Customizable and Improves Every Second

Linux is a user’s OS as it is highly customizable. You can customize it from themes to fonts as per your requirement. People from all over the world are working over this OS and it is improving every second. Even you can confer to its growth and enrich it.

9. No installation problems

Linux can be installed along with Windows and you can play any number of games for free with this OS.

10. So many flavours

Linux comes in so many flavours that you have a wide variety to choose from. I personally use Ubuntu 12.04 and I love it. You could also try out Linux mint, debian, openSuse etc.

Well, that was all about my experience with Linux. Please share your Linux story here in comments.

Here are some related articles:

http://www.whylinuxisbetter.net/
http://ubuntu-artists.deviantart.com/journal/8-Advantages-of-using-Linux-over-Windows-291681914
http://www.techrepublic.com/blog/10things/10-reasons-why-linux-will-triumph-over-windows/528
http://linuxshark.info/

The post Linux newbie – 10 reasons why I won’t miss Windows appeared first on MyLinuxBook.

Assumption: Ubuntu Linux is used for all the examples in this article. The command line utilities described in this article may or may not be present by default on your Linux system.

Funny and interesting Linux command line utilities

1. Linux ‘sl’ command

Although ‘sl’ stands for ‘steam locomotive’, it was created to jazz up commandline addicts who, in a haste, sometime mistype ‘ls’ command as ‘sl’. Let us unveil what it does by running it on our system.

First we need to install it as it doesn’t come along with standard Linux. However, it is pretty convenient to install it using ‘apt-get’

sudo apt-get install sl

Most of the installation needs sudo privileges. When it is done, type ‘sl’ on the command prompt

$sl

We see an impressive animated steam locomotive loving across the screen from right to left. The locomotive has been drawn using ASCII characters.

Here is how the output looked on my machine:

(Click image to enlarge)

Isn’t is so different than what we see and do on Linux Command line everyday? I think it will definitely bring a smile on the face of the lieux user who was deeply absorbed into running something and realises his typo error on seeing something unexpected and amazing as this animation.

Well, even this simple command have certain options to offer. Here is the excerpt from its man page

SYNOPSIS
   	sl [ -alFe ]

DESCRIPTION
   	sl Displays animations aimed to correct users who accidentally enter sl instead of ls.  SL stands for Steam Locomotive.

OPTIONS
   	-a 	An accident seems to happen. You'll feel pity for people who cry for help.

   	-l 	shows little one.

   	-F 	It flies.

   	-e 	Allow interrupt by Ctrl+C.

One can play a prank on someone by

$alias ls=sl

Caveat: Enjoy at your own risk!

2. Linux ‘yes’ command

Here is a command which just prints the input string repeatedly unless the process is killed. In case, the user does not specify any input string, the default is ‘y’.

This is how the command runs like

$yes mylinuxbook
mylinuxbook
mylinuxbook
mylinuxbook
mylinuxbook
mylinuxbook
mylinuxbook
mylinuxbook
mylinuxbook
mylinuxbook
mylinuxbook
mylinuxbook
mylinuxbook
mylinuxbook
^C$

We kill the foreground running process by ‘ctrl + c’.

Strange, isn’t it? Why would we want a command to keep on printing a string all the life of the process? Though the way it works is silly, but it might not be useless. We can use ‘yes’ command in certain scripts where we want to feed the same answer in a repeated operation. For example, we are doing an operating on a set of files and Linux asks us to confirm for each and every file. We can auto-feed a yes using the ‘yes’ command.

3. Linux ‘rev’ command

Although very simplistic, I found this command very fascinating. It reverses all the input strings given to it line by line. The name of the command ‘rev’ comes from reverse. To play around, type the command ‘rev’ on the command prompt and press enter

$rev

We’ll be prompted by the terminal to provide a string through standard input line by line. We can see the output spontaneously after each line.

Like, here we give the input as ‘mylinuxbook’ and press enter.

mylinuxbook
koobxunilym

To get back to the command prompt, the golden trick of ‘ctrl+c’ works.

We see the reversed string as output on the next line. Again we can type the next string which we want it to be reversed and on pressing enter we get the output on the standard output.

$ rev
google
elgoog
linux is fun
nuf si xunil
^C$

This command also takes the input in the form of a file, where it reverses all the strings line wise in the file and prints the output to the standard output.

$ cat strings.txt
MyLinuxBook
Linux is so much fun!
Happy Birthday
$ rev strings.txt
kooBxuniLyM
!nuf hcum os si xuniL
yadhtriB yppaH

4. Linux ‘fortune’ command

The fortune command is in the same lines as fortune cookies. We get a random adage or a message when we run this command.
It needs an explicit installation first,

$sudo apt-get install fortune

Once the installation is done, the way we run this command is

$ fortune
You have the power to influence all with whom you come in contact.

So with this command, Linux can even stand by us as a fortune teller.

5. Linux ‘figlet’ command

This displays our input string in large characters as banners formed out of ASCII characters.

We need to install this utility as it doesn’t come along with standard.

$sudo apt-get install figlet

This is really amusing to watch our string drawn big on the terminal.

$ figlet mylinuxbook

The snapshot of output:

(Click image to enlarge)

One can add such banners in the scripts headers or sources using ‘figlet’.

6. Linux ‘toilet’ command

I have no idea where this command got it’s name. However, its a very colourful command. Similar to figlet, it displays our text as banners but in a prettier way.

First of all, installation:

$sudo apt-get install toilet

Lets try the simple command :

$toilet mylinuxbook

The output looks like:

(Click image to enlarge)

It is much different and artistic than figlet.

However, it has some colours to offer too. Lets see by running following command

$toilet -f mono12 -F metal mylinuxbook

This is what I get on my system :

(Click image to enlarge)

7. Linux ‘cowsay’ command

The cowsay command is an amusing command. It depicts the power of ASCII characters to draw a cow, sheep, and many other animals. However it might not always be present in every distribution of Linux.

Use following to install on Ubuntu Linux:

$sudo apt-get install cowsay

Now run the command giving it a message string,

$cowsay “Linux is fun”

We see an interesting figure,

(Click image to enlarge)

Basically, we see a cow which is saying the message as per the command input. Although the command name suggests a cow, it also offers to draw a sheep which is saying a message.

$cowsay -f sheep “I too love linux”

The snapshot image I get is

(Click image to enlarge)

To have all the capabilities as to what all animals it can draw, just use option ‘-l.

$cowsay -l

I get following set on my system.

Cow files in /usr/share/cowsay/cows:
apt beavis.zen bong bud-frogs bunny calvin cheese cock cower daemon default
dragon dragon-and-cow duck elephant elephant-in-snake eyes flaming-sheep
ghostbusters gnu head-in hellokitty kiss kitty koala kosh luke-koala
mech-and-cow meow milk moofasa moose mutilated pony pony-smaller ren sheep
skeleton snowman sodomized-sheep stegosaurus stimpy suse three-eyes turkey
turtle tux unipony unipony-smaller vader vader-koala www

Therefore, we can input any of the above animals with the ‘-f’ option.

To make it even more fun, one can pipe fortune message to cowsay as

$fortune | cowsay

I get following output

(Click image to enlarge)

8. Linux ‘cmatrix’ command

This command produces a ‘Matrix’ style animation made of ASCII on the terminal.

Lets install it first

$sudo apt-get install cmatrix

Now run it,

cmatrix

It is really awesome what we get. I won’t say much. Just enjoy!

(Click image to enlarge)

Its an animation so do check it yourself.
To terminate and come out of animation, use ‘ctrl+ c’ key combination.

9. Linux ‘oneko’ command

This is the best of all. I just love it. We all know ‘tom and jerry’, and this command reminds us their chasing game. With this command, we see a cat (I call it tom) which is chasing our mouse (the mouse pointer, tom calls it jerry).

Without further delay, installing works as

$sudo apt-get install oneko

Running the command, we do

oneko

And you can enjoy seeing tom running towards wherever we move the mouse pointer. Though a snapshot can do no justice to the actual version. Still, just as a breather here is a snapshot:

(Click image to enlarge)

The cat i.e tom won’t leave the mouse(jerry) even if we switch the application. That is its not limited to the terminal even.
When you are done, just terminate the process from the terminal by ‘ctrl + c’.

Conclusion

We hope the readers enjoyed knowing about these funny and interesting Linux command line utilities. If anyone knows more of such commands, please leave a comment.

The post The funny side of Linux command line appeared first on MyLinuxBook.

Sometimes we use the terms process and program interchangeably. However, under legitimate glossary, programs and processes are absolutely different terms. When we write a source code of some logic, it is a file which is stored in the hard disk. This file on the hard disk is called as a program. However, when we run this program (i.e. the program executable, obtained after compiling and linking), it creates its own memory space in the RAM. This running instance is a process. A process can be initiated in two significant ways. One, as we just mentioned above, by running a built executable/command from a Linux shell and other, from within a program. We shall discuss programmatic approach more in further sections.

Linux Processes in Memory

Well, now we know that an active process occupies memory in RAM. An immediate question which pops out is, how is this memory allocated, and what all does it enfold?

A clear and comprehensive understanding of the memory layout of linux processes involves myriad linux operating system concepts and memory management theory. Here in this part, we shall learn about some of the key ideas to grasp the overall understanding.

While a process is running, it is doing certain task, so it might have to use the system resources. A simple example to illustrate a system resource is a file on the disk. In order to read a file from the file system, it has be accessed. Now, what if another process has to access the same file on the disk? Who will decide whether it should be allowed to, and if it is allowed and Linux has to manage all the accesses to the file.

How Linux manages its resources is, it does not allow any user running program to directly access any of the system resource. We have system calls in a program which are called from the user space to use the system resources. Only when a process enters kernel space it can access the file, and kernel keeps track of the opened files in the form of kernel file tables.

In memory, every process is given a 4GB of virtual address space considering a 32-bit architecture. The lower 3GB virtual addresses is accessible to the user space portion of the process and the upper 1GB is accessible to the kernel space portion.

Following is a diagram illustrating the 4GB process virtual address space.

              (Click to Enlarge)

The above process memory split of 1G to kernel space and 3G to user space is changeable though as per the need. However, in most of the cases, 1G/3G split suits the best. The program which we generally write to create a process is at the user space, and hence we shall be eyeing more for the user space memory layout of the process. Zooming into the user space address memory layout, there are various segments of a process. Following is a diagram to get the picture clear in our minds.

(Click to Enlarge)

The above diagram is an abstract snapshot of a generic process image in memory. We see the memory has been categorized into various segments in accordance with the ELF format.

Let us walk through these segments and see what is in store there.

Text Segment

The executable binary is mapped onto this text segment and therefore is a read only segment for the process. Basically, this segment contains the instructions to be followed by the processor in a language that the processor understands. Hence this is also called the code segment. In certain scenarios, where multiple processes are created out of the same program, Linux allows sharing of the text segment to avoid reloading the same instructions.

Data Segment

This segment cannot be shared among processes. The data segment is internally parted into two areas. One part of the segment memory holds all the initialized data variables i.e. initialized global variables or static variables. The second part, also called the BSS segment of the process image enfolds the uninitialized data of the program, which includes the global variables which have not been initialized. However, upon the onset of the process, all the data of the BSS segment is zero-initialized.

Heap

When there is a dynamic memory allocation in the process, heap is the segment which is being used for all the dynamic memory allocations. In the C source code of the user program, standard library function ‘malloc()’, ‘calloc()’ or ‘alloc()’ are used to allocate linear memory dynamically.

Stack

The stack contains all the local variables used in the program considering their respective local scopes. Whenever a local variable is defined, it is pushed into the stack and whenever the scope for that local variable ends, it is popped out. The stack might be decreasing or increasing in linear addresses depending upon the underlying architecture.

Shared Libraries

This is no segment as such. In case we have dynamically linked our program to shared objects, shared objects are loaded at the runtime. This part of memory help the process in mapping and accessing the functions which are used from the shared libraries.

The process virtual memory status

We’ve learnt about how the various aspects of a process being held in the memory. Get ready to see the real statistics. However, getting down into the memory, one needs to understand the intricacies of concepts like pages, physical address mappings, etc which is out of scope of our current article.

Anyhow, in this section, we’ll touch base some of it.

To begin with, lets code our ancient hello-world C program.

#include < stdio.h >
#include < unistd.h >

int main()
{
	char mesg[] = "HelloWorld";

	/*We need time to check process stats*/
	sleep(100);
	printf("%s\n", mesg);
	return 0;
}

Well, the above program is pretty straightforward, except the ‘sleep()’ call we have before we print our message. This is because, we want the process to be valid for sometime, so that we can explore the memory layout of the process. While the process is sleeping, we can access the status of the memory layout.

We compile the program and run it in the background.

$gcc helloworld.c -Wall -o helloworld
./helloworld &

To get any information regarding a process, PID is the prime key. Hence, we need to retrieve the assigned PID of our process. (Refer part I to what know PID is.)

$ps
  PID TTY      	TIME CMD
 1746 pts/1	00:00:00 bash
 2808 pts/1	00:00:00 helloworld
 2809 pts/1	00:00:00 ps

In order to get the complete status of our newly created process including the status, size of memory segments, etc, we use command

$cat /proc/2808/status

Note: 2808 in the above command is the PID of our process of interest. The generic syntax looks like

cat /proc//status

Well, this is a command to retrieve data using /proc file system which is a special linux file system providing information about system and processes. More about /proc file system can be referred here. We will see, procfs is really helpful in getting more and more about the current processes.

The output I see on my system is

Name:    helloworld
State:    S (sleeping)
Tgid:    2808
Pid:    2808
PPid:    1746
TracerPid:    0
Uid:    1000    1000    1000    1000
Gid:    1000    1000    1000    1000
FDSize:    256
Groups:    4 24 27 30 46 109 124 1000
VmPeak:    	2048 kB
VmSize:    	1988 kB
VmLck:       	0 kB
VmPin:       	0 kB
VmHWM:     	280 kB
VmRSS:     	280 kB
VmData:      	32 kB
VmStk:     	136 kB
VmExe:       	4 kB
VmLib:    	1788 kB
VmPTE:      	16 kB
VmSwap:       	0 kB
Threads:    1
SigQ:    0/3851
SigPnd:    0000000000000000
ShdPnd:    0000000000000000
SigBlk:    0000000000000000
SigIgn:    0000000000000000
SigCgt:    0000000000000000
CapInh:    0000000000000000
CapPrm:    0000000000000000
CapEff:    0000000000000000
CapBnd:    ffffffffffffffff
Cpus_allowed:    1
Cpus_allowed_list:    0
Mems_allowed:    1
Mems_allowed_list:    0
voluntary_ctxt_switches:    4
nonvoluntary_ctxt_switches:    0

The output gives us humongous information regarding our process.

Name : Name of the process
State   : Process state
Tgid   : Thread group ID, equal to the PID of the process (and this is also the TID of the first thread started in the process).
Pid     :  PID i.e. Process Identifier
PPid  : PID of the parent process.
TracerPid : PID of process tracing this process (0 if the process is not traced).
Uid    : Set of four User IDs: real, effective, saved, filesystem.
Gid   : Set of four Group IDs: real, effective, saved, filesystem.
FDSize : Number of file descriptors in use.
Groups : List of GIDs of supplementary groups.
VmPeak : Peak size of the virtual memory of the process.
VmSize : Current total size of the virtual memory.
VmLck : Size of locked memory.
VmPIN : Size of pinned pages i.e. which are never swappable.
VmHWM : Peak size of the resident set (“high water mark”). The resident set is the part of process memory which currently resides in the physical memory.
VmRSS : Current size of the resident set.
VmData : Size of the data segment.
VmStk : Size of the stack segment.
VmExe : Size of the text segment
VmLib : Size of shared libraries loaded by this process
VmPTE : Size of page table entries
VmSwap : Size of swap space used by this process.
Threads : Number of threads.
SigQ : Two values separated by “/”: Current number of queued signals/maximum allowed number of queued signals. (Signals are one of the means of communication among processes. They are also used to send alerts/notifications to the processes.)
SigPnd : A bitmap (as a hexadecimal value) of pending signals for the thread[2] whose TID == TGID == PID.
ShdPnd : A bitmap (as a hexadecimal value) of pending signals targeted on the whole process.
SigBlk : A bitmap (as a hexadecimal value) of blocked signals for the thread whose TID == TGID == PID.
SigIgn : A bitmap (as a hexadecimal value) of ignored signals (per-process).
SigCgt : A bitmap (as a hexadecimal value) of signals a signal handler is installed for (per-process).
CapInh : The inheritable capability set (a bitmap shown as a hexadecimal value). More about capabilities here
CapPrm : The permitted capability set (a bitmap shown as a hexadecimal value).here
CapEff  : The effective capability set (a bitmap shown as a hexadecimal value). here
CapBnd : The bounding capability set (a bitmap shown as a hexadecimal value). here
Cpus_allowed : A bitmap (as a hexadecimal value) of CPUs where the process may run.
Cpus_allowed_list : A list of CPU numbers where the process may run (same information as Cpus_allowed).
Mems_allowed : A bitmap (as a hexadecimal value) of memory nodes the process can use.
Mems_allowed_list : A list of memory nodes the process can use
voluntary_ctxt_switches : Number of voluntary context switches.
nonvoluntary_ctxt_switches : Number of involuntary context switches.

It is fine, if one is not able to understand what each and every value in the output means. Linux processes are like an ocean of concepts and knowledge. Hence, one cannot take-in everything in one gulp. The principle mantra is try to grasp as much as one can. Things will link on its own in the journey of learning.

Although, at the moment it is significant to know following :

State: S (sleeping)
Since, the process is currently having a valid PID, only because of the sleep() call, hence we understand the process is sleeping.

Tgid: 2808
The thread group ID(Tgid) here is same as the PID of the process

Pid: 2808
Nothing new here, we already knew this number.

PPid: 1746
The parent ID. In our case, the bash shell is the parent process as we executed the binary from the shell. To confirm, just note the PID of ‘bash’ from the ‘ps’ command output.

$ps 
  PID TTY      	TIME CMD
 1746 pts/1	00:00:00 bash

So this confirms our understanding.

VmPeak: 2048 kB
The peak virtual memory size infers that the memory size of the process keeps on varying.

VmSize: 1988 kB
The current size of the virtual memory being used by the process.

VmData: 32 kB
The size of the data segment of the process in memory.

VmStk: 136 kB
The size of the stack segment of the process in memory

VmExe: 4 kB
The size of the text segment of the process in memory is 4KB

VmLib: 1788 kB
The size of virtual memory occupied by the shared objects is 1788KB.

Threads: 1
The number of threads. Since, we never started any new thread, just the main thread is running.

The real addresses

It is time to jump into the addresses of the segments which we just discussed in the previous section of this article. The process segments are also termed as virtual areas in the kernel terminology. Worth mentioning, the addresses we see in this section are all virtual addresses.

We shall pick up the same ‘helloworld’ program what we wrote in the previous section.
Let us create our process and get it running and sleeping

$./helloworld &

We again will use the procfs to get the absolute process virtual memory mapping to each segment. The generic command would be

 cat /proc//maps

The process ID would be different this time, hence we need to get it through linux ‘ps’ command.

  PID TTY      	TIME CMD
 1746 pts/1	00:00:00 bash
 2866 pts/1	00:00:00 helloworld
 2867 pts/1	00:00:00 ps

Therefore, with the new process ID as ‘2866’, we read the procfs as:

$ cat /proc/2866/maps

The memory maps from my system looks like

$ cat /proc/2866/maps
08048000-08049000 r-xp 00000000 08:01 393767 	/home/ubuntu/progs/helloworld
08049000-0804a000 r--p 00000000 08:01 393767 	/home/ubuntu/progs/helloworld
0804a000-0804b000 rw-p 00001000 08:01 393767 	/home/ubuntu/progs/helloworld
b75b0000-b75b1000 rw-p 00000000 00:00 0
b75b1000-b7750000 r-xp 00000000 08:01 658874 	/lib/i386-linux-gnu/libc-2.15.so
b7750000-b7752000 r--p 0019f000 08:01 658874 	/lib/i386-linux-gnu/libc-2.15.so
b7752000-b7753000 rw-p 001a1000 08:01 658874 	/lib/i386-linux-gnu/libc-2.15.so
b7753000-b7756000 rw-p 00000000 00:00 0
b7765000-b7768000 rw-p 00000000 00:00 0
b7768000-b7769000 r-xp 00000000 00:00 0      	[vdso]
b7769000-b7789000 r-xp 00000000 08:01 658854 	/lib/i386-linux-gnu/ld-2.15.so
b7789000-b778a000 r--p 0001f000 08:01 658854 	/lib/i386-linux-gnu/ld-2.15.so
b778a000-b778b000 rw-p 00020000 08:01 658854 	/lib/i386-linux-gnu/ld-2.15.so
bf8d2000-bf8f3000 rw-p 00000000 00:00 0      	[stack]

Plethora of hexadecimal numbers, correct? Welcome to the world of memory addresses!  First of all, let us understand what each column of the output signify.

• 1st column from the left, is the start address and the end address of a particular segment.
• 2nd column is a string which depicts the permission flags where :

 r means readable
w means writable
x means executable
p means private i.e it is not shared.
s means shared

• 3rd column is again a number which indicates the offset in the file where the mapping begins. Not every segment is mapped from a file, so the value of offset is zero in that case.
• 4th column is of the form “major number : minor number” of the associated device, as in, the file from which this segment is mapped from. Again, the segments which are not mapped from any file, value is 00:00.
• 5th column is the i-node of the related file.
• The last column on the right is the path of the related file. Its blank in case there is no related file.

In order to identify the segments, we need to notice the access permissions associated with each segment. Lets take the first segment i.e. the first row of the output.

 
08048000-08049000 r-xp 00000000 08:01 393767 	/home/ubuntu/progs/helloworld

The access permissions implies it is a readable and executable private segment. From the all the segment descriptions, we can make out it is the text segment. The text segment is the read-only with contains the instructions from the binary. Looking at the related file, it is not hard to guess, the region from virtual address ‘08048000’ to ‘08049000’ is the text segment of our helloworld program.
Moving on to the next row

08049000-0804a000 r--p 00000000 08:01 393767 	/home/ubuntu/progs/helloworld

From the permissions, this looks like a read-only private segment. This is one of the additional segment a process image can possess.

The next one,

0804a000-0804b000 rw-p 00001000 08:01 393767 	/home/ubuntu/progs/helloworld

Again, noticing the access permissions, its a read/write segment which points to the data segment of the process.

The following row again looks like a segment with read/write permissions.

b75b0000-b75b1000 rw-p 00000000 00:00 0

However, it is not related to any file (as offset = major # = minor # = inode = 0 and file is blank). It is the BSS segment which is mapped to the zero page and is initialized to zero therefore making it a zeroed memory area.

The next ones, again reads like a text segment, read-only segment and data segment and bss respectively, but the related file is a shared object. Our program is implicitly dynamically linked to the ‘libc’ standard library, which we can see here.

b75b1000-b7750000 r-xp 00000000 08:01 658874 	/lib/i386-linux-gnu/libc-2.15.so
b7750000-b7752000 r--p 0019f000 08:01 658874 	/lib/i386-linux-gnu/libc-2.15.so
b7752000-b7753000 rw-p 001a1000 08:01 658874 	/lib/i386-linux-gnu/libc-2.15.so
b7753000-b7756000 rw-p 00000000 00:00 0

Note that, although these segments are mapped out of a shared object, though currently in this virtual memory area, they are not shared. Hence the permissions states them as private memory mapping.

We have similar set of segments (read, read-only and data) for the dynamically linked ld library.

b7769000-b7789000 r-xp 00000000 08:01 658854 	/lib/i386-linux-gnu/ld-2.15.so
b7789000-b778a000 r--p 0001f000 08:01 658854 	/lib/i386-linux-gnu/ld-2.15.so
b778a000-b778b000 rw-p 00020000 08:01 658854 	/lib/i386-linux-gnu/ld-2.15.so

Besides, we have three more additional segments as listed below.

b776or5000-b7768000 rw-p 00000000 00:00 0
b7768000-b7769000 r-xp 00000000 00:00 0      	[vdso]
bf8d2000-bf8f3000 rw-p 00000000 00:00 0      	[stack]

The first one represents yet another anonymous read/write segment which may be used as a backing store.
The second one, though not related to any file, but specifies itself by [vdso]. It is a special memory area for kernel provided shared library to aid userspace call to kernel-space. The abbreviated full form is virtual dynamically linked shared object.
The third one is the stack segment. It is already know it enfolds all the local variables.

A simple exercise

We have one local variable in our helloworld.c program. Let us check out which segment it belongs to in the process image. It is pretty simple. What we need to do is just print the address of the variable and find the correct address range from the memory mapping which includes the address of our variable.

To print the address of the variable, we modify our helloworld.c to

#include < stdio.h >
#include < unistd.h >

int main()
{

	char mesg[] = "HelloWorld";

	/*We need time to check process stats*/
	sleep(100);

	printf("Address of string mesg is %x\n", mesg);
	printf("%s\n", mesg);

	return 0;
}

Lets build and run the binary, and in the meantime till we get the address of our ‘mesg’ variable, lets get the memory mapping of the newly created process.

$gcc helloworld.cl -o helloworld
$./helloworld &
  PID TTY      	TIME CMD
 1746 pts/1	00:00:00 bash
 3036 pts/1	00:00:00 helloworld
 3037 pts/1	00:00:00 ps

Retrieving the memory segment mapping,

$ cat /proc/3036/maps
08048000-08049000 r-xp 00000000 08:01 393656 	/home/ubuntu/progs/helloworld
08049000-0804a000 r--p 00000000 08:01 393656 	/home/ubuntu/progs/helloworld
0804a000-0804b000 rw-p 00001000 08:01 393656 	/home/ubuntu/progs/helloworld
b759e000-b759f000 rw-p 00000000 00:00 0
b759f000-b773e000 r-xp 00000000 08:01 658874 	/lib/i386-linux-gnu/libc-2.15.so
b773e000-b7740000 r--p 0019f000 08:01 658874 	/lib/i386-linux-gnu/libc-2.15.so
b7740000-b7741000 rw-p 001a1000 08:01 658874 	/lib/i386-linux-gnu/libc-2.15.so
b7741000-b7744000 rw-p 00000000 00:00 0
b7754000-b7756000 rw-p 00000000 00:00 0
b7756000-b7757000 r-xp 00000000 00:00 0      	[vdso]
b7757000-b7777000 r-xp 00000000 08:01 658854 	/lib/i386-linux-gnu/ld-2.15.so
b7777000-b7778000 r--p 0001f000 08:01 658854 	/lib/i386-linux-gnu/ld-2.15.so
b7778000-b7779000 rw-p 00020000 08:01 658854 	/lib/i386-linux-gnu/ld-2.15.so
bff47000-bff68000 rw-p 00000000 00:00 0      	[stack]

After 100 secs since the launch of our process, we get,

Address of string mesg is bff66561
HelloWorld

We need to find out, the address 0xbff66561 lies in which memory segment.Therefore, look for memory segment whose end-address is greater than 0xbff66561. We can see only one memory segment entry with has its end address greater than 0xbff66561 address value.
That is,

bff47000-bff68000 rw-p 00000000 00:00 0      	[stack]

Now, check the start address of this segment if it is less than 0xbff66561. Yes, it is. Hence we are sure the variable ‘mesg’ is stored in the above memory segment which is the stack.

One more

So, now, we know the virtual addresses of the process memory areas and we also confirmed our understanding that local variables go to stack. But did we miss heap in the above discussed output? Well, maybe it was never used.
Lets write another program with a dynamic memory allocation which uses heap. To get realistic, let us convert a number to its corresponding string. the C source looks like

#include < stdio.h >
#include < stdlib.h >
#include < unistd.h >

int g_init_number = 123;
int g_uninit_temp;

/*convert a number to a string*/
int main()
{
	int local_size = 1;
	char *dynmem_str = NULL;
	int local_i = 0;
	int local_temp_int = 0;

	/*Determine the length of our output
    string i.e how many numbers form our number*/
	g_uninit_temp = g_init_number;
	while (1)
	{
    	g_uninit_temp /= 10;
    	if (!g_uninit_temp)
    	{
        	break;
    	}
    	local_size++;
	}

	/*Allocate memory for string of
	*   	 computed size + 1 for terminating
	*   	 null character*/      	 
	dynmem_str = (char*) malloc ((local_size + 1) * sizeof(char));
	if (dynmem_str == NULL)
	{
    	printf("Memory error!\n");
    	exit(1);
	}

	g_uninit_temp = g_init_number;
	for (local_i = local_size - 1;local_i >= 0 ; local_i--)
	{
    	local_temp_int = g_uninit_temp % 10;
    	dynmem_str[local_i] = local_temp_int + '0';
    	g_uninit_temp /= 10;
	}

	dynmem_str[local_size] = 0;

	printf("The output string is %s\n", dynmem_str);

            /*We need time to get hold of the memory maps*/
	sleep(100);

	printf("\n\nAddresses of local variables: &local_size = %x\n \t &local_i = %x\n\t &local_temp_int = %x\n", &local_size, &local_i, &local_temp_int);
	printf("Address of global initialized variable g_init_number = %x\n", &g_init_number);
	printf("Address of global un-initialized variable g_uninit_temp = %x\n", &g_uninit_temp);
	printf("Address of dynamically allocated variable dynmem_str = %x\n", dynmem_str);

	free(dynmem_str);
	return 0;
}

In the above written source, first of all we determine the size of our output string i.e. number of individual characters that form the number. We make an effort to determine the size, because we wish to dynamically allocate the memory for the output string, for which we need the size.

Once we have the size, allocate that much amount of memory and apply the logic to populate this newly allocated memory with our desired number-equivalent string.

In the end, we print the addresses of all the data i.e. variables used in the program. We’ll repeat the exercise of determining which variable goes in which memory segment. This will help us give a full-proof seal to our understanding.
We are all set for the fun. Lets build and run the program.

$ gcc memmaps.c  -o memmaps
./memmaps &
[2] 2423

To clench the PID of our newly created process,

$ ps
  PID TTY      	TIME CMD
 2004 pts/1	00:00:00 bash
 2423 pts/1	00:00:00 memmaps
 2424 pts/1	00:00:00 ps

Now using the PID of our ‘memmaps’ process, we retrieve the memory maps

$ cat /proc/2423/maps
00110000-00111000 r-xp 00000000 00:00 0      	[vdso]
00514000-006b7000 r-xp 00000000 08:01 15729750   /lib/i386-linux-gnu/libc-2.15.so
006b7000-006b8000 ---p 001a3000 08:01 15729750   /lib/i386-linux-gnu/libc-2.15.so
006b8000-006ba000 r--p 001a3000 08:01 15729750   /lib/i386-linux-gnu/libc-2.15.so
006ba000-006bb000 rw-p 001a5000 08:01 15729750   /lib/i386-linux-gnu/libc-2.15.so
006bb000-006be000 rw-p 00000000 00:00 0
00993000-009b3000 r-xp 00000000 08:01 15732611   /lib/i386-linux-gnu/ld-2.15.so
009b3000-009b4000 r--p 0001f000 08:01 15732611   /lib/i386-linux-gnu/ld-2.15.so
009b4000-009b5000 rw-p 00020000 08:01 15732611   /lib/i386-linux-gnu/ld-2.15.so
08048000-08049000 r-xp 00000000 08:01 7345013	/home/ubuntu/aprograms/memmaps
08049000-0804a000 r--p 00000000 08:01 7345013	/home/ubuntu/aprograms/memmaps
0804a000-0804b000 rw-p 00001000 08:01 7345013	/home/ubuntu/aprograms/memmaps
082f1000-08312000 rw-p 00000000 00:00 0      	[heap]
b76ec000-b76ed000 rw-p 00000000 00:00 0
b7700000-b7703000 rw-p 00000000 00:00 0
bfe5a000-bfe7b000 rw-p 00000000 00:00 0      	[stack]

After 100 seconds of sleeping of the process, we get the addresses of all the variables as well.

Addresses of local variables: &local_size = bfe79520
	  &local_i = bfe79524
   	   &local_temp_int = bfe79528
Address of global initialized variable g_init_number = 804a028
Address of global un-initialized variable g_uninit_temp = 804a034
Address of dynamically allocated variable dynmem_str = 82f1008

We got all the data to analyse. First look at the procfs output. we got the memory map entry for heap as well. It is given area from virtual address 082f1000 to 08312000.

Studying the addresses printed by the program, its not that difficult to affirm, the local variables belong to the stack segment, as stack memory begins at address 0xbfe5a000 and end at 0xbfe7b000. The address if local variable ‘local_size’ is 0xbfe79520 which is

0xbfe5a000	 >	0xbfe79520	 <	 0xbfe7b000
|stack-start-addr|	|local_size addr|	|stack-end-addr|

Similarly, the address of ‘local_i’ = 0xbfe79524 and ‘local_temp_int’ = bfe79528 lies within the address limits of the stack.

Next, moving on to check which memory segment the global variables belong to. The initialised global variable ‘g_init_number’ is at memory address 0x804a028 and the un-initialized global variable ‘g_uninit_temp’ at memory address 0x804a034 falls in the range of the read/write memory segment

0804a000-0804b000 rw-p 00001000 08:01 7345013	/home/ubuntu/aprograms/memmaps

We rightly comprehended it as the data segment. Although internally the the un-initialized globals should be in the bss portion of the data segment as per our understanding.

The last but not the least, we have the pointer ‘dynmem_str’ which stores the address of the dynamically allocated memory i.e. 0x82f1008. Looking at the memory map, this address belongs to

082f1000-08312000 rw-p 00000000 00:00 0      	[heap]

This memory area represents the heap. So, we even proved that ‘malloc()’ allocates memory from the heap segment.

Creating new processes from existing processes

Standard C facilitates to create new processes from a program in execution. This is called creating processes from a running process, which is generally true in most of the cases. Another paramount fact is that, when a process creates a new process, both the two processes have their own separate memories in the RAM, where each of the process have their own individual memory segments.

There are two popular ways of creating new processes from a program.

The system() method

Standard C gives its programmers a convenient option to run commandline commands/executables from within a program. It is done through the system() method.
The syntax from the man page looks like:

   	#include < stdlib.h >
   	int system(const char *command);

It takes a command in the format of a string as its input argument and returns the command status after the command completion.
Here is an example program to illustrate the use of the system() method

#include < stdio.h >
#include < stdlib.h >

int main()
{
	int retcode = 0;
	retcode = system("cat sys.c");

  	 return retcode;
}

Compiling and running the built binary,

$ gcc sys.c -Wall -o sys
$./sys

The output I get is:

#include < stdio.h >
#include < stdlib.h >

int main()
{
	int retcode = 0;

	retcode = system("cat sys.c");

   return retcode;
}

Pretty much as we expected. It runs the command given to the system() method which displays the contents of the ‘sys.c’ file on the standard output.

However, interesting to know is that it isn’t the ‘sys’ process which created the new process running ‘cat’ executable. With the system() method, it creates new process ‘shell’ and hands over the command to it, which in turn triggers the ‘cat’ command and creates that process. To confirm, let us run our ‘helloworld’ binary from our source and check its parent process.

Here is the modified source, to trigger ‘helloworld’

#include < stdio.h >
#include < stdlib.h >

int main()
{
	int retcode = 0;
	retcode = system("./helloworld");

	return retcode;
}

We build the source and run the binary in the background.

$ gcc sys.c -Wall -o sys
$./sys &

We know running ‘helloworld’ executable is a blocking call as it has a 100 sec sleep().
Therefore, in the meanwhile, first wish to see what all processes are running and their PID’s.

$ps
  PID TTY      	TIME CMD
 1912 pts/1	00:00:00 bash
 2112 pts/1	00:00:00 sys
 2113 pts/1	00:00:00 sh
 2114 pts/1	00:00:00 helloworld
 2115 pts/1	00:00:00 ps

We get an inkling from the running ‘sh’ process that it must have been started by the system() call in the ‘sys’ process. Alongwith, we also notice the ‘helloworld’ process running, which has been launched from within our program using the ‘system()’ call.

To check the parent process of ‘helloworld’, we use the Linux command ‘ps’ as

$ps -f
UID    	PID  PPID  C STIME TTY      	TIME CMD
ubuntu  1912  1902  0 16:12 pts/1	00:00:00 bash
ubuntu  2112  1912  0 18:07 pts/1	00:00:00 ./sys
ubuntu  2113  2112  0 18:07 pts/1	00:00:00 sh -c ./helloworld
ubuntu  2114  2113  0 18:07 pts/1	00:00:00 ./helloworld
ubuntu  2116  1912  0 18:08 pts/1	00:00:00 ps -f

Note: One can also use the procfs as /proc/2114/status to know the PPID of the ‘helloworld’ process.

From the ‘ps -f’ output, our line of interest i.e.

ubuntu  2114  2113  0 18:07 pts/1	00:00:00 ./helloworld

sets forth the PPID as ‘2113’ which is the PID of the shell process. Moreover, the PPID of the shell process is ‘2112’ which is the PID of our ‘sys’ process. The numbers above says it all.

Caveat  : Although, using the ‘system()’ method is pretty convenient, it has limitations and drawbacks too. Since, it uses shell to run the command, the behavior of the command will depend upon what shell it is using. If the shell is compromised in security, using the ‘system()’ method could be a hazard.

The fork() method

The fork() call is used to create a duplicate child process as the parent process which is calling it. So, from the point, the fork() call was made, both the parent and the child process starts executing the same program.
The syntax from the man page is

#include < unistd.h >
pid_t fork(void);

Since when this method returns, we have two processes running the same program. Therefore, in the main parent process, the return value is the PID of the newly created child process. However, in the newly created child process, the return value is zero. This is a significant distinguishing parameter between a child process and the parent process while in the program. We shall see more in the later discussions.

Although we would be discussing the data-structures related to processes in the next part, we can’t ignore the datatype used for the PID.

pid_t

Therefore, if we want to store a PID in a variable, we now know what data-type it should be.

Further, we shall experience using the fork() method in a program.

#include < stdio.h >
#include < unistd.h >

int main()
{
	pid_t pid_child = 0;
	int a = 12;
	int b = 3;
	int result = -1;

	printf("All set to create another process\n");
	pid_child = fork();
	if (pid_child)
	{
    	result = a + b;
    	printf("Parent process : The result is %d\n", result);
	}
	else
	{
            /*The pid_child = 0*/
    	result = a * b;
    	printf("Child process : The result is %d\n", result);
	}

	/*Buying time to check the running processes*/
	sleep(100);
	return 0;
}

In the above example source code, we do two different operations in both the child and parent processes. The way we distinguish what to do in the parent process and what has to be done in the child process is by checking the value of returned PID by the fork() call.

In the parent process, the value returned by fork() would be a valid PID i.e. non-zero positive value. However, in the child process instance, the variable value would be just zero, as this process has just been created. Well, we’ve sent both the processes to sleep for 100 seconds.

Time to compile and launch the process:

$ gcc frk.c -Wall -o frk
$./frk &
[3] 2153
$ All set to create another process
Parent process : The result is 15
Child process : The result is 36

The process is now sleeping after printing the results. Meanwhile, let us check the active process information.

$ps -f
UID    	PID  PPID  C STIME TTY      	TIME CMD
ubuntu  1912  1902  0 16:12 pts/1	00:00:00 bash
ubuntu  2153  1912  0 18:57 pts/1	00:00:00 ./frk
ubuntu  2154  2153  0 18:57 pts/1	00:00:00 ./frk
ubuntu  2155  1912  0 18:57 pts/1	00:00:00 ps -f

From the above output, we identify our two processes with the same command. One of them(1) is a parent process which as the PPID of the ‘bash’ and other(2) is the child process which has the PPID as the PID of (1).

(1) ubuntu  2153  1912  0 18:57 pts/1	00:00:00 ./frk
(2) ubuntu  2154  2153  0 18:57 pts/1	00:00:00 ./frk

Conclusion

Linux processes part II is an effort to extend the horizons of the readers with how processes reside in the virtual memory of Linux along with a pragmatic approach to visualize the memory areas. The article also talked about how we can create processes programmatically. We hope this could be a little contribution in the vast and diversified topic as Linux Processes and provide a platform to initiate a child process in the mind of readers, which begins playing around with the memory addresses and launching new complex processes.

For now,

 $ps
 PID CMD
 222 Article Linux Process Part II

 $kill -9 222

In the Linux processes part III, we shall get apprised with data-structures related to processes and much more.

Want more? Read an interesting article on file extensions in Linux.

The post Linux Processes explained – Part II appeared first on MyLinuxBook.

• Word processor
• Impress
• Calc
• Draw
• Math
• Base.

If you are used to MS-Office but want to switch over to a free and open source alternative the you must give LibreOffice a try. This comprehensive office suite gives you high professional quality productivity. In this article, keeping in mind the theme ( LibreOffice for beginners ), we will briefly explain six feature-packed applications of LibreOffice that will definitely help you to get started with this amazing office suite.

LibreOffice For Beginners

1. WRITER

LibreOffice Writer is a word processor inside this office productivity suite. User can create text documents like letters, resumes etc. as well as include graphics, tables and charts. You can also merge the long and complex documents in it. Documents can be saved in various formats as it is compatible with ODF, HTML, Word.doc etc.

LibreOffice Writer includes a thesaurus, auto-completion, a spell checker, auto-correct and various templates. With this program, user can design and structure their documents using its style and formatting options. User can create a complete book as it gives you full platform where you can put tables, create diagrams, embed illustrations, create indexes and do much more.

Then user can do desktop publishing, calculations, create drawings, insert graphics with different formats and much more using LibreOffice word processor. Navigation is easier with LibreOffice and drag-drop feature is an add-on. You can create from a simple text document to a very complex book as this office suite has no dearth of options, you just need to explore more.

(A Snapshot of LibreOffice Word in action)

2. CALC

LibreOffice Calc is a spreadsheet program which is similar to Microsoft Excel. Calc can be used to calculate, analyse, and manage your data as well as modify and import Microsoft Excel spreadsheets. Users can manage and save their data with spreadsheets like in excel sheets. User can easily organize the data in tabular form which also makes the analysis easier.

You can arrange your data and can quickly perform mathematical calculations over it. Calc has inbuilt functions including statistical and banking functions, that you can use to create formulas to perform complex calculations on your data. User can always add to or reorganize these spreadsheets. This program also lets you present spreadsheet data in dynamic charts as shown in the screen-shot that gets updated automatically when the data changes as well as it can convert files in various formats which LibreOffice Calc is compatible with.

 (A Snapshot of LibreOffice Calc in action)

3. IMPRESS

LibreOffice Impress is like Microsoft power point application which lets you create smart presentations. This presentation program enables you to display information in the form of a slide show. Using Impress program, user can create professional slide shows that may include charts, drawing objects, text, multimedia and a various other items. You can even import and modify Microsoft Power-Point presentations with this program as it is compatible with MS-Power Point.

Special effects and stunning inbuilt animations will let you create powerful and effective multimedia presentations. You can create slides using multiple feature options and then choose to run them either automatically or manually. With the help of vector graphic tools, you can create impressive vector graphics in your slides.

(A Snapshot of LibreOffice Impress in action)

4. DRAW

LibreOffice Draw is a drawing application like Microsoft Visio that lets you draw and make sketches right from the scratch. You can produce from simplest to complex drawings using this program. User can insert tables, charts, formulas and much more from the gallery which contains images, sounds, animations etc. You can also create vector graphics like ellipses, lines etc.

You can create 3D objects like spheres, cubes etc. and even modify them as per your requirement. Then you can display dimensions, connect objects to show relationships etc. and believe me that it is not at all difficult. It is compatible with common graphic file formats like PNG, JPG, GIF etc.

 (A Snapshot of LibreOffice Draw in action)

5. BASE and CHART

Base is a database component of LibreOffice with which you can create and manage databases like you do with Microsoft Access. This program supports dBase format but you can also use Base to connect to external databases. You can use charts which enable you to present data in a form which is easy to visualize and understand. You can produce a chart from source data in a Calc spreadsheet or a Writer table.

 (A Snapshot of LibreOffice Base in action)

6. MATH

LibreOffice Math function is an application which is used to type a formula directly or create it with the help of its operators, functions and formatting assistants which are listed in the selection window. This application enables you to create and edit mathematical formulas which include mathematical functions, integrals, fractions, equations and much more. You can create a formula directly in this application and insert it in your document or you can also start this application from within the Writer, Calc and Impress via menu.

 (A Snapshot of LibreOffice Math in action)

Interested in more?

Here are a few links for you :

• Homepage
• Download
• Wikipedia Link
• A video for Beginners

The post LibreOffice For Beginners – Six Feature Packed Applications To Get You Started appeared first on MyLinuxBook.

The scrot utility can be used to take screen-shots from command line. There are various options available with this command that make this utility equally powerful and flexible as its graphical peers. In this article we will discuss some important and useful features of scrot utility through practical examples.

Scrot

The scrot utility does not come by default on most of the Linux distributions. You have to download it first. For example, on my Ubuntu machine, I used the following command to download scrot utility :

sudo apt-get install scrot

Once the utility is downloaded, it can be used as a command on Linux command line.  Now lets discuss in detail the usage of scrot command along with its options.

1. Scrot without any options

If you use the scrot command without any options then it will capture the complete screen in a .PNG image and save it in the current directory. The name of the file would be derived from current date and time.

Here is an example :

$ scrot

$ ls | grep *.png
2013-03-28-204412_1280x800_scrot.png

So you see that after running scrot command, a date stamped .PNG file was created in current directory.  If I open this image, it looks like :

(Click to enlarge)

So we see that complete screen was captured when scrot command was run without any option.

2. Select capturing area using -s option

Like any other capable screen shot utility, scrot is also capable of capturing user defined area of screen. This can be done by using -s option along with scrot command.

Here is an example :

$ scrot -s

When you hit enter after typing the above shown command, the scrot utility waits for user to select a screen area of interest using mouse. You can then select an area using your mouse and as soon as you release the mouse button, a screen shot is taken and stored as .PNG file in current directory.

Here is capture that I did using this option :

3. Store the output in a directory other than current directory.

As you would have observed till now, the scrot command saves the captured image in current directory. But, if a path is specified along with scrot on command prompt then this utility saves the image in that directory. Also, if you specify the name of file in the path then it even uses that name for the captured file.

Here is an example :

$ scrot /home/himanshu/Desktop/testScrot.png
$ cd /home/himanshu/Desktop
$ ls | grep test*.png
testScrot.png

So you can see that the file was stored in the specified directory and with the specified name.

4. Add delay before taking screen shot through -d option

Just like a family photograph (that includes the photographer also) , sometimes it is required to introduce a delay before taking a screen-shot on a computer. The scrot utility provides an option -d for doing the same.

For example :

$ scrot -d10

The command above would wait for 10 seconds before capturing the screen.

5. Display a countdown through -c option

If you are using a delay (-d option) then scrot provides a countdown feature through -c option. If you use -c option with -d option then a countdown is displayed during the delay session.

Here is an example :

$ scrot -cd10
Taking shot in 10.. 9.. 8.. 7.. 6.. 5.. 4.. 3.. 2.. 1.. 0.

As you can see a countdown was displayed during 10 seconds of delay.

6. Generate a thumbnail through -t option

The scrot utility also provides an option -t through which a thumbnail of captured image can be generated. This option requires an argument that specifies the percentage of the original size for the thumbnail.

Here is an example :

$ scrot -t20
$ ls
2013-03-28-220748_1280x800_scrot.png  2013-03-28-220748_256x160_scrot-thumb.png

So you can see that along with the captured image, a thumbnail (whose size is 20% of the original) was also produced.

7. Capture only the currently focused window through -u option

There are when screen is full of applications each covering small area.

For example :

(Click to enlarge)

Now, in this kind of scenario, if it is required to take screen shot of a specific window rather than the whole screen then you can use the -u option provided by scrot utility.

If it is desired to take snapshot of the command prompt window the simply run the following command :

$ scrot -u

This command will capture only the command prompt window.

If it is desired to take snapshot of some other window then you can use the delay option (-d) with scrot command, run the command and during the delay focus the window (ie make the desired window your current window by clicking on it). The scrot utility will automatically take the screen shot of the focused window.

8. Open an application to display the screen shot through -e option

If you have ever used a graphical screen shot utility, you would have observed that it immediately displays the captured screen shot. The scrot utility also provides the same capability through -e option. For example, I used the following command to capture screen through scrot and display it through gimp utility.

$ scrot -e 'gimp $n'

This is a special syntax that is required to execute gimp tool with the file saved. It’s worth noting that $n represents the file-name with which the screen-shot will be saved. Instead of gimp, you can use any other tool but $n will remain same.

Just like $n, there are various other format specifiers :

$f image path/filename (ignored when used in the filename)
$n image name (ignored when used in the filename)
$s image size (bytes) (ignored when used in the filename)
$p image pixel size
$w image width
$h image height
$t image format
$$ prints a literal ‘$’

Besides displaying a screen shot using a relevant application, the -e option opens up infinite possibilities. For example, if you want to take a screen shot and store its copy to a separate directory (screenshots) then this can be done in the following way :

$ scrot -e 'cp $n ~/screenshots'

So you can see that you can do endless stuff with -e option.

Just like we discussed the some format specifiers above, there exists another category of format specifiers for year, month and day :

%Y – For year

%d – For date

%m – For month

Here is an example using these specifiers :

$ scrot '%Y-%m-%d_UbuntuLinux.png'

$ ls | grep *UbuntuLinux*
2013-03-28_UbuntuLinux.png

So we see that these format specifiers were replaced by current year, month and date respectively.

Note : To learn about some other interesting Linux commands, read our articles on netcat and strace commands.

The post Empower Linux Command Line With Screen Capturing Capability Through Scrot appeared first on MyLinuxBook.