My Developer Personality

I took a Developer Personality Test, conducted by DZone and it almost sums up what I am! Here’s the result I got:

Here are your results!

Independent vs Collaborative

You are Independent!

You prefer to spend most of your time working in an isolated environment.  You rarely want to collaborate because you have a better chance of solving problems on your own.  If you do have to collaborate on the direction of a project, you dislike it when you have to defend your position or when others try to muddy your plans for the project.  It’s better to have one strong vision for a project from the lead programmer on that project.  Having a large team or allowing others to have significant control over the project risks communication errors, a muddied code base, and inefficiencies.  If one developer has a firm grasp on the entire codebase, they’ll be much better at fixing and improving it quickly.

Good code doesn’t happen in a vacuum.  You need a team to keep you energized and on your toes so that you’re constantly improving the project code using the entire team’s varied experience and strengths.  You like to talk frequently with colleagues and discuss ideas so that you can learn from others and spark ideas.  It doesn’t matter what their experience level is, you can always learn something by including everyone.  A solo coder can’t possibly code a large software project with the speed and quality that a team can.

Abstract vs Low-Level

You are both Abstract & Low-Level!

You prefer to write in languages and frameworks that simplify development as much as possible and use as few characters and lines of code as possible. The trajectory of software development has always been toward making life easier and error-free. Programming has always been about adding more abstraction layers to simplify tasks, so why not trust the technology on your layer and don’t worry about handling the lower layers?

The more abstraction tools and high-level languages we build, the further we get from understanding and controlling the deeper components in our programs.  This means lower performance and endless bug searches.  Developers today need to have a stronger understanding of compilers, memory management, pointer arithmetic, and other low-level topics.

Frontier vs Conservative

You are Conservative!

You like to work at the cutting edge.  Using too many old languages and technologies bores you, and it severely hinders your software’s potential to keep outdated technologies in it for too long. Developers need keep their ears to the ground for new technologies and new versions of tools that they already use.  Even if the community and maturity of the project isn’t at a level that most enterprises would consider “safe,” you’re willing to be an early adopter if you believe the community and the technology has momentum.  Development technology is changing faster every day, and we need to constantly be adopting new tools and methods to keep up.

It seems like every 10 years we forget all the problems we solved in the previous decade and start to build ‘new’ tools that solve the same problems, even though there is a perfectly good solution that has existed for years.  Enterprises have it right when they make conservative decisions about their technology stack. Why would you hang your business on a technology with only a few years of maturity in just a handful of production use cases?  Technologies like PHP, Java, and SQL have been mainstays of the development industry for years, and it takes a lot of time for new technologies to make it into that maturity tier.

Generalist vs Specialist

You are both a Generalist & a Specialist!

You like to be known as a “Jack of all Trades” and a reference for others on your team. You jump at every chance to enhance your skills in a wide variety technology topics, not just the ones that apply to your day to day work.  You don’t always know when it might be useful to have these extra skills, but when the time comes, you are ready.  If more developers took the time to learn other skills outside of the ones relevant to their project, they’d work more seamlessly with the rest of their organization because they’d have more empathy and understanding of the challenges that their colleagues face.

If you’re a Jack of all Trades, you’re a master of none. Mastery in one or two areas is what makes you valuable.  What’s the point of learning skills for other jobs you don’t have and can’t control? When you plan for a project or do technical research, it’s always focused on something you’re working on. You don’t get side-tracked. If you learn a new skill, it’s because the project requires that you do it. Most or all of your hobby projects are also building your mastery of the skills you use at your job.

Idealist vs Pragmatist

You are an Idealist!

You believe in the power of well-defined processes. It’s crucial to an organization’s success that they create and follow appropriate and effective processes for building software. Trying to improvise or play it by ear invites the possibility of workflow errors that can decrease the quality of the software or even cause major product failures. Planning is also extremely important to you.  You like to research all of the things you will need to know before starting a project.  It’s important to find out the best architecture for your software beforehand, and then strictly implement that architecture with objective best practices.  The more planning and scaffolding you do in the beginning, the less overall work you will have to do to complete the software.

Speed is your best weapon in a competitive industry, and to quickly prototype and build new products, you need to have a flexible, pragmatic process.  You don’t have a few months to plan your projects, you need to just start coding and a good path for the project will reveal itself.  Great products are made through frequent feedback and releases, so why shouldn’t your plan be just as adaptable? Your plan should be adapted to changes in the software, and your expertise should be adapted to the project. You shouldn’t spend your precious time studying a problem that you’re not certain to run into while coding your projects.  Trying to build test coverage for every possible scenario and having long meetings throughout the process are a waste of time and distract you from doing more productive work.

RIP Thulika Keyboard.. (sob).. (sob)

Just got to know that Google has came up with an handwriting recognition app – Google Handwriting Input.

And the good part is it has got Indian language support. Yay!!

But the bad part is that, it means the demise of my very own Thulika Keyboard. I had created it about 2 years back, and at that time there was no handwriting recognition app for any Indian language. I also had opensourced it, and have got requests from many to translate it to their language(Arabic, Hausa, Tamil to name a few) and some even have used it as part of their school/college projects.

RIP Thulika Keyboard, it was pleasure to have you around(it’s still out there, so you can download it and play with it, but with Google’s new app, mine seems a bit primitive😦 ).


Google’s new app is awesome though, it recognises full words (mine could only do a letter at a time), and speaking about recognition, its very good at that.

So, here is me(Thulika), the old out dated tech giving way for the new stylish Google app😉

Programmer Zen

Just read this quote and I loved it:

A beginning programmer writes her programs like an ant builds her hill, one piece at a time, without thought for the bigger structure. Her programs will be like loose sand. They may stand for a while, but growing too big they fall apart.

Realizing this problem, the programmer will start to spend a lot of time thinking about structure. Her programs will be rigidly structured, like rock sculptures. They are solid, but when they must change, violence must be done to them.

The master programmer knows when to apply structure and when to leave things in their simple form. Her programs are like clay, solid yet malleable.

— Master Yuan-Ma, The Book of Programming

Authenticating using Facebook

I had figured out how to authenticate users using Facebook a couple of months back. But I didn’t document it, and so yesterday I again wasted my time figuring it out. So here is the brain dumb so that I won’t waste my time again at the time of need.:)

Prerequisite: Create an app using Facebook Developer account and create the necessary App ID and App Secret keys.

If you are testing out your app and you are running it locally, the site URL should be something like http://localhost:8090/

At the client side:

Asking for permission and login:

  • Use the SDK provided by facebook
  • I am assuming Javascript SDK is used. Inspect the response returned.
    • Send the authResponse.accessToken and authResponse.userID to the server for authentication.

At the server side:


  • Verify the user by calling the Facebook Graph API:{authResponse.accessToken}&access_token={app_id|app_secret}


    "data": {
        "app_id": "1234",
        "application": "testapp",
        "expires_at": 1426158000,
        "is_valid": true,
        "scopes": [
        "user_id": "111112223333"

  • input_token is the authResponse.accessToken we obtained as a result of the login process from Facebook.
    access_token is the App Token. It can either be generated as mentioned in this link. Or instead of generating we can use the concatenated form: {app_id} + ‘|’ + {app_secret}. I have used this second form above.
  • Verify the JSON obtained and check whether “is_valid” == True and “user_id” == authResponse.userID to make sure user is a valid one.
  • The authResponse.userID returned can be used to identify the user and used instead of username to lookup users.

Using the Graph API:

Suppose we want to obtain the user’s email Id at the server side:
Call the API as follows:{authResponse.userID}?fields=email&access_token={authResponse.accessToken}