• resizing for every push_back is extremely costly
• contiguous memory may not be free at the location you wish to expand

I have assimilated what I found after a little googling and some code-probing here.

The implementation of vector in STL never resizes the vector to size()+1 for every push_back. That would just be way too costly and the performance loss would be huge. One solution is to resize the vector to size()+c every time the end of the vector is reached. That is, increment the size by a constant amount c instead of 1 when the vector is full. So, whenever push_back is called, if the capacity of the underlying container is greater that the number of elements currently present in the vector, no resizing/reallocation takes place. When the size of the vector is equal to the capacity of the container, size gets increased by c. The drawback with this idea is that the constant c is independent of the size of the vector. Choosing an appropriate value for c requires a knowledge of the application in which the vector is used.

A quick look at the implementation of vector in STL should clarify things. Here is the STL source code for the vector container: http://www.sgi.com/tech/stl/stl_vector.h. Thanks to variable naming conventions, it is a fairly trivial task to get a grasp of what the hell is going on underneath the container by just reading a couple of functions.

push_back():

  void push_back(const _Tp& __x) {
    if (_M_finish != _M_end_of_storage) {
      construct(_M_finish, __x);
      ++_M_finish;
    }
    else
      _M_insert_aux(end(), __x);
  }

If we have not reached the end of storage, the new element is just inserted and the end iterator is incremented by 1. When the vector runs out of capacity, the function _M_insert_aux() gets invoked.

_M_insert_aux():

template <class _Tp, class _Alloc>
void
vector<_Tp, _Alloc>::_M_insert_aux(iterator __position, const _Tp& __x)
{
  if (_M_finish != _M_end_of_storage) {
    construct(_M_finish, *(_M_finish - 1));
    ++_M_finish;
    _Tp __x_copy = __x;
    copy_backward(__position, _M_finish - 2, _M_finish - 1);
    *__position = __x_copy;
  }
  else {
    const size_type __old_size = size();
    const size_type __len = __old_size != 0 ? 2 * __old_size : 1;
    iterator __new_start = _M_allocate(__len);
    iterator __new_finish = __new_start;
    __STL_TRY {
      __new_finish = uninitialized_copy(_M_start, __position, __new_start);
      construct(__new_finish, __x);
      ++__new_finish;
      __new_finish = uninitialized_copy(__position, _M_finish, __new_finish);
    }
    __STL_UNWIND((destroy(__new_start,__new_finish),
                  _M_deallocate(__new_start,__len)));
    destroy(begin(), end());
    _M_deallocate(_M_start, _M_end_of_storage - _M_start);
    _M_start = __new_start;
    _M_finish = __new_finish;
    _M_end_of_storage = __new_start + __len;
  }
}

The else clause basically has what we are looking for. If the old size is 0, the new size is set to 1, otherwise, new size is set to twice that of the old size. So, basically, whenever the container gets full, its capacity is doubled, leading to an exponential growth in the capacity. This addresses our first issue.

I ran a couple of simple programs to empirically gauge the performance variations. The code below simulates the method of incrementing the size by 1 for each push_back.

#include <vector>

using namespace std;

const int MAX_ITERATIONS = 1e7;

int main() {
	vector<int> v;
	int i;
	for (i = 0; i < MAX_ITERATIONS; i++) {
		v.resize(v.size()+1);
		v[i] = i;
	}
	return 0;
}

The time taken for 10^7 reallocations is quite staggering.

viswanathgs@viswanathgs-laptop:~$ time ./single

real	0m2.194s
user	0m2.100s
sys	0m0.092s

Incrementing the capacity by a constant amount (128, in my case) results in a major performance boost.

for (i = 0; i < MAX_ITERATIONS; i++) {
	if (i == v.size()) v.resize(v.size()+128);
	v[i] = i;
}
viswanathgs@viswanathgs-laptop:~$ time ./constant

real	0m0.289s
user	0m0.212s
sys	0m0.072s

Finally, using just std::vector::push_back, I got a slightly better improvement in the running time.

viswanathgs@viswanathgs-laptop:~$ time ./exponential

real 0m0.265s
user 0m0.152s
sys 0m0.108s

Although the improvement in time here is just marginal, the latter method is better for containers with objects of larger sizes. The reason for this will become more apparent when we address the second issue.

So, it’s settled that we reallocate sizes exponentially, but doubling the size of a vector means having to find contiguous free space at the current location of the vector, which is almost always not possible. The only solution here is to find a contiguous empty block of size twice the current container capacity and to move/copy all the elements to the new location. Looking into the function _M_insert_aux(), this is basically what STL does. But, what about the overhead due to copy? Does this mean push_back does not always take constant time? Yes. Every time reallocation takes place, O(n) copy has to be done, but since the increment in capacity is exponential, the number of times we reallocate (and hence the number of times we copy) decreases exponentially compared to the first two cases. Hence, the amortized complexity of push_back for all the elements in the vector remains constant.

Also, for a vector of large-sized objects, moving the elements around often means too much delay. Reducing the number of reallocations here is crucial, and this is the reason why doubling the capacity seems to work better than a constant increase in capacity. Yet another case of time-space trade-off.

The following code pushes back 1e7 objects of a class that holds 10 ints.

class Class {
    int a[10];
};

int main() {
    vector< Class > v;
    Class obj;
    int i;
    for (i = 0; i < MAX_ITERATIONS; i++) {
        v.push_back(obj);
    }
    return 0;
}
viswanathgs@viswanathgs-laptop:~$ time ./objects 

real	0m1.602s
user	0m0.460s
sys	0m0.952s

Since we have now learnt that elements are copied during every reallocation, it would be a much wiser choice to store pointers to objects in the vector rather than the entire objects. This improves performance as only addresses are copied (4 bytes) and not the objects along with their member variables. Compare the previous running time with the one below.

int main() {
    vector< Class* > v;
    int i;
    for (i = 0; i < MAX_ITERATIONS; i++) {
        v.push_back(new Class());
    }
    return 0;
}
viswanathgs@viswanathgs-laptop:~$ time ./pointers

real	0m1.213s
user	0m0.592s
sys	0m0.616s

Moving elements to a different location also leads to problems like invalidating the iterators that point to elements in the current memory location. It’s quite amazing how these issues are taken care of in the STL. Also, to know the capacity of the container at anytime, use the function vector::capacity. vector::size returns the number of elements currently in the vector (which is basically end_iter – start_iter), whereas vector::capacity returns the maximum number of elements the container underneath can hold without further reallocation.

That’s all folks!

There aren’t many who can identify the above to be a working code from an actual programming language. BrainF*ck is an absolutely pointless, but pretty amusing esoteric programming language. Anyway, the above code prints viswanathgs.

The language has just 8 valid characters in total.

(Source: Wikipedia)

Here is a walk-through of the code above.

+++++ +++++
[
 > +++++ ++++
 > +++++ +++++
 > +++++ +++++ +
 <<<-
]

Just 4 memory locations have been used here. The first line increments the value at loc[0] 10 times. This is used as a counter for the while loop that follows. The statements in the loop perform loc[1] += 9, loc[2] += 10 and loc[3] += 11. The last line before ] decrements loc[0] (the loop counter) by 1. At the end of the loop, the values at loc[1] to loc[3] are 90, 100, 110 respectively.

> +++++
> +++++
> +++++

This does nothing but add 5 to each of loc[1], loc[2] and loc[3]. Now the values at loc[1] to loc[3] are 95, 105 and 115, the ASCII values of ‘_’, ‘i’ and ‘s’ respectively.

+++ .

This just adds 3 to loc[3] (the current memory location is loc[3] remember. I did not decrement the pointer from the previous step). Now loc[3] has the ASCII value of ‘v’ which just gets printed.

< .

The pointer is decremented by one, and the memory location now is loc[2], which already has 115 as its value (the ASCII for ‘i’). The rest of the code pretty much prints the remaining characters. Now, it should be a fairly simple task to write an interpreter for BrainF*ck!

Download: DeltaDrain.jar

Source Code: https://github.com/viswanathgs/DeltaDrain

App Overview

"My Buggers" list

Here are some screenshots of the app on a Nokia N97 mini. On opening the app, “My Buggers”, a list of people that you generally maintain delta with, are displayed. People can be added to or removed from this list by selecting “Add Bugger” or “Delete Bugger” respectively in the menu.

Main Menu

Selecting a person from this list takes you to a different form, where you can add the amount of money that you borrow (to be entered as a positive integer), or the amount of money that you lend (to be entered as a negative integer). In addition to this, the form has a comment section allowing you to enter some data about the transaction (generally, you might enter dhaba, aavin, etc). This feature comes in handy when you’re dealing with people like Mayank Badani, who can fool you into believing that he never borrowed anything from you in Bru!

Update Delta

View Delta, Category and History

Selecting “View Bugger Info” from the menu, takes you to a form that displays the current delta value, which is positive if you owe the person, and negative, if the person owes you. This form also contains two more sections – Category and History. History displays the amount, date, time and comments pertaining to the last 20 transactions that you had with this person in reverse chronological order.

Category can take four different values based on the following criteria:

1. If you currently owe the person an amount greater than 199 bucks, then, this person is called a “Bank”.

2. If this person currently owes you an amount greater than 199, then he falls under “Bitch-face”.

3. If, in any of the last 20 transactions with that person, he has borrowed a single digit amount from you, he is called “Cheap-ass”.

4. In all other cases, the person belongs to the category “Wokay”.

DeltaDrain – How I learned to stop worrying and code an app

Anirudh's DeltaDrain Specs!

It all began when TheDudeWing stopped by at Nescafe this friday night and ended up quarreling over their deltas. Anirudh, with his usual sense of zeal, pitched in the idea of creating a mobile app to maintain delta, and for the first time, even the non-compsci’s of the wing showed much excitement about something compsci’ish and got into framing the ideas and specifications for the app. After a 15-minute discussion in my room that involved 6-7 _elite_ members of the wing, we had a specification ready.

The rest of the task was upon me. I fired up Netbeans 6.9, only to find that I don’t have Java ME. I dug up my external drive, installed Netbeans 6.7.1 with Java ME, started writing a couple of classes for the back-end, by which time much of the wing’s initial enthu had wearied down. I tried using the visual MIDlet feature of Netbeans, and eventhough it allows you to visualize the control flow and trivializes the task of defining which commands and features belong to which entities in the GUI, I was not very comfortable with it preventing me from modifying the skeleton code. After a certain point, the front-end code had become so obscure that I had to trash it and re-code the front-end, this time without using the visual MIDlet.

Java ME’s record management system, RecordStore, stores records in the form of byte[]. I was hoping that I could convert my objects directly to an array of bytes using Java’s ObjectOutputStream. As it turns out, Java ME does not have support for ObjectStream, and to work around the issue, I had to write my own wrappers that convert byte[] to Object and vice versa.

After a night-out and a substantial part of the next afternoon patching up stuff, TheDudeWing’s app (bar features like splash-screens that I thought would be too irritating) was ready! Yay!

[If you are not worried about the details, scroll down and download the etymology file]

Sungwoo Park has a complete list of the Barron’s words that he compiled while he was preparing for GRE. His word list in various formats can be found here: www.postech.ac.kr/~gla/gre/. The script, first retrieves the 4842 words ASCII text file from his site, and creates a list.

def main():
    word_list_file = urllib.urlopen('http://www.postech.ac.kr/~gla/gre/33new.txt')
    word_list = []

    print 'Obtaining Barron\'s word list from www.postech.ac.kr/~gla/gre/33new.txt...'
    for line in word_list_file:
        if not line or line == '\n':
            continue
        if (line[0] == 'h' or line[0] == 's') and line[1] == ' ':
            continue
        if line[0] == 'n' and line[1] == ' ':
            line = line[2:]

        word = line.split()[0]
        if word[-1] == '-':
            continue

        if not word.isalpha():
            word = cleanse(word)

        word_list.append(word)

    word_list_file.close()

    parser = etymoparser.Parser('barrons_etymology.html')
    count = 1

    print 'Extracting etymologies from www.etymonline.com...'
    for word in word_list:
        if count % 50 == 0:
            print 'Extracting etymology for word', str(count), '(' + word + ')'
        parser.getetymo(word)
        count += 1

    parser.close()

The word list text file is read using the urllib module. Park has actually added around 1300 words to this text file, additional to the 3500 in Barron’s. Such words are preceded by an ‘s’ mark. The script ignores such words. But, if you are the kind of person who targets a 1600, edit the lines in etymosucker.py

        if (line[0] == 'h' or line[0] == 's') and line[1] == ' ':
            continue
        if line[0] == 'n' and line[1] == ' ':
            line = line[2:]

to

        if line[0] == 'h' and line[1] == ' ':
            continue
        if (line[0] == 'n' or line[0] == 's') and line[1] == ' ':
            line = line[2:]

and execute the script.

Some of the words in the text file contain non-alpha characters including ‘\’, ‘^’, etc. The functions cleanse and eraseall strip these characters off from the word.

def eraseall(word, char):
    pos = word.find(char)
    while pos != -1:
        word = word[:pos] + word[pos+1:]
        pos = word.find(char)

    return word

def cleanse(word):
    word = word.replace('_', ' ')

    pos = word.find('(')
    if pos != -1:
        word = word[:pos]

    word = eraseall(word, '\\')
    word = eraseall(word, '\'')
    word = eraseall(word, '^')

    return word

Each word is then added to the word list. Once the word list has been created, etymoparser does the job of retrieving the etymology of each word from www.etymonline.com.
The constructor of etymoparser.Parser creates the output html file, and writes the opening tags <html>, <head>, <body>, <table>, etc.

class Parser:
    def __init__(self, out_file_name):
        self.outfile = open(out_file_name, 'w')
        self.outfile.write('''<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"><head><title>Barron's GRE Word List Etymology</title></head><body><table style="font-size:14px">''')
        self.count = 1

The function getetymo of the class Parser retrieves the etymonline.com html page corresponding to the given query. A quick <Ctrl>+U on etymonline.com search page shows that the desired info generally lies between the comments <!--NAVIGATION--> and <!--DICTIONARY-->. If this section does not contain the string “No matching terms found”, it is extracted.

    def getetymo(self, word):
        etymo_file = urllib.urlopen('http://www.etymonline.com/index.php?search=' + word + '&searchmode=term')

        etymo = ''
        in_etymo = False

        for line in etymo_file:
            if not in_etymo and line.find('<!-- NAVIGATION -->') != -1:
                in_etymo = True
                continue
            if in_etymo and line.find('<!-- DICTIONARY -->') != -1:
                break
            if not in_etymo:
                continue
            etymo += line

        if etymo.find('No matching terms found') != -1:
            return

        start = etymo.find('<dd')
        end = etymo.find('</dd>')

        assert start != -1
        assert end != -1

        etymo = etymo[start:end+5]

        self.writeetymo(word, etymo)

The extracted string is now passed to the function writeetymo, which encloses it in <tr> and <td> tags and writes it to the output html file.

    def writeetymo(self, word, etymo):
        self.outfile.write('<!--' + str(self.count) + '-->' + '<tr> <td><b>' + word + '</b></td> <td>' + etymo + '</td> </tr>' + '\n')
        self.count += 1
        self.outfile.flush()

Finally, on closing the parser, the closing tags </table>, </body> and </html> are written to the output html file.

    def close(self):
        self.outfile.write('</table> </body> </html>')
        self.outfile.close()

The time taken to extract etymologies of all the words could vary from 45 minutes to 2 hours, depending on your internet connection. Out of the 4842 words from Park’s text file, 3963 words are from Barron’s, if I’m correct. Out of these, 3800 words have their etymologies defined in etymonline.com, which are tabulated in the output html file.

Downloads:
EtymoSucker Source [zip, 2.6KB]: http://www.box.net/shared/vkp0imedy1
Etymology file [html, 1.9MB]: http://www.box.net/shared/xtxvzzsui1

What is GNOME?

If you aren’t aware of what GNOME (GNU Object Model Environment) is, it is a desktop environment for Unix/Unix-like operating systems, running on top of the OS. Another famous desktop environment is KDE (K Desktop Environment), which fancies looks more than anything else. The projects under Gnome include the pretty famous text editor Gedit, file manager Nautilus, mail client Evolution among many others. For a complete list of Gnome projects, look here. Gnome uses the Gtk+ toolkit for development (more about Gtk+ below) and KDE uses the Qt toolkit.

Building from Source

Before you can modify the source, you need to build the project from its source code. The source code for Gnome is maintained in Git, from where it has to be downloaded and built.

Git – The distributed revision control

Git is a revision control system used to manage and maintain the development of softwares and changes made to the source when usually a team of people are working on it. Source code management has become vital for orderly development of open source projects as usually a large number of people work on them. Gnome recently moved from svn (Subversion) to git. Git was developed by Linus Torvalds for maintaining the source of linux kernel. The advantage of Git over Svn is that, git is distributed. A distributed revision control system contains more than one central repositories, and any change to be made, can be made to your own branch, which can then be merged with other branches. You need not require network as you would be having a branch locally on your computer. But, in the case of centralized version control systems like svn, you should have ‘commit’ access to submit your changes to the trunk (or befriend a person having commit access, of course). Other projects using git include Perl, Debian, Android, Fedora. The source code for all the Gnome projects is available for online browsing at git.gnome.org.

Now, let’s say you want to download gedit from git. This is what you would do.

Fire up your terminal.

$ git clone git://git.gnome.org/gedit

This will download the source code of gedit in your current working directory. Now, cd into gedit and

$ ./configure
$ make
$ sudo make install

This builds and installs gedit from source.

Note: Sometimes you would be using ./autogen.sh instead of ./configure

Jhbuild – Automate the building process

If you had tried building gedit as given above by just downloading from git, most probably you would have encountered errors while doing ./configure . This is because, the dependency packages for gedit have not been installed. You can read the error produced, which would probably complain about the absence of packages and install them yourself, or use jhbuild to automate the building of all the depending modules, alleviating the trouble from you.

Before that, you need to install jhbuild. First install the jhbuild dependencies listed here for your distro. Once that is done, create a directory in your home to download all the source code from git. It is advisable that you use the same directory name given here.

$ mkdir -p ~/checkout/gnome2
$ cd ~/checkout/gnome2

Now download jhbuild from git and install it.

$ git clone git://git.gnome.org/jhbuild
$ ./autogen.sh
$ make
$ make install

Add jhbuild to the PATH environment variable.

$ PATH=$PATH:~/.local/bin
$ echo PATH=$PATH:~/.local/bin >> ~/.bashrc

This updates the PATH variable in the .bashrc file in home. Be sure to use >> and not > as the latter will overwrite the file while the former just appends to the file.

Copy the sample jhbuildrc file to your home.

$ cp ~/checkout/gnome2/jhbuild/sample.jhbuildrc ~/.jhbuildrc

You can edit the .jhbuildrc file in your home to change the modulesets, but, in our case you need not do anything.

We need a directory where we could install gnome. Again, it’s better to use the same directory name as listed here.

$ sudo mkdir -p /opt/gnome2

Since all the installation takes place in the above directory, we obviously need that directory to be owned by us instead of ‘sudo’ing everytime.

$ sudo chown your_user_name /opt/gnome2

Now, do

$ jhbuild sanitycheck

If this throws any error, do

$ jhbuild bootstrap

This downloads the packages required for compiling the packages in the Gnome moduleset.

Do a sanitycheck again. One of the common errors you will find now is the absence of db2html. Install the package docbook-utils to fix this. Unless the sanitycheck produces no error, you can’t proceed. Check here for common problems existing with sanitycheck after bootstrap and fix them, if any.

Now that jhbuild is installed, we are ready to build entire gnome or any particular program along with all the dependencies.

To build the latest gnome from source, type in

$ jhbuild build

To build any particular program, say gedit, type in

$ jhbuild build gedit

To list all the modules that will be installed,

$ jhbuild list [package_name]

Gedit depends on around 35 modules. Jhbuild will take care of downloading all of them from git and installing them. During building, if jhbuild throws any error (which is sure to happen), the cause would be the absence of packages. Just google the error produced, find out the missing package and installing it manually. It’s really difficult to list all the errors that would be produced, as it depends on your distro and your computer. I faced a much lesser number of errors while building Gnome Evolution in OpenSuse 11.2 than in Ubuntu 9.10.

Once the build is complete, you can now run gedit (or any other program that you have built) by

$ jhbuild run gedit

Before going through the source code, we could have an overview of the toolkit Gnome uses for its development.

Gtk+ Toolkit

As mentioned earlier, Gnome uses Gtk+ (GIMP toolkit) in its source. Gtk+ is a widget toolkit for creating GUI applications. It is object oriented and written in C (irony?), but also has bindings for many other languages like C++ (gtkmm), Python (pygtk), PHP (PHP-Gtk), Perl (Gtk2-Perl), Java (java-gnome) among others. Gtk+ was actually developed for use in GIMP and later the Gnome community adopted it for all its projects. Unless you learn the basics of Gtk+, the source code would make little sense to you.
Here is a hello world program in Gtk+.

#include <gtk/gtk.h>
int main(int argc, char *argv[])
{
GtkWidget *window;

gtk_init(&argc, &argv);

window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW(window), “Hello World”);

gtk_widget_show_all (window);

g_signal_connect (G_OBJECT(window), “destroy”, G_CALLBACK(gtk_main_quit), NULL);

gtk_main();
return 0;
}

The above code produces a simple Gtk Window with the title “Hello World” on it. The program closes when you click the close button on the titlebar.
To compile the code

$ gcc hello.c `pkg-config --libs --cflags gtk+-2.0`

assuming the file is saved as hello.c. Make sure pkg-config is installed.
Now, run the program by

$ ./a.out

Glade is an user-interface designer that can be used with gtk+ to produce GUI applications easily.
A basic tutorial on Gtk+ and Glade is available at http://www.micahcarrick.com/12-24-2007/gtk-glade-tutorial-part-1.html
To learn more about the different widgets of gtk+, http://zetcode.com/tutorials/gtktutorial/ is a great tutorial.
Foundations of Gtk+ Development is a book providing an in-depth knowledge of Gtk+.

Finding an itch to scratch – Bugzilla

Bugzilla is a bug-tracking tool employed to file and manage bugs. Gnome bugzilla is available at bugzilla.gnome.org. Every bug has an associated number. Bugs are classified based on the product or the severity of the bug or its priority. Once you find a bug that interests you, you would want to fix it. If the source code of your project has fewer number of lines, it would not be a big deal to find the bug. But this is not the case with most of the Gnome projects. But, the task of finding the bug could be easily simplified by using grep, which is one command you would probably be using the most number of times. Furthermore, if you have questions regarding the bug, you can always post them as a comment in bugzilla.

In case you are working on a feature or an enhancement or a pretty severe bug, you would want to inform other developers through the mailing list, so that the same work is not reproduced. Each project has its own mailing list, where you can post your problems as a developer or suggestions for new features, etc. Here is a list of all the Gnome mailing lists – http://mail.gnome.org/mailman/listinfo.

IRC’s are a great place to hangout for technical discussions. Again, each project has an IRC channel, where you would find its developers. All IRC channels of Gnome are listed here – http://live.gnome.org/GnomeIrcChannels.

Generating patches

A patch file is the difference between the source code before and after a commit. To fix a bug, first grep for some pattern related to the bug to locate the file to edit.

$ cd ~/checkout/gnome2/gedit
$ git grep "pattern_you_want_to_search_for" *

git grep recursively searches for the provided pattern in the mentioned directory and all its sub-directories. The output will be the names of files in which the given pattern is found, with each file name followed by the line containing the pattern. Once you find the file and edit it, you can rebuild the source to test your change. This can be done as

jhbuild build gedit --start-at=gedit --no-network

The –no-network option tells jhbuild not to checkout the source in from the git repository. If you do not use this option, you need an active internet connection while rebuilding.

If you are satisfied with the change, you can submit it as a patch to bugzilla. The difference in the file edited before and after the change can be viewed using

git diff

The lines beginning with + indicate the new lines that have been included and those beginning with – are the ones removed. You can save this output in a file with .patch extension.

git diff > name_of_patch.patch

Submit the patch so that it gets verified and committed to the main branch.
To commit the changes to your working branch on your computer, use

git commit -a

It’s good to use a meaningful comment for your commits.

Further, tools like valgrind and gdb make debugging easier by finding memory leaks and other hard-to-trace bugs.

Further Reading

GnomeLove – Collection of resources for Gnome developers and enthusiasts.
Gtk+ 2.0 Tutorial – Official Gtk+ tutorial.
Valgrind – A tool to trace memleaks.
GDB – Wikipage on Gnome Debugger.

Have fun hacking!

This is what Google says in its blog about Go.

Go attempts to combine the development speed of working in a dynamic language like Python with the performance and safety of a compiled language like C or C++. In our experiments with Go to date, typical builds feel instantaneous; even large binaries compile in just a few seconds. And the compiled code runs close to the speed of C. Go is designed to let you move fast.

We’re hoping Go turns out to be a great language for systems programming with support for multi-processing and a fresh and lightweight take on object-oriented design, with some cool features like true closures and reflection.

A hello world program in Go.

package main
import "fmt"
func main() {
fmt.Printf("Hello, 世界\n")
}

If you are wondering about the non-English characters(Japanese), Go supports Unicode.
To learn about the language, go to GoLang.org.

This is a Google Tech talk by Rob Pike, a lead developer of Go. Other advancements include compilation speed. Go seems to have considerably reduced the compile time as Rob demonstrates in the video. He justifies the necessity of a new language mentioning the problems in existing languages are endemic and adding features through libraries will only make the language fat.

Go’s goals:

• The efficiency of a statically-typed compiled language
• with the ease of programming of a dynamic language.
• Safety: type-safe and memory-safe.
• Good support for concurrency and communication.
• Efficient, latency-free garbage collection.
• High-speed compilation.

First, make sure wvdial is installed. If not,

sudo apt-get install wvdial

To add the module usbserial into the kernel, type the following in the terminal.

sudo modprobe usbserial vendor='0xeab' product='0x9357'


The vendor and product serials are specific to LXU800 modem. If you are trying to configure any other modem, you would want to google to get the corresponding serials.

Now, we edit the file /etc/wvdial.conf
Open the above file in your favourite text editor with sudo. In the file, enter the phone number (mostly #777), username and password. Remove the semicolons, if any, at the beginning of each of these lines. Add the following line to the end of this file

Stupid mode = Yes

The modem has been configured successfully.

To dial, everytime you have to type the following three lines.

sudo modprobe usbserial vendor=’0xeab’ product=’0×9357′
sudo wvdialconf
sudo wvdial

To make things simpler, you can create a shell script with these lines and run it everytime you want to connect to the internet.

Travelling-Salesman problem !

Traveling Salesman problem

Partitioning:

First, you need a primary partition to install opensolaris. Use the ‘Disk Management’ utility of vista to create/resize/format your partitions as per your needs. OpenSolaris recommends atleast 9GB of space for your partition. Don’t forget to backup essential data in the partition you want to format or you will end up losing them.

Installing OpenSolaris:

Once you have got a primary partition, insert the opensolaris cd and reboot your computer. If you don’t have a cd, you can download its image from http://www.opensolaris.com/get/index.jsp and write it or you can order a free cd from https://oscd.sun.com/ , though the latter option requires you wait for a month or so.

Booting into the live cd, you will be asked for keyboard layout and default language. Once you enter them, gnome loads. You have an ‘Install OpenSolaris’ icon. This will guide you through the installation process. In step 2 of installation, you would be asked for the partition to which opensolaris has to be installed. Set the partition that you had prepared as ‘Solaris’. The other steps need no explanation.

Editing the grub:

After installing, when you reboot the system, the opensolaris grub loads and provides you with options for Windows and OpenSolaris, but not for Ubuntu.

Now, we’ll be editing the ubuntu grub to add a chainloader to the solaris grub.

Part I: Recover ubuntu grub

i. Boot into ubuntu live cd.

ii. Open the terminal.

iii. Enter

sudo fdisk -l

This will list the details of all the partitions in your hard disks. This is what the command displays in my laptop.

Disk /dev/sda: 500.1 GB, 500107862016 bytes
 255 heads, 63 sectors/track, 60801 cylinders
 Units = cylinders of 16065 * 512 = 8225280 bytes
 Disk identifier: 0x60000000
Device Boot      Start         End      Blocks   Id  System
 /dev/sda1              21        6522    52224000    7  HPFS/NTFS
 /dev/sda2            6522       11749    41984000   83  Linux
 /dev/sda3   *       11749       14299    20480000   bf  Solaris
 /dev/sda4           14299       60802   373536768    f  W95 Ext'd (LBA)
 /dev/sda5           14299       60802   373535744    7  HPFS/NTFS

Note down the partitions in which linux and solaris are installed. The ‘a’ after /dev/sd represents the hard disk in which the partition is present. ‘a’ refers to first hard disk, ‘b’ to second, etc. The number represents the partition in that hard disk. In the terminal, I would be typing (hd0,1) to represent linux partition and (hd0,2) to represent solaris partition. Here, the partition numbering starts for 0. Write down the partitions in which linux and solaris have been installed in your computer.

iv. In the terminal type sudo grub

v. In the grub prompt, type

root (hd0,1)

 

*Replace (hd0,1) with the partition in which ubuntu is installed in your computer.

vi. Type

setup (hd0)

Once it says done, you have got back your ubuntu grub, but you can’t boot opensolaris from it. So, we now have to add a chainloader to the solaris grub in the ubuntu grub.

Part II: Chainloading to solaris grub from ubuntu grub

Reboot your system and remove the live cd. Boot into ubuntu (from the ubuntu grub which loads now). Open the terminal and type

sudo gedit /boot/grub/menu.lst

This opens the grub menu. At the end of the file, append the following lines and save the file.

title OpenSolaris

rootnoverify (hd0,2)

makeactive

chainloader +1

boot

*Replace (hd0,2) with the partition where you have solaris installed.

Reboot the system and you have ubuntu grub loading first with an option to OpenSolaris grub other than vista and ubuntu.

Edit: Not Applicable for Ubuntu 9.10 (Karmic Koala). Karmic uses grub2, whose architecture differs from the previous grub.