First thing to do is to give my bash some colour (mainly so I don’t get my terminal sessions for various machines mixed up – but secondly so it looks pretty ).

One – give my bash prompt a lovely raspberry colour by adding this to my .bashrc :

export PS1=’\[\e[1;31m\][\u@\h \W]\$\[\e[0m\] ‘

Two – change my motd so I get a shiny new intro when logging in (stolen and modified from http://www.raspberrypi.org/phpBB3/viewtopic.php?f=2&t=5494) :

/etc/motd

Now when I login I get a nice prompt forcing my brain to acknowledge which terminal I’m screwing around in!

Now having used MySQL (whee!) and Oracle (boo!) quite a lot in my day job(s), I consider myself to have a pretty good grounding in relational database magic. Although having said that, I’ve never actually used PostgreSQL, and have heard fanatical talk about how “amazing it is” when compared with similar DB’s, so I’m looking forward to enjoying some of that wonder for myself.

So to start, we’re left on our own to install the application (which is fine by me), and as the book mentions, we get more of the good stuff due to the space saved. Thanks to pacman (not the greedy yellow thing that’s s**t scared of ghosts) it’s all sorted in one command, done!

Day One

For first part we’re taken through some of the basics of relational DB’s, namely creating tables with relationships which we join across, adding indexes to improve performance etc – the usual stuff, that if you’ve been a developer for more than a week you should know by now!

It’s nice to have a some exercises to walk through but generally you’ve seen it all before, and it becomes a little tedious. Don’t get me wrong, I understand why it had to start like this (to give some context and a decent introduction to the 5% of readers not familiar with the material), but you just have to go through the motions and accept that the goodies will start soon. Sooner than I expected to be honest, I thought the whole PostgreSQL chapter was going to be (inevitably) a little slow, but I was definitely wrong there …

Day Two

Starting off with the usual aggregate functions (COUNT, SUM, MAX etc) you get that “been there, done that” feeling again, but before you know it you’re stumbling into new territory (for me at least).

Key areas that tweaked my interest were talk of distributed databases and the CAP theorem (Consistency vs Availability vs Partition Tolerant, of which you can only ever support two of the three), PL/PGSQL scripting (which initially gave me cold sweats when recalling Oracle’s own PL/SQL, but the knowledge of other scripting solutions, ala Python, Ruby, gave some welcome relief), and rules. I was impressed by rules in particular, reminiscent of metaprogramming or AOP for SQL, where you can essentially rewrite a user’s query to add a welcome twist – the example given in the text is insertion of a record into a view, although I can imagine countless other applications of this.

After day two I’m feeling like I’ve learned some interesting new things about PostgreSQL, which were well worth my time, …,  but just wait until the craziness of day 3 …

Day Three

Here’s where things really get interesting! We start looking at many of the PostgreSQL contrib packages, allowing us to take the DB from the usual every-day querying tedium to the fringes of artificial intelligence!

Rather than sticking to basic equality or wildcard matches used for querying an actor’s name in a movie database we extend our schema to use various natural language processing libraries. This gives our humble set-up the ability to match ‘Broos Wils’ correctly as the star of the Die Hard films (many thanks on behalf of members of the SMS generation everywhere), most impressively matching based on how words “sound” using metaphones.

We finish up querying for movie recommendations based on a multidimensional hypercube (had to put that in ‘cos it makes me sound well clever). It basically works by comparing similarity of the various genres into which a movie falls (action, romance, comedy etc) – but check out the book, they explain it much more clearly!

Finishing Up!

To be honest I didn’t expect much from this chapter, nothing more than a recap over old knowledge anyway, filling the relational database corner for completeness and comparison. And yes it did start out a little like that, but it quickly moves into much meatier territory that sucks you in and teaches you things you had never considered possible in a RDBMS … or maybe that’s just my ignorance. Regardless, I’m impressed so far, and I am definitely looking forward to reading about databases I don’t already “know”!

Disclaimer

‘Seven Databases in Seven Weeks’ is still in production, and this preview was based upon the beta 2 release. The material is likely to change.

Check out the following links for more details :

http://pragprog.com/book/rwdata/seven-databases-in-seven-weeks

http://www.sevenweeks.org/

A modern lisp on the JVM, built for easy concurrency in today’s multi-core world – how awesome. There’s just one problem if you’re from a usual OO background like me … and that’s getting your head around lisp and functional programming in general!

Once you’ve got your head around the syntax and basic semantics of a language, the best way to learn is to play – and that’s where 4clojure comes in. An extensive list of challenges ranging from the very basic to nicely challenging gives you the opportunity to play with your new found skills in a quick and easy sandbox.

Be warned though – after completing the first few challenges, you’ll have a taste for blood and won’t sleep until you’ve completed them all!!

Check it out @

4clojure.com

Due to my recent use of several dynamic and lisp based languages, most notably Ruby and Clojure, I’ve taken on the challenge of learning Emacs to increase my productivity ten fold! Using my old staple Eclipse to develop in dynamic languages just seemed like too much effort – something akin to using a sledgehammer to engrave some delicate glass.

Anyway, enough rambling, and onto the tip. To try and avoid getting the infamous ‘Emacs pinky’, I’ve remapped my CAPS LOCK key to be another CTRL, and ALTGR to be equivalent to ALT – this makes the key chords so much more comfortable. To achieve this in Linux, just add the following to your .bashrc or something similar :

xmodmap -e 'remove Lock = Caps_Lock'
xmodmap -e 'keysym Caps_Lock = Control_L'
xmodmap -e 'add Control = Control_L'
xmodmap -e 'keycode 108 = Alt_L'

Aha! Time to learn some Erlang.

I’ve been meaning to check out Erlang, as another awesome functional language, for some time now.

And now, by the same author as ‘Learn you a Haskell for Great Good’, is a similar tutorial for Erlang.

I can barely wait to start programming some crazy agents!

Learn You Some Erlang for Great Good

Week one of the ‘course’ gives a good baseline by starting with the solid, but interesting world of ruby. The author gives ruby the persona of Mary Poppins – solid and practical with that little bit of magic.

I’m sure many readers have used ruby before, but regardless the chapter begins as an excellent refresher (or introduction) to the syntax and ‘everything is an object’ approach of the language. This is later built upon by seeing a glimpse of ruby’s meta-programming magic – concepts that you can see filtering into other languages, such as Groovy.

Overall the chapter is a good start to the book, easing you into the process with a clean, modern language and a number of simple but fun exercises … onto Io.

For my solutions to the exercises in the ruby chapter, check out : https://github.com/lucas1000001/seven-languages-in-seven-weeks/tree/master/ruby

A few months ago I published a post on keeping techie books entertaining, led by Why’s? poignant guide to Ruby. It seems the trend is catching on …

Already available in ebook format, and soon to be released is ‘The Land of Lisp’, a comic book guide to lispy languages. With the popularity of functional programming growing each day, (thanks to languages like Ruby, Clojure and Scala), this seems like an awesome way to get your head around a tricky subject.

The music video says it all!

Well I like a bit of a Linux challenge, so rather than use boring old Ubuntu or Fedora, Gentoo should present the opportunity to learn a bit more … well it’s certainly achieving that.

So for those of you struggling to connect wirelessly from the livecd (so you can actually emerge stuff) here goes an issue I experienced.

My computer has a ralink card :

lspci | grep RaLink

> 01:03.0 Network controller : RaLink RT2561/RT61 802.11g PCI

When I try to do something useful with it (like enable it) I get the following issue :

ifconfig wlan0 up

> phy0 -> rt2x00lib_request_firmware: Error – Failed to request Firmware.

> SIOCSIFFLAGS: No such file or directory

Well it’s pretty obvious the firmware is missing or screwed, so just download the zip from the Ralink site.

http://www.ralinktech.com/support.php?s=2

Unzip, and copy over to your potential Gentoo box via usb (or some other magic).

Just drop all the bin files into the ‘/lib/firmware’ directory :

cp *.bin /lib/firmware

Try your wireless card again, and success!

Coming from a Java background (yes, yes, boo all you want), one of the most strikingly different aspects of JavaScript is its prototypal nature.

It’s a common misconception by many (myself included) to think that JavaScript is a good old classical language, thanks mainly to the new operator. Where in fact it is of that rare class of prototype languages (sorry to all those who thought this was about the game).

So what are the benefits of prototype? What use is it really?

Inheritance

Unlike classical languages, JavaScript has no class vs instance pairing. Instead ‘real’ working objects are there to be extended by new objects.

Lets look at a quick example :

var Animal = function() {
    this.eat = function() {
        alert('num num num');
    }
}

var Cat = function() {};
Cat.prototype = new Animal();

var myCat = new Cat();
myCat.eat();

As you can see Cat extends Animal by setting it’s prototype to an instance of Animal.

Now any calls to Cat.eat() will take the following chaining process :

1. Does object Cat have an eat() method? : No
2. Get prototype : Animal
3. Does Animal have an eat() method? : Yes
4. Run eat().

This is called prototype chaining, in which a method or element call will move through the objects along the prototype chain checking for existence of the requested property.

Memory Efficiency

Consider the following two snippets of code :

var Efficient = function() {}
Efficient.prototype.func = function() { alert('Hello World!'); }
var e1 = new Efficient();
var e2 = new Efficient();


var Duplicate = function() {
    this.func = function { alert('Hello World!'); }
} 
var d1 = new Duplicate();
var d2 = new Duplicate();

In the first example the function object for func() is assigned to the prototype object. So every instance of Efficient will share the same func(), as all calls will fall through to the prototype. There is one version of func()!

On the other hand, for every instance of Duplicate created, a new (but identical) version of func() will be created by the constructor. This means if we have ten Duplicate objects, we will also have ten func()’s defined, although their behaviour will be exactly the same.

As you can imagine, the latter will consume more memory than the former, as there are no shared functions.

Retrospectively Changing a Class of Objects

JavaScript is kind enough to allow us to change objects by adding methods or properties at any point during runtime. In other words dynamic objects!

But what if we have 100 instances of an object ‘class’ (and I use class loosely) out there, and we want to add a method to them all!

Prototype to the rescue! Let’s reconsider that Cat example from earlier :

var fluffy = new Cat();
var smelly = new Cat();
var bitey = new Cat();

So we have three cats, fluffy, smelly and bitey. Suddenly (at some point in the code) there is the need for a meow() method that didn’t exist initially.

We could add our new meow() method to every existing Cat instance, but that seems too hard, and error prone.

… or we could just add it to the prototype, and all Cat’s will automatically get the method :

Cat.prototype.meow = function() {
   alert('meow');
}
fluffy.meow();

bitey.meow();

smelly.meow();

Now that was a little easier. Using this you can change a whole class of objects at runtime!

As a massive geek I do have a softspot for vim.

Unfortunately, vim frequently clashes with your cool black terminal background, and causes blindness due to having dark writing on it’s equally dark background.

Good news everybody! It’s pretty darn easy to fix this.

Just create your ~/.vimrc file using your favourite text editor (vim of course).

And add the following lines :

:syn on

set background=dark

Now you’ll have nice shiny writing on your cool black background – awesome!