To know the return value of a command, in BASH run
$ echo $?
and in CSH/ TCSH run
$ echo $status
which will give you the return value (0 or 1) of the last command (the one issued just before the echo).

In both the shells, if the above spits out 0 (zero), it means the previous command was successfully completed, otherwise it’ll give rise to 1 (unsuccessful!) — quite contrary to our concept of 0 being false and 1 being true, eh!

Credit: Oracle Spin.

I’ve been working on some graphics work using SlimDx. I really like the library but the documentation is sparse in some places

Divide et impera (pronuncia: dìvide et ìmpera) è una locuzione latina che tradotta letteralmente significa

dividi e domina. Divide et impera (pronuncia: dìvide et ìmpera) è una locuzione latina che tradotta letteralmente significa dividi e domina. Ai tempi dei romani era il modo di governare il territorio italiano e di evitare rivolte da parte delle popolazioni italiche.

Un esempio moderno si poteva veder applicato nell’impero coloniale britannico, più precisamente nell’India britannica, dove gli inglesi utilizzavano marginalmente i loro eserciti, ma al contrario alimentavano le diatribe tra le tribù che combattevano l’una contro l’altra, ignare che cosí facendo semplificavano il governo e il dominio dei britannici.

Nello specifico, gli inglesi mantennero i confini regionali tra le varie etnie indiane, per preservare le diversità culturali e linguistiche nonché gli attriti e le rivendicazioni territoriali di un’etnia sull’altra, e per mantenere i dissapori e i contenziosi di carattere religioso e sociale. Difatti, questa situazione sopravvisse anche all’indipendenza delle India britannica, che sfociarono in una serie di lotte interne al subcontinente indiano, che frammentarono quello che un tempo era il grande impero indiano-britannico in 6 stati indipendenti (India, Pakistan, Nepal, Bangladesh, Bhutan e Sri Lanka) invece che in una grande entità nazionale. Le diatribe e i contenziosi tra etnie avevano vinto sulla volontà di un popolo di costituire una nazione unita.

Durante este tiempo que he hecho esta serie de post me he dado cuenta de 2 cosas, las aplicaciones son tan funcionales como las de GUI y que la mayoria de los que comentan usan Vim , asi que hoy les traigo esta util aplicacion.

Vifm o vi file manager, es un explorador de archivos basado en ncurses, que se maneja a traves del teclado y comandos que recuerdan a Vi, la interfaz es de 2 paneles o si solo queremos uno ejecutamos la orden nly y para regresar a la vista predeterminada :split. Otros comandos utiles en este programa son la busqueda de archivos (/expresion de busqueda), colocar marcadores a las carpetas para su pronta navegacion(m[0-9][a-z][A-Z] y los podemos ver con :marks), ejecutar archivos, usar sesiones de screen, y claro que no puede faltar la edicion de texto con Vim.

Vifm solo depende de Python y puede encontrarse en la mayoria de las distribuciones. En Ubuntu se encuentra en los repositorios universe y en Arch Linux en AUR.

Espero que les sirva esta aplicacion.

Mata ne!

There may be occasions when you may need to split a huge file  into smaller pieces for storage restrictions (or if you plan on sending them piece-by-piece to a friend!):

The following nifty trick (picked up from Commandline-fu) explains how a directory, <dir>, can first be tarred and split into smaller pieces and later rejoined as need arises:

$ tar cf - <dir> | split -b<max_size>M - <name>.tar.

Rejoin later with `cat’ and then extact:

$ cat .tar.* |tar xf -

Credit: Commandline-fu.

UPDATE: Problems with the first line of the code is fixed. This arose in the first place because when I put <dir> in the  raw HTML box, it just ignored it since <dir> is not a valid HTML tag (as if I wanted it to be!).

خیلی از کسایی که عشق لینوکس هستن بیشتر اوقات دوست دارن به کامند لاین ور برن تا این که کارشون رو به صورت گرافیکی انجام بدن‌! این پست هم مختص همون افراده! البته این کار برای سرور ها و… هم کاربرد داره
اول باید مخازنمون رو عوض کنیم!
فایل etc/apt/sources.list را باز کنید و تمامی خط ها را کامنت کرده و سپس مخازن جدید را به آن اضافه کنید:(لیست مخازن را از خود سایت دریافت کنید)
برای آپگرید دستور زیر را بزنید
sudo apt-get update && sudo apt-get dist-upgrade && sudo apt-get dist-upgrade
حالا سیستم عامل شروع به دانلود پکیج های جدید می کند! که ممکن است چند ساعتی طول بکشد
سپس برای اطمینان از تمام شدن کار دستورات زیر رو بزنید:
sudo apt-get update && sudo apt-get dist-upgrade

sudo dpkg --configure -a
سیستم را ریست کنید
خوش باشید

Click click click……..

Instrucciones: (Por si no se dan cuenta de que en la página están)
Deben de ver la cruz del centro por 20 MINUTOS nah… haaha 20 segundos y de alli miren a algun otro lugar… yo les recomiendo ver otra página de internet… y asi finalmente entenderán porque la Vista Aguosa… y no Pablo… no se vista aguosa porque llorás sino porque simula la superficie del agua………………… Just kidding….

de neave.com

Who wouldn’t appreciate an application named after the Ewok word for freedom?

If you like the command line, you’ll love <a href=”http://yubnub.org”>YubNub</a>. And even if you don’t know what the command line is, you’ll probably still love YubNub because it saves you time just about every time you use the browser. For the first in a series of screencasts on applications I can’t live without, I couldn’t have picked a better one: the Ruby built application is a staple of my everyday life.

Come see why in this video.

Notes: Screencast was recorded with gtk-recordMyDesktop, audio was recorded with Audacity, and the final video was rendered using PiTiVi. Thanks to those projects for their hard work.

This is an update on our bash command line calculator posted a few days ago — except for the fact that this time we’ll use awk to do the calculation instead of bc. As I mentioned in that post, you may use python or ruby (irb) to do the same thing, but these tricks may be useful if you don’t ruby or python installed (bc and awk, in general, come by default in any Unix or GNU/Linux distro).

First, create (or rewrite if you used our last trick) function “?”  as follows and put it in your ~/.bashrc file:

and make sure to reload your ~/.bashrc file (do the similar thing if you're using any other shell). [NOTE: ZSH does not like ``?'' as a function, so you might consider replacing it with something reasonable, e.g., ``compute'']


Now, if you want to calculate an expression, do it, for example, as

and don’t forget the quotes.

.

The advantage of this over bc is that you can use more arithmetic and trigonometric functions (link):

              atan2(y,x)     Arctan of y/x between -pi and pi.

	      cos(x)	     Cosine function, x in radians.

	      exp(x)	     Exponential function.

	      int(x)	     Returns x truncated towards zero.

	      log(x)	     Natural logarithm.

	      rand()	     Returns a random number between zero and one.

	      sin(x)	     Sine function, x in radians.

	      sqrt(x)	     Returns square root of x.

.
You may include variables as well in the function definition itself:

where we have defined the variable pi and degree (such that tan(pi/4.0) = 1.0 and pi radians is equivalent to 180 degrees) to be used later, e.g.

and I’m sure that you’ll get -1 and 0 (within the machine precision), respectively, as the answer!

(You may find some more interesting calculator related tricks posted in this blog scattered in different pages)

Credit: here and here (via LifeHacker).

UPDATE: I just realized that I can use the calc package (besides bc, awk, python and irb) to do the command line math wizardry more efficiently (and let’s take that as the end to this command line calculator series!). It has a larger set of built-in functions. You may grab the source code from the maintainer’s website and follow my instructions to install it on your system [although binaries are also readily available, e.g. apcalc package for Ubuntu 9.10 (Karmic Koala)].

Out of laziness I’ll just plagiarize LifeHacker for this tip.

When you spend as much time at the terminal as I do, having a calculator at your fingertips can be a really useful feature, and the Command-Line Fu web site tells us how to create one easily.

To create the calculator, you can just enter this function on the command line to test out how it works, or add it into our ~/.bashrc file to make sure that it’s always available after restarting the terminal.

calc(){ awk "BEGIN{ print $* }" ;}

To use it, you can simply type calc followed by the calculation you want to solve, making sure to use quotes around the calculation if there are spaces or special characters the shell can’t handle. For instance, if you entered calc 3*99/7+18 at the prompt, you’d get 60.4286 as the answer. For more complex calculations, you can use parenthesis, but make sure to put quotes around it, like this:

calc "((3+(2^3)) * 34^2 / 9)-75.89"

It’s an extremely useful tip for those of us that live at the terminal. It should work on any OS running the bash shell, including Linux, Mac OS X, or even Windows with Cygwin installed.

Up until I saw this I used bc as a calculator. This should shave off a few seconds from basic calculations.

[Lifehacker]

I sometime have problem finding which persistent process is not letting me eject a volume (CD/DVD/USB drive). The error message is not very helpful at all:

Try quitting applications

OK, but which one(s)? I often have hard time figuring that out using htop/ top or a combination of ps and grep.

But actually this is what I want:

where Volume_Name is the name of the volume (or an ‘identifying’ part of the name) I want to eject. This gives me the name(s) and process ID(s) of the run-away process(es) as well as the path to the file(s) in use on the volume, Volume_Name.

Now that I know the names I should first try to save the documents and quit the applications involved in the normal way. However, if a particular application does not oblige, I can always kill it (with the risk of potential data loss!) using its process ID (say, 123):

After that, the ejection of the volume should not be difficult at all.

Needless to say, being a Unix utility, lsof (=“list open files”) may be used on other *nix-based systems as well.

You may find out your IP using commands like ifconfig, but if your computer is behind a firewall, that is not the IP that the world sees. Here’s a quick how-to to find out what your external IP is.

First, let’s create an alias: (link)

Next time when you need the public IP of your computer, just type getip in the command line and hit enter.

The above command gets the IP from http://whatismyip.com/automation/n09230945.asp (just copy and paste this URL to your location bar and hit enter, and see what it does!). The “-q” is to suppress verbose information (quiet mode) and “-O -” causes the output to be written to STDOUT.

You may use dyndns.org too to find out the IP, but in this case you may need some trimming: substitute the text within the code above by the following:


wget http://checkip.dyndns.org/ -O - -o /dev/null | cut -d: -f 2 | cut -d\< -f 1

A few words about various flags above:
The output of the first command (everything before the first pipe) is

<code><html><head><title>Current IP Check</title></head><body>Current IP Address: xxx.xxx.xx.xx</body></html>

(the actual IP address is masked by x).
The “-o /dev/null“ part redirects the STDERR of wget to /dev/null. The “-d :” option in first “cut” tells it to use colon (:) to be used as the delimiter and “-f 2” causes it to print second of the delimited fields. Similarly, the flags of the second “cut” cause it to use “<” as the delimiter for the piped output from the first “cut” and choose the first of the delimited fields.

UPDATE: Another one using curl [link]. You may again change the quoted text within the alias above by the following:


curl --connect-timeout 3 http://www.whatismyip.org/

I quite often don’t bother starting something as slow as X just to watch a video or view some images. This can be achieved through something called framebuffer. I’m not the right person to describe what it is exactly, so I’ll just quote wikipedia for convenience.

The Linux framebuffer (fbdev) is a graphic hardware-independent abstraction layer to show graphics on a console without relying on system-specific libraries such as SVGALib or the heavy overhead of the X Window System. Linux kernel has generic framebuffer support since 2.1.107 kernel.

To start, you should either switch over to one of the 6 (default) ttys with the handy Ctrl-Alt-F[1-6] and login. That or you could simple shutdown X (usually done by stopping the [gkx]dm service). You are likely to notice that the font is stretched and clearly not displayed at your native resolution. To remedy this you should first find out the code for the mode that your tty should be running at. You can do this by running hwinfo –framebuffer as root. Install as needed.

$ sudo hwinfo --framebuffer
02: None 00.0: 11001 VESA Framebuffer
[Created at bios.464]
Unique ID: rdCR.DOLBnVJRT0D
Hardware Class: framebuffer
Model: "NVIDIA G92 Board - 071116A"
Vendor: "NVIDIA Corporation"
Device: "G92 Board - 071116A"
SubVendor: "NVIDIA"
SubDevice:
Revision: "Chip Rev"
Memory Size: 14 MB
Memory Range: 0xf9000000-0xf9dfffff (rw)
[........]
Mode 0x0362: 768x480 (+768), 8 bits
Mode 0x0364: 1440x900 (+1440), 8 bits
Mode 0x0365: 1440x900 (+5760), 24 bits
Mode 0x0368: 1680x1050 (+1680), 8 bits
Mode 0x0369: 1680x1050 (+6720), 24 bits
Mode 0x037c: 1920x1200 (+1920), 8 bits
Mode 0x037d: 1920x1200 (+7680), 24 bits
Config Status: cfg=new, avail=yes, need=no, active=unknown

You should (hopefully) find a mode that corresponds to your native resolution, if not then you are out of luck – your gpu doesn’t support it. If you see multiple entries with the correct resolution, pick the one with the greatest depth (24 bits). In my case, the correct mode is 0×0369. Now that I have it, all I do is append it vga=0×0369 to my kernel line in grub’s menu.lst. Here’s mine.

kernel        /boot/vmlinuz-2.6.31.5-20091024 root=UUID=2d8a6294-3a89-4a94-8c2a-81962ccb37c4 ro vga=0×369 rootflags=data=writeback

Sadly, the only way I know of getting into the mode is by restarting. If anyone has a better way to instantly set the resolution please comment.

After the restart, you should get back into a tty and login. To view images, you need fbi, which (I assume) stands for frame buffer imageviewer. Install as needed. Let’s say you want to see that photo of your cat you took yesterday. All you have to do is

$ fbi my_delicious_kitty.jpg

And voila! Your kitty is on your display without the help of X! You can pan or zoom. Press h for help, q to quit. Of course you can load multiple images at once.

$ fbi *kitty*.jpg

And you can browse through them with Page up and Page down. Unfortunately animated gifs are not supported.

But what if you wanted to watch a video? That’s just as simple.

$ mplayer -vo fbdev2 kitty_in_the_sunshine.ogm

Add the -fs arg to center the image on the screen.

————————————————-

Ok, maybe that wasn’t a “bite size” tip, but it is nonetheless rather helpful. Be sure to check out man pages of both mplayer and fbi for more details.

Feedup with gray on black text?
Want a simple way to combine formatting out with colour?

    public static class MyConsole
    {

        /// <summary>Writes the text representation of the specified objects to the standard output stream using the specified format information.</summary>
        /// <param name="s">the list of objects to write</param>
        /// <example>
        /// <code>
        /// MyConsole.WriteLine("\rthe cost of the application is :", ConsoleColor.White, "{0:c}!", product.cost );
        /// </code>
        /// </example>
        /// <remarks>
        /// the objects in the list should be:
        /// <list type="">
        /// <item>ConsoleColor</item>
        /// <item>format</item>
        /// <item>Object 1</item>
        /// <item>Object 2</item>
        /// <item>Object 3</item>
        /// <item>Object n</item>
        /// </list>
        /// this then can be repeated.
        /// </remarks>
        public static void WriteLine(params object[] s)
        {
            Write(s);
            Console.WriteLine();
        }

        /// <summary>Writes the text representation of the specified objects to the standard output stream using the specified format information.</summary>
        /// <param name="s">the list of objects to write</param>
        /// <example>
        /// <code>
        /// MyConsole.WriteLine("\rthe cost of the application is :", ConsoleColor.White, "{0:c}!", product.cost );
        /// </code>
        /// </example>
        /// <remarks>
        /// the objects in the list should be:
        /// <list type="">
        /// <item>ConsoleColor</item>
        /// <item>format</item>
        /// <item>Object 1</item>
        /// <item>Object 2</item>
        /// <item>Object 3</item>
        /// <item>Object n</item>
        /// </list>
        /// this then can be repeated.
        /// </remarks>
        [CLSCompliant(false), HostProtection(SecurityAction.LinkDemand, UI = true)]
        public static void Write(params object[] s)
        {
            ConsoleColor cc = Console.ForegroundColor;
            try
            {
                List<object> lo = new List<object>();
                string format = null;
                foreach (object o in s)
                {
                    if (o is ConsoleColor)
                    {
                        Console.Write(format, lo.ToArray());
                        lo.Clear();
                        format = null;
                        ConsoleColor cfc = (ConsoleColor)o;
                        Console.ForegroundColor = cfc;
                    }
                    else if (format == null)
                    {
                        if (o is string)
                            format = (string)o;
                        else
                            throw new ArgumentOutOfRangeException("format should be a string");

                    }
                    else
                    {
                        lo.Add(o);
                    }
                }
                if (format != null)
                {
                    Console.Write(format, lo.ToArray());
                }

            }
            finally
            {
                Console.ForegroundColor = cc;
            }
        }

    }

to use it use

                MyConsole.WriteLine("\rthe cost of the application is :", ConsoleColor.White, "{0:c}!", 100);

Ever wanted to quickly send files to someone without using any of those fancy uploading services? Bash (python) has a solution.

python -c 'import SimpleHTTPServer;SimpleHTTPServer.test()'

That will serve your pwd on port 8000 (default), which you can visit in a browser. It looks like this:

To terminate it, simply ^c. If you want others outside your lan to view this, you need to open up a port (I’m assuming here most people sit behind routers these days).

The main advantage over file hosting services is that the recipient starts downloading the content instantly, no need to wait for it to upload, then have them download. With that comes the disadvantage that you can’t really have multiple people download at once because most home up speeds are crap.

Com esta entrada inauguro aqui no debiandicas uma nova rubrica, aplicações leves, rápidas e que fazem de forma exemplar as funções para as quais foram concebidas, correndo em CLI, ou seja no terminal.

De uploads

Quando arrancamos esta aplicação, vem à cabeça o excelente gestor de ficheiros também de consola, o MC, que por aqui falarei numa próxima entrada.

Aqui fica uma pequena lista do site polishlinux e tuxarena:

• a add music files to the playlist
• C clear the playlist
• Right Arrow seek forward
• Left Arrow seek backward
• Space play/pause currently selected song
• s stop playing
• S shuffle playlist
• R repeat playlist
• Tab switch between panels
• , increase volume by 5%
• . decrease volume by 5%
• Q quit mocp
• ? get help

• ENTER – switch to a folder, start playing the song, etc
• ‘o’ – play URL (for instance some Internet radio)
• ‘p’ or space bar – pause playing
• ’s’ – stop playing
• ‘l’ – switch between one and two-column view
• ‘a’ – add current file to the playlist
• ‘A’ – add current folder (recursively) to the playlist
• ‘C’ – clear the playlist
• ‘q’ – turn the console interface off (MOC server is still running and you can come back by entering mocp again)
• ‘Q’ – hard power-off MOC

MOC can be also manipulated when the console interface is switched off. Here are some commands that may be useful for that:

• ‘mocp -S’ – run the MOC server
• ‘mocp -p’ – start playing the playlist
• ‘mocp -f’ – switch to the next track on the playlist
• ‘mocp -r’ – switch to the previous track on the playlist
• ‘mocp -s’ – stop playing
• ‘mocp -P’ – pause playing
• ‘mocp -U’ – resume playing
• ‘mocp -x’ – kill the server

E pronto toca a curtir música a partir do terminal, gastando poucos ciclos de CPU e ainda menos RAM.

Powered by ScribeFire.

Powered by ScribeFire.

Did you want to run some command again, but don’t remember what it was? If it’s still in your history, you can try ‘reverse-i-search’ -ing it.

In bash, just press ^r, and you should have something along the lines of this show up:

(reverse-i-search)`':

Just type what ever part of the command you want, and it will search through history, backwards (most recent results first). Press ^r until you find what you’re looking for (or until you run out of history), following which you can press enter to run that command or left/right arrow keys to edit it first. This command is especially useful if you have an unlimited history, because you can find something you executed over a year ago.

Note: you can use grep on ~/.bash_history, but it’s generally faster to use ^r.

When you execute programs in the shell, where do you think the binaries are stored? /bin, /usr/bin, /usr/local/bin, etc. But how about adding some custom paths? What if you have some personal scripts, but don’t want to move them to any of the system bin folders? There’s a simple solution for that. What does the following print out for you?

$ echo $PATH
/home/kernel/bin:/usr/local/bin:/usr/bin:/bin:/usr/games:/home/kernel/scripts/

This is how bash knows where to search for binaries. Searching the whole system would be terribly inefficient, thus it is restricted to a few folders. $PATH is an environment variable, and because it is a variable, you can change it.

$ export PATH="$PATH:~/bin"
$ echo $PATH
/home/kernel/bin:/usr/local/bin:/usr/bin:/bin:/usr/games:/home/kernel/scripts/:/home/kernel/bin/

What we did here is set the value of $PATH to itself, plus the custom path you want to add. As you can see from the previous example, the paths are separated by colons, so we do the same here. Now you can execute whatever executables you want that are located in the ~/bin folder.

If you were to quit the shell however, your change to the variable would be lost. To make the change permanent, do the following:

$ echo export PATH="$PATH:~/bin" >> ~/.bashrc

Here we append that command to the bashrc file (config for your bash), so it would get set every time you open up a terminal.

Note: only files with execute permissions will work, otherwise bash would not be able to tell what you want to execute, and what you don’t.

I myself forget to use this, although it saves lots of time. The following goes back to the previous dir that you were in:

cd -

That way you don’t have to type in the whole path. So a quick usage example would be:

$ pwd
/home/kernel/.themes
$ cd /usr/share/themes/
$ pwd
/usr/share/themes
$ cd -
/home/kernel/.themes
$ pwd
/home/kernel/.themes
$

It’s like that previous channel button on the tv remote. Learn it, use it, love it.

Apparently you can use PHP via a command line interface (CLI). Fancy that!

I’m not sure if it’s worth it or whether I want to, but for some reason I’ve always liked CLIs. Maybe it’s because of the simplicity of command-response. Maybe it’s because there’s something mysterious about the obscure sequence of characters that you need to learn. I’m not even sure if anyone’s reading this. Even they are, I’m not sure if they’ll find this interesting. And if they do, I’m not sure if they’ll find it useful.

I’m just not sure.

I’m pretty sure it’s almost time to go home soon, though. I’m also almost certain that if I keep typing like this and don’t look at the clock then the time will fly by. Except now I’m thinking about it, so it won’t. Gah!

Too often I see people doing something like this:

cat /foo/bar | grep baz

Now why would you do that? This is not the *nix way. How it should be done is:

grep baz /foo/bar

This is also advantageous because it allows you to search multiple files, without having them all grouped into one long string first.

First, some basics about directory stack:

1. Show directory stack with indices:
$ dirs -v
The top directory, i.e. the one with index=0, is the current working directory. On the other hand,
$ dirs [-N | +N]
where -N (+N) will show the Nth directory from bottom (top) where the entry at bottom (top) has index=0.

2. Add a directory, dir, to the stack
$ pushd -n dir
which puts dir (index=1) just below the current working directory (index=0) but above all others in the stack. If the -n is missing, pushd will change the working directory to dir thus causing dir to have index 0 and all other directories to be pushed down the stack.

3. Go to the Nth directory from the top without changing the relative positions of the entries in the stack:
$ pushd +N
“rolls up” the stack to bring the directory with index N on top so that now it has index 0 (the indices of other directories in the stack change accordingly so as to keep the relative positions fixed).

4. Effect of cd: substitute the top directory with another_directory:
$ cd another_directory
will replace the top direcotry (index=0) with another_direcotory, as well as you’ll be taken to another_directory.

5. Remove an entry from the directory stack:
$ popd +N
will remove directory with index N counting from top (first is always 0) from the stack. If you remove the top directory (i.e. the working directory, i.e. the one with index 0) you’ll be automatically taken to the next directory in the stack,  whose index then will become 0.

Tilde Expansion [link]

$ echo ~N   # same as: echo `dirs +N`
$ echo ~+N  # same as: echo `dirs +N`
$ echo ~-N  # same as: echo `dirs -N`


Example

$ cd ~N
will replace the top directory with the Nth directory (without any other change in the stack). The same effect may be invoked by
$ pushd -n +N