I had tried Picasa about two years ago and it seemed completely inadequate to me. It tried to do everything and it was hard for me make it do what I wanted. I tried Picasa 3.6 this week and I totally converted.

THe best feature that makes Picasa a winner is face recognition. It works amazingly well and it improves continuously. First it locates faces quite well. Secondly, it has a very efficient user interface that lets you tag photos with people’s names. Then, it finds matching faces with 90-95% accuracy and continously adds to the collection, seemingly improving its match algorithm. It even correctly identified pictures from people over 20 years of aging.

The naming tools are also quite efficient. For example, in the unnamed category, the tools similar faces close to each other so you can select multiple images and tag at once.

In addition, the photo processing tools it provides are quite good. It has the usual special effects tools such as contrast, sharpening, sepia etc. Another useful tools is cropping. It comes with some preset cropping ratios and even provides some cropping suggestions based on face placement.

Over all, a great improvement as compared to previous versions.

The tools works like a charm and I like their sales model in which you can use the tool for free for a one-off personal use. I highly recommend it and encourage you to try and buy it.

Game of Cricket: Gol guttam lakad battam de danadan pratiyogita

Cricket Test Match: Pakad dandu, maar mandu, de danaadan pratiyogita

Table Tennis : Lakdi ke phalak shetra pe le takaatak de takaatak

Lawn Tennis : Harit Ghaas par le tada tad, de tada tad

Light Bulb: Vidyut Prakashak Kanch golak

Neck Tie: Kanth Langoti

Match Box: Ragdampatti Agni Utpaadan Peti

Traffic Signal : Aavat Jaavat Suchak Jhandaa

Tea: Dugdh Jal Mishrit Sharkara Yukt Parvatiya(pahaadi) Booti

Train: Sahasra Chakra Louh Path Gaamini

All Route Pass: Yatra Tatra Sarvatra Gaman Aagya Patra

Rail Signal: Louh path gaamini aawagaman suchak yantra

(Another) Rail Signal: Agni Rath Aava Gaman Soochak Pattika

Button for clothes: Ast Vyast Vastra Niyantrak

Mosquito: Gunjanhaari Manav Rakt Pipasu Jeev

Cigarette: Shweta patra mandit dhumra shalakha

But, there are large parts of your life you DO NOT want to share with the world. It is for yours to manage, preserve for when you want to look back at life and cherish. You want to be able to create and store information in a way that is easy available but is safe so you can always get to it and secure so no prying eyes can look into it.

Towards this end, a few friends of mine and I created a website called, bereadyforlife.com. The idea was to enable a place on the web, or in the cloud as it is called nowadays, where we can keep our digital assets in a secure fashion. This could include

• Important documents such as copies of house deeds, tax returns, warranty information etc.
• Your personal thoughts in the form of loose documents or as a journal or diary
• Checklists such as important numbers, emergency preparedness lists etc.
• List of assets and their value so you can easily create insurance claims
• And we added interesting information management apps such as shopping list manager

We then created security mechanisms such as high strength 256-bit encryption for your documents, journal, checklists etc. so that only you can get access to them. This is multi-level security. The site is first protected by your password. Then each area such as document vaults and diary is protected by separate keys. No one knows the keys except you. It is not stored anywhere on the site. So you can be assured that no one can compromise your data.

In fact, we keep our own data now on this site.

Check it out. I will welcome your comments on the beta version of the site at bereadyforlife.com. And spread the word!

Data Transfer Interrupted

The connection to has terminated unexpectedly.
Some data may have been transferred.

and

(98)Address already in use: make_sock: could not bind to address 0.0.0.0:80

I am using a certificate from GoDaddy and running Apache2 on Ubuntu 8.04.

Not sure what series of corrections fixed the problem but the following configuration is now working:

/etc/apache2/sites-enabled/000-default


NameVirtualHost :443
NameVirtualHost :80

And, the ssl.conf directory (/etc/apache2/mods-enabled/ssl.conf)

SSLRandomSeed startup builtin
SSLRandomSeed startup file:/dev/urandom 512
SSLRandomSeed connect builtin
SSLRandomSeed connect file:/dev/urandom 512

##
## SSL Global Context
##
## All SSL configuration in this context applies both to
## the main server and all SSL-enabled virtual hosts.
##

#
# Some MIME-types for downloading Certificates and CRLs
#
AddType application/x-x509-ca-cert .crt
AddType application/x-pkcs7-crl .crl

# Pass Phrase Dialog:
# Configure the pass phrase gathering process.
# The filtering dialog program (`builtin’ is a internal
# terminal dialog) has to provide the pass phrase on stdout.
SSLPassPhraseDialog builtin

# Inter-Process Session Cache:
# Configure the SSL Session Cache: First the mechanism
# to use and second the expiring timeout (in seconds).
SSLSessionCache shmcb:/var/run/apache2/ssl_scache(512000)
SSLSessionCacheTimeout 300

# Semaphore:
# Configure the path to the mutual exclusion semaphore the
# SSL engine uses internally for inter-process synchronization.
SSLMutex file:/var/run/apache2/ssl_mutex

#SSLEngine on
SSLCertificateFile SSLCertificateKeyFile SSLCertificateChainFile

SSLRandomSeed startup file:/dev/urandom 1024
SSLRandomSeed connect file:/dev/urandom 1024

SSLSessionCache shm:/usr/local/apache2/logs/ssl_cache_shm
SSLSessionCacheTimeout 600

Hope this helps some other soul having the same tribulations.

After you use the record and play for a few times, the next big road block that you have to get over is to learn how to select elements on the web page especially if it has a complicated nested structure, does not have an id or in case of using third party libraries such as extJS, the ids can change with each run.

In that case, I have found xpath to be very powerful. Below are some examples of the locators. Note that if an expression can return more than one element, the first element is returned by default. You can also use [1], [2] etc. to get a specific element.

1. If you know attribute value of an element

   //div[@id='xyz']: selects the div whose id is exactly xyz

2. If the attribute value should contain a string

   //div[contains(@id, 'xyz')]: matches divs whose id attribute contains the string xyz

3. If you want to select an element inside another one

   //div[contains(@id, 'xyz')]//div[@id='abc']: matches div whose id is abc and is contained in a div whose id contains the string xyz in it.

4. If you want to match on the text in an element

   //a[text()='My Text']: matches a link whose text is “My Text”

5. If you want to match more than one string in attribute or text

   //a[contains(text(),'Bill') && contains(text(), 'Clinton')]: matches a link whose text contains both Bill and Clinton. You can use any xpath function or operator to create your expression

6. Find the nth element of a type

   //div[position()=3]: matches the third div on the page

   //div[@id='abc']//table[position()=3]: matches the third table inside the div whose id is abc

As a complicated example consider

//div[@id='editClaimPopupPanelDiv']//div[contains(@class,'x-grid3-row')][1]//table//tr[1]/td[1]

This find the div whose id is editClaimPopupPanelDiv. Inside div(s), the first div whose class attribute contains x-grid3-row is matched. Inside this div the first table is matched inside which the the first row and then the first td is matched.

Some functions you might find useful are (excerpted from the w3 spec):
String Functions

1. string concat(string, string, string*) : The concat function returns the concatenation of its arguments.
2. boolean starts-with(string, string) : The starts-with function returns true if the first argument string starts with the second argument string, and otherwise returns false.
3. boolean contains(string, string) : The contains function returns true if the first argument string contains the second argument string, and otherwise returns false.
4. string substring-before(string, string) : The substring-before function returns the substring of the first argument string that precedes the first occurrence of the second argument string in the first argument string, or the empty string if the first argument string does not contain the second argument string.
5. string substring-after(string, string) : The substring-after function returns the substring of the first argument string that follows the first occurrence of the second argument string in the first argument string, or the empty string if the first argument string does not contain the second argument string.
6. string substring(string, number, number?) : The substring function returns the substring of the first argument starting at the position specified in the second argument with length specified in the third argument.

Node Selection Functions

1. number last()
2. number position() : position of selected element

For a detailed review of xpath see the w3 spec

As more and more companies moved to India, a major issue has been and still is being felt in the areas of hiring and retaining good people. Culturally, Indian engineers have gravitated towards larger companies like IBM, Oracle, Google. And due to the huge demand for limited talent, typical engineers have developed a knack for jumping jobs to gain increases in their compensation packages. In this context, smaller companies including startups are finding it hard to acquire good people.

I am experiencing similar issues in the hiring for people for my company, Arlak. We develop web applications hosted at infodoro.com. I have had some early successes. The strategy that has worked for me is to hire people who are early in their careers. The key is to look for people who are hungry to grow and hungry to learn. Find people who have the fire in their belly even though their skills are still not yet up to par. Then, nurture them, mentor them and educate them just like you would a young engineer in the US. Treat them with respect as people and as professionals. Give them challenges and important work, not just work that you don’t want your US engineers not to do. In one of my previous jobs, we outsourced mundane work that we wanted to protect our US engineers from and the low quality of people and the work produced was a reflection of this attitude.

In some ways, the selection of enthusiastic and willing people for small companies is a self-selecting process. Given the current environment, the people whom you will be able to attract to your small company will be the ones who are hungry to grow. You have to make sure that you have the commitment and the will to mentor these cubs.

Stumble it!

We have found the following tools to be help teams of software developers.

Source Control System (SCS)

The product of a software development process is source code. All the investment and effort of the process ultimately goes towards producing this asset. Therefore, it is important that the source code is protected on an ongoing basis. However, a source control system is more than just a backup. It needs to aid in the development process by providing features such version management, roll-back, and support for branching.

A set of desirable features for a source control system are:

• Maintenance of version history: The SCS should be able to maintain the version of each check-in to the code so that the state of the code as it existed at an earlier time can be recreated as necessary.
• Atomic commits: The SCS should support atomic commit so that a commit failure does not leave the SCS in an inconsistent state.
• Support secure Internet access: The SCS should support access in a secure manner over the Internet so that distributed teams can collaborate.
• Efficient Branching and Tagging: The development team should be able to tag any revision as a significant revision. During the development process, it will be necessary to branch the code for operations such as development of a new version and bug fixing. The SCS should provide support for creating and new branches and for merging. In particular, good SCSs will create a lazy copy for a branch so that multiple identical copies of files are not created.

There are a number of commercial SCS (Perforce, Clear Case, Microsoft Source Safe) as well open source SCSs (Subversion, CVS).

We have used Subversion with success in co-located as well as distributed teams.

Bug or Issue Tracker

Where there is code, there are bugs!

An effective bug and issue tracking system is critical to build and maintain quality of code. It is important to be able to log issues and defects as they arise so that decisions as to the priority and scheduling of the issue can be made.

A good bug/defect/issue tracker system should support:

1. Simple user interface
2. Search and filtering capability
3. Notification system
4. Support for work flows
5. Access control
6. Integration with source control system
7. Custom Fields
8. Monitoring capability

There are a number of commercial (ClearQuest, BMC Desk Express, JIRA) and open-source issue tracking (e.g., Bugzilla, Mantis) systems

We have found Mantis, an open-source tracking system to be an effective system providing all of the above features.

Continuous Integration

The traditional model of breaking your development into modules, developing the modules independently and then, late in the development cycle, integrating them into one whole system is fraught with finding incompatibilities and system-level issues late in the process when everyone is in a crunch. Most often, it leads to schedule slippages, buggy software and unhappy customers.

Continuous Integration (CI) is a means of reducing the chances of finding surprises late in the development cycle. CI involves building the latest code into a package to make sure that the code at least compiles and any recent changes have not caused compile failures. In addition, a good CI process should deploy the code as well as run automated tests to catch regression failures due to new changes in the code.

CruiseControl is a popular continuous integration tool that supports automated builds and test integration. It also supports a web-based console for the tool.

Wiki

A wiki is a collaborative communication tool. Simply put, it is a website that can be edited by authorized users using the web interface itself. Most wikis support versioning so that any old version of the edited page can be viewed or recovered. Wikis provide a simplified mark up language so that an editor can created a formatted page with different formatting elements such font styles, indentations, and tables.

A wiki provides a mechanism for the team to create areas of discussion. The informal nature of content creation on a Wiki encourages team members to create content more rapidly and keep them more current than in more formal documents. In addition, the web nature of the tool make the wiki available to every member of the team irrespective of location and time. In addition, a wiki always provides the latest version of the document as opposed to documents created as MS Word files or in some such desktop tool.

There are a variety of commercial (Confluence, SocialText) as well as open-source (e.g., MediaWiki) wikis.

Automated Testing System

For any project of significant value, the number of tests to perform feature, acceptance and regression testing will grow in to the thousands. In many cases, the ability of the QA team to run these tests becomes a gating factor for how quickly and how often new features can be released. I speak from experience!

The good news is that a large percentage of these test can be automated resulting in significant savings in human effort. And since it is much cheaper and easier to put additional computers into service than hiring new QA personnel, automating tests has a great return on investment.

There are a number of test automation levels (unit testing, acceptance testing) and tools (Junit, Winrunner, WATIR).

Test Tracking System

A test tracking system is an important tool for a Quality Assurance (QA) team. This tool lets the QA team keep track of the test cases to test a product in a systematic manner. These tools let the team organize the test cases in test scripts and test plans. Good test tracking systems also integrate with the bug tracking system This way failed tests can be linked to bugs when when fixed get reflected in the test case. Also, integration into a test automation system enables the running of the test cases and updating the pass/fail status of the system.

In summary, installing a set of collaboration tools and using them in a disciplined manner can increase the productivity of a software development team significantly. And, most tools are now available in open source form, there by reducing the investment into these tools.

In the traditional SDLC methodology, sometimes also referred to as Waterfall method, the SDLC is divided up into multiple phases that are performed in sequence. The phases are:

Requirements Gathering

In this phase, the idea for the product or release is explored. Representatives from multiple cross-functional teams including marketing and engineering discuss the business and technical feasibility of the product. Product management will translate market needs into product requirements and features. Working jointly with Engineering to estimate costs of these features, Marketing will prioritize the features so that the appropriate set can be selected for a release and a release horizon can be created.

Design

In this phase, the Engineering team will design the product. A new architecture or enhancements to the current architecture will be created. Appropriate technologies and components will be selected. The components that are available off the shelf (preferred!) will be evaluated for feasibility. Components that need to be built out will be designed. Typically, a high level and a detailed design is created. The high level design defines the system level description of the component and how it interacts with other parts of the system. The low-level design will describe the detailed APIs and software modules that comprise the component.

Implementation

Using the output of the design phase (high-level and low-level designs), the engineering team will start implementing the components that are required to build the product. As the implementation progresses, there will usually be changes to the design based on the new findings. These changes will be incorporated in the design and any effects of these changes on other modules will be communicated to the relevant sub-teams.

Integration

Once the modules are completed, the integration of the modules to build out the complete release will be undertaken. Representatives from various sub-teams will integrate the modules created by their teams. In theory, if the modules have been build according to the specifications that were created for them, they will integrate quickly and well to create the software. In practice, this phase brings forth a number of issues of incompatibility. The common cause of this is the inevitable inadequate communication of changes to the design as each team was developing their own components and making changes to incorporate new findings.

Verification or QA

After the modules have been integrated, the software will be release to QA who will perform testing on the system. During this phase, the QA team will find bugs and defects in the product which the development team will fix. Frequent updates to the software are released to the QA team incorporating the fixes for the bugs.

This phase continues until no more high severity bugs remain in the product. The Engineering and Marketing team will decide if the product is at acceptable level of quality to release to the market by evaluating the severity of the remaining bugs.

Release and Maintenance

Once the product has reached an acceptable level of quality, the product will be released. Depending on the type of product, the release team might burn master CDs, deploy the release on web servers or post the package on a website.

After the product hits the market, the customers during the use of the product may also discover more issues which will be reported back to the Marketing and Engineering teams. These changes will be factored into the product road map and minor releases might be created to take care of the issues that cannot wait for the next major release.

Agile Development

The method described above, the Waterfall method, has multiple phases. Each phase is completed one by one and the output of each phase drives the next phase. This method is easy to understand and to communicate, especially for scheduling and budgeting purposes. Gross mistakes can usually be caught earlier and phase milestones can be approve by customers.

However, in practice things don’t work as well as one might imagine. In a dynamic market where new business realities make changes necessary in a product under development, it is hard to incorporate changes in this phased model. A discovery in a later phase can invalidate earlier decisions. Since each phase can last many months, customers have to wait for a long time before working product can be reviewed. Also, since not all people are needed in each phase, some resource are wasted as they are waiting for other resources to generate the deliverables.

To address these shortcomings, an Agile Development Methodology has been developed in recent years. There are several types of agile methodologies. Most of them share similar principles. They emphasize

• Individuals and interactions over processes and tools
• Working software over comprehensive documentation
• Customer collaboration over contract negotiation
• Responding to change over following a plan

The items on the right of each statement are important and will be needed in the process, but more value is put on the items on the left.

At its basic level, agile development turns the waterfall method into an iterative and incremental model. That is, small chunks of functionality is developed incrementally in separate iterations. This functionality is released to QA and demonstrated to customers. In this process, changes are made to the code as feedback is received from QA and customers. This is in contrast to getting feedback from QA in the QA phase and from the customers after release.

The main benefits for Agile are:

• Deliver working code and valuable features to customers fast
• Continuous and better visibility for customers and stake holders
• Better productivity, quality and happiness in software development organizations

Since frequent and constant communication is essential to make Agile development work effectively, a number of tools and processes can be utilized including:

1. A central source control system
2. A bug tracking system
3. A test case management system
4. Insistence on writing unit tests
5. An automated test suite and harness
6. A continuous code integration system with the unit tests and the automated test suite integrated in
7. A wiki, task management and messaging system

I had spent 4 years at my last job at VeriSign and the urge to do another startup started to gather steam. I left VeriSign in November 2006 and decided to strike out on my own. This time though, I decided to take a different tack.

In my previous two startups, I had raised millions of dollars in venture money and taken the conventional route of building a company. I started my first company, Adaptive Media, in 1996 and my second company, Langoo.com in 2000. The computing environment, the development tools, and the availability of global development talent has changed considerably since then. My gut feeling, when I was thinking of my third company, was that the cost of development for most web-based applications is now significantly lower and one can make a lot more progress with limited capital. I decided to test this hypothesis by self-funding some ideas of my own. I registered a domain name (infodoro.com) and made the plunge.

While at VeriSign, I also got quite interested and gained experience in the Agile methodology for software development. VeriSign, being a 10 year old company, already had a number of processes and tools in place. Based on the different trainings on Agile methodologies as well as internal reasons, the focus of Agile at VeriSign at the outset was on the daily scrum, creating backlog and tracking the backlog (in that order).

When I started to develop software for my new company (infodoro.com), I started to work with a distributed team in eastern Europe and India and the daily scrum was not as practical. During that time, I realized that Agile is a lot more than the daily scrum. And it is quite practical and effective to do Agile development in the true sense.

Agile development is really about iterative and incremental development (IID). And, it is about avoiding surprises. And, it is incorporating change continuously into the development process and in to the code. Towards that, from almost the beginning we made sure that we had

1. A central globally available source control system
2. A globally available bug tracking system
3. A globally available test case management system
4. Insistence on writing unit tests
5. An automated test suite and harness
6. A continuous code integration system with the unit tests and the automated test suite integrated in
7. A globally available wiki, task management and messaging system

And we were able to do all of the above with just a few hundred dollars of infrastructure cost by leveraging open source where we could. I will write separately about the tools we used and the setup we created.

We still have daily meeting with one team (India). We have frequent communication with the developers in eastern Europe.

The results of this upfront work have been very encouraging with the quality of code produced and the quick turn around on features.