It's very easy to setup Cucumber. First create your rails application (we are using Rails 3.0.3), here we need to skip over creating the test directory by giving the following command:

  
 $ rails new projectname -T

-T option will skip the Test::Unit framework as we plan to use RSpec.

Next add this to your Gemfile:

  
    group :test do
      gem 'rspec-rails'
      gem 'cucumber-rails'
      gem 'capybara'
      gem 'database_cleaner'
    end 

For a Sinatra Application, you need to install the following gem:

gem 'cucumber-sinatra'

Then install everything using bundler.

  
 $ bundle install

The above installation will provide two generators. To setup cucumber in your Rails application, use the following commands:

 
  cucumber:feature
  cucumber:install

We are using capybara for testing ajax, java-script. Since the integration testing would involve testing ajax/javascript and rails/sinatra, we would need both capybara and cucumber. Capybara has built-in drivers such as rack-test, Culerity, Celerity and Selenium for running your tests.

For testing a rails application, we would need capybara and cucumber-rails for testing our rails application.
The below command will generate the necessary code to use capybara and rspec with cucumber for your rails project.

 
$ rails g cucumber:install --capybara --rspec

For testing a Sinatra Application, we need to give the following command to set the cucumber environment:

 
$ cucumber-sinatra init Myapp lib/my_app.rb 

It will set the environment for cucumber. This command will generate the step definition and support folders. In the step definition folder, we have a file named web_steps.rb, which provides a broad set of steps that can be used in our specific steps file. In the support folder we have two files env.rb and paths.rb. This env.rb is a configuration file and paths.rb is used for mapping the corresponding path in the feature file. Feature file will have the scenarios in plain english. The .rb file contains the corresponding code for the scenarios in the feature file.

After setting the environment we need to create a feature file. That is, we can use cucumber generator for generating feature

 
$ rails g cucumber:feature user email:string password:string confirm_password:string

It is generally recommended that you do not create feature by using generators. It's better to write your own feature file. It will help you to define the scenarios on your own and helps in turn in implementing step definitions for the scenarios.

Let us consider an example. I am going to test the signup feature for my application. Since it's generic for any application, I took this as an example.

First we are going to describe the behavior in plain text. That is, create a feature file for signup. In this example, I am going to test one scenario while signing up. The user enters input in the following fields-e-mail, password and password confirmation. If the input in password and password confirmation fields do not match, an error message should be displayed. I am going to write a test case for this.

 
#sign_up.feature
Feature: Sign up
As an unauthorized user
I want to signup with my details
So that I can login

Scenario: Password doesn't match confirmation
  Given I am on the signup page
  When I fill in "Email" with "manisiva19@gmail.com"
  And I fill in "Password" with "Secret"
  And I fill in "Password confirmation" with "Password"
  And I press "Sign Up" 
  Then the Sign up form should be shown again
  And I should see "Password doesn't match confirmation"
  And I should not be registered

Next we need to run the features by the following command:

#To run full test suite
$ rake cucumber

#To run a single feature
$ cucumber features/signup.feature

When you run the above command, you will get the following output in your console:

$ cucumber features/sign_up.feature
Using the default profile...
F-------

(::) failed steps (::)

Can't find mapping from "the "signup" page" to a path.
Now, go and add a mapping in /home/manivannan/myproj/Projects/test/features/support/paths.rb (RuntimeError)
./features/support/paths.rb:36:in `rescue in path_to'
./features/support/paths.rb:30:in `path_to'
./features/step_definitions/web_steps.rb:20:in `/^(?:|I )am on (.+)$/'
features/sign_up.feature:7:in `Given I am on the "/signup" page'

Failing Scenarios:
cucumber features/sign_up.feature:6 # Scenario: Password doesn't match confirmation

1 scenario (1 failed)
8 steps (1 failed, 7 skipped)
0m0.362s

The output is usually color coded to indicate failures. Now we need to map the corresponding path in paths.rb. It looks like as follows,

#paths.rb
      when /signup/
        new_user_registration_path

I had used devise (ruby gem) for signup, and so I give the corresponding path. new_user_registration_path is generated when I use devise_for:users in the routes file.

After mapping the path, run the feature again as follows:

 
$ cucumber features/signup.feature
Using the default profile...
.....U-U

1 scenario (1 undefined)
8 steps (1 skipped, 2 undefined, 5 passed)
0m2.295s

You can implement step definitions for undefined steps with these snippets:

Then /^the Sign up form should be shown again$/ do
  pending # express the regexp above with the code you wish you had
end

Then /^I should not be registered$/ do
  pending # express the regexp above with the code you wish you had
end

It will indicate the undefined steps for your feature. You just need to copy and paste it in the step definition file for signup feature. This is how my step definition file looks.

 
#sign_up.rb
Then /^the Sign up form should be shown again$/ do
  get "users/new"
end

Then /^I should not be registered$/ do
  assert_nil User.find_by_email("manisiva19@gmail.com")
end

Now run the test again,

 
$ cucumber features/sign_up.feature
Using the default profile...
........

1 scenario (1 passed)
8 steps (8 passed)
0m1.477s

Now you can see that all the tests have passed. Hurray!

Testing Javascript & AJAX

While testing an application, it is hard to test the javascript and AJAX. But, cucumber makes it easy. Since capybara is integrated with cucumber-rails, capybara takes care of these javascript and AJAX using various drivers such as Selenium or Culerity/Celerity.

We will cover the topic of Javascript and AJAX in a different post. Go and play around your application using Cucumber, RSpec and Capybara and let me know if you like it.

The moment we logged out, the stylesheets and other static assets were not being served by nginx. The client called up and said that the UI looks screwy. We visited the site and we could not believe that all the static resources where throwing up 404s. We logged in again to the machine wondering if any of us had accidentally deleted the files but we found that they were all there. We checked the server again and we found everything was working. We looked at the logs and we found that when we were logged in the requests are served directly by Nginx however when we were logged out of the ssh session, the requests were not served by nginx and as a fallback were attempted to be served by the thin cluster, which failed as well.

This was really odd. They were just static assets - images, js and css. And the worst part is that any attempt made to study the bug rectified it. We knew were dealing with a Heisenbug. We figured that there had to be something that was running when we login and killed when we log out. We looked at .bashrc, .profile and everywhere else. We could not find it. Out of sheer guess work, we looked at /etc/mtab. There it was the home directory of the user was encrypted using ecryptfs. We maintain different apps on the servers under different user accounts. During ubuntu server installation the person who installed it from the client end had chosen to encrypt the home folder by mistake. Thin was serving fine as it had loaded the code on to memory while Nginx read files on demand and was unable to serve any static assets.

All we had to do was move the code out of the home folder and it started serving fine. One heisenbug successfully squashed. Or as Cecelia likes puts it, we squished it with a 10 ton hammer.

Comic shamelessly stolen from PhD Comics.

On closer inspection of the code, one can only conclude that the HIS was written by a bunch of intoxicated simians. It seems that their manager was aiming for the Ballmer peak but over shot it by a fair amount.

There are a few gems that I want to share with you. Guess where the bill details are stored

• bill_main
• bill_details
• opd_bill_main
• opd_bill_main_details
• opbill
• ipbill
• ipd_bill_main
• ipd_bill_main_details
• dbo.xxxx_bill (where xxxx is a random 0-7 characters string)

The answer: Depending on when the patient enrolled

This table is for storing "special" test results.

• lab_regno
• some
• irrelevant
• fields
• item1
• value1
• item2
• value2
• ...
• ...
• item100
• value100

The values may be or may not be stored in contiguous item numbers. I was interested how this came about and after a little digging around I got the answer. They copy-pasted existing forms to create new forms and did not want to alter the binding of the old controls so the created new ones and deleted the old ones. In short, you need to know which columns to select depending on the test that you want to load.

This one is a classic. Each one of the modules is a separate executable but is supposed to act like a single app. Once you click on a menu item or a button it is supposed to open a new executable. Guess where the state is stored. Exactly... the registry. If you locate the individual executable and open it, no authentication, viola. But the IT department has given strict orders that their front-desk guys login with the shortcut on the desktop.

In the end, you feel like gouging out your eyes after seeing such frankenware.

I cannot believe that people are dumb enough to buy such software. So, what should a IT manager do before they buy software? You should read Joel Test. If the company does not follow these practices, do not buy their software. I repeat. DO NOT BUY THEIR SOFTWARE . You will be making this world a much better place and saving a lot of good developers from undeserved grief.

Images licensed under creative commons. Click on the images to know the source.

Beanstalk is a simple, fast work queue.

Its interface is generic, but was originally designed for reducing the latency of page views in high-volume web applications by running time-consuming tasks asynchronously.

It has a simple text based protocol inspired by memcached to put in messages that can then be run with workers. It is persistent and most of its clients support connections to multiple beanstalkd servers. There are different choices of ruby clients. While there is the standard ruby beanstalk client, there is also an asynchronous EventMachine version called em-jack. You can choose your pick depending on the type of jobs. If the jobs are IO bound and not too much processing, EM-Jack is a good choice. If the jobs are fairly performance intensive, then you are better off using the standard loopy constructs or implement your own threaded client.

Tubes

In addition to the standard global queue, beanstalk supports the concept of tubes. Tubes are independent job queues. You can imagine an app having multiple producers each pushing jobs to a queue and multiple consumers consuming and processing the jobs from these queues. This is not as exhaustive as RabbitMQ's queues, exchanges and keys but it is simple enough for most web apps.

Usage

Connecting to beanstalkd and creating a job is is fairly simple.

email={:to=>['email@example.com'], :subject=>'Some Subject', :body=>body}
beanstalk = Beanstalk::Pool.new(['localhost:11300'])
beanstalk.use "emailtube"
beanstalk.yput(email) # yput converts the object to yaml before putting it in the queue

Processing the job is equally simple.

beanstalk = Beanstalk::Pool.new(['localhost:11300'])
beanstalk.use "emailtube"
loop do
  job = beanstalk.reserve
  email=YAML.load(job.body)
  # send the email
  job.delete
end

We have used beanstalkd in a couple of applications as a replacement to RabbitMQ. And so far, we have had a great experience using it. Try it out and let me know if it works for you.

Although this is good advice for users, I would like to give 3 important points for developers storing passwords in their database.

• Use BCrypt
• Use BCrypt
• Use BCrypt

BCrypt is a hashing scheme based on the Blowfish algorithm. It is excellent for password hashing as it is dog slow. The usual general purpose hashing algorithms like MD5 or SHA1 are really fast. They are meant to hash a lot of content and return a unique hash efficiently. This makes them an easy target for brute force attacks. Bcrypt on the other hand is very slow. On my machine, it is about 4 orders slower than MD5 when the number of rounds is 10. This is what wikipedia has to say about bcrypt.

Blowfish is notable among block ciphers for its expensive key setup phase. It starts off with subkeys in a standard state, then uses this state to perform a block encryption using part of the key, and uses the result of that encryption (really, a hashing) to replace some of the subkeys. Then it uses this modified state to encrypt another part of the key, and uses the result to replace more of the subkeys. It proceeds in this fashion, using a progressively modified state to hash the key and replace bits of state, until all subkeys have been set.

Provos and Mazieres took advantage of this, and actually took it further. They developed a new key setup algorithm for Blowfish, dubbing the resulting cipher "Eksblowfish" ("expensive key schedule Blowfish"). The key setup begins with a modified form of the standard Blowfish key setup, in which both the salt and password are used to set all subkeys. Then there is a configurable number of rounds in which the standard Blowfish keying algorithm is applied, using alternately the salt and the password as the key, each round starting with the subkey state from the previous round. This is not cryptographically significantly stronger than the standard Blowfish key schedule; it's just very slow.

The number of rounds of keying is a power of two, which is an input to the algorithm. The number is encoded in the textual hash.

Ruby developers can use bcrypt-ruby. bcrypt-ruby also salts your passwords to ensure that it is safe from Rainbow Table attacks. You can install it using the following command.

$ gem install bcrypt-ruby

And here is a quick example of how to use it.

require 'bcrypt'

class User
  include BCrypt
  attr_accessor :password_hash

  def password
    @password||=Password.new(password_hash)
  end

  def password=(passwd)
    @password = Password.create(passwd)
    password_hash = @password
  end

end

#usage

user = User.new
user.password = "password"

user.password == "password" # true

Let us make the web safer for our users.

There are several aspects to consider before selecting a database solution for your app. In fact, it has come to point that if your application is sufficiently complex, then you would have to use more than one database for your app depending on the kind of problem you would like to solve. To be clear, databases like MySQL and Postgres have served us well for the larger part of this century and will continue to do so. The class of problems that require a different datastore are statistically outliers. But many of the problems that were eariler solved with standard databases with intelligent hacks can now be solved with a wide variety of NoSQL databases.

Before understanding the why of each database, you need to understand the CAP theorem.

The CAP theorem, also known as Brewer's theorem, states that it is impossible for a distributed computer system to simultaneously provide all three of the following guarantees:

• Consistency (all nodes see the same data at the same time)
• Availability (node failures do not prevent survivors from continuing to operate)
• Partition Tolerance (the system continues to operate despite arbitrary message loss)

According to the theorem, a distributed system can satisfy any two of these guarantees at the same time, but not all three. (from wikipedia)

Most of the NoSQL solutions focus on the AP slice instead of consistency. However, databases like VoltDB focus on CA. HBase chooses CP and so on and so forth. I will not bore you with the details but you can read all about the charecteristics of your favorite database at http://nosql.org.

But you need to understand your requirement before you can pick your database. Most of the SQL databases wait for a 2-phase commit. It is a blocking call. If you have a website or a solution with hundreds/thousands of users with only a few number of concurrent connections, you might still be fine. However, you have to understand that each write is basically a blocking operation. So, if you have an application that is write intensive, then you pretty much have to wait on the database to write to the disk and update the indices for every request. This is the case for most apps. Since, we are designing apps which we can control, now organizations can harvest a lot of data like usage patterns and such. Writing such data to a SQL database during the request is wasteful and considered extremely harmful for your user experience. Now it is easy to understand why so many NoSQL systems like CouchDB, MongoDB and others sacrifice on consistency and focus on availability and performance.

One of the other things that you would want to choose a NoSQL system is for its flexibility with schema design. Assume that you are running a web app where you would want users to store custom fields for the same data model. Usually you will have to provision a database for each customer as their schema would change. Or, if you are using a slightly more evolved database like Postgres, you can use schemas and schema search paths. But then you cannot collate results across different schemas or different customer databases. Depending on your requirement, you may or you may not have to. But using a NoSQL datastore like CouchDB or MongoDB, you can have a flexible schema.

The third thing about NoSQL systems is the ability to perform DB level operations in a distributed manner. Yes I am talking about the elephant in the room - Map/Reduce. Some of the NoSQL databases include a computational layer that can scale and run in a distributed manner across many machines. Databases like CouchDB push it to the extreme while a few like MongoDB use it in moderation. But this is an important piece nevertheless. You can always replicate this by rolling out your hadoop cluster. But I feel going the DB way might be more efficient. After all, the data is already there.

All in all, I believe that NoSQL and SQL both have its uses. It is no more NoSQL vs SQL it is NoSQL and SQL. In fact, I am looking forward to new application frameworks that support polyglot persistence.

Usually configuring a DHCP server and a firewall for connection sharing is a pain. But Ubuntu has a piece of software called FireStarter. A small quote from their website.

Firestarter is an Open Source visual firewall program. The software aims to combine ease of use with powerful features, therefore serving both Linux desktop users and system administrators.

We strongly believe that your job is to make the high level security policy decisions and ours is to take care of the underlying details. This is a departure from your typical Linux firewall, which has traditionally required arcane implementation specific knowledge.

We hooked up the USB modem to Jai Keerthi's laptop and installed firestarter on it. Although not the ideal setup, it works. As Paul Graham puts it, India forces entrepreneurs to be relentlessly resourceful.

Quartz is a full-featured, open source job scheduling service that can be integrated with, or used along side virtually any Java EE or Java SE application - from the smallest stand-alone application to the largest e-commerce system. Quartz can be used to create simple or complex schedules for executing tens, hundreds, or even tens-of-thousands of jobs; jobs whose tasks are defined as standard Java components that may executed virtually anything you may program them to do. The Quartz Scheduler includes many enterprise-class features, such as JTA transactions and clustering.

The Java Way

To have a simple cron job, you need to write something like this. First you write the job. For example, here we have a cron job that gets fired every 20 seconds.

//SimpleJob.java
import java.util.Date;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class SimpleJob implements Job {

    private static Logger _log = LoggerFactory.getLogger(SimpleJob.class);
    public SimpleJob() {
    }

    public void execute(JobExecutionContext context)
        throws JobExecutionException {
        // do something complicated
        _log.info("hello job");
    }

}

And then you have to schedule it.

//CronScheduler.java
import java.util.Date;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.impl.StdSchedulerFactory;

public class CronScheduler{

    public void run() throws Exception {
        Logger log = LoggerFactory.getLogger(CronScheduler.class);
        
        // First we must get a reference to a scheduler
        SchedulerFactory sf = new StdSchedulerFactory();
        Scheduler sched = sf.getScheduler();

        // jobs can be scheduled before sched.start() has been called

        JobDetail job = new JobDetail("job1", "group1", SimpleJob.class);
        CronTrigger trigger = new CronTrigger("trigger1", "group1", "job1",
                "group1", "0/20 * * * * ?");
        sched.addJob(job, true);
        Date ft = sched.scheduleJob(trigger);
        //start the scheduler
        sched.start();
    }

    public static void main(String[] args) throws Exception {
        CronScheduler example = new CronScheduler();
        example.run();
    }

}

The Ruby Way

Although the above code works, this seems very .... umm... verbose. I have written a wrapper around Quartz that makes it a lot more palatable. Now presenting quartz-jruby. You can install it like below.

$ jruby -S gem install quartz-jruby

Now for some ruby code. This sets up the logger, manages jobs and schedules them with a friendly syntax.

# cron_scheduler.java
require 'java'
require 'rubygems'
gem 'quartz-jruby'
require 'quartz'

# configure log4j the way you want. I am lazy. :-)
org.apache.log4j.BasicConfigurator.configure

class CronScheduler
  
  # this adds all the scheduler stuff to your class
  include Quartz::Scheduler
  schedule(:hello_job, :every=>20.seconds) do 
    # any ruby code
    info "I fire every 20 seconds"
  end

end

# run the scheduler
CronScheduler.instance.run

Feedback

If you would like to check the source, you can visit quartz-jruby on github. Your comments are welcome.

Initially, from the initial research I did, I found Shapado had an implementation of exactly what I wanted, however when I studied and understood their implementation in detail, I realized that it doesn't really work that well in most scenarios, especially the ones we were tackling in our project. Shapado's versionable allows you to define a set of keys for a document, whose changes would trigger creation of new versions. However in our project we needed to track changes at the complete document level, i.e. even for changes in the associations. Also the versions were embedded within the document itself, which implied that the document would grow in size very rapidly, even though our changes in each iteration could be minor, since each version would literally be a snapshot of the complete document itself.

So we made quite a few design changes in the same, externalized the versions, changed the way one would enable versioning since in our case we wouldn't be keeping track of changes only in specific keys. Even here, we found that there were certain bottlenecks in the case if there were a whole lot of versions, for which we introduced the :limit feature which allows us to define how many of versions would need to be loaded instead of loading all of them at once.

The result of it is this mm-versionable.

If you have any comments, suggestions, requests, queries or feedback, please do let us know in the comments section below.

This thinking comes from a flawed assumption that programmers are somehow interchangeable cogs in a system. I used to use the term hackers in my previous job descriptions but I got too many people looking for roles specific to computer security and most of them did not know anything. So I now use the term programmer/developer which gets the point across. However, when I say I am looking for programmers/developers, it means that I am looking for a kick ass hacker who is equally comfortable in coding, testing his code and deploying it on to a server and debug issues with it. You see, a hacker does not write a piece of code to a specification. A hacker creates. It is that creativity that we are looking for which the current education system and companies like these are fighting so hard to kill.

So coming back to this company, I visited their website just for the heck of it. It landed me on a blank page, with their name and a "click here" link. I followed the link and I got assaulted with a flash based image gallery. I then went to their SEO page. Please notice the URL. Would you trust this company with your SEO? I then looked at careers page and found no job openings. The thing is that they have opened the module to add a job opening for any visitor. I do not mean to pick on Mentis. Their website might be a work in progress but it just sounds bad when client or prospective employees visit your site and a lot of this stuff is broken.

We should not forget that Broken Windows Theory applies to software as well. Bad code begets bad development practices and there is no escaping the death spiral.

This is what I think would work better. Invest in people instead of investing on the platform. It seems to be Microsoft and Windows Server all over again. The promise of windows was that it made it so easy that any MCSE would be able to manage the network. But for really large networks we needed good admins nevertheless who could have done a better job with Linux and their tools of choice. Also PaaS solutions tie you down to the platform. Even if the language is open, you will have to architect your application to the design choices of the platform. This makes the app very hard to port if you ever want to move out of the platform. Imagine rewriting an app that has been written for GAE to a normal Django/Postgres stack. It is insanely difficult. You are better off rewriting it from scratch.

Also if you would like to integrate your app with other software that is not supported on the stack, you are pretty much left to the mercy of the company building the platform. We have just learned not to build on closed source platforms and to embrace open source. But PaaS vendors want to take their closed source platforms all over again and they preach lean startups and cloud computing to mask their closed source monopolistic intentions.

We have an interoperable choice with IaaS vendors. EC2, Rackspace Cloud, Linode, Slicehost and others provide an interoperable solution. Although their service interfaces are different, they offer a similar service. You can reasonably port your app across EC2 to Rackspace to Linode and so on. They have varying degrees of flexibility, but at the core, they do not shackle you on to their platforms and ask for your first born. I have been seduced by GAE and have even thought seriously about using that as a platform to build applications. Then I realized that I was just being lazy. Scaling apps is hard but building apps that need that scale is much harder. If you can get to that stage, I reckon that you can figure out the scaling problem as well.

I am an open source developer and never will I give away my freedom to companies even as benevolent as Google. I wonder who else is using Microsoft Azure apart from Bing?

Programmers are like vampires. They're frequently up all night, paler than death itself, and generally afraid of being exposed to daylight. Oh yes, and they tend think of themselves (or at least their code) as immortal.

System Administrators are like werewolves. They may look outwardly ordinary, but are incredibly strong, mostly invulnerable to stuff that would kill regular people -- and prone to strange transformations during a moon "outage".

However, in my opinion, there are a new breed of engineers. The so called hybrids.

Hybrid is a pseudo-race from underworld evolution. They are both a vampire and a lycan (werewolf) at a cellular level and are stronger but have more craving for blood (to get things done). They switch roles between a programmer and a system administrator at a drop of a hat. They are comfortable configuring firewall rules, setting up log rotation, backing up and restoring databases and can comfortably snap into developing the next big feature once this is done. If you do not believe me, look at github.com or read about Zed Shaw. It is difficult to evolve into a hybrid. It takes years of practice but it is possible.

Once you are a hybrid, many people tend to call you the architect. And I do not mean the bald, old ones dabbling with abstract diagrams but people with common sense who can come up with pragmatic solutions that most people are blindsided to. Also the newer frameworks like Rails/Sinatra and databases like MongoDB provide ample space for either of the species to evolve into a hybrid. I always encourage the vampires at Artha42 to become werewolves and the vice versa. If you think you are a good vampire or a werewolf and would like to join our clan, you can apply here.

If you use Rails then you must use the awesome rails.vim. Git integration is just unbelievable with the fugitive plugin. A good programmer should be able to navigate the code regardless of the project he is working on. I found that when diving into new projects, the NERDTree plugin is really helpful. Grep is the swiss army knife of search but ack is even better. Ack helps you search your sub-tree very quickly. Ack has even got an awesome vim plugin to make it easy to search your code while you are working on it. If you know the path to the files but want to quickly open it, there is no better candidate than the Command-T plugin. It emulates the Goto File feature of Textmate. You need to have vim compiled with ruby to use this plugin.

By the way, I use zenburn as my color theme. This website's grey theme is an inspiration from zen burn. What are the plugins that you use with vim? Do let me know.

Well why Sanskrit? It is said that the difference between other languages (both Indian and foreign) and Sanskrit is that this language was not created by humans, but discovered. It is said in the yogic lore that each sound has a corresponding form and each form has a corresponding sound. So the sound corresponding to the form had been discovered by the yogis and made as a collection to form the Sanskrit language. Usually Sanskrit names also carry a meaning. Infact Samskritam(which is now anglicised to Sanskrit) means "well-created". Vagmi means one who speaks well. Shanthi means peace. Well this sound actually may not correspond to the form ;-)

Vagmi finally agreed to go with a Sanskrit word and liked Artha and Tejas the most. Artha means "meaning". It also means "wealth", but that is not the context we chose it. However we couldn't get artha.com or tejas.com. So we were looking at alternatives. The domain names weren't available for most of them. So then I "deepthought" of some combinations and landed up with 42. (Those who don't understand deepthought or 42, refer "Hitchhiker's guide to the galaxy"). So I came up with 42artha. Vagmi initially liked it, but then said it sounded like 37signals. I didn't know such name combinations really existed and was a little disappointed that there was a pioneer. So I proposed finally "Artha42". Artha42 Private Limited was rejected by the Registrar of Companies saying a company Artha already exists and merely numbers can't differentiate company names. So we gave them options of Artha42 Software, Artha42 Consulting, Artha42 Technology Solutions and finally they approved Artha42 Technology Solutions.

Each time I call a candidate or a vendor, in one breath, I say "I am Shanthi from Artha42 Technology Solutions". The response is "Shanthi from what?" The name has to be spelt and repeated thrice and they "correctly" note it down as "Artha 42 Technologies". I cannot avoid a grin when Vagmi introduces himself "I am Vagmi from Artha42 Technology Solutions" as I could picture the response would be "Hmm?" I am sure they can't figure out both names and they would not have even heard the tail end (Technology Solutions). So, what can they ask? :-)

Ok, I thought I can atleast fix one in three(Vagmi, Artha42, Technology Solutions). Like most developers, I chose the easiest. ;-) I came up with choices like Artha42 Innovations, Artha42 Crafting, Artha42 Labs to express what we do or intend to. We are glad that ROC accepted the first choice itself. Hence, we now are "Artha42 Innovations Private limited" since June 3rd, 2010.

Initially we started with the thought process on who are the users of the website. Obviously it is you who have the inclination to either take our services or join our family to provide them. Even if not, to provoke such an interest is the aim. With this intention, we started with the simple home page sporting links for Hire us, why hire us, Join us, why join us.

As per the new trend, we started with a dark themed website (dark grey, close to black). But then I had the feeling, "why do the same colour as others?". Grey was never my favourite. So we then tried white background. The first colours we used in combination with white looked awesome on a MAC, but horrible on a DELL Vostro. So we went ahead playing around with different colours. We started with orange (the chosen colour for Artha42) made it darker to subdue the brightness. Ultimately it landed in chocolate brown. It looked unconventional and it became my favourite of the three. However Vagmi had a differing opinion. So we then tried the theme (stylesheet) switcher and based on a poll within closed set of voters, we decided brown to be default. As we anyway want to give room to differences in taste, the theme switcher is left as intended design.

The website is powered by Apache with Phusion Passenger and is built on Sinatra and Mongo with aggressive caching. We had initially started off with a completely static site using jekyll but eventually chose the excellent Sinatra microframework to build this site.

We then felt the need to express our victories, challenges, the rough roads we travelled and the roller coaster rides. To cut it short, we always want to blog, but did not find the right platform or the opportune time until now. Your comments are most welcome. Do let us know what you think of our posts.