Live Fast - Code Young

I'm an Engineer!

2011-11-17T16:22:00.003+02:00

Haven't posted for a very very long time, but this one deserves at least a tiny post. This blog's subtitles changes from A software engineering student's blog to A software engineer's blog. Yepee!

C# rocks or how I made the Shmorgif Animator

2009-12-11T19:03:00.006+02:00

The other day I was looking for a free tool to make .gif animations. I haven't found anything free worthy of using, so I figured I might as well write my own with the features _I_ would like to see in a simple gif animator.

You can download it here.

A quick search brought me to the NGif library page on CodeProject, this is the core code that actually does all the animating, I've simply set up [what I'd like to think is] an intuitive GUI.

Features:

Drag/Drop images on the app window to load new frames.
Change the order of the frames
Remove/add frames
Preview animation
View thumbs of individual frames
Pause/Play animation
Change delay between frames
Set custom quality
Set loop on/off

Let me know if you want the details

ADXL345 accelerometer breakout board + Arduino and Processing

2009-11-30T18:03:00.062+02:00

Some time ago I've purchased an ADXL345 accelerometer breakout board from SparkFun.com. After some searching and datasheeting (that's an awful term, I know :D), I've finally came up with code, which will allow me to talk to the accelerometer using my Arduino and even pass the data on, to Processing (it's a fun language, covered in my previous post)

In this post I will cover the setup for the communication procedure between the ADXL345 and the Arduino and then, between the Arduino and Processing (ie your PC). All the sources are at the bottom of the post, as usual.

To tell you the truth, I don't know which you should do first, code the Arduino or hook up the ADXL (probably code first), but my fingers were itchy, so I hooked up the ADXL to the Arduino first:

Here's how it actually looks in life (click the pics for larger image)

Now, after we have everything plugged in nicely, we may start writing the code for getting the acceleration values from the sensor. You might want to have the ADXL345 Datasheet handy while you code.

There are two ways to talk to the sensor, SPI and I2C protocols. I've chose the I2C (the schematics above are for I2C communication) because it is easier to wire for, and easier to code - the downside, they say, is that I2C is slower.

The Arduino Wire library provides a sort-of-easy way to interact with components that implement the I2C communication protocol. I wish I could say it's usage is straightforward, but it is not quite so. There are few catches! Though, if you're aware of them, the library should be easy to use.

Open page 10 in the datasheet, this page explains how to talk to the device using I2C protocol. When using I2C protocol there are two ways (yes, again two ways) to wire the ADXL345, each way gives it a different device address (so that may prevent address collision). You can see, that the wiring I chose, defines the device address as 0x53, the datasheet also says that this translates to 0xA6 address for write and 0xA7 address for read (because the base device address is 7-bit + 1 read/write bit). Ignore the read and write addresses as the Wire library takes care of this for us (catch).
Now, at the bottom of page 10 in datasheet, you see a diagram of how reads and writes should be performed. We'll start with the writes because:

It's what we do first in the code
Surprisingly, it's easier to do

The diagram shows that in order to perform a write to a register on a device, we need to go through the following steps:

Initiate transmission to device (using write address*)
Write the address of the register we want to write
Write the data we want to write to the register
Finish transmission

* We only use the base address of the device (0x53) because the read/write bit is handled by the Wire library.
** You will also note that there are 'ack' signals coming from the device, those are too, handled by the library

Looks pretty logical, and here's a function that will write a value to a certain register on a specified device (you'll need to add #include <Wire.h> to the top of your program to use the Wire library):

void writeTo(int device, byte address, byte val) {
Wire.beginTransmission(device); //start transmission to device 
   Wire.send(address);        // send register address
   Wire.send(val);        // send value to write
   Wire.endTransmission(); //end transmission
}

So, let's say we want to write the value 8 to register 0x2D on device 0x53 (true story :D), we'll use this function like that:

writeTo(0x53, 0x2D, 8);

Ok, that was easy. The reading function is a bit longer, but uses similar conecepts, so it's not going to be hard to follow. This time we want to perform a multiple-byte reading (as opposed to single byte writing we did in the writeTo() function). We need to read 6 bytes of data from the sensor (2 bytes for each axis), because, as the datasheet suggests, we don't want one axis value to change while we're reading another axis' values.

Lets look at that communication diagram on page 10 of the datasheet again. The steps we are to follow, in order to perform a multi-byte reading, are:

Initiate transmission to device (using write address*)
Write the address of the register we want to start** reading from
Initiate transmission to device, again! (using read address*)
Read bytes one after another
Finish transmission

* Again, we only use the base address of the device (0x53) because the read/write bit is handled by the Wire library.
** When we're doing multiple bytes read (or write) we provide the start address - for example 0x15 - and the number of bytes we want to read - for example 4. That way we'll read values of registers 0x15, 0x16, 0x17, 0x18

So, let's see the read function:

void readFrom(int device, byte address, int num, byte buff[]) {
Wire.beginTransmission(device); //start transmission to device 
  Wire.send(address);        //sends address to read from
  Wire.endTransmission(); //end transmission

Wire.beginTransmission(device); //start transmission to device (initiate again)
  Wire.requestFrom(device, num);    // request 6 bytes from device

int i = 0;
while(Wire.available())    //device may send less than requested (abnormal)
  {
buff[i] = Wire.receive(); // receive a byte
    i++;
}
Wire.endTransmission(); //end transmission
}

The new elements in this function are

Wire.requestFrom(device, num) - requests num number of bytes from device. The reading will start from the register passed in the Wire.send() call.
Wire.available() - returns true if there's something to read from the device
Wire.receive() - reads one byte from the device

Essentially, this function performs the reading steps listed above. One thing to note, the result is saved in the buff array, and not returned by the function. So you must pass an array to the function and it has to be long enough to hold the data.

Whew! Ok, we have the read and write functions set. We're ready to write a program that will talk to the sensor (finally).

#include <Wire.h>

#define DEVICE (0x53)    //ADXL345 device address
#define TO_READ (6)        //num of bytes we are going to read each time (two bytes for each axis)

byte buff[TO_READ] ;    //6 bytes buffer for saving data read from the device
char str[512];                      //string buffer to transform data before sending it to the serial port

void setup()
{
Wire.begin();        // join i2c bus (address optional for master)
  Serial.begin(9600);  // start serial for output

//Turning on the ADXL345
  writeTo(DEVICE, 0x2D, 0);    
writeTo(DEVICE, 0x2D, 16);
writeTo(DEVICE, 0x2D, 8);
}

Most of the code is pretty self-explanatory, so I'll explain only the code after the //Turning on the ADXL345 comment.
As you can see we are writing three different values to register 0x2D. 0x2D is the Power Control register of the ADXL345 (see datasheet). We first reset the power control register, then put the sensor in standby mode, and last we are putting it in to measure mode. We're doing the writes one after another because that's what the datasheet recommends. We could simply do the last write also. If you don't turn on the fourth bit on (writeTo(DEVICE, 0x2D, 8)) the sensor will be in sleep mode, and will give zero readings!!

And now, finally, the reading loop:

void loop()
{
int regAddress = 0x32;    //first axis-acceleration-data register on the ADXL345
  int x, y, z;

readFrom(DEVICE, regAddress, TO_READ, buff); //read the acceleration data from the ADXL345

//each axis reading comes in 10 bit resolution, ie 2 bytes.  Least Significat Byte first!!
//thus we are converting both bytes in to one int
  x = (((int)buff[1]) << 8) | buff[0];
y = (((int)buff[3])<< 8) | buff[2];
z = (((int)buff[5]) << 8) | buff[4];

//we send the x y z values as a string to the serial port
  sprintf(str, "%d %d %d", x, y, z);
Serial.print(str);
Serial.print(10, BYTE);

//It appears that delay is needed in order not to clog the port
  delay(15);
}

Let's start from the beginning. The regAddress variable represents the register we want to start reading from (registers 0x32 - 0x37 are acceleration data registers, page 18 in the datasheet). We're defining the ints (x,y,z) which we'll use later, to send the data through serial port to Processing.
Next we're performing a readFrom function call, we pass our device's address, the register address to start reading from , the number of bytes to read and the buffer in which to save the data.
Now comes the tricky part - convert the data received from 2 bytes in to one int. Each axis' pair of bytes are manipulated, in order to create an int from two bytes using C bitwise operators (see here and here for more info on bitwise operators in C).
Afterward we're using the sprintf() function to turn the integers we have in to one string. And then we send that string to the serial port, terminating it with end-of-line character. The delay in the end is not strictly necessary, but it gave me better performance that way.

That's it! Below is a link to the sources - it also contains a matching Processing application to read the data and manipulate a model on the screen accordingly.

The next step is writing an actual 3D game for this thing, I'll probably do it using Microsoft's XNA studio, which appears to be pretty awesome. Stay tuned. Questions and comments are of course welcomed.

Source code files

Programmer and Artist? (Processing and pixlr.com discovery)

2009-11-24T12:12:00.019+02:00

Very long time passed since my last post. Since then I have discovered more than a few interesting things but some of them will have to wait as I'm not yet proficient enough to elaborate on those. I'm going to devote this post to something that is close to my heart as an ex-animator and as a programmer - computer generated art (and relevant tools)!

Part 1

First of all we'll start with a relatively young (2001 born) programming language - Processing. As stated on the processing website: Processing is an open source programming language and environment for people who want to program images, animation, and interactions.

The language is designed to be simple, so that artists and hobbyists can use it also. Processing is Java based, which leads to all kinds of cool effects:

If you're not new to that kind of syntax (C++/Java) you're good to write pretty complex code almost instantly
It's object oriented

You can export your sketches (that's how applications are called in Processing) directly to Java applets or applications!
It's system independent

I've been messing with it for a few weeks now and I must tell you, it's lots of fun! It has a nice little IDE, which is not too feature-rich (to say the least) but is very light and fast to grasp.

Here's an example of a game I made in a bit more than an hour - including the exporting and uploading to the web.

Part 2

Now to my other (not less exciting) finding!
Recently I've read some blogposts about the controversial ChromeOS. One dude was claiming that we need raw horse power on our puters because Picasa's editing tools are fun, but they're not Adobe Photoshop. Regardless of my opinion of this (I think he's actually right about the whole ChromeOS thingie), another guy made a great point by simply saying pixlr.com.

pixlr is an online image processing tool, and damn, it's a good one! Here's a short list of my pros:

It's free
It's web based! Simply open your browser and it runs
It has most of the tools I need in photoshop to do my occasional image editing
It's shortcuts and menus are almost PS identical
It loads FAST
Last but not least, you have an API - I havn't gone in to it too deep, but it looks like cool stuff could be done with it!

I've found this app to be extremely useful in the 2-3 days that I actually know it. Give it a run ;)

Have fun, and let me know if you have any questions!

Simple PHP socket-based terminal chat

2009-07-23T15:14:00.058+03:00

Some time ago I decided it would be interesting to write an extremely simple PHP terminal chat to try out PHP's sockets and the socket_select() function usage. If you're not in to reading, feel free to skip to the samples and/or the sources ;)

What is a socket_select() (or *_select() for that matter) you ask? In general a select() function takes a list of resources (files, sockets, etc) and waits for at least one of them to be available for reading (or writing), and when that happens it lets you know which resources from the lists you've passed are ready for action. This is extremely helpful when dealing with sockets, because they - unlike local files for example - aren't as ready to be read or written to because of net lag and such. Why am I telling you this? Because this function is crucial for writing a responsive real time chat in PHP.

Because of the fact that my first serious encounter with select() was in Communication Applications course - we coded in C - I naively believed that the socket_select() function in PHP will be glad to take file descriptors and sockets mixed just like the C select() function does. I was very wrong.

PHP actually has different (!!) selects for files and for sockets. A question arose in my head: WTF!? Doesn't that kinda beat the point of select if I can not actually monitor two different resource types?? Well, after some foruming and reading I've found out that you can spawn sockets in a file stream form, using the stream_socket_server() and the stream_socket_client() functions. Great! Now that we know some techy details, we can look at some code:

Server side setup

$PORT = 20222;            //chat port
$ADDRESS = "localhost";    //adress
$ssock;        //server socket
$csock;        //chat socket
$uin;        //user input file descriptor

$ssock = stream_socket_server("tcp://$ADDRESS:$PORT");        //creating the server sock

echo "Waiting for client...\n";
$csock = stream_socket_accept($ssock);            //waiting for the client to connect
                                        //$csock will be used as the chat socket
echo "Connection established\n";

$uin = fopen("php://stdin", "r");        //opening a standart input file stream

What did we do?
In the first two lines we define the address and the port for the socket. Then we use the stream_socket_server() function to create a TCP server socket in stream form, so it can be used later by stream_socket_accept(). The $ssock stream is used only for waiting for an incoming call from a client, it's not actually used for the communication. The $csock is the actual chat socket we will use, it will be open as soon as a client initiates communication with the server. As soon as that happens we give the user a notification that we're connected and put the standart-input stream in to $uin so that we can take user input directly from command line.

Now for the code meat. The communication/select loop!

Server communication

$conOpen = true;    //we run the read loop until other side closes connection
while($conOpen) {    //the read loop

    $r = array($csock, $uin);        //file streams to select from
    $w = NULL;    //no streams to write to
    $e = NULL;    //no special stuff handling
    $t = NULL;    //no timeout for waiting
    
    if(0 < stream_select($r, $w, $e, $t)) {    //if select didn't throw an error
        foreach($r as $i => $fd) {    //checking every socket in list to see who's ready
            if($fd == $uin) {        //the stdin is ready for reading
                $text = fgets($uin);
                fwrite($csock, $text);
            }
            else {                    //the socket is ready for reading
                $text = fgets($csock);
                if($text == "") {    //a 0 length string is read -> connection closed
                    echo "Connection closed by peer\n";
                    $conOpen = false;
                    fclose($csock);
                    break;
                }
                echo "[Client says] " .$text;
            }
        }
    }
}

What are we doing? The while loop will run umm.. while connection with the other side is open (if we got this far in the code it is already open).
Now what are the $r, $w, $e and $t variables? Understanding this part is 80% of understanding select().

The $r is an array of streams (sockets, files, etc) we want to read from. As soon as one of them becomes available for reading, select() returns.
The $w is the same as the $r only it will wait for streams to become available for writing instead of reading.
The $e is for high-priority in-bound communication (not interesting atm)
The $t variable tells the stream_select() function for how long should it wait for a change of status of any of the streams passed to it in the various arrays. We don't want a timeout (ie we don't mind waiting forever), that's why we set it to NULL. Btw, setting $t to 0 will only check once and return immediately.

A most important thing to know about the select() family is that it changes the arrays you pass to it! And leaves in the array only the streams that has actually changed status. What does it mean? Well, two things in general:

Save your streams in other place, so you don't lose them after passing them to select().
Re-initialize your $r, $w, and $e arrays every time you call select().

Back to our issue, when the stream_select() function returns with values greater than 0, we know that we have a stream we can read from! And that's exactly what we are doing in the foreach loop, we iterate over the changed array of streams and read from each one of the available streams. If it's the socket stream, we read the data and put it on the screen, if it's the user input, we send it to the socket.
Another thing to note: when connection on the other side closes, the socket appears to be readable, but, we can only read 0 bytes (empty string). This is how we know the connection was closed.

Now let's take a look at the client setup

$PORT = 20222;    //chat port
$ADDRESS = "localhost"; //adress

$sock = stream_socket_client("tcp://$ADDRESS:$PORT"); //creating the client socket

echo "connection established\n";

$uin = fopen("php://stdin", "r"); //opening a standart input file stream

Looks pretty much like the server setup, except for the fact that we don't need two sockets. We use the same socket for connection and communication. The communication loop of the client is almost identical to that of the server so I'm not going to cover it. You can get both sources at the bottom of the post.

Running the chat
Open two terminals, one for server and one for client.
First run server.php (I'm on Linux):

$> php server.php

The server now waits for an incoming connection

then go to your other terminal and run client.php:

$> php client.php

Both programs should notify you that connection has been established, now type something in any of the terminals to test communication :)

Server:

Client:

You can find the sources here. Questions, suggestions, criticism and love letters are welcome!

Copying programming homework

2009-05-15T10:39:00.017+03:00

Before I start telling you the story which led me to write on this topic, I feel I'm obligated to reveal the main idea of this post:
In order to copy programming homework, you mustn't be a dumb fuck. (And a few ways to avoid being one)

And now the story. I have a colleague (let's call him John) at work who also checks programming courses homework at my college. Our college is really harsh about students copying programming homework (you can xerox algorithms homework, but programming is a big no-no).

One day John gets an email from one of the students claiming that he has submitted the last exercise but in the grades sheet it was marked "Wasn't submitted", so he demanded from John to check the issue. John checked his college email inbox to see if he has overlooked the poor guy's exercise. Surprise! The guy indeed sent him a programming exercise that week. Why wasn't it graded then? Well, when he opened the exercise to check it (as he was sure he overlooked it the first time) he saw that the name and the ID number at the top of the source code files were those of another student, not the one who submitted them and demanded a recheck. The moron copy/pasted the exercise from another student and didn't even change the name on it.

This is a true, although a bit extreme, example of a dumb fuck copying programming homework. If you want to avoid being caught in such situations, keep reading.

Two inputs to the beginning homework copier:

It's very hard to make copied code completely unrecognizable.

It is almost always easier (and more productive, and more fun) to write the program from scratch than trying to rewrite it for the pure purpose of making it unrecognizable.

If you don't mind the inputs, and you still want to copy someone else's code, you should at least put some minimal effort in camouflaging it, as you don't want to offend the intelligence of your exercise checker. You want to show him that you at least tried :D

Camouflaging equipment and techniques:

Equipment:

Get yourself a descent IDE (I recommend NetBeans), as it enables advanced Find/Replace (regular expressions, refactoring, etc)
Or at least a descent text editor (Notepad++ for windows. Ubuntu comes with Gedit)

Techniques:

Change the name, the ID number and any other personal information that shows unambiguously that you are not the real owner of this code. Otherwise you're a dumb fuck and the rest of the techniques are not going to help you.
The basic and most straightforward thing to do is rename your classes, functions and some vars. In the text editor you simply do Find/Replace (usually in the Edit menu). If you're not using an IDE you're gonna have a headache with Java classes as you need to rename all the files which contain those classes. With an IDE you can simply select a name of a class (or a function for that matter) right click > Refactor > Rename. And tada! You have your class/function/variable renamed on every reference to it, no matter where in the project.
Change indentation, change comments. In an IDE or an advanced text editor (which supports regular expression or at least Find/Replace) It's really easy to do both. Remove all comments: Find regex "//[.]+\n" and replace with "\n". After all comments removed add yours in random order (remeber to remember what things do in general). Change indentation: Find regex: "\n[\s]+{" and replace with "{", or vice versa.
Change for to while and while to for. Anything you can do with a for loop you can do with a while loop, playing a bit with those might make your code look a bit different. While to For translation example.
Change temp variables to direct function call and vice versa. If you see too many redundant temp vars you can cut their count by by putting the calculation they hold directly to where you'd put the variable later. Sounds blurry I know, here's a code example.
Use functions instead of in-main code and vice versa. Take pieces of code that perform some action and put them in a function (that involves some work compared to previous techniques). Or take some function and replace it's every occurrence with it's code (also takes some work to make it work). Make sure it's not an exercise dealing with functions before you remove them - otherwise you're a dumb ass!

These were just a few tips on how to make your code keep it's initial functionality, but resemble less to it's original. Please note that the tips provided arn't for code efficiency, but solely for the purpose of making it less recognizable!

As always questions, comments and slander are most welcome!

Opening a PHP to Java socket

2009-04-28T16:16:00.020+03:00

In a project I've been working on recently we needed to integrate a functionality we have in a few Java classes we developed in to a PHP script. If those specific classes could be wrapped in a simple command-line app, it would not have been a problem, as you can execute command-line apps from PHP easily. But! These specific Java classes took very long time to load (around two seconds!) before they could be used. So command-line app was out of question, because two seconds delays for every command-line execution are unacceptable when dealing with thousands of calls a day, so the solution was to load the app once and to use the already running application when needed.

How do you use a running Java application from PHP code? A quick (and dirty?) solution is sockets. In this case the Java app is the server and PHP is the client. Ok, lets take a look at some code (Links to the sources are at the bottom of the page).

The Java server class looks like this:

public class MyJavaServer {
   public static void main(String[] args) {
       int port = 20222;
       ServerSocket listenSock = null; //the listening server socket
        Socket sock = null;             //the socket that will actually be used for communication

       try {

           listenSock = new ServerSocket(port);

           while (true) {       //we want the server to run till the end of times

               sock = listenSock.accept();             //will block until connection recieved

               BufferedReader br =    new BufferedReader(new InputStreamReader(sock.getInputStream()));
               BufferedWriter bw =    new BufferedWriter(new OutputStreamWriter(sock.getOutputStream()));
               String line = "";
               while ((line = br.readLine()) != null) {
                   bw.write("PHP said: " + line + "\n");
                   bw.flush();
               }

               //Closing streams and the current socket (not the listening socket!)
                bw.close();
               br.close();
               sock.close();
           }
       } catch (IOException ex) {
           ex.printStackTrace();
       }
   }
}

What it does:
Opens a listening (server) socket which waits for incoming connections on port 20222 in an endless loop. As soon as a connection is received the socket's input and output streams are "turned" in to buffered reader and writer (so they can be manipulated in an easier and more effective way).
Afterward we read line by line the incoming message, add a "PHP said: " prefix to each line we received and then send it back to the client. After the incoming message is over we close the buffered reader, writer and the socket, and wait for another incoming connection.

Note: It's important that you add a end-of-line char ("\n") to the end of the reply when you are writing to the socket, as the PHP client finishes reading when it encounters the end-of-line char.

The PHP client looks like this:

$PORT = 20222; //the port on which we are connecting to the "remote" machine
$HOST = "localhost"; //the ip of the remote machine (in this case it's the same machine)

$sock = socket_create(AF_INET, SOCK_STREAM, 0) //Creating a TCP socket
        or die("error: could not create socket\n");

$succ = socket_connect($sock, $HOST, $PORT) //Connecting to to server using that socket
        or die("error: could not connect to host\n");

$text = "Hello, Java!"; //the text we want to send to the server

socket_write($sock, $text . "\n", strlen($text) + 1) //Writing the text to the socket
        or die("error: failed to write to socket\n");

$reply = socket_read($sock, 10000, PHP_NORMAL_READ) //Reading the reply from socket
        or die("error: failed to read from socket\n");

echo $reply;

What it does:
We define a port (20222 - the port that MyJavaServer listens on) and a host we want to connect to (localhost is our own machine, change to a specific IP to connect remote machines). Create a socket descriptor ($sock), and connect the socket to the "remote" host (the $succ variable is used to check if the connection was successful). Afterward we write the contents $text to the socket, and then read the server's reply. The PHP_NORMAL_READ flag tells the socket_read() function to read until the first end-of-line char.

Notes:
* Make sure you add an end-of-line ("\n") to the string you send to the server, as the server reads until it encounters the end-of-line char.
* Don't forget to add 1 to the length of the string you are sending so that the added end of line will actually be sent.

Conclusion:
There's nothing new in this code neither for "Javers" nor PHPers. The novelty here (for me anywayz) is the interaction between the codes, which on the other makes perfect sense because of the fact that sockets on both utilize the same protocol - in this case TCP/IP.

If you still have questions please ask! If you have comments, well, comment :D

Sources: php_java_sock.zip

Accessing command line from PHP code

2009-02-07T11:26:00.013+02:00

It is sometimes necessary (or easier) to execute command line commands from within PHP code, in this post I will show an example of such usage. If you only need an über-basic example, here it is:

<?php

$thisf = $_SERVER['SCRIPT_NAME'];
`cp $thisf newname.php`;

?>

This little piece of code will copy the running script to newfile.php. If you're not satisfied yet, keep reading.

The scenario: You have a folder with lots of .zips, and you want to unzip each one in to a relevant folder according to it's name's first letter. For example if the .zip's name is somefile.zip we'll unzip it to dir s, if it's name is anotherfile.zip we'll unzip it to dir a. To keep the code short we assume that all needed directories already exist and that there are only .zips in the src dir.

Before we dive in to PHP lets go over the Linux command line unzip. To unzip file.zip residing in dir src to dir trg you use the following command:

$ unzip -d trg src/file.zip

Finally, ladies and gentlemen, the code:

<?php
//directory where the zips reside
$srcdir = "/home/user/zips/";

//the output master directory inside we have all the letters
$trgdir = "/home/user/out/";

$dirh = opendir($srcdir);            //the dir handler of the zips

while(($zip = readdir($dirh)) !== FALSE) {        //reading next file in dir
    if($zip == "." || $zip == "..") continue;    //checking that those are actual files
    
    $firstL = $zip[0];                            //getting the first letter of the file
    `unzip -d $trgdir$firstL $srcdir$zip`;        //running the CLI command
}
?>

Comments and questions are very welcome!

Setting up the terminal (Ubuntu)

2009-01-13T14:14:00.009+02:00

My first encounter with Ubuntu happened when I started my current job. In contrast to Fedora (the Linux distribution installed in school) it was easy and stable, and for the first time I really started to appreciate Linux. When I had to pick a distro to install on my laptop for Communication Applications course the choice was pretty obvious.

Now 2 month deep in to the semester I find myself using Ubuntu in general a lot (yes, I watch movies in Linux) and the terminal specifically (for debugging Comm Apps exercises). There are a few little terminal tips I'd like to share with the Ubuntu terminal beginners:

Adding terminal launcher to panel
Instead of going to Application > Accessories > Terminal every time, you can add the launcher (shortcut in Windowsian) to the panel for a quick reach like this: go to Application > Accessories, but instead of left clicking the Terminal right click it and pick Add this launcher to panel.

Changing the default terminal size
If you're running the terminal for debugging purposes like me, chances are you are not satisfied with the default size of the terminal - especially if you want to have a few tabs (in Ubuntu you can open a few tabs in one terminal - to open a new tab press CTRL + SHIFT + T). Resizing manually every time you open the terminal is an option, but a lame one. So here are two ways to make it happen automatically:
The first way is through the launcher on the panel we've just added: Right click the terminal launcher and pick Properties

In the properties window edit the Command field, so it looks something like:
gnome-terminal --geometry=120x26
Where 120 is the number of chars in a row (width) and 26 is the number of rows (height)

The second way (if you're having troublems with the first one - clashes and stuffs or if you need a lower level control for some reason) is to edit the /usr/share/vte/termcap/xterm file, which holds the terminal profiles. To do this, run the terminal, and type this command:
sudo gedit /usr/share/vte/termcap/xterm
This will open gedit text editor with the xterm file in it (you type in the sudo before the command to open the file in super user mode which gives you access to special system files) look for a line which says something like:
:co#80:it#8:li#24:\
and change it to:
:co#120:it#8:li#26:\
To get the default size of 120x26

That's it for now, critics and questions and general replies are welcome!