Now with the goodness of Hacker News and reddit. Thank you everyone for doing a great job proof reading the post.

Do checkout stackmonthly. A monthly roundup of best questions on

Good, creative writers are the backbone of our business. We try to hire and retain the best of them.

Our interview process is aimed to make the process efficient and objective. This ensures that we do not have to waste time in our hiring process and get back to real work ASAP. I outline the process below; in case someone else is interested.Continue reading

It is the process of observing people to discover their needs, goals, and values. Although the course if about “Human Computer Interaction”, the process of need finding is relevant to developing new products or even new businesses.

A good starting point for any new product is to clearly identify an existing problem or need. That’s because finding a big problem and need often yields important untapped opportunities. Observing people also helps build empathy and think from their point of view. So, how do we observe people and identify their needs?

Participant Observation

Observe the users and their behavior in context (performing the activity). This is most useful when you want to see users in their element and learn about their experience.

While observing, we seek answers to these questions:

  1. What do people do now?
  2. What values and goals do people have?
  3. How are these particular activities embedded in a larger context, or the big picture?
  4. Similarities and differences across people
  5. …and other types of context, like time of day

While observing people, pay particular attention to any hacks or workarounds. These could be a gold mine for new ideas.
Continue reading

There are several methods to evaluate a design:

Usability studies

  • This could be informal, watch and learn or formal usability labs.
  • They offer good learning and uncover quirks, bugs or false assumtions.
  • it is not the same as user’s using it to perform real work in real environment
  • difficult to compare alternatives
  • experimental bias


  • quickly gets feedback from a large number of users
  • relatively easy to compare alternatives
  • No need to build prototype, a screenshot or mockup will do.
  • There is a difference between what people say they’ll do and what they actually do.

Focus groups

  • gather a small group of people to discuss a design or idea.
  • could be difficult due to group dynamics or if the subject makes people uncomfortable

Feedback from Experts

  • peer review
  • dogfooding
  • heuristic evaluation

Comparative experiments

  • taking two or more distinct options and comparing their performance to each other.
  • observe actual behaviour as opposed to self report (in surveys)
  • it can be better than usability studies since it compares multiple alternatives.
  • but you can’t observe people like in usability study.

Participant observation

  • observe people in their actual work environment


  • Useful when alternatives can be mathematically evaluated against design goals
  • Allows lots of alternatives to be compared


The method of evaluation to be used for the specific design goal depends on these (often conflicting) parameters:

  • Reliability: could be reproduce the results
  • Generalizability: applicability to larger set of people
  • ¬ěRealism: do the observations hold good in real world situations
  • Comparison: can we easily compare different (new of existing) designs
  • Work involved: the effort to get the feedback

I am currently taking the Human Computer Interaction class, and unlike last time, will make notes during the course and not after.

What is Human Computer Interaction?

HCI is the design, implementation and evaluation of user interfaces.


Good design is a pleasure to use; it increase efficiency and prodcutivity. Whereas bad design can be frustrating and in extreme cases can even costs lives.

Design using Prototypes

Prototyping is the single most important strategy for effective design. It should focus on the goals and not get stuck with some (current fad) design idea.

Design prototype as like software prototypes. Quick approximation of the idea, that helps collect feedback and iterate towards the final (design) goal. They let the users experience what the final product might look like (feel), work like (implementation) or the UX (role).

While visiting today, I was intrigued by the home page promotion of ‘Biz Solutions’. Clicking through, I was surprised to see an unbelievable price for .in domains. This sent me hunting for the fine print, but I found none. Here is a screenshot of the offer.

.in - Rs. 125 for one year

Not ready to give up, I decided to test the offer by trying to purchase a dummy domain.

Still Rs. 125, still no fine print or renewal rates. Only when I changed the registration period to 2 years, could I tease out a probable year 2 rate.

So there you have it, rediff advertises a low-low price of Rs. 125, and never discloses that it will cost you Rs. 800 to renew.

I looked up 2 more alternates that target customers of similar skills, bigrock and yahoo. Both had the first year fees lower than renewals (industry trend I am fully aware of), but were upfront that the renewals rate differs. Yahoo was very upfront, whereas bigrock needed some digging.

Yahoo's offer

Bigrock's offer

I started Sangeet Planner based on micro framework, which allowed for rapid prototyping. Soon I hit some problems with the plug-ins (lack of them) as well as issue supporting multiple plugins. Hence I decided to move over to Flask, which has a much bigger ecosystem. Below are the steps I took to convert most of the application to Flask.

Fix the imports

Use these imports:

from flask import Flask, render_template as template, request, make_response, jsonify, abort from flask.ext.sqlalchemy import SQLAlchemy 

instead of

from bottle import route, run, template, install, static_file, response 
import bottle 

The important part was importing flask.render_template as template. This lets you continue using the bottle style call to template.

Similarly, I imported

from flask.ext.sqlalchemy import SQLAlchemy 

instead of

from bottle.ext import sqlalchemy 

Change the startup process

if __name__ == "__main__": 

changed to

# towards the beginging of the file, soon after imports 
app = Flask(__name__, template_folder='views',static_folder='public/static') 
# towards the end of the file 
if __name__ == "__main__": 

important to note, we are overriding the flask defaults to make them use the bottle conventions of having the templates stores in the views folder (template_folder=’views’) and tell flask to serve all files from public/static as static files. This allows us to remove the static serving routes needed in bottle. For e.g. I had a few routes like the below, which are no longer needed.

def server_static(filename): 
    return static_file(filename, root='public/static') 

Fixing the sqlalchemy plugin

The plugins in Flask are initialised differently to bottle. So I needed to change the bottle style sqlalchemy load as below:

app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///mysqlite.db' 
conn = SQLAlchemy(app) 
db = conn.session 

The db object is not injected anymore in functions, so remove the input param. Along with other changes needed to account for the differences between bottle and flask the routes will look like this:

def index(db): 
    #no change to function body 
    return template('index') 
def index(): 
    #no change to function body 
    return template('index.tpl') 

Reading request values

There are subtle differences in bottle and flask. I think some of them can be fixed with some monkey patching, but a quick find/replace did the trick for me.

A comparative table:

Bottle Flask
request.forms request.form
request.POST request.form
request.POST.getunicode(key) request.form.get(key)
request.GET request.args
request.GET.getall request.args.getlist
request.get_cookie request.cookies.get (haven’t looked into secure cookies yet)
response.set_cookie response = make_response(…)

Declare the HTTP methods allowed

One last change was how allowed HTTP methods are delared.

In bottle:


In changed in flask to:

@app.route(' some/route', methods=['POST']) 


Well, a few changes would have been less for me if I had used an app object in bottle as well, but the fixes were trivial.

Hope this guide helps you. In case you run into some other difference, please leave a comment below.