Installing VirtualBox for any given Linux release (provided that VirtualBox dev have tested it for that release).

Okay straight to the point. Given any host as Linux release (e.g., 3.2.2), one can get VirtualBox up and running using the following method. The reason I write this is so that users also get that *aha!* and at the same time I also get that aha! without bothering to use search engine as I often use VirtualBox (almost exclusively sometimes). Just so you know, Host OS is what *hosts* Virtual Machines (known as guests). So, in this small note, I am trying to run VirtualBox 4.1.8 (latest stable release at the time of writing) on Linux 3.2.2 Host.

I finally got some time this weekend to switch over my website over from Apache to Nginx and everything seems to be working alright at this point. Not that this really deserves a blog post of it's own but we'll see.

I've always wanted to sort of learn JVM-based functional+OO scripting language so thought that now would be a good time to learn Scala. However, it wasn't available in OpenBSD ports. The following are the steps needed to get it up and running -

1. Download Scala from http://www.scala-lang.org/downloads/distrib/files/scala-2.9.0.final.tgz

2. tar zxf scala-2.9.0.final.tgz

3. Install jdk: pkg_add -vi jdk.

Also, make sure bash is installed: cd /usr/ports/shells/bash, sudo make install.

4. Add full path to the bin in your PATH environment variable (for e.g. ksh/bash) in your ~/.profile or ~/.bashrc (ksh/bash respectively):

export PATH=$HOME/bin:/bin:/sbin:/usr/bin:/usr/sbin:/usr/X11R6/bin:/usr/local/bin:/usr/local/sbin:/usr/games:/usr/local/jdk-1.7.0/bin:.

5. Go to the dir you installed scala:

[~/scala-2.9.0.final/bin] $ ./scala
Welcome to Scala version 2.9.0.final (OpenJDK Client VM, Java 1.7.0-internal).
Type in expressions to have them evaluated.
Type :help for more information.

scala> println("howdy sathi!")
howdy sathi!

scala>

All done. Happy Scala'ing! :)

var http = require("http")
var spawn = require("child_process").spawn;
http.createServer(function(req,res){
    var tail = spawn("tail", ["-f", "/var/log/messages"]);
    res.writeHead(200,{"Content-Type": "text/plain"});
    tail.stdout.on("data", function (chunk) {
        res.write(chunk);
    });
    tail.on("exit", function (status) {
        if (status !== 0) 
        {
              console.error("tail exited with code " + status);
              exit(1);
        }
        res.end();
    });
}).listen(8000);

I've just ported and tested stock busybox-1.16.1 for Android. Also ported is the linux tree(1).

Both of these packages are linked statically so are quite fat.

You can download them from my downloage page. Enjoy!

Some useful links for the day and status updates-

Lot of cool stuffs were written by Nepali Open source developers and enthusiasts - http://github.com/theinitmag/201005/blob/master/releases/theinitmag06.pdf (Lucid Lynx is covered by Jitendra Harlalka). A wonderful read it's been.

I have been playing around with Rabbitmq, Celery and Django of lately - I'll try to cover them in coming weeks if time permits. One can refer to these links for more info into the whole AMQP microcosm. 

• http://www.rabbitmq.com/documentation.html
  
• http://ask.github.com/celery/index.html
  
• http://decafbad.com/blog/2008/07/04/queue-everything-and-delight-everyone
  
• http://www.slideshare.net/hungryblank/rabbitmq-with-python-and-ruby-rupy-2009
  
• http://www.slideshare.net/idangazit/an-introduction-to-celery?from=ss_embed
  
• http://robertpogorzelski.com/blog/2009/09/10/rabbitmq-celery-and-django/ 
  

Having up'ed http://slader.com from scratch with Peter Bernheim, it feels much better now. It was a good 4 week marathon working with the team. If you're a Maths geek, do sign up with slader.com :-)

Another interesting project is the APE project (Ajax Push Engine). It uses client and server side script written in JavaScript to accomplish server push for real-time data. More available @ http://www.ape-project.org/ 

Enjoy! :B

A pretty decent definition of bound vs. unbound variable. A very good Erlang book is at http://learnyousomeerlang.com/; the author of the book hangs around at #erlang@freenode and overall, he's a great guy who helps folks with problems in Erlang.

On that note, Erlang is a powerful functional language with the following features:

• Shared-nothing memory architecture - we don't have to worry about resource locking scheme (deadlock/livelock) since nothing is shared. If you need to name a variable twice use a different variable name.
  
• Asynchronous message-passing - means decent performance on multiple cores within an Erlang cluster and worry free variables (they don't need supervisory locks to monitor their state because again it's not shared! :)
  
• Functional language properties - A high-order function for control abstractions, anonymous functions and lambda expressions(in spirit of Python)
  
• OTP and libraries - Running network applications with about 10 lines of server code and about 6 lines of client code is awesome. I've never seen something like it honestly; Or what about full-on binary IP packet matching (what some folks call packet sniffing) in less than 10 lines?
  
• Full-on Exception model - try/catch/throw semantics (like Java)
  
• Hot-swappable code on live ...

Multiple things have happened over the last couple of weeks and few months I spent not blogging.

First, I picked this wonderful post by Robert Kern on python mailing list today that made me blog in the first place; Much thanks owes to him for enlightening mere mortals like me. I am still to play around with it but reading the docs is half the battle done. It is all documented at http://www.corepy.org; if you flip over and start reading the "hello world" side of things at http://www.corepy.org/wiki/index.php?title=CorePy_Basics, it looks ridicolously fun and easy again! I think assembly just became fun again :-)

I'll leave it upto you as to basically what you can do them but essentially to do anything substantial you'd have to pump out a lot of asm using CorePy. One could implement some native assembly code in it and use other python libraries to do some really neat stuff. If you only dabble in Assembly like me and wish to not leave the comfortable rear-view seat of Python's high-level world, then CorePy is for you!

Take a look at this snippet:

  import corepy ...