It’s sophisticated yet simple. In its core it’s just a text editor. Yet it has tabs, colored syntax, auto-complete, excellent regexp support, go-to-definition capability, snippets, multi-line selection and million other features that make you love it. It’s all there but it doesn’t manifest itself unless you say so.

It’s centered around you and your work. It doesn’t enforce it’s own workflow (think ‘create project’ from some IDEs). It doesn’t ask stupid questions (try closing an editor with 10 unsaved documents, you will get 10 stupid dialog boxes, 0 in Sublime Text 2). It remembers where you left your work and just gets there when started again.

It’s blistering fast. It pops up immediately – no splash screen, no questions asked. It opens and parses 150K lines of xml in just below 3 seconds (and that’s on my non-SSD PC!) and you can edit and navigate it smoothly without waiting for anything.

It’s extensible. There are hundreds of plugins and you can write your own if you know python.

It’s truly cross-platform. I’m regularly using Sublime Text 2 on Linux and Windows, with exception for some key-bindings it’s exactly the same piece of software. And a single license covers them all!

It’s elegant.

Other software like that: Blender, Firefox, Chrome, XBMC… Gosh why this list is so short?

Similar revolution happened to PC games: You need to download Steam, Origin or other spyware, create an account to play a single game these days. Origin takes 5 minutes to start on a well-spec gaming rig and Steam will fuck-up my game every time an update is release. And once you get through all this crap a small fluctuation on your network connection will stop you from playing thanks to our new friend DRM. This is supposed to stop piracy they say, but hey it has been on the Pirate Bay day before the official release day and Razor 1911 made it EASIER to install the damn thing than the distributor itself. Put the disc in, double click razor_install.exe, select path, click OK, grab a drink, play.

Another thing – programmer’s best friend – the IDE (or a very clever editor). My programming environment is like a temple so I can’t stand one that takes 20 seconds to start like Eclipse does, or one that crashes every 30 minutes like Komodo does. Since I’m using different operating systems it can’t be platform limited like Visual Studio and hey I appreciate the fact that your vim/emacs can do all that Eclipse does but I don’t have 10 years spare to learn all the magic nor I really want to use a command-line text editor 40 years after Apple stole GUI from Xerox.

Sometimes I find myself thinking that I should have become a monk; find myself an isolated cave in Himalayas and spend rest of my life searching for inner peace. Yet they don’t have 3G up there so I’ll stick to my software engineer career.

When would you use var in your declaration and when you wouldn’t?

Always use var. Not using var for variable declaration will traverse scopes all the way up till the global scope. If variable with that name is not found it will declare it in the global scope. Therefore not using var implicitly declares variable in the global scope (which, let me remind you, is a bad practice).

(function() {
   baz = 5;
   var bar = 10;
})();
 
console.log(baz); // outputs 5
//console.log(bar); // error: bar is not defined

A common mistake is to not use var in loops which might, in some cases, bear unexpected results or pollute the global scope:

(function() {
    var baz = "Hello World";
    for(var bar=1; bar

Try it: http://jsfiddle.net/tnajdek/AKxn9/

What does the attribute defer/async do when added to the script tag?

The defer attribute will cause browser to execute script after the document has been parsed. This attribute was first implemented in Internet Explorer 4, then added to HTML 4 and more recently HTML 5 spec. You might not have heard of it as it has not been supported till version 3.5 (Gecko 1.9.2). Async is another attribute that can affect how a script is loaded and executed, here is a quote from HTML 5 spec on how this is expected to work:

There are three possible modes that can be selected using these attributes. If the async attribute is present, then the script will be executed asynchronously, as soon as it is available. If the async attribute is not present but the defer attribute is present, then the script is executed when the page has finished parsing. If neither attribute is present, then the script is fetched and executed immediately, before the user agent continues parsing the page.

Note: A somewhat (but not exactly) similar defer behavior can be achieved by placing your script tags at the end of the body tag and that’s what is considered to be modern ‘best practice’

What is the difference between == and ===? Which one would you use?

The equality (==) operator will compare for equality after doing necessary type casting, the identity operator (===) doesn’t do any conversions. A good practice suggested by Douglas Crockford is to always use strict equality,  couple of examples from Douglas’ book JavaScript: The Good Parts

'' == '0'          // false
0 == ''            // true
0 == '0'           // true
 
false == 'false'   // false
false == '0'       // true
 
false == undefined // false
false == null      // false
null == undefined  // true

How would you check if a variable is null/undefined?

//check if bar is null
bar === null

//check if bar is undefined
typeof bar === "undefined"

How do you check if a variable is an object
You can use typeof to determine if variable is an object, however bear in mind that null is actually an object! However null object is ‘falsy’ thus the following will work:

if(bar && typeof bar === "object") {
    console.log('bar is object and is not null');
}

Discuss  scoping in JavaScript.

JavaScript has lexical scoping based on functions but not blocks. Therefore:

//global scope
(function() {
    //anonymous function scope
    var foo = 1;
    function bar() {
        //bar function scope
        var foo = 2;
    }
    bar();
    console.log(foo); //outputs 1
    if(true) {
        var foo = 3; //redeclares foo
    }
    console.log(foo); //outputs 3
})();

Try it: http://jsfiddle.net/tnajdek/8y3XC/. Note: from within function scope everything in above scope(s) is available (see closures below)

Explain hoisting in JavaScript.

As some might not be familiar with the term ‘hoisting’ yet have the relevant experience this question could be asked indirectly

In JavaScript function declarations ( function foo() {} ) and variable declarations ( var bar  ) are ‘hoisted’ i.e. are silently moved to the very top of the scope. Consider the following code:

(function() {
    console.log(bar); //returns 'undefined'
    //console.log(baz) // error: baz is not defined
    foo(); // outputs 'aloha' to the console
 
    //function declaration AND its body is hoisted
    function foo() {
        console.log('aloha');
    }
    //variable declaration is hoisted but value assignment stays here
    var bar = 1;
    baz = 2; //defines baz in global scope
})();

See for yourself: http://jsfiddle.net/tnajdek/FxDrj/

What are closures?

(function() {
    function foo(x) {
        var baz = 3;
        return function (y) {
        console.log(x + y + (++baz));
        }
    }
var moo = foo(2); // moo is now a closure.
moo(1); // 7
moo(1); // 8!
})();

The inner function inside foo will close-over the variables of foo before leaving creating a closure.

Try it: http://jsfiddle.net/tnajdek/Rj6mK/

Explain prototypal/differential inheritance

Conceptually this is very simple: A new object can inherit properties of an old object.

(function() {
    var genericObject = {
        bar : "Hello World",
        get_bar : function() {
            return this.bar;
        }
    };
    var customObject = Object.create(genericObject);
    customObject.bar = "Aloha folks!";
    console.log(customObject.get_bar()); //outputs: "Aloha folks"
    delete customObject.bar;
    console.log(customObject.get_bar()); //fallbacks to the prototype's value, outputs: "Hello World"
})();

While JavaScript has always been a prototype-oriented language, tools to work with prototypes were somewhat missing. Object.create used in the code snipped above has been added in ECMAScript 5 and has not been supported prior to Firefox 4, Chrome 5, IE 9

What is Strict Mode in JavaScript
Strict Mode has been introduced as part of ECMAScript 5 and introduces new, restricted variant of JavaScript which has following aims:

• Throws errors for actions that are rather silly but previously didn’t throw an error
• Throws errors for potentially unsafe actions
• Disables functions that are poorly thought out
• Potentially code in strict mode could run faster by eliminating mistakes that would make it difficult for JavaScript engines to perform optimizations

Strict mode can be enabled for the entire source file or on per function basis by adding a string literal “use strict” on top of the file/function i.e.

function foo(){
  "use strict";
  // ... your code ...
}

For more detailed information about the strict mode consult relevant article on MDN

Extra topics for discussion:

• What’s your favorite browser, framework, JavaScript book
• How do you approach debugging in JavaScript
• What do you think of JSLint?
• Browser detection vs. feature sniffing

Anything I missed? Had a surprising interview question I haven’t covered? Let me know in comments below!

The Begining

We begin with guesstimating the correct order for colourful balls. This is the easy part, it’s pretty much a Mastermind game, but I didn’t realize it at that time. There is no limit on the number of attempts and you can pretty much brute force it. Each time you attempt to make a guess, you are being given a ‘hint’ or a ‘score’ on how close was your attempt to the actual solution. After trying for couple of times you can deduct what’s the meaning of these little black/white/gray bulbs even if you’ve never seen a Mastermind game before.

Here is how I started the game:

Terminology: What in Mastermind is called code pegs I ignorantly refer to as ‘balls’ within this document. What in Mastermind would be key pegs I simply call ‘bulbs’. 

After each guess I’m getting a feedback consisting of 6 bulbs:

• each black bulb represents a single ball in correct spot
• each white bulb represents a single ball in incorrect spot i.e. a ball of this color should be used somewhere else in the sequence
• gray/empty bulb represents ball that has no place in the final answer

The Mysterious Code

Not much huh? Well that’s all the help you will get! After each level a screen similar to the one above is displayed. Eventually you will be asked if you’ve ‘cracked the code’ and to submit a solution. After finishing all 11 levels I’ve stopped for the moment an summarized my knowledge so far:

1. There are 11 levels in total and 22 bulbs in 2 rows, 11 bulbs each
2. Each level is associated with 2 lightened bulbs
3. Lightened bulbs are unique for each level
4. Each level is associated with 6 balls in one out of 4 colors

From the points listed above I’ve deducted the following:

1. Bulbs represent some kind of ‘meta data’ – position, location, placement.
2. The actual value must be represented by the colorful balls
3. There are 6 balls and 2 highlighted bulbs per each level thus each 3 balls must represent a single ‘unit’ of data

Based on these assumptions I’ve tried to come up with some way (an algorithm) to derive a value from the set of 3 balls, usually by mixing and re-calculating their RGB representations in different ways. That didn’t work.

So let’s have another look at the screen above, there is one more hint on that screen which I’ve managed to completely ignore. On the very top of the screen there are 6 balls that are persistent between levels. It’s easy to miss them because colors are quite familiar – it’s Google logo colors. Let’s make another assumption:

4. The key to the solution is Google logo or its colors.

At this point my imagination went quite wild. I’ve tried to perform various calculations on RGB representations of Google logo bulbs and each level’s solution bulbs. I’ve went as far as counting the number of occurrences of each color (blue and red -> 2, green and yellow ->1), converting that to binary and trying to get the answer that way. I’ve gave up after about an hour, finished lunch and get back to office work.

The Revelation

After a busy day in the office I’ve been chilling at home with some cold beer when a revelation struck me – I already had the algorithm I’ve been looking for so badly! The algorithm has been used to give me feedback after each guess in the initial Mastermind-like game. Let’s try to recreate it:

1. Iteratively compare a ball from the guessed answer to a bulb in the same spot in the secret solution
2. If bulbs have the same colour, the result is black dot [•]
3. If bulbs have different colour, check other bulbs in the secret solution. If there is one with a matching colour in the secret solution (that is not matched correctly in the guessed answer and it has not been used before) the result is white dot [◦], otherwise it’s null [0].
4. In case where operation 3 results in [◦], mark that bulb in secret solution as ‘used’.
5. After comparing all balls Count [•], [◦] and [0] and use sorted counts to give feedback

In practice this is how it would look like:

Let’s re-use the same algorithm to score the level’s 1 solution against Google colors:

Let’s reassess the assumptions made earlier on:

1. Bulbs represent some kind of ‘meta data’ – position, location, placement.
2. The actual value must be represented by the bulbs.
3. There are 6 balls and 2 highlighted bulbs per each level thus each 3 balls must represent a single ‘unit’ of data
4. The key to the solution is Google logo or its colors.

Based on assumptions 2 & 4 we’ve derived a value, marked as score on the chart above. Based on assumption 3 we need to derive 2 ‘units’ of data. Earlier on feedback has been given in 2 rows, 3 bulbs each, so let’s do the same – but without sorting (effectively skipping step 5 in the algorithm described above). We will have:

1. [◦] [•] [0]
2. [◦] [•] [0]

Same? Funny.

Now follows the tricky part – so far we’ve been speaking about balls and bulbs, however the final answer must be a number or sentence. I’ve asked myself a question – how can I convert these symbols into values? Well there are 3 possible values for each scoring operation ([•], [◦] or [0]). Let’s assign these symbols numerical values – 2 for [•], 1 for [◦] and 0 for [0]. So far we have

1. 1,2,0
2. 1,2,0

120 in ascii is lowercase ‘x’, however if you think about it, most of the combinations of 0, 1 and 2 don’t produce meaningful values in ascii (e.g. 012 would be ‘vertical tab’). You can’t build a sentence with such a limited vocabulary either. It’s an incorrect approach, let’s try something different.

With my scoring algorithm I can produce no more than 3 symbols, later converted into numeric values. Since I can have only 3 different values I shouldn’t assume a decimal system! A Ternary (base 3) system would be more suitable, let’s try it:

1. 120₃ = 15₁₀
2. 120₃ = 15₁₀

Ok… that still doesn’t mean much in ascii. Let’s see what kind of values I can expect with 3 digits ternary system:

• Minimum: 000₃ = 0₁₀
• Maximum: 222₃ = 26₁₀

26? Hold on, isn’t that a total number of letters in english alphabet? Wikipedia!

The modern English alphabet is a Latin-based alphabet consisting of 26 letters

Bingo! Lazy as I’m I’ve googled for english letters ordering numbers (got this) and looked up 15th letter of the alphabet (it’s letter O). So we have:

1. [◦] [•] [0] => 1,2,0 => 120₃ = 15₁₀ => ‘O’
2. [◦] [•] [0] => 1,2,0 => 120₃ = 15₁₀ => ‘O’

Assumption no 1 says “Bulbs represent some kind of ‘meta data’ – position, location, placement”. Let’s try that:

From that point it’s couple of minutes to work your way through the remaining 10 levels reusing the same approach. Couple of minutes later I had the code cracked and submitted to Google. And hey! I’ve won a Chromebook :)

The Summary

Cracking logic puzzles like this one is not something you can learn. Yet having a correct approach can definitely help. Couple of hints I can share:

1. Whenever you’re stuck – stop and assess your knowledge. Write it down as a list, graph or something.
2. If you’re still stuck make an assumption and chase it. Gazing at the problem usually doesn’t help.
3. It’s ok to fail. Learn from it, then discard a non-working solution, revert back to a known state and start again.
4. If you’re stuck for a long time, leave it. Look for something else to do and come back to a problem later on.
5. Don’t give up!

What is a Bitcoin

Bitcoin is an anonymous, decentralized, p2p, digital (crypto)currency that comes with a network to maintain it. There is no central authority to maintain the currency, thus the network has a mechanism to track transactions and the ownership of Bitcoins, as well as prevent any fraudulent behavior such as spending Bitcoins you don’t have, double spending or creating Bitcoins out of a thin air. New Bitcoins are created at predictable rate through a process known as ‘mining’ which requires a lot of computational power to do and is also used to verify past transactions. Bitcoin has been created in 2009 by a mysterious Satoshi Nakamoto who wrote the original client and helped the network to take off, then gradually reducing his involvment. To join the Bitcoin community and start using it is an open source client which you can download from bitcoin.org.

Mining explained

Mining is the process of generating new Bitcoins as well as validating transactions that have been made by other members of the network. The process itself is somewhat peculiar and there are some who would say it’s a pointless waste of resources. In simple terms a miner would continually calculate a sha256 hash of a representation of Bitcoin transactions and a certain nonce (a meaningless number used only to change the hashing result) to generate a block and create a proof of work. Generated hash is then compared to a target (current value) and if it is less or equal it is accepted and the block is generated (if it is grater than the target then hash is discarded, nonce is modified/increased and process is continued). If a miner is successful he is allowed to append a transaction of 50 BTC credited to his Bitcoin account – an incentive for miners for doing the hard work. The block generated is then propagated into the Bitcoin network where it exists inside a ‘chain’ so that each block is connected to a previous one and the next one. More detailed (and far more technical) description of the process can be found on Bitcoin Wiki/Help page.

The Bitcoin economy

Gradually, over time, the amount of Bitcoins awarded for generating a block will decrease at predictable rate (it’s halved every 210’000 blocks, recently we’ve reached block 127’000 so it is still months if not years till that happens). Bitcoin network controls the amount of blocks generated every week by amending the difficulty of coming up with a valid hash (see ‘target’ above) – the target is to achieve exactly 2016 blocks generated every week (in other words 144 a day or  1 every 10 minutes). At some point in distant future generating a block will yield a neglectable amount of Bitcoins thus making it inefficient for miners to participate. For that reason one can add an additional fee to the transaction which will be awarded to the miner discovering the block. Transactions with fees will have higher priorities thus being processed and confirmed first. Currently and in the near future this is not really needed as the default 50 BTC is lucrative enough but in the future it will ensure a well-being of the Bitcoin network.

Bitcoin Markets

Bitcoins can be used for paying for goods and services in many places but it is still far from common to accept Bitcoins as a form of payment. Another thing you can do with your Bitcoins is trade them for fiat currencies and gold on various markets. Out of curiosity I’ve experimented with trading few Bitcoins for GPB and getting money in and out with wire transfers – it all went well. Usually you can trade Bitcoins without paying any fees – similarly, as of today, you can send them around without paying any transaction fees. That means that with a little extra effort you could use Bitcoins to send money to different countries without paying outrageous bank fees for such transfers. I can also think of some ‘shady’ ways Bitcoins could be possible used but let’s leave this out of the picture.

Reception

Bitcoin community has gained a lot of attraction during past month. There were couple of interesting articles that have made it to the top of the Hacker News, most notable: Why Bitcoin will fail aka ‘the rant’ and the answer for that. Bitcoin seems to gain popularity and it is about time that governments start poking around sniffing potential threat to the controlled economies. While this interest is a potential threat to the Bitcoin currency, the currency itself is doing very well. Over past month the value of a Bitcoin raised multiple times:

BTC/USD exchange rate value 1 April - 28 May - chart courtesy of bitcoincharts.com

My findings

I’ve begun mining with my desktop machine approximately a month ago. After trying couple of different miners I’ve chosen a Phoenix Miner for my Linux box with Ati Radeon 6950 (flashed to 6970) which is capable of doing approximately340Mhash/s without breaking a sweat (usable desktop, fat @50%). At current difficulty mining solo with this kind of computational power might turn out to be very unrewarding – you could be mining for days, weeks even months without finding a single block and thus earning exactly 0 BTC.  However a group of people working together can easily find a block within minutes thus mining pools have been conceived. Effectively pool is just a group of people working together on the same block in order to boost chance of finding a block. Pool’s computational power reaches many GHashes per second and finding a block is a matter of hours or even minutes for a crowded pool! Once block is found, the reward is then divided between all participants usually based on amount of shares each has provided. I’ve tried 2 different pools, deepbit and bitcoinpool, first one being the biggest public pool currently in existence and running at speeds above 1 Thash/s (!), second much smaller (currently around 100 Ghash/s). Effective earnings at each pool are comparable – deepbit gives you a lot of small payments (they usually find a block within minutes), bitcoinpool gives you a slightly bigger payouts but less often – still it is at most couple of hours between payouts.

With my 340Mhash/s machine I’ve been initially able to generate approximately 3BTC during each 24hrs period but due to the increase in difficulty over past month I can now roughly do half of that. At the same time I’ve been using the same machine for day-to-day activities and occasionally I’ve been forced to switch mining off if I had a need of GPU. After a month I’ve decided to get a dedicated mining machine and see how it fares.

For my dedicated machine I’ve chosen Radeon 5870 cards with hope to keep it most cost-effective. I’ve built the following spec:

• Motherboard: ASUS Crosshair IV
• Power Supply: Corsair CMPSU-1000HX 1000W
• GPU: 3x XFX Radeon HD 5870
• CPU: AMD Sempron 140 2.7 GHz
• RAM: Corsair 2GB 1333MHz DDR3

Couple of things you don’t really need but will make things easier:

• Cheapest HDD you can put your hands on
• Plain tower case with lots of fans
• Cheap dvd drive or a usb stick to boot the operating system

Which can produce between 1.1 and 1.3Ghash/s (depending on how good cooling you have) using Phoenix miner executed as follows:

python2.7 phoenix.py -u http://login:password@miningpool:8334/ -k phatk DEVICE=0 VECTORS BFI_INT AGGRESSION=11 WORKSIZE=128

There are couple of things you can tweak. Theoretically with excellent airflow through your case and A/C in the room it should be possible to overclock all your cards to 900Mhz and reach speeds >400Mhash/s per card (thus total speed of 1.2-1.3Ghash/s is possible). In practice, the cards are sandwiched and the card in the middle will run at slightly higher temperature than other two thus I’ve been forced to lower it’s clock:

My mining rig which I proudly call Arrakis

Threats

Ok, this all sounds exciting so before you jump onto the wagon and spend your savings on numerous top-shelf graphic cards, let me at least outline couple of potential and actual threats that can make mining unprofitable or even trip the entire Bitcoin ecosystem.

• Raising difficulty. There are more and more miners, the overall speed of a network is rising in a steep curve and Bitcoin network tries to catch-up by increasing the difficulty. Due to the nature of the network, mining will eventually become  unprofitable:

Difficulty of Bitcoin network over time - chart by courtesy of bitcoin.sipa.be

• Governments will try to kill it, there is no doubt in that. Bitcoin can turn out to be an interesting experiment in fields of p2p, the Internet and social freedoms in general.
• Technology fails big time – a single failure of the technology could cause a huge and violent hyperinflation which in turn renders mining hugely unprofitable discouraging most miners and, in worse case scenario, killing the network.
• A new technology comes with computing power so great that it will render GPU mining obsolete, in a similar fashion that GPUs made CPU mining obsolete.

This is by no means complete list of threats but only ones that I’ve personally found most accurate.

Summary

Recently Bitcoin has definitely gained some traction and more and more people are looking into it. Currently value of a Bitcoin it pretty unstable but the general trend is upwards, or using more economic we’re in a long-term rally period. At this moment mining using a GPUs should turn out profitable but it might change due to multiple threats and rather unpredictable market. Whether you’re looking into becoming a miner, trading currencies, thinking about accepting Bitcoins on your e-commerce or just found Bitcoin an interesting curiosity it is definitively something worth keeping an eye on.

Resources

• Home page: http://bitcoin.org/ and wiki: https://en.bitcoin.it/wiki/Main_Page
• Markets overview: http://bitcoinwatch.com/ and http://bitcoincharts.com
• Interesting visualization of a Bitcoin network (real-time) http://www.bitcoinmonitor.com/
• Mining pools: https://deepbit.net/ (3% charge), http://mining.bitcoin.cz (2% charge), http://bitcoinpool.org/ (0% charge), http://btcguild.com/ (0% charge)
• Profitability calculator (I would call it ‘guestimator’): http://bitcoinx.com/profit/
• Mining hardware comparision: https://en.bitcoin.it/wiki/Mining_Hardware_Comparison

If you would like to support my world domination plan, please send Bitcoins to: 1DNeuiLoEj6yJ16snHKg3e1DHyTeb6dz5g. I shall share them with Pinky and Brain.

Flight from London to Washington DC takes roughly 8.5 hours. Minus time for the take off, landing and food that gives you approximately 7hrs of interruption-free time. In other words a true blessing! There are no co-workers to distract you, no lengthy meetings, no family or friends, no cell phone, not even the Internet access with things like Skype, Facebook, Twitter and Hacker News lingering for your attention. I’ve realized that I can do much more in a single block of uninterrupted time that I can in the same time split between other arrangements.  It’s amazing on its own, but there more to it!

Let’s analyse the standard approach that most developers take when facing a problem (and I’m being guilty of it as well!):

1. Search on Google – surely someone already did that before
2. Have a look on Stack Overflow – there is bunch of  clever developers there
3. Ask other developers (online or offline) around
4. Think

While on plane options 1-3 are not there at your disposal, thus you tend to spend more time actually thinking and trying to come up with a viable solution.  I’ve realized that code produced this way is of much better quality!.

Unfortunately this kind of environment is not easily reproduced. I’m under strong impression that the following could help to achieve it, at least partially:

1. Work during night or early morning hours – people are less pesky at that time
2. Try to manage your time and arrange your time into a block of uninterrupted time (takes some human skills)
3. Change the environment of work - leave your multi-screen setup behind and take your laptop to the local coffee shop, park or library
4. Switch off Skype, mobile and email while working

Update: A day after I’ve published this article Jacques Mattheij wrote a very interesting piece about ‘living in the zone‘, i.e. being in a state of mind where you’re entirely focused on something (like programming task) without interruption within a block of time. It’s definitely worth reading.

• Cloud hosting like Amazon EC2 that can be instantly ‘thrown away’ when no longer needed’
• Social Media
• LaunchRock
• Frameworks and rapid development technologies that get you halfway through to ready product instantly
• Supporting communities
• A real fever of events like Startup Weekend

But to call it a bubble? I think that’s too much. Until yesterday I’ve been convinced that as Naval Ravikant has stated: there is no bubble. Yesterday however Color has lunched and not without lots of hype. And hype is all I expect from something that managed to attract 41 million dollars of funding. Last night I’ve snatched an Android phone to check what is all this commotion about.

So let me quickly describe my experience with Color. The phone I have been testing this on was Desire Z and the installation went fine, then the application started OK as well (I’ve seen  some comments about troubles getting that far). There were some significant problems with the interface (i.e. critical buttons hidden underneath the virtual keyboard and ignoring ‘enter’ on a single input form) but it’s a alpha version so I can understand these as long as the app is usable. On first run I have been asked to enter my name and take a photo of myself which seems to me like too much to ask during the initial run. Nevertheless I took ‘some’ photo and continued to see what can this app offer. Problem is that there is NOTHING more. Blank screen with a single photo of my wall that I’ve just taken. OK I’m guessing that’s because no one else is or has recently been using this app in my area, but hey! I’m not living in the middle of nowhere. Based on poor rating of this app on the Android Market I reckon I’m not the only person not being able to make any use of this app. I believe that there are some uses that I didn’t discover. Perhaps it’s really cool when used while attending a conference or a concert. Perhaps we have not yet discovered its full potential. It’s possible that Color will be ‘the next big thing’ but if you ask me I say it’s highly unlikely.

Let me summarize: valuation of 80 something million dollars, no track record, lots of hype and product that is, so far, less than average. Sounds irrational, doesn’t it? It all seems to me like characteristics of many ventures that we’ve seen during the previous bubble era. And there is more to it! Jacques Mattheij has posted an entire list of indicators that we’re indeed in the next bubble.

Bubble or not I think it might be an era of opportunity for some. We live in interesting times and with all these assets at hand I tend to agree with Cristina Cordova – let’s stop building photo sharing applications and aim a bit higher…

Edit: Apparently we have all misunderstood Color. It’s not a yet another photo sharing app, it’s a data mining trojan horse that runs on your mobile. Does it change anything? No.

It seems that folks at Quora don’t like the OpenID even going as far as claiming that:

OpenID is the worst possible “solution” I have ever seen in my entire life to a problem that most people don’t really have

Sounds pretty harsh, doesn’t it? Personally I think it’s all bunch of bollocks! I think problem does exist and OpenID is part of a solution. Fortunately Stack Overflow community, which opinion I highly value, has not yet  ruled out the OpenID. In this post I intend to revisit the ‘problem that most people don’t really have’ and take a fresh look at  OpenID-based implementation.

A common problem

I believe that nowadays average, day-to-day Internet user has to find a method to store tens, sometimes hundreds of authentication details. Most resolve to re-using the same password(s), using a password manager or using a “method”  for password generation. Either way when presented with a registration form for a new service, users are reluctant. They start to ask questions: “Do I really need to post that opinion online?”, “Are they going to send me spam?”, “Can I be bothered to remember another login/password combination”, “Do I have time to wait for the confirmation email?” etc. This is unpleasant for a first-time visitor who wants to quickly see what is your service about. It also lowers your conversion rate. Various implementations of a federated login mechanism have been devised or adapted as a solution to this problem and OpenID is one of them. While it might not be perfect it is a viable alternative to standard login/password combination, especially if used as part of solution and not as a solution on its own. And only if  implemented right.

Doing it Right

To define what I consider right implementation I will first explain what’s definitely should be avoided – a plain  ’enter your OpenID’ box is simply wrong. It’s wrong because it’s very confusing for users who are not familiar with OpenID. Average user probably already has an account with an OpenID provider and is not even aware of that! Major online service providers such as Google, Yahoo and AOL all can act as OpenID Identity Providers – if your visitor has an account with any of these guys, it means he already has an OpenID account. So let them know! Rather than asking for OpenID identifier, ask your visitor to log in with any of these providers.

I’ve already seen couple of examples of a good implementation of a federated authorization in the web and, despite of what people at Quora say, most of these make use of OpenID among other methods.  I believe that SpringPad has got it almost right, the only thing I don’t really like is the fact that they put so much emphasis on a classic login/registration and so little on the actual federated login capability. Personally I would make it more obvious that you don’t really need to register. Also Stack Overflow implementation is not bad for more ‘geeky’ audience but forces users to register with some arbitrary third party provider if they don’t have an OpenID or Facebook account which might discourage some potential visitors. Also there is no single sign-on between all Stack Exchange Q&A sites (you need to login to each of these separately), which is pretty disappointing.

My approach

I think that a decent implementation would:

1. Offer access with multiple popular, respectable (also trustworthy) and recognizable providers such as Google, Yahoo, Facebook, Twitter
2. Offer a fallback mechanism – alternative for those who can’t or don’t want to use federated login
3. Don’t ask ANY questions or confirmation if user logs in with a third party provider. In particular don’t ask to create an account.
4. Be able to spot user that has previously logged in with another provider. Allow manual associations of additional third party accounts (i.e. user has logged in with Google, but wants to associate their Facebook with their profile)
5. Explain why do your users need to use a third-party provider to login and what are the benefits
6. Make a promise not to spam

I’ve been working on implementation that would meet the requirements listed above and as of today my code covers items 1 through 3 from the list above.  I’ve setup a working demo and shared code on github so feel free to grab yourself a copy or even better fork me! – I would love to see this code brought to completion.

With my WebSocket experiment I’ve decided to go a little bit beyond a ‘chat application’ and develop a game using only WebSockets and HTML. I (incorrectly) assumed that a simple tic-tac-toe game (aka noughts and crosses) would be cool to begin my journey with Websockets. I don’t like reinventing the wheel so I’ve picked up a first php websocket library I could find and begin implementing the tic-tac-toe game. While I’ve failed to come up with a truly playable game I’ve learned couple of important lessons:

• A tic-tac-toe game is effectively a turn based game thus it doesn’t really benefit from WebSockets. Halfway through I’ve made a decision to convert my game into a red-and-blue squares game.
• PHP might not be best suited for socket-based programming.
• At this moment effectively ONLY Chrome supports web sockets!
  • Firefox 4 and Opera comes with the support for WebSockets disabled due to a potential security issue
  • IE9 doesn’t support WebSockets. I mean it does but only through a Silverlight object so you need extra JavaScript-Silverlight bridge. So it doesn’t.
• For browsers that do not support WebSockets yet, there is a nifty flash compatibility wrapper (it will use native WebSockets if available, fall back to use WebSockets through flash)

Eventually I got my red-and-blue-square prototype game into kind of playable state but it’s far from complete. After each ‘game’ you need to truncate a table in the database and also there is no logic to understand the win/lost condition thus you can play forever. Not a particularly useful piece of code but I decided to share it nevertheless, you can grab it on github.

I’m now working on a TRON game, expect update soon!

Recently as a part of a bigger project we’ve been working on a piece of software that would need to generate an extensive, complex and nested hash structure, then compare it with another, previously cached version of the same structure and decide whether it’s the same or different. The rest of the system has been written in perl thus logically we’ve selected perl for the implementation. Our hash comparison tool would be executed every 30 seconds and it  had to perform well on a rather busy system. We knew that a brute-force approach of comparing each key and value recursively would definitely cause performance issues. It was time to do some cheating!

Cheating in Perl

Fast forward to my findings, here is a table comparing various solutions for hash comparison:

               Rate  testdeep comparedata    dumper freezthaw storable    jsonxs
testdeep    0.152/s        --        -90%      -93%      -94%     -99%     -100%
comparedata  1.45/s      855%          --      -29%      -42%     -87%      -96%
dumper       2.04/s     1245%         41%        --      -18%     -82%      -95%
freezthaw    2.50/s     1547%         73%       22%        --     -78%      -93%
storable     11.3/s     7329%        678%      452%      351%       --      -70%
jsonxs       37.9/s    24861%       2514%     1755%     1415%     236%        --

Benchmark performed by running 100 iterations of each comparison subroutine using two identical hashes occupying approximately 4MB of memory each. Tested on a server with 8GB of RAM and powered by a 64bit, 2Ghz AMD Opteron 2212 CPU

1. Solution marked as testdeep above  is using the eq_deeply method from the Test::Deep package.
2. Solution marked as comparedata above is using the Compare method from the Data::Compare package.
3. Solution marked as freezethaw above is using the freeze method from the FreezeThaw package on both hashes then compares strings returned by this method.
4. Solution marked as storable above is using the freeze method from the Storable package on both hashes, then compares strings returned by this method. In order to achieve comparable results the  $Storable::canonical property is set to be true.
5. Solution marked as jsonxs is using the encode method from the JSON::XS package on both hashes, then compares strings returned by this method. Before the encode method can be applied, module needs to be configured in order to make sure that it always produces identical output. I’ve have used the following method in my benchmark:

my $json = new JSON::XS;
$json->indent(0);
$json->space_after(0);
$json->space_before(0);
$json->canonical(1);
return $json->encode($hash) eq $json->encode($hash2);

So why did JSON::XS perform  so much better than any other comparison/serialization method? First of all JSON format is quite good for serialization/deserialization performance (not so much for the size). But why it’s really so much faster is the fact that all the actual heavy lifting is done in a nicely-optimized code written in C.  Perl is just a wrapper using an XS Interface.

More cheats?

There are many more Perl XS libraries available on CPAN that can give a decent performance boost to your applications.  Aside from JSON::XS we’ve been using two other XS packages:  CSV_XS for parsing/generation of comma-separated values and YAML::XS for YAMLS serialization. Furthermore if you can think of any piece of functionality that would benefit from a C-based implementation, you can create your own Perl XS implementation thought it is not very straight forward and there is certain amount of hacking required.