There are more than 6,000 languages in use around the world today. So imagine the vast array of characters your application is introduced to. Any software product that involves users across the globe, has a very important requirement - the ability of users to interact with it in their own specific language, locale or cultural conventions. There are two main concepts that facilitate a software for international use

• Internationalization - The software is designed such that it can be used in multiple geographic locations. This involves requirements such as requiring all messages and constants to be stored externally and not hard coded. Date, time or currency should not be assumed to have a certain convention but instead should be generic and manageable.
• Localization - This is the process of adapting internationalized software to the user needs in a particular region or locale. This includes ability to translate.

The following cultural conventions impact internationalization (i18n for short).

• language and punctuations
• date and time
• numbers
• currency

ASCII and beyond

Character handling is also a very import aspect of i18n. The first step here is to be able to encode or represent alphabets. Initially when ASCII was introduced it could be stored in 7 bits and was used to represent a character using a number between 32 and 127. This was great until the world became a smaller place to live in, and new language started to be used in the world of computer science. This is where Unicode came into picture and was an effort to create a character set to be able to handle every character on the planet. It is a 16 bit character set. In Unicode every letter has what is called a code point as this : U+. This Unicode had to be stored, thus introducing the concept of encoding. UTF-8 provides a way to store the code points in 8 bit bytes. Anyways the story of Unicode is our cup of tea for another day.

Designing Tellurium with Internationalization in mind

Now let me get back to the point, One of the key features of 0.7.0 version of Tellurium is it’s ability to be used effectively in multiple locales. Tellurium provides a very effective internationalization functionality.

First let us look at the key Java i18n modules that we use to implement Internationalization.

Every Locale is represented by a String language code and String country code. ResourceBundles have key value combination with the key representing a bundle name and the value is the particular ResourceBundle. NumberFormat, MessageFormat and DateFormat provides internationalization support for numbers, messages and dates respectively.

Tellurium uses the following design strategy to provide internationalization

• ResourceBundleSource handles resource bundles that are defined as properties files. Every Locale has an associated properties file, like for ex: DefaultMessagesBundle_en_US. All messages that need to be internationalized are defined separately in the properties file. The ResourceBundleSource maintains a map of bundles to locales.
• ResourceBundle handles internationalization for all other data types in addition to the message management provided by ResourceBundleSource.
• IResourceBundle provides the polymorphism required to provide access to resource bundles.

These provide a very effective way to run tests all within the confines of one’s own locale, it cannot get much simpler than that. Another great aspect of internationalization in tellurium is that users can extend ResourceBundle and provide their own default implementation very easily.

If you want to know more about usages of i18n Functionality in Tellurium check out the latest Tellurium User Guide.

Resources

• Tellurium Project Home
• Tellurium 0.7.0

In simple terms Tellurium is an automated testing framework for web applications. Imagine a selenium like framework but without many of the disadvantages of selenium, imagine the freedom from having to use long and unwieldly XPath expressions, imagine tests robust enough to maintain themselves as the UI changes.

For a developer imagine the awesomeness and goodness that comes out of using Groovy and JQuery, intrigued?

Come join us, by checking out this link http://code.google.com/p/telluriumsource/wiki/TelluriumCallForParticipation

• MIT/BSD - this is a very liberal license that allows redistribution even without the source.
• GPL - copy left license. This is a way to negate copyrights to encourage collaborative development. IT essentially grants the following rights - anyone can use the code, anyone can redistribute the code as long as the source is included and distribution license remains GPL, any derivative work created of the code needs to be licensed under GPL.
• LGPL - weaker copy left license, it allows lesser restrictions on making derivative work open source when there is a linking between non GPL and non open source software.
• Apache License

Now the project I work on is a closed source project primarily because thats the way the client wants it. I strongly agree with Paul Ramsey in that open source should be not about the product itself but about the community arranged around them.

The members of the team i belong to have contributed a lot to open source java. But restrictions around our project that is servicing a particular client should not prevent us from having to not use open source. I like the LGPL licensing mainly because it allows us to work around some of the restrictions of GPL.  But a lot of open source software these days are focussing more on GPL, which is in a way a good thing to prevent commercial closed source competitors from taking the IP.But I still do wonder, what happened to the real free and open software revolution that started off with Unix.

But is there an end  to this licensing dilemma? I dont think so, maybe a dual licensing scheme might help, maybe a dynamic licensing with a lesser restriction in exchange for contribution to the project might help. Only time will tell how this will end.

These are some links that i referred to for this post

• http://www.smashingmagazine.com/2010/03/24/a-short-guide-to-open-source-and-similar-licenses/
• http://blog.cleverelephant.ca/2010/04/on-road-to-damascus-gpl-to-bsd.html

• Did Ya Know that Java has virtual functions?

A virtual function is a member function that you expect to be redefined in derived classes. So yes Java does have virtual functions. Although functions in Java are virtual by default. But in essence what we cann method overriding is actually virtual functions. In order to prevent a method from being vitual just declare it as final.

What was the issue?

Our application was a web based GIS decision support system. We have a web mapping server that renders out WMS and WFS responses. We have a caching layer, a servlet that caches responses from the web mapping server and connects to it through a URLConnection. Our application is SSL based i.e. we use https. We had a demo scheduled for a client when lo and behold Mr murphy strikes.

We were able to access our application, login to it and perform most of the task. But when accessing a particular cachable GIS layer, bada bing!! … we got the notorious

java.net.ConnectException: Connection refused

So how did we tame the beast ?

So we followed the myriads of steps described in tons of forums:

1. Check apache’s httpd.conf (or ssl.conf if you have SSL configured) configuration and check if the VirtualHost matches the Listen address and port

2. Check if the JkWorkers is defined correctly

3. Check if JkMount mounts the addresses correctly matching the right URL to the right Runner that is defined in the workers file.

Finally we hit jackpot when we found out the real reason for the issue - our hosts table was screwy with incorrect IP address settings

THis leads us to another mystery — how did everything else work and the failure happened only when URLCOnnection was invoked ?? , Sherlock Holmes wanna take the case??