My Tech Blog - Gautam

Backup & Restore HCL Me X1

2011-11-27T19:42:00.001+05:30

If you are planning to experiment with any Android phone/tablet, the first thing you would like to do is take a backup of it just in case things get messy. Typically in such situations you would like to take a backup of not only the user-data but also the operating system.

In this post I will be discussing on how to create a backup and restore the backup. You don’t need to root your device for this since adb already has root access in HCL Me X1. But you will need fastboot which can be obtained by compiling the Android source code.

Remember that the source code can be built only on a Linux distribution, so make sure you have one (I would recommend Ubuntu 11.10). fastboot will be available at <source_code_dir>/out/host/linux-x86/bin/fastboot after the compilation. If you don’t want to compile the source, you can try a compiled version of fastboot from the link specified at the end of the post; I built it on Ubuntu 11.10.

Replacing the Recovery Image

Before replacing the recovery image, create a backup of it in case you want to revert it back. Open the shell of the device using adb shell. Find the mount-point of the recovery image using cat /proc/mtd. There will be an entry like - mtd6: 00a00000 00200000 "recovery"

The recovery image can be created by reading the contents of the recovery mount-point and writing it into a file. This can be done using the following command - cat /dev/mtd/mtd6 > /sdcard/recovery.img

The recovery image is written to the sdcard in this case, you can redirect it anywhere you want to. The recovery image can be flashed back using fastboot. For this you have to boot the device into the bootloader using adb reboot-bootloader. The image can be flashed using the following command - fastboot flash recovery recovery.img

You can backup other mount points like system, userdata, etc. using this method but it's a lot easier to do so using the ClockworkMod’s Recovery Image. You can download it from the link specified at the end of the post. Flash it using the same fastboot command as above.

Creating a Backup

Reboot the device into the ClockworkMod's recovery mode using adb reboot recovery. This console has options to backup and restore the operating system. However it does this using the sdcard, so make sure you have one in the device before you proceed.

From the recovery console, select Backup and Restore > Backup. After a series of messages the ROM will be backed up.

Restoring a Backup

From the recovery console, select Backup and Restore > Restore. Select the backup you want to restore. After a series of messages the ROM will be restored.

In case you are looking for the stock ROM you can find it here. It's not the exact stock ROM but an unrooted factory reseted ROM. And the original recovery image, ClockworkMod’s recovery image and the compiled version of fastboot is available here.

Rooting & Unrooting HCL Me X1

2011-11-19T18:40:00.001+05:30

Android is primarily an operating system based on the Linux kernel. So similar to other Linux based operating systems Android has a special user account known as the root or super-user. Unlike other user accounts which have limited control over the operating system this account has complete access to the system.

However several (almost every) carriers and manufacturers don’t allow users to access this account mainly due to security concerns. Few carriers and manufacturers also do this because they don’t want users to access features for free when they can sell them :). Rooting is a process that allows users of phones/tablets to gain this privileged control (the root access). Here is an article with the Top 10 Reasons To Root Your Android Phone.

Though rooting your device is not illegal it might void the warranty of the device. So think twice (make that trice) before rooting your device and make sure you have a good reason to do so. Read these articles on The dangers of rooting your Android phone and What is Rooting on Android? The Advantages and Disadvantages

The process of rooting a device changes from device to device. It usually involves using an exploit to either gain temporary root access or to flash a custom recovery image to attain permanent root access. There are popular exploits like GingerBreak, psneuter, etc. and applications like GingerBreak.apk, SuperOneClick, etc. for rooting a device.

If you have read the articles and still want to go ahead let me remind you once again that trying to root your device might brick the device. I am not responsible if you brick your device, so proceed at your own risk.

Rooting the Device

You don’t require any exploit or any application to root HCL Me X1 and in-fact vulnerabilities like GingerBreak have already been patched. However it is possible to root the device using the adb shell so make sure you have the Android Debug Bridge (ADB) on your system.

Connect the device through the USB and open the shell using adb shell at the command prompt. If you are seeing the # here then that indicates that your adb shell has root access. Instead if you are seeing a $ this process won’t work for your device. Please put in a comment if you see $ so that me and the other readers know that HCL has changed something.

Typically in most of the devices the adb shell does not have root access. However looks like the Android build of Me X1 isn’t a production build. Not sure if this was done knowingly or unknowingly by HCL but either way the tablet has root access through the adb shell. You can confirm this by trying one of these -

Type adb root at the command prompt, it will show you a message stating that adb is already running as root
Type getprop ro.secure at the adb shell, it shows 0
The ro.secure property can also be examined from the /default.prop. If this is 0 then it indicates that the adb will login as root by default. Note that this file cannot be changed since it’s a part of the ramdisk

Though the adb shell has root access, the su command which is used in Linux doesn’t work in Android since there is no su binary in Android. Download the su binary and the Superuser application from here (backup).

There are two steps for rooting the device -

Copying the su binary to the /system/bin directory

Since this directory is on the Android PATH, applications will be able to call su directly. However since the /system is a read-only file system (type mount at the adb shell to check this), the file cannot be directly copied. Push the su binary from the system/bin directory in the zip to a temporary folder of the device (like /data/local/tmp) using adb push. However note that the su binary does not work directly from this directory since applications on the /data file system do not have the setuid bit on. Remount the /system with read-write capabilities with the mount -o remount -rw -t yaffs2 /dev/block/mtdblock2 /system command (check the actual device mount-point using mount). Copy the su binary to /system/bin and set the permissions of the binary using chmod 4777 su.

Install the Superuser.apk from the system/app directory of the zip

Install the application using adb install or transfer the file to the sdcard and install it from there. The Superuser application intercepts the calls made to the su binary and informs the user about the usage so that unauthorized applications cannot attain root access.

Unrooting the Device

To unroot the device, uninstall the Superuser.apk and delete the su binary from the /system/bin directory.

A Primer To Android Development

2011-11-04T01:20:00.001+05:30

As most of you know, Android is a mobile operating system initially developed by Android Inc. and presently being developed by the Open Handset Alliance led by Google. Android consists of a modified Linux kernel and software built on the Apache Harmony framework (an open source Java implementation). The best thing I like about the Android platform is its versioning. The code names are released in alphabetic order of dessert items - Cupcake, Donut, Éclair, Froyo, Gingerbread, Ice Cream Sandwich and Jelly Bean.

I am a newbie myself when it comes to Android, so the past few days I was trying to understand the various development models of Android. During my search I came across several good tutorials. This blog post is primarily to consolidate these tutorials for beginners like me.

Android, like most open source Operating Systems allows developers to look at development from two different perspectives - working on Android (Application development) and working with Android (Operating System development, not possible with proprietary Operating Systems). Google understands this and therefore has two different sites for Android developers - Android Developers (has the Android SDK to build applications) and Android Open Source Project (has the Android source code).

Android Developers

The Android Developers site provides various Development Kits to create applications for the Android platform. The Android SDK allows developers to write applications for the Android platform in a slightly modified version of Java which runs on a virtual machine called Dalvik.

The Android SDK can be installed by following the instructions specified here - Installing the SDK. And in case you want to start programming right away, here’s a classic Hello World tutorial.

The Java APIs are pretty much what most developers use. However there might be situations where you would like to harness the true potential of the underlying Linux kernel through a low level language like C. Android does allow developers to do that but they cannot call the C binary directly as an application, they will need to go through Java with the JNI (Java Native Interface). This methodology of development is supported by the NDK (Native Development Kit).

The Android NDK can be installed by following the instructions specified here - Installing the NDK. The NDK does come with the Hello World example but it isn’t as easy as the regular one.

The most useful tool Android provides developers with is the Android Debug Bridge. It is a command line utility that supports several commands like pulling/pushing files to and fro the device, installing applications, etc. This is one tool that every Android developer will have to use irrespective of whether he is developing applications or playing with the source code. Please note that the adb is part of “Platform Tools” which can be installed through the Android SDK Manager. If you stuck trying to install adb, read this.

Android Open Source Project

The Android Open Source Project site provides access to the source code of Android. A majority of the operating system infrastructure of Android is distributed under the Apache License and the core kernel is licensed under the GPLv2 License.

Certain developers use the Android Open Source Project to find vulnerabilities in the Android operating system and exploit them to execute tasks which cannot be done normally like attaining root access. Examples of these exploits are GingerBreak, psneuter, etc. Typically these vulnerabilities are patched for security reasons.

A majority of developers use the Android Open Source Project to modify and customize the operating system to create custom images. Several vendors add device drivers for their hardware and install pre-release applications to the operating system before flashing it onto the device. There have also been situations wherein vendors have customized the UI to suit their product lines before flashing.

You can obtain the complete source of the Android operating system by Downloading the Source Tree. There is an awesome tutorial on building Android 2.3.7 on Ubuntu 11.10 (64 bit) here. Even though the AOSP site specifies instructions on compiling the code, they are a bit outdated so visit the above link if you are stuck anywhere.

Underneath the layers of application frameworks, Android is primarily a Linux kernel and therefore is built on a C library. Unlike the traditional Linux based operating systems, Android uses a custom tiny libc called bionic. C programs can be written in an Linux environment running on x86/x64 architectures and cross compiled to Android running on ARM by linking Bionic to gcc. Here is an excellent tutorial which shows you exactly that. The compiled code can be run using adb shell. However note that codes compiled this way aren’t recommended to be used with Java applications, the NDK should be used instead.

HCL Me X1 - A Customers Review

2011-10-30T13:05:00.000+05:30

HCL Me X1 is HCL Technologies latest tablet and is one of the cheapest tablets available in India priced at Rs. 10,490. HCL released the X1 on October 14th. This is HCLs third tablet in the Me Series after the AE7-A1 and AM7-A1. I ordered the tablet on 19th through the HCL Store and received it this Tuesday. The entire week I have been toying with the tablet and here are my initial impressions on the Me X1.

This is my first Android tablet (my first Android device in fact) and one of the main reasons I bought the tab was to put up with the Android craze and have my share of fun with the Android platform. So expect to see several posts on the Android platform and the HCL Me X1 on this blog :).

I have been researching Android budget tablets for quite some time and finally decided to get myself the Me X1 (The Lenovo IdeaPad A1 was another option but decided to go with Me X1 after Lenovo priced it at Rs. 15000). Before going deeper into the review let me start by saying that the HCL Me X1 is a good tablet from a price to performance perspective and does a decent job in gaming, music and movies.

The specifications of the HCL Me X1 can be found here. Though HCL hasn’t specified the actual Application Processor they are using, it is expected to be the Marvell ARMADA 610.

As evident from the above specifications, the HCL Me X1 doesn’t have a SIM card slot and so doesn’t support 3G directly. However it does support 3G through a USB dongle. This wasn’t much of an issue for me since I was planning to use my Nokia X6 as a WiFi hotspot (haven’t tried this yet). The touch responsiveness of the device is good and Gingerbread performs well on the device thanks to the 1 GHz processor.

However the HCL Me X1 does have its shortcomings,

A major drawback of the Me X1 is that it doesn’t have the Android Market on it. Whatever HCL may say, its App Store is no match to the Android Market
The device works for around 6-8 hours (usage + standby) with a single charge. I wasn’t satisfied with this as my Nokia X6 gives me much more than this. However benchmarking a tablet to a phone isn’t correct
The display would have been better if it was a slightly brighter

The biggest weakness of HCL is their delivery service. When most online sites ship within 2-3 days, HCL as a policy takes a minimum of 7 to 10 days to ship the product. However they sent me the devices in 7 days when I pestered them a lot. In fact I would recommend people to buy the device at a local Sangeetha store where you can get it immediately. On the other hand their customer care was good, especially the Live Chat, they answered a lot of questions and followed up on phone as well.

I think the biggest technical improvement opportunities the Me X1 has are the integration of the Android Market and getting out an Ice Cream Sandwich as soon as possible. This should attract more customers towards the product.

Before I wrap up, here are some excellent reviews on the tablet which helped me take a decision on the purchase -

Update 2011/11/10

After several discussions at arpandeb, we finally concluded that the actual Application Processor being used is the Telechips TCC 88xx. We also found striking similarities between HCL Me X1 and Coby Kyros MID7022.

Named Groups In Regular Expressions - Java 7

2011-10-16T19:45:00.001+05:30

One of the new features added in Java 7 was the introduction of named groups in regular expressions through the java.util.regex package. This article covers the various features of named groups in regular expressions and their syntax in Java.

Parts of a Regular Expression can be grouped together by placing them inside round brackets. A major advantage of grouping is that various regex operators can be applied to these groups. Grouping is also useful for back-referencing a match. This allows developers to write regular expressions involving complex repetition patterns more easily.

The value of the captured group can be retrieved directly or be referenced in replacement patterns for changing the format of an input string. Though Java supported Regular Expressions and Grouping through the java.util.regex package from Java 1.4, it was limited to numbered groups.

Here’s an example showing how numbered groups can be used in Java. To read more about Grouping and Backreferences, check this out.

Parallel to numbered groups exists named groups. Named groups do not change the underlying concept of grouping and back-referencing but provide more readability to the regular expressions and make back-referencing easier for developers since remembering names is easier than remembering the relative position of a group.

Named groups are already present in languages like Perl, Python and .NET but wasn’t available to Java prior to Java 7. Well, better late than never.

The newly added RegEx constructs in Java 7 are as follows -

(?<name>) defines a named group "name"
\\k<name> back-references a named group "name"
${name} can be used to reference a captured group in a replacement string
group(String name) returns the value of the captured group

Here’s an example showing how named groups can be used in Java 7. To read more about Named Groups, check this out.

However if you are using Java 7, I would strongly recommend using the java.util.regex package but if you are using a Java version older than 7, there are other alternatives available for named groups in Java like Named-RegExp and JRegex. These alternatives were highly recommended by other developers at stack overflow.

Remote Debugging Java Applications

2011-07-28T09:38:00.002+05:30

After my previous article about Remote Debugging .NET Applications using Visual Studio 2010, I was curious to see how Remote Debugging works for Java Applications. This blog post covers Remote Debugging Java Applications using NetBeans 7.0.

The basic concepts of Remote Debugging are the same for .NET and Java but the process of setting up the host and remote computers varies between Visual Studio and NetBeans. Similar to the .NET application used in the previous post, the screen shots correspond to a simple Java application which would popup a MessageDialog on a button click. Get the code here.

Before configuring the host and remote computers, it is vital to understand the Java Platform Debugger Architecture (JPDA). JPDA provides the infrastructure you need to build end-user debugger applications for the Java Platform. It includes the following APIs broken into three layers -

Java Debug Interface (JDI), a high-level Java programming language interface including support for remote debugging
Java Debug Wire Protocol (JDWP), which defines the format of information and requests transferred between the process being debugged and the debugger front end
JVM Tools Interface (JVM TI), which is a low-level native interface that defines the services a JVM provides for tools such debuggers and profilers

Configuring the Remote Computer

Run the Java application using the -Xdebug and -Xrunjdwp options from the command line.

java -Xdebug -Xrunjdwp:transport=dt_socket,address=6000,server=y -jar RemoteDebugging.jar

Here’s a description of the options of the java command -

Option	Description
-Xdeubg	Enables debugging support in the VM
-Xrunjdwp	Loads in-process debugging libraries and specifies the kind of connection to be made

The -Xrunjdwp option has several sub options. Here are the descriptions of the ones that are used above -

Option	Description
transport	Name of the transport to user in connecting to debugger application
address	Transport address for the connection If server=n, attempt to attach to debugger application at this address If server=y, listen for a connection at this address
server	If y, listen for a debugger application to attach If n, attach to the debugger application at the specified address

By default the application starts in suspended mode. In suspended mode the application waits for a debugger to attach itself to the server at the specified port before the application starts.

Configuring the Host Computer

The host computer is the system running NetBeans 7.0. Open the code of the application in NetBeans and select "Attach Debugger". Specify the Connector as SocketAttach, the Host as the hostname of the remote system and the Transport and Port as specified above.

Specify the breakpoints in the code and they would hit appropriately. There are two major bottlenecks in Remote Debugging -

The code from which the executable was built should be available at the time of debugging
Applications cannot be configured for Remote Debugging at runtime. The -Xdebug option must be specified at the instantiation of the application, making debugging live production code difficult

Before I conclude, here’s an article from OTN (Oracle Technology Network) on the Java Platform Debugger Architecture. Visit it if you would like a deeper insight into Java Debugging. The schematic of the JPDA is from a weblog, check it out here.

Remote Debugging .NET Applications

2011-07-18T01:06:00.004+05:30

From the past few days I have been stuck in resolving a bug which cropped up in one of my applications after it went to Production. The worst part was that it was a machine-specific issue and we couldn’t reproduce it in any of our development systems. While trying to find a solution for this, I came across the concept of Remote Debugging.

Remote debugging is debugging a remotely running application through a development environment running on a system other than the one running the app. This is done by connecting the remote system to the system containing the development environment (in turn the debugger) through Sockets. Theoretically this is achieved in two steps -

The remote computer would open a socket and listen to debug instructions through it. These instructions are feed to the application that is being debugged and the application responds appropriately
The debugger would connect to the socket opened by the remote system and send instructions through it

Remote debugging can be used in many live situations. Examples include -

Debugging a machine specific issue which can’t be reproduced on systems running the development environment (my exact requirement :))
Debugging applications which can run only on the server machine due to dependent third party libraries that cannot be used in the development machine

In this blog post, I will be focusing on Remote Debugging .NET applications through Visual Studio 2010. The screen shots correspond to a simple .NET application which would popup a MessageBox on a button click. Get the code here.

Configuring the Host Computer

The host computer is the computer containing the development environment. This is the system running Visual Studio 2010. To enable Remote Debugging, make sure the following ports are open on the host computer -

Ports	Protocol	Description
135	TCP	Required
500, 4500	UDP	Required if your domain policy requires network communication to be performed through IPSec

IPSec (Internet Protocol Security) is a protocol suite for securing IP communications authenticating and encrypting each IP packet of a communication session. Read more about IPSec here. However I am not going cover IPSec in this post.

You can check if the ports are open by using the telnet command at command prompt (telnet isn’t installed by default on Windows 7. Install it from the "Turn Windows features on or off" section in the Control Panel).

Configuring the Remote Computer

To configure the remote system for debugging, either download and install the Microsoft Visual Studio 2010 Remote Debugger or copy the folder Remote Debugger from the Visual Studio install path, which is typically C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE. The Remote Debugger is available for three configurations – x86, x64 and ia64.

Visual Studio takes the .pdb files for debugging from the remote system for managed code. So copy the .pdb from the bin/Debug folder of the project to the remote system. Put this folder on share so that Visual Studio can access it later.

To enable Remote Debugging, make sure the following ports are open on the remote computer -

Ports	Protocol	Description
135, 139, 445	TCP	Required
137, 138	UDP	Required
500, 4500	UDP	Required if your domain policy requires network communication to be performed through IPSec
80	TCP	Required for Web Server debugging

That’s it; both the host and remote computers are up and ready for Remote Debugging.

Start the application on the remote system if it isn’t running already. Also start the Visual Studio Remote Debugging Monitor on the remote system using the msvsmon.exe from the appropriate configuration folder in the Remote Debugger directory (The screenshot uses the x86 version).

Open the code in Visual Studio on the host system and select "Attach to Process". Typically Visual Studio identifies the .pdb file of the remote system if it can. If it doesn’t, open the Modules screen from Debug -> Windows -> Modules. Check the Symbol Status of the .exe file which is being debugged and if it shows "Cannot find or open the PDB file" right-click on it and select "Load Symbols From" and specific the share path through the "Symbol Path".

Specify the breakpoints in the code and they would hit appropriately. There are two major bottlenecks in Remote Debugging -

The code from which the executable was built should be available at the time of debugging
The above mentioned ports should be open for debugging. Most of the developers wouldn’t have administrative privileges on the client systems, so they would require people with sufficient privileges to open up these ports. However several organizations wouldn’t prefer opening up ports for incoming connections

Before I conclude, here’s an article from MSDN on how to Set Up Remote Debugging. Visit it if you would like a deeper insight into Remote Debugging.

TVPs Vs XML - An Analysis Through .NET

2011-06-11T23:10:00.003+05:30

A common requirement of .NET applications that connect to databases like SQL Server is passing Lists and Arrays to the database server. Since most of these databases are relational, transferring these Lists of Objects isn’t really straight-forward.

One way of passing these objects would be to send individual properties of these Objects to the database server, one object at a time. Obviously this is highly inefficient. Understanding this, various database management systems have provided various approaches to achieve this.

There are two ways of passing such content to SQL Server –

Generating an XML from the List and passing it as a parameter
Creating a Data Table from the List and passing it as a Table Valued Parameter

Passing Lists and Arrays as XML to SQL Server has been a common approach since SQL Server 2000. From SQL Server 2008, Microsoft introduced a new way of passing Lists and Arrays – Table Valued Parameters.

In this post, I will be evaluating the performance statistics of XML and TVP though a .NET application. I will be doing this through the RetrieveStatistics method of the SqlConnection class. This method retrieves the statistics of an operation through an IDictionary which contains various performance metrics.

This happens only when the StatisticsEnabled property is set to true before executing the query/stored procedure. These metrics can be reset using the ResetStatistics method of the SqlConnection class. Here’s a typical usage of this method –

The dictionary contains several provider statistics. There are 18 values that can be obtained from the Microsoft SQL Server provider. A detailed analysis of the metrics that can be obtained from the dictionary is available here - http://msdn.microsoft.com/en-us/library/7h2ahss8(v=vs.80).aspx.

The .NET application that is being used in this post to compare the performance of TVP and XML captures these 18 metrics into an object. However the final analysis focuses on three of these properties – Execution Time, Bytes Sent and Bytes Received.

The application primarily inserts records into a table. The number of records and the value of the records are decided by the application. To understand the effect of load, the numbers of records are raised from 25 to 2500 in gradual steps of 25. For an accurate measurement each step is repeated for 25 times and an average of the metrics obtained is considered.

Here are the graphs obtained for Execution Time, Bytes Sent and Bytes Received –

Execution Time (Records on X-Axis and Time on Y-Axis)

Bytes Sent (Records on X-Axis and Bytes on Y-Axis)

Note – The Bytes Sent for OpenXML and Nodes are almost the same.

Sent Received (Records on X-Axis and Bytes on Y-Axis)

Note – The Bytes Received for TVP and Nodes are the same.

The observations that I could conclude are as follows –

The execution time for TVP is less than XML (Using OpenXML took more time than Nodes). The execution time of OpenXML was far higher than TVP
The bytes sent for XML was higher than for TVP. This is probably due to the XML tags that had to be added for the transfer
The bytes received in all the three cases were constant irrespective to the bytes sent. Though the number of bytes received for TVP and Nodes was the same, the number of bytes for OpenXML was slightly higher. This might be due to the procedure calls of sp_xml_preparedocument and sp_xml_removedocument

On a whole, TVPs look more promising than XML. However this was a very preliminary test and the actual results might vary in live environments.

The SQL scripts and the Visual Studio project used in this post can be found here.

Compiling Visual Basic, C# & F# Code Into A Single DLL Using msbuild

2011-03-22T00:53:00.003+05:30

Recently I had a requirement in which a C# file had to be included in a VB.Net project. I knew I couldn’t add the file directly to the project, so I cut over the C# file to VB.Net. At first this seemed pretty obvious since Visual Studio maps every project to a programming language and uses an appropriate compiler to compile the files in the project.

But giving it a deeper thought, I felt something didn’t fit the picture. Every project, rather every file that we compile using the .NET Framework generates Common Intermediate Language which is used by the Common Language Runtime. It is because of this CIL that we have language interoperability in .NET. So theoretically speaking, code written in different languages should be able to exist in a single assembly.

Though I couldn’t find a way to directly add a C# file into a VB.Net project, I found a way to create a DLL from compiled VB.Net and C# code through a concept of the .NET framework called Multi Module Assemblies.

In .NET, the minimum unit of deployment is an assembly; Dynamic Link Libraries (DLLs), Executables (.exe), etc. are all assemblies. An assembly can contain multiple files like resource files, the manifest, etc. It can contain files of another type called netmodules. A netmodule is a unit of compilation. It cannot be deployed directly but can be linked into an assembly. netmodules written in different .NET languages can be linked into a single assembly.

Unfortunately Visual Studio wasn’t built for Multi Module Assemblies, hence there’s no way to create a netmodule from a project in Visual Studio. However msbuild allows us to create a netmodule from a project. There are typically three changes that have to be done to the .proj files (.fsproj, .vbproj, .csproj, etc.) for msbuild to generate a netmodule –

Changing the OutputType to Module. Visual Studio doesn’t recognize this output type, so even when you change this in the .proj files, Visual Studio won’t be able to show it in the Project Properties.
Exclude the AssemblyInfo file from the project. netmodules aren’t supposed to have an application manifest. If they do, the linker won’t be able to resolve which application manifest should be used when we are building an assembly from multiple netmodules.
If one netmodule is dependent on another netmodule, a reference to the dependent module should be specified using the AddModules XML node in the .proj file. Similar to DLLs, netmodules cannot be circularly referenced.

Once the .proj file has been modified, the project can be built using msbuild. If the project is a part of a solution, building the solution will create a netmodule for this project – msbuild solution_path

Once the netmodules are created using msbuild, a DLL can be created from them using the Assembly Linker of the .NET framework - al /t:library /out:"path_to_dll" path_to_netmodules

With this we have a DLL which contains all the netmodules bundled into one assembly. To understand this better, let’s consider an example – I have three projects, one in F#, VB.Net and in C# under a solution called MultiLanguage.

The .fsproj, .vbproj and .csproj have to be changed as mentioned above. From the netmodules obtained from msbuild, the DLL can be created using the assembly linker.

The sample solution and the build script can be downloaded from here. I automated the .proj changes using Microsoft’s Build Engine API. You can give it a try here; it takes the .sln file as an input and modifies all the projects in the solution to generated netmodules.

Windows Phone 7 - Hello World!

2011-03-13T23:20:00.006+05:30

Ever since Nokia announced its partnership with Microsoft and made Windows Phone 7 its primary smartphone operating system, I anxiously wanted to give it a spin. So in this post, I am going to start by setting up a development environment for Windows Phone 7 followed by a simple Hello World example.

Windows Phone 7 is primarily a successor of the Windows Mobile Platform (the last one in the line being Windows Mobile 6.5). It’s a major revamp in Microsoft’s Mobile strategy in terms of its application development model.

Windows Phone 7 no longer supports unmanaged code (Win32 and C++ are gone). It is purely built on Managed Code covering Silverlight, XNA and the .NET Framework (Programming Languages include C# and VB.Net). Here’s a nice article on Windows Phone 7 application development model - http://blogs.msdn.com/b/abhinaba/archive/2010/03/13/windows-phone-7-series-programming-model.aspx.

To get started with Windows Phone 7 development, download the Windows Phone Developer Tools RTW (Release To Web). It includes the following tools –

Visual Studio 2010 Express for Windows Phone
Windows Phone Emulator Resources
Silverlight 4 Tools for Visual Studio
XNA Game Studio 4.0
Microsoft Expression Blend for Windows Phone

If you are already using a higher version of Visual Studio or Expression Studio, this toolkit will install extensions to the existing IDEs. The release is also available as an .iso image. Though the Windows Phone 7 toolkit comes equipped with Expression Blend, for most of the basic applications the design mode of Visual Studio should be sufficient.

To get a hands-on experience with Windows Phone 7, let’s take a simple application which accepts a username and greets him/her in the next page. The best part of Windows Phone 7 development is that it is pretty much in the lines of other Visual Studio project types we are familiar with like the Windows Forms Applications, WPF Applications and ASP.Net Applications where in the UI can be created easily using the designer and the business logic is maintained in a code beside event driven model in another .cs or .vb file depending on the programming language.

As already mentioned, Windows Phone 7 is built on Silverlight and thereby every screen has a corresponding XAML (eXtensible Markup Language) page, each having its own code file. Movement between these XAML pages is made possible through an instance of a NavigationService class for every page.

There are three important methods provided by NavigationService – Navigate, GoForward and GoBack. Navigate takes a Uri instance specifying the URI location and loads the XAML page specified.

NavigationService.Navigate(new Uri(“/NamePage.xaml”, UriKind.Relative));

GoBack and GoForward loads the previous and next pages respectively.

NavigationService.GoBack();
NavigationService..GoForward();

Parameters can be passed across XAML pages by appending them to the URL and retrieving them using the QueryString property of the NavigationContext object. This concept of Windows Phone 7 was very surprising. Since Mobile Applications are very similar to Windows Applications, passing parameters through URLs like Web Applications looked a bit off-track.

NavigationService.Navigate(new Uri(“/NamePage.xaml?name=” + name, UriKind.Relative));
string name = NavigationContext.QueryString[“name”];

Download the example code here.

Introducing ADO.NET Entity Framework

2011-01-30T22:46:00.005+05:30

This is the third and final part of my ORM series in which I am going to introduce the ADO.NET Entity Framework, an in-built Object Relational Mapping model of the .NET Framework.

Similar to the previous post, this one also covers the same four principles –

Configuring a .NET project for the ADO.NET Entity Framework
Inserting data from Objects directly
Retrieving data using Object Lists and LINQ
Changing the Database Management System

Though the screen-shots and the example codes emphasize on C#, the principles are same for all the .NET languages.

Requirements to run the example in this article – Visual C# Express, SQL Server Express and MySQL. Download Visual C# Express here, SQL Server Express here and MySQL here.

Configuring a .NET project for the ADO.NET Entity Framework

To configure a .NET project to work with the ADO.NET Entity Framework, an Entity Data Model is added to the project. The Entity Data Model is primarily a schematic representation of the database tables stored as a XML file. Each of these tables is converted into a class and foreign key relationships between these tables are maintained as Lists inside the objects.

Visual Studio provides a Wizard to create Entity Data Models. Right click on the project and select New Item from the Add menu. Choose the ADO.NET Entity Data Model template from the chooser. There are two approaches available to build the Entity Data Model – Database First Approach and the Model First Approach.

In the Database First Approach, the Entity Data Model is generated from existing table structures. The wizard allows the developer to setup a connection by providing the Database Server name and the Database name. The wizard also allows developers to choose tables, views and stored procedure that are to be a part of the Entity Data Model.

In the Model First Approach, the Entity Data Model is created from scratch and the database tables are generated based on this model.

Once the wizard completes, a designer opens up which shows a schematic representation of the generated .edmx file. This file contains the table mappings as a XML along with a code behind file (.Designder.cs extension) for the auto-generated classes corresponding to the tables. However a drawback with the Entity Data Model is that it combines all the classes into a single file which makes manual maintainence a little difficult.

I used the Database First approach to create the sample application to insert and retrieve data. You can get the MySQL and SQL Server scripts along with the Visual Studio solution here.

Inserting data from Objects directly

The Entity Model generates a class which inherits from ObjectContext. This class acts as a data manager to connect to the Database Management System to retrieve, insert, update and delete records.

ADO.NET Entity Framework maintains the records of the table as a List of objects. To insert new records into the table, create new objects, add them to the appropriate lists and then save the changes using a ObjectContext instance. The following piece of code shows how objects can be persisted –

using (Context context = new Context())
{
// Create the object
context.Objects.Add(object);
context.SaveChanges();
}

ADO.NET Entity Framework does a wonderful job while storing objects with foreign key dependencies. These dependencies are maintained as lists inside objects and while storing these records, the appropriate identity keys are inserted into the child tables. However this feature is limited to a few DBMS like SQL Server.

Retrieving data using LINQ and Object Lists

The ADO.NET Entity Framework retrieves data from the back-end tables in the form of object lists. So accessing records is as simple as iterating through these lists.

using (Context context = new Context())
{
foreach (Object object in context.Objects)
// use the object appropriately
}

Since data retrieval is in the form of lists, developers can piggy-back on an other .NET framework feature – LINQ (Language Integrated Query). LINQ makes conditional querying of data a lot easier.

using (Context context = new Context())
{
var objects =
from object in context.Objects
where “condition”
select object;
// use the objects
}

Changing the Database Management System

Before changing the DBMS of the Entity Model, it is important to understand how the ADO.NET Entity Framework stores the connection strings and the mapping between classes and the back-end tables. The connection string is stored in the App.Config file of the project and the table mappings are stored as a XML in the form of the .edmx file as mentioned earlier.

Unfortunately the ADO.NET Entity Framework slightly varies it’s implementation with the DBMS. Because of this modifying the XML manually isn’t easy. For Example, ADO.NET Entity Framework does not support foreign key constraints in the form of lists for DBMS like MySQL.

The sample application contains another Entity Model which connects to a MySQL Server containing similar tables. To use MySQL with the ADO.NET Entity Framework, an connector is needed. The MySQL Connector/NET is available here.

Introducing Hibernate In Java Using NetBeans

2011-01-05T00:37:00.002+05:30

In one of my recent posts, I introduced the theoretical topic of Object-Relational Mapping (ORM) - http://gautam-m.blogspot.com/2010/11/object-relation-mapping.html. In this post I am going to take a step forward and introduce Hibernate – an open source Java persistence framework from JBoss.

This post covers four basic principles of Hibernate –

Configuring a Java project for Hibernate
Inserting data using Object Persistence
Retrieving data using Hibernate Query Language (HQL)
Changing the database configuration to connect to another DBMS

Though the post and screen-shots emphasize on NetBeans, the concept is the same for all IDEs. Hibernate configuration files can definitely be written without an IDE but make sure all the required class libraries are properly referenced.

Requirements to run the example in the article – NetBeans, MySQL, JavaDB, Java and Hibernate. Java can be downloaded here, installing the All NetBeans package will cover JavaDB and Hibernate and MySQL can be downloaded here.

Configuring a Java project for Hibernate

The crux of Hibernate is the creation and usage of configuration files. There are three types of configuration files which are to be setup for Hibernate –

The .cfg.xml file – this is the main configuration file which contains information about the database like the URL, the driver, the username and password, etc. Hibernate can optimize it’s behavior depending on the DBMS being used. To facilitate this, a property called Dialect is specified. However this is an optional property as Hibernate can deduce this depending on the JDBC metadata returned by the driver
The .reveng.xml file – this file holds the data corresponding to the schemas and tables being utilized by Hibernate in the application
The .hbm.xml – these files maps POJOs (Plain Old Java Objects) to the table schemas of the database

Typically one .cfg.xml and one .reveng.xml exist for a project and one .hbm.xml exists for each table (mapped to a class). The .hbm.xml maps the object properties to the table columns. It is possible to add new properties to the class which have no effect on the backend tables.

To create these files in a NetBeans project, select New File and select the following File Types from the Hibernate category –

Hibernate Configuration Wizard
Hibernate Reverse Engineering Wizard
Hibernate Mapping Files and POJOs from Database

Follow the wizards to complete the configuration setup. I used MySQL and JavaDB as my DBMS to create a sample application to insert and retrieve data. You can get the MySQL and JavaDB scripts along with the NetBeans project here.

Inserting data using Object Persistence

Inserting data is a cake-walk in Hibernate. All that is there to do is to create the object and store the object data in the database tables using the save method of a SessionFactory object. The following piece of code persists the object data –

SessionFactory sessionFactory =
new Configuration().configure().buildSessionFactory();
Session session = sessionFactory.openSession();

// Create the object
session.save(object);

Retrieving data using Hibernate Query Language (HQL)

Retrieving data is done through a query language designed for Hibernate called the Hibernate Query Language. HQL is a Object-Oriented Query Language and is very much similar to the traditional SQL we use. The beauty of HQL is that the result of the query is returned as a list of objects rather than as a ResultSet. These objects can be used directly in the code without any overheads. HQL is very wide topic, so I am going to skip the details here but there are several tutorials available for HQL on the Internet. The createQuery method of the above Session object is used along with the list method of the Query object to get the objects –

Query query = session.createQuery(queryString);
for (Object object : query.list()) {
// cast and use the object appropriately
}

Changing the database configuration to connect to another DBMS

The best feature of Hibernate according to me is it’s ability to change a DBMS without any change to the application code. To change the DBMS, open the Hibernate Configuration File (typically hibernate.cfg.xml) and change the dialect, driver class, connection URL, username and password to the values corresponding to the new DBMS.

These changes can be done either through the design view or directly on the XML.

RockMelt - Will Melt Your Heart

2010-11-15T00:52:00.002+05:30

In my previous post I said I would be writing about Hibernate in this article, however I made an exception to write about a new browser I just started using – RockMelt. RockMelt is a social media web browser developed by Tim Howes and Eric Vishria and backed by Netscape founder Marc Andreessen.

It wouldn’t be an overstatement if I say that it will melt your heart, especially if you’re into social networking and particular a regular Facebook user like me. Here’s how RockMelt looks like –

By this time, I guess most of you must have realized that it looks pretty much like Google Chrome. In fact it is more-or-less Chrome itself. Developers who have been interested in Google Chrome would have heard about Google’s Chromium project – the open source project from which Chrome was born. Chromium was the parent of browsers like Nickel and now RockMelt.

However RockMelt was built to target a specific crowd – the Social Networking generation, especially users of Facebook and Twitter. Let me highlight a few features of RockMelt which I found interesting –

Friends Strip

RockMelt integrated Facebook’s chat application directly into the browser as a strip running in the left side. The chat UI is pretty impressive; in fact it is as good as Google Talk. The best part is that each chat window now runs as a desktop app independently of the browser allowing users to use chat windows individually like Google Talk.

Status Updates

Updating your status in Facebook is just a click away from any site. With RockMelt, you need not actually go to Facebook to change your status or share a link. The browser itself allows you to do it.

RSS Feeds

The best thing I liked about RockMelt was its integration of RSS/ATOM feeds with the browser itself. Though many browsers manage feeds, nothing can beat this. The integration of the feeds as a strip to the right is really awesome. By default, feeds of Twitter and Facebook are built into the browser. Feeds from other sites like Gmail and Blogs can be added easily.

For people who use browsers only for surfing the web and reading articles, these changes won’t be much and the regular Chrome browser should be enough. But people who are into Networking, Blogging, etc. will find it exciting and might enjoy it.

RockMelt was released a few days back and is presently “By Invitation” only and if you are interested, you should register yourselves here for an early access – http://www.rockmelt.com/. Lucky I got an invitation from one of my friends :). So if you want to try it, either register at the mentioned site or catch hold of a friend who already has an invitation :D.

Know more about RockMelt straight from the horse’s mouth –

I will back on Hibernate and ADO.NET Entity Framework in my next two posts. Until then Happy Facebooking and Happy Twittering :).

Object-Relational Mapping

2010-11-12T00:24:00.006+05:30

Over the years we have seen a paradigm shift in Programming Languages from the traditional Procedural programming approach to an Object-Oriented approach. However Databases have changed very little in terms of their fundamental principle – Set Theory. Databases are and have been Relational almost from their advent. Most of the Database Management Systems which we use like MySQL, Microsoft SQL Server and Oracle are Relational to a very large extent. Though there have been approaches like Object-Relational DBMS and Hierarchical DBMS, they have rarely been adopted in production environments.

This article focuses on creating a relationship between Object-Oriented Programming Languages and Relational Databases through a concept called Object-Relation Mapping. This article will be followed by two related articles – Using Hibernate in Java with NetBeans and Using ADO.NET Entity Framework in .NET (C#) with Visual Studio.

Before jumping into ORM, here are two common concepts which most of you must be familiar with –

Class – A class is a construct that is used as a blueprint (or template) to create objects of that class. A class defines the properties that each and every object possesses.

Table Schema – A table schema primarily defines the fields and relationships of a table. A table contains records which have the same structure.

Observing closely, we can notice that these two definitions are pretty similar. Both of them talk about a template which multiple instances follow (objects in OO and records in DBMS). Both of them talk about fields (properties) these instances possess.

This similarity is the basis of ORM. Table Schemas of Relational Databases correspond to Classes in an Object Oriented Programming Language and Records of these tables correspond to instances of the Classes (Objects).

Consider an example of a Student table in a Database created with the following schema –

CREATE TABLE Student_tbl
(
        StudentId INT PRIMARY KEY,
        Name VARCHAR(MAX),
        Age INT
)

This table can be translated into a Class with the following structure –

class Student
{
        Int32 StudentId;
        String Name;
        Int32 Age;
}

Each record of the Student_tbl will be an object of the Student class.

There are several free and commercial packages for Object Oriented languages that perform Object Relational Mapping. Most of these packages incorporate advanced features like –

Automating the class generation process from the Database Schemas
Maintaining foreign key dependencies using Lists
Generating identity keys while inserting records and using these keys in subsequent insertions as foreign keys if required
Creating methods for retrieving data and saving data directly as objects

The major advantages of ORM lie in –

Minimal database dependency – most of the ORM packages use a concept called ‘Dialect’ to identify the DBMS the application is connecting to. So changing the dialect when the DBMS is changed is sufficient for the application to run. No application code has to be changed
ORM reduces the amount of code that needs to be written by a developer

However it is often argued that ORM packages don’t perform efficiently during bulk deletions and with joins. So generally it is recommended to check if there a hit in the efficiency of the application when ORM tools are introduced, especially when complex operations are involved.

Though ORM is a simple concept, it’s a rapidly over-shadowing the traditional database connectivity models in Object Oriented Programming Languages like Java and C#. In my next post, I will be introducing Hibernate – an ORM package for Java and in the subsequent post I will introduce the ADO.NET Entity Framework – an ORM package for .NET.

Standard Compression Scheme For Unicode (SCSU) - Java & .NET Implementations

2010-09-26T21:20:00.004+05:30

In the previous article, I introduced the compression techniques available in SQL Server and highlighted the Unicode Data Compression feature of SQL Server 2008 R2. This post will cover the algorithm used by SQL Server for Unicode compression.

The Java and .NET (C#) implementations of the algorithm have been attached to the post. They have been built as Class Libraries to support reusability.

Standard Compression Scheme for Unicode

As evident from the post title, the algorithm used in Unicode Data Compression is the Standard Compression Scheme for Unicode (SCSU). SCSU is a technical standard for reducing the number of bytes needed to represent Unicode text. It encodes a sequence of Unicode characters as a compressed stream of bytes. It is independent of the character encoding scheme of Unicode and can be used for UTF-8, UTF-16 and UTF-32.

I am not going to explain the entire SCSU algorithm here but you can get its specifications from the Unicode Consortium. The SCSU algorithm processes input text in terms of their Unicode code points. A very important aspect of SCSU is that if the compressed data consists of the same sequence of bytes, it represents the same sequence of characters. However, the reserve isn’t true; there are multiple ways of compressing a character sequence.

Applications/Organizations using SCSU –

Symbian OS uses SCSU to serialize strings.
The first draft of SCSU was released by Reuters, a news service and former financial market data provider. Reuters is believed to use SCSU internally.
As already mentioned, SQL Server 2008 R2 uses SCSU to compress Unicode text.

To be honest, SCSU has not been a major success. There are very few applications which need to compress Unicode Data using a special compression scheme. In certain situations, especially when the text contains characters from multiple character sets, the compressed text can end up being larger in size than the uncompressed one.

SQL Server and SCSU

SQL Server stores data in the compressed format only if it occupies lesser space than the original data. Moreover there must be at least three consecutive characters from the same code page for the algorithm to be triggered.

A major issue with the implementation is determining whether the stored text is in compressed or uncompressed format. To resolve this issue, SQL Server makes sure that the compressed data contains an odd number of bytes and adds special case characters whenever required.

The SQL Server implementation details are from a blog post by Peter Scharlock, a SQL Server Senior Program manager.

SCSU Implementation

Though the specifications of SCSU are pretty compressive and a sample Java implementation is available at the Unicode Consortium, the implementation isn’t reusable as it is built as a Console App.

Using the specification and the sample Java implementation, I built a similar implementation as a Class Library to encourage reuse. The implementation is available in two languages – Java and C#.

The Java implementation is made available as a NetBeans project and the .NET implementation is made available as a Visual Studio solution. The implementations come along with a sample Front End which uses the corresponding Class Library.

If you are planning to modify the source code of the implementations, please keep these points in mind –

The .NET implementation differs from the Java implementation on a basic fact that the byte in Java is signed and the byte in .NET is unsigned. sbyte is available in .NET but using byte is more comfortable.
Both the implementations have been tested for UTF-16 Little Endian encoding schemes. Since the default behavior of a Unicode character in Java is Big Endian, a few tweaks have been implemented.

Example

To check the integrity of the SCSU implementations, a sample text file contains text from German, Russian and Japanese (the same text available at the SCSU specifications site) is taken and verified if the compressed text is as expected. The size of the file was compressed from 274 bytes to about 199 bytes.

The source code of the Java and .NET implementations can be found here. If you find any bugs, please let me know and I will make the necessary modifications.

Unicode Data Compression In SQL Server 2008 R2

2010-09-17T18:31:00.013+05:30

SQL Server 2008 R2 was released a few months back and one of the features I found interesting was its ability to compress Unicode data. In this post, I will be introducing the various compression options available in SQL Server and towards the end I will emphasize a sample analysis used to estimate the efficiency of Unicode Data Compression and the Compression-Ratio improvements of SQL Server 2008 R2 over SQL Server 2008.

In my next post, I will emphasize on the actual algorithm used by SQL Server to achieve this compression and will provide the Java and .NET implementations of the algorithm.

Compression Techniques in SQL Server

In computer science, compression is the process of encoding information in fewer bits than an un-encoded representation would use. The compression techniques available in SQL Server can be broadly categorized into two types depending on the way they are architected – Data Compression and Backup Compression.

Data compression occurs at runtime, the data is stored in a compressed form to reduce the disk-space occupied by a database. On the other hand, backup compression occurs only at the time of a backup and uses a proprietary compression technique. Backup compression can be used on a database that has already undergone data compression, but the savings might not be significant.

Data compression is again of two types – Row level Data Compression and Page level Data Compression. Row level compression primarily turns fixed-length data-types into variable data-types, thereby saving space. It also ignores zero and null values saving additional space. Because of this, more number of rows can be accommodated in a single data page. Page level compression initially performs Row Level compression and adds two additional compression features – Prefix and Dictionary Compression. As evident, page level compression offers better space saving than row level compression.

Though compression can provide significant space saving, it can also cause severe performance issues if misused. For further reading on compression, refer “An Introduction to Data Compression in SQL Server 2008”.

As the name suggests, Unicode Data Compression comes under Data Compression, and to be more specific it’s a part of Row-level Compression.

Sample Analysis

Microsoft had promising stats on the Unicode Data Compression in SQL Server 2008 R2, going up to a 50% space savings on a few character sets like Hindi, German, etc. So I decided to give it a try myself.

Being from India, I decided to test the compression ratios for Hindi text. I created a randomizer in C# (.NET) to generate random text from a few Hindi phrases obtained from Linguanaut. The program generates 1.5 million random Hindi strings and writes them into a temporary file which is Bulk Inserted into a table.

To check the improvement of SQL Server 2008 R2 over SQL Server 2008 in terms of Data Compression, two separate instances of SQL Server were established on the same system configuration (Intel Core 2 Quad and 4 GB RAM). Both the instances had the same schemas for the databases and the tables. The Randomizer and the Schemas + Bulk Insert scripts are attached below.

A major drawback of Unicode Data Compression in SQL Server 2008 R2 was that it couldn’t be applied on columns of the data type NTEXT and NVARCHAR(MAX) and to highlight this we used two different tables, one using NTEXT and another using NVARCHAR(250).

Here is a quick reference table of the compression-ratios obtained in the analysis –

	SQL Server 2008	SQL Server 2008 R2
NTEXT	98.24%	98.25%
NVARCHAR(250)	95.68%	57.78%

From the above table, we can observe the compression-ratio for Unicode Data in SQL Server 2008 R2 is around 57% (nearly the space saving mentioned by Microsoft). However in all the other cases, we can observe that the saving savings is almost negligible. For space savings of other character sets refer “Unicode Compression (MSDN)”.

Get the Visual Studio Solution of the Randomizer and the Database Scripts here.

SQL Server 2008 R2 Screen Shots

SQL Server 2008 Screen Shots

Creating A Bootable Windows 7 USB Flash Drive

2010-08-22T11:49:00.002+05:30

In this post, I am going to emphasize on how to create a bootable USB drive with the Windows 7 installer. It’s a pretty simple and straight-forward process. There are several advantages of doing this –

Installing Windows 7 on computers without an Optical CD/DVD Drive. Many of the new laptops/desktops come without the CD/DVD drive. Using a bootable USB is very helpful here.
Installing from the USB drive is typically faster than installing from a DVD drive.
OS disc images (.iso, .nrg) need not be burned onto a CD/DVD to use them. You can make a bootable USB drive from the image and install the OS from the USB.

There are two phases involved in the process – “Formatting the USB drive” and “Copying the installation files and making it bootable”.

Formatting the USB drive

I am using the Diskpart command line utility in the following steps to format the USB drive. I guess even the Right-click and Format option can be used, but I haven’t tried it. If you get into any trouble using the Format from the Right-click menu, put in a comment and I will look into it.

Open the command prompt as an Administrator.
Start the DiskPart utility by typing in “diskpart”. This will show a list of all the drives connected to the system. Identify the disk corresponding to the USB drive.
Select the USB drive using the “select ###” command.
Clean it using the “clean” command.
Create a primary partition on the USB using the “create partition primary” command. This is where we will be copying the installation files.
Select the partition using the “select partition 1” command.
Make it active by typing “active”.
Format the drive and create an NTFS filesystem on it using the “format fs=ntfs”command.
Assign a drive letter to the USB disk using the “assign” command.
Exit the DiskPart utility using the “exit” command.

The USB is now formatted and is ready for the transfer.

Copying the installation files and making it bootable

The following steps are the crux of the process.

Insert the Windows 7 DVD.
Navigate to the boot directory of the DVD.
There is a utility “Bootsect” which comes bundled in the Windows 7 DVD. This does the entire work for us.
Run the utility from the command line and specify the drive letter of the USB drive. bootsect.exe /NT60 X:
The utility adds the appropriate boot-code to the USB drive.
Copy the contents of the DVD onto the USB drive.

That’s it, reboot the system, make sure that the USB boot is given the highest priority and the installation starts.

Integrating OACurl With A Java Desktop Application

2010-07-10T17:12:00.003+05:30

In my previous post, I introduced the Google Buzz API and the technologies surrounding it. In this post, I will be emphasizing on how to integrate OACurl with a Java Desktop Application to make the authentication process simpler. Before I continue, let me categorical state that this method is good for small student projects; but for serious production applications, OACurl integration isn’t a good option.

OACurl is primarily an OAuth aware wrapper around the popular cURL command line utility. If you are wondering what cURL is, it is a software project providing a library and command-line tool for transferring data using various protocols like HTTP, FTP, HTTPS, LDAP, IMAP, POP3, etc. The beauty of cURL is that it simplifies the process of data transfer using these protocols to a very large extent. OACurl is an extension to this utility which supports OAuth, the authentication/authorization protocol of the Google Buzz API. OACurl provides an easy way to experiment with the Buzz API.

Before I start with OACurl Integration, let’s see how we can connect a desktop application to the Google Buzz API without OACurl. As I mentioned in the previous post, the OAuth token request and authorization process takes place through a Web Browser. So the desktop application should open the Browser and allow Google to verify the user credentials. Then Google issues an authorized token to a Callback URL as specified by the application. This has to be detected by the application and it has to regain focus. For a more detailed view on this, check out – http://code.google.com/apis/accounts/docs/OAuthForInstalledApps.html.

The biggest challenge in this process is that in devices like Gaming Consoles, Set-top Boxes, where a Web Browser isn’t available the entire procedure goes haywire. Google is working on a solution for this, until then we have to adjust with the Web Browser technique.

OACurl is a pretty easy tool to work with. It is available as a Java Archive with multiple classes for various operations like Logging in, Fetching data from URLs, etc. To use OACurl directly from the command-line, refer http://code.google.com/apis/buzz/v1/oacurl.html.

To use OACurl within a Java Desktop Application, add a reference to the jar file from your project. Now there are two classes which do the entire thing for us – Fetch and Login. Both of them contain a main method; actually it is these classes that are being used in the URL mentioned above. But instead of using classes from the command-line, we will directly call the main method in them from our Java program.

A bit of reverse engineering makes it clear that the flags like “-buzz”, “-X”, “POST”, etc. are being sent as command line arguments. So we can create a String array of these flags and sent it to the main method.

com.google.oacurl.Login.main (new String[] { “-buzz” });
com.google.oacurl.Fetch.main (new String[] { “-X”, “POST”, URL });

The main methods push the output content to the default output stream as specified by System.out. By default, this is the user screen. If we want to use this output, we can transfer this output into a temporary file and read from this file.

File temp = File.createTempFile (“output”, null);
PrintStream output = new PrintStream (temp);
System.setOut (output);

Similarly, the main methods read the input from the default input stream as specified by System.in. By default, this is the keyboard. If we have to send our input, we can create a temporary file, write the content into it and make the file the default input stream.

File temp = File.createTempFile (“output”, null);
// Write into the file
PrintWriter writer = new PrintWriter (temp);
System.setIn (writer);

This way, we can use the Google Buzz API within our Java Desktop Application without having to worry anything about the authorization process. Developers curious to know how this works can explore the OACurl project hosted on Google Code at http://code.google.com/p/oacurl/. The complete source code of the Login and Fetch classes as well as the Callback Server and other classes is available at the link.

Before I wind up, here is a small project developed in NetBeans which reads the latest buzz and publishes buzz content.

The Google Buzz API

2010-06-26T14:49:00.005+05:30

It’s been a month Google released their Buzz API at Google I/O and I have been dying ever since to write an article on it. Finally got an opportunity today and really hope that the posts live up to my expectation :).

In this post, I am going to introduce the Google Buzz API and the technologies surrounding it like OAuth, REST, AtomPub and JSON. And in my next post, I will be emphasizing on how to integrate OACurl, an OAuth wrapper, with a simple Java Desktop Application. Most of the information in this post is pretty basic and if you are comfortable with these technologies, I would recommend you to skip the post.

Google Buzz

Google Buzz is a social networking and messaging tool from Google, designed to be integrated into Gmail. Google Buzz was an attempt by Google to compete with micro-blogging services like Twitter. After the release of the Buzz API, it has been well received both as a platform and as a service.

The Google Buzz API revolves around two main concepts – Authentication which is done through Open Authorization (OAuth) and Service Usage which is managed using the REST architecture with data formats like XML (through AtomPub) and JSON.

Authentication

OAuth is an open standard that allows users to share their private resources like photos, videos, etc. stored on one site with another site without having to hand out their username and password. It works through the exchange of tokens which provides access to a specific site for specific resources for a defined duration.

Most of Google Data APIs like the Google Calendar Data API, Blogger Data API, Google Contacts Data API, etc. use OAuth for authentication. The authentication process is done through a Web Browser for web applications as well as desktop applications using the APIs. A browser pops up and users are authenticated with respect to their usernames and passwords directly by Google and then the control is returned back to the application which can proceed accordingly.

A major disadvantage of this process is that a web-browser should be available for authentication even for desktop applications.

Service Usage

Data transfer for the Buzz API is done primarily on the basis of REST (Representational State Transfer). It is a style of software architecture for distributed hypermedia systems such as the World Wide Web. The crux of REST is that is uses the basic HTTP methods like GET, POST, etc. for resource manipulation (getting a resource, saving a resource, etc.)

Google Buzz API returns data in two formats – XML and JSON. XML is sent in the form of AtomPub. AtomPub (also known as APP) stands for Atom Publishing Protocol. It is a HTTP-based protocol for creating and updating web resources. It uses an XML language known as the “Atom Syndication Format” (ASF) and is very popular for web feeds. The Atom Syndication Format and AtomPub form the Atom Standard. The ASF is primarily an XML format with tags like feeds, links, etc.

Google Buzz API can also return back data in the form of JSON. JSON, standing for JavaScript Object Notation, is an open standard designed for human-readable interchange. Despite its strong relationship to JavaScript, it is language-independent with parsers available for almost every language.

The major reason for Google Buzz API to offer JSON besides ATOM was that JSON parsing is comparatively faster than XML parsing in JavaScript. So in web applications which might pull data from the Google Buzz API using JavaScript and AJAX, JSON parsing will be a major performance gain.

A Quick Example

Navigate to https://www.googleapis.com/buzz/v1/activities/userId/@public to see your latest public buzzes in the ATOM format and to https://www.googleapis.com/buzz/v1/activities/userId/@public?alt=json to see them in the JSON format.

There are several URLs like these available at the Google Buzz API site - http://code.google.com/apis/buzz/v1/using_rest.html. However most of them require authentication before they show the results, which means that without authorization by OAuth, a URL based mechanism will not fetch the data.

To know your userId, you can do the following steps –

Login to GMail and go to the Buzz tab.
Click on your name which is displayed at the upper-left corner of the Buzz tab.
The last handle (the string after the last /) is your userId.

NetBeans 6.9 - The JavaFX Composer Rocks

2010-06-19T21:14:00.006+05:30

NetBeans 6.9 has finally been released a few days back, June 15th 2010 to be exact. It was a very special release in the NetBeans community as this was the first major revision after Oracle’s acquisition of Sun Microsystems this January. Check out the release notes at http://netbeans.org/community/releases/69/relnotes.html.

Along with NetBeans, a minor revision of GlassFish, GlassFish 3.0.1 has also been released. The minor revision contains several bug fixes and the GlassFish Server Open Source Edition 3.0.1 has been integrated with NetBeans 6.9.

There are several new features which been added to NetBeans this time, like the support for Zend Framework on PHP, Ruby on Rails 3.0 Beta support, Spring Framework 3.0, JavaFX SDK 1.3, CSS Refactoring and Code Completion, support for JDK 7 and several other features. The complete feature enhancement list is available at http://wiki.netbeans.org/NewAndNoteworthy69.

But personally, I felt the best feature addition to NetBeans this time was the JavaFX Composer. For people who are new to JavaFX, it is a Java platform for creating and delivering Rich Internet Applications (RIA) that can run across a wide variety of connected devices like computers (as browser-based and desktop applications), mobile phones, TV set-top boxes, gaming consoles and Blu-ray players.

The JavaFX Composer is a visual layout tool similar to Project Matisse for Swing. Initially released as a plugin for NetBeans 6.8, it has now been completely incorporated into NetBeans 6.9. The primary features of the JavaFX Composer are –

Visual editor for a form-like UI using components
Dynamic design editing based on states
Data access to Web Services, databases and local storage
Support for JavaFX binding
Simple animation editor
Multi-screen-size editing

Create a new JavaFX project using the JavaFX Composer by navigating to File, New Project and choosing a JavaFX Desktop Business Application or a JavaFX Mobile Business Application under the JavaFX category depending on the requirement. Give a project name and the UI editor opens for creating the UI from the JavaFX components.

Drag and drop components from the palette and create the user-interface as you want. Here’s a small echo application which echoes what has been typed in the text-box. To be honest, this is my first application in JavaFX and I could finish it by typing only a single line of code and that too a JOptionPane.showMessageDialog and I had help from the auto-complete feature of NetBeans for this :), rest of the work was done the JavaFX composer. That actually reflects the ease of development which the composer and NetBeans are driving. On a whole, a big thumps-up for the JavaFX composer and the entire NetBeans development team for integrating this into the IDE.

Download the project here.

If you give the JavaFX Composer a try, check out the huge arsenal of features which the palette possesses like Shapes, Effects, Charts, etc. You will definitely love them.

Cloud Computing Portal For SMEs - Curtain Raiser

2010-05-17T19:13:00.011+05:30

As our final year project, me and two of my classmates (A. Raghuveer and G. Nishanth) are working on a project (Cloud Computing Portal for SMEs) under the domain of Cloud Computing.

In this blog-post, I will be introducing the domain of Cloud Computing and give a small overview of our project. In a few days, I will be unveiling the code along the documentation at – http://cloud-smes.appspot.com/, so keep checking this space for more updates.

Here’s a short video about the project –

Cloud Computing

Cloud Computing is a paradigm in the field of computing. Technically, Cloud Computing is defined as –

“A computing capability that provides an abstraction between the computing resource and its underlying technical architecture, enabling convenient on-demand network access to a shared pool of configurable resources that can be rapidly provisioned and released with minimal management effort or service provider interaction.”

From a customer’s perspective, Cloud Computing is a cost-effective solution offering flexibility in usage at low investment costs. From a vendor’s perspective, Cloud Computing helps in reducing the operational costs of a data-center with a high degree of customizability. Cloud Computing allows vendors to reach more and more customers with a low cost of delivery.

Cloud Computing is mainly built on its delivery mechanisms which define the service being provided by an application running in a Cloud Computing environment. There are hundreds of delivery mechanisms available like Infrastructure as a Service (IaaS), Platform as a Service (PaaS), Software as a Service (SaaS), and Data as a Service (DaaS).

Advantages of Cloud Computing include Reduced Costs, Increased Storage, High Levels of Automation, Flexibility, More Mobility, etc.

Cloud Computing Portal for SMEs

Small and Medium Enterprises (SMEs) are companies whose headcount or turnover falls below certain limits. In most economies smaller enterprises are greater in number. In many sectors, SMEs are responsible for driving innovation and competition. In India, the Micro and Small Enterprises sector plays a pivotal role in the overall industrial economy of the country.

Every organization consists of several applications like –

Financial Accounting
HR Payroll
Inventory Control
Management Systems

Every organization makes a certain investment in its core infrastructure for these applications and for scalability and expandability of this infrastructure; Cloud Computing Centers are viable solutions.

This approach is very useful in high-risk SMEs where the requirements are high, stability is low and sustenance is risky. This methodology allows such organizations to outsource their mundane housekeeping tasks to Cloud Computing Centers and pay as per their usage. This reduces their initial investments for hardware and software, minimizing their risk. As time progresses and things stabilize in the organization, situation can compare the available options and proceed accordingly.

Cloud Computing Centers benefit from the fact that they leverage their hardware and software across multiple SMEs. With appropriate planning, the breakeven point can be reached easily and as time progresses the center can profit from such a venture.

Understanding this potential market, the project concentrates on SMEs by providing them with business applications on demand. These applications form a web portal, which is distributed across multiple Cloud Computing environments to avoid vendor lock-in.

The applications covered as a part of the project are –

Self-Managed Repository
Name Finder
Knowledge Management System
Sales Management System
Appraisal Management System

These applications are the primary requirements of any organization, irrespective of its sector – Education, IT, Banking, Automobiles, etc. and every organization needs them for its proper functioning.

Running Chromium OS In VirtualBox

2010-04-08T12:36:00.012+05:30

If you would like to try Chromium OS without disturbing your system or without going through the trouble of downloading the source code and building it, this blog-post is for you.

The Chromium OS has been built and bundled as a VMWare image (.vmdk). This image can be used with VMWare workstation, but this piece of software isn’t free. So in this blog-post I will be targeting the free virtualization application – VirtualBox.

Oracle VM VirtualBox is an x86 virtualization software package originally created by a German software company Innotek, purchased by Sun Microsystems and now being developed by Oracle Corporation as a part of its family of virtualization products. Download VirtualBox from http://www.virtualbox.org/wiki/Downloads

Download the VMWare image of Chromium OS as a zip file at - http://uploading.com/files/ff856c8d/chrome-os-0.4.22.8-gdgt.vmdk.zip

Extract the VMWare disk image from the zip using a compression utility like WinZip, WinRar or IzArc. Fortunately .vmdk images can be used in VirtualBox without any prerequisites, so we don’t need a VMWare workstation to use the image.

I couldn’t find a proper .vdi image when writing this article. If you find one, please post a link in the comments section. Either way, the series of steps will still be the same.

The following steps will get Chromium OS running in VirtualBox as a Virtual Machine.

Start VirtualBox
Create a new Virtual Machine
Name the Virtual machine as Chromium OS and select the operating system type as Other/Unknown
Allocate certain RAM for the operating system to run

Use the existing available hard-disk (the image which we have just downloaded)
The Virtual Media Manager ups on clicking the button beside the drop-down list
Add the image file which was obtained after extraction
The new image becomes the hard-disk for the virtual machine now

Click on Finish to complete the process
You can now see a new virtual machine docked on the right-hand panel of the window
Double-click on the VM and Chromium OS boots up
Login using your Gmail username and password

That’s it, Chromium OS is up and ready. Explore it!!!

Chromium OS

2010-04-08T12:14:00.008+05:30

Chromium OS is the open source development version of the Google’s Chrome OS. The source code of Chrome OS was released on November 19th, 2009 under the BSD license as Chromium OS.

Chromium OS aims to build an operating system that provides a fast, simple and more secure computing experience for people who spend most of their time on the web. It targets to build a powerful platform for developing a new generation of web applications.

Chromium OS is the name of the project and Google Chrome OS is the name of the product. But the developer builds are still termed as the Chromium OS.

But the advent of the Chrome OS has led to a bigger question – Do we really need a new Operating System? More specifically – Why Google Chrome OS?

The traditional boot-up process that we go through everyday involves a series of steps like –

Loading the BIOS
Hardware detection
Loading and starting the Boot-loader
Loading and starting the Kernel
Starting the OS primitives
Running the startup applications

Even the fastest computer in the world takes about 45 seconds for this to happen.

This was the focal point of Google while building the Chromium OS. For millions of naïve users who use their netbooks/laptops mostly for internet, 45 seconds is a lot of waiting time. Google plans to make the web browser the Operating System for fast boot-up and this OS is the Chromium OS. In fact Google is claiming a 7 second boot-up for the Chrome OS and in certain instances the boot-up time has been as low as 3-4 seconds.

The Chrome OS hasn’t been released yet and the expected release date of the Chrome OS is late 2010 or early 2011. But technical enthusiasts can still get first impressions through the open-source Chromium OS project.

Google Chrome OS is built on the Linux kernel and is expected to be free on release, but then what’s the economy model of Google? – Chrome pushes Google web applications like Google Docs, Google Calendar, Picassa, Youtube, etc. The major revenue stream of Google is through its advertisements. More users of Google applications will yield more revenue to Google through advertisements.

All the applications utilized by the Chorme OS are cloud based applications. A major drawback is the customer trust on Google. All our documents – text docs, spreadsheets, and presentations are all on the Google cloud. How can an individual be sure that his documents are secure from unprivileged users? The recent crash of Gmail has strengthened the apprehension and has caused a panic about the cloud based OS of Google.

Major Drawbacks

Google is considering Chrome OS as a companion device. It is assuming that every user will have another work-station at their disposal
Vague support for working offline. Google is planning to provide a little support through Google Gears and local caches, but every the idea has to be solidified
Android applications are incompatible with Chrome OS
Chrome OS requires internet access for everything
Every application which users desire cannot be integrated into the cloud
Browser lock-in. No other browser can be used expect for Google Chrome

The Brighter Side

Speedy boot-up
Security by default
Support for both x86 and ARM architectures
Several applications are available by default like Google Docs and Microsoft Office Live
No need to install anything. Just plug-n-play

On a whole, Google has created a lot of buzz about its new Operating System. Let’s wait and watch. I recently was a part of a presentation around the Chromium OS – check it out here.

If you would like to try out Chromium OS for yourself, either follow the build instructions at http://www.chromium.org/chromium-os (or) check out my next post – Running Chromium OS in VirtualBox.

Passing Functions To Functions In C++, C# & Java

2010-02-28T10:55:00.008+05:30

Before I start the article, I admit I used the word “Function” a little loosely in the title. Functions are available in C++, but in C# and Java it would be more appropriate to call them methods of a class because of the Object Oriented approach followed by these languages.

There are a lot of situations where we write modules such that other developers have the flexibility to fine-tune them to meet their requirements. Assume we are writing a module (function/method) wherein a function/method will be called in the middle of its execution but we don’t know the implementation of this function/method nor its actual name. Wouldn’t it nice if we could just leave the implementation of the function/method to the developer who will be using the module?

This is exactly what I target in this blog-post. The article will give a quick overview of how to pass a function (actually a reference to a function) to another function in C++; how to create and use delegates in C#; and finally how to simulate a similar effect in Java which has neither pointers nor delegates.

To help the readers understand the concept better, I will be taking a simple example here. In the example, there is an addition module which takes three arguments – two integers and a function/method which is the display routine. It’s not a real-world example as I could have just returned the sum back.

An apt real-world example for this approach would a customized sort routine which takes a function/method which can be used as a comparator for the sort. I will leave it to the users to think of more complex situations where such an approach will be beneficial.

Function Pointers in C++

A Function Pointer is a pointer in C/C++ which points to a function. When dereferenced, a function pointer will result in the execution of the function it points to. A function pointer is defined as –

return_type (*function_name)(argument_list)

An important point that is to be noticed here is that the signature of the function to which the pointer can point to has to be declared in the declaration of the pointer. Once that is done, it can be assigned to any function which follows that signature.

Here is an example C++ program which uses function pointers –

Function pointers play a very important in Callback layered architectures. For example, function pointers can be used to register a function with an event handler.

Delegates in C#

A delegate is a type that references to a method. When a method is assigned to a delegate, the delegate behaves exactly like the method. A delegate in C# is defined as –

access_modfier delegate return_type delegate_name(argument_list)

Similar to Function Pointers in C/C++, the method signature has to be specified in the definition of the delegate. But unlike function pointers, delegates are type safe. This is because since Function Pointers are basically pointers, even an improper assignment will not raise any error until it’s too late. On the other hand delegates are associated with the signature specified and any wrong assignment will lead to a compilation error.

Another important feature of delegates is that delegates can be chained together. That is, multiple functions can be executed when the delegate is called. This is done through + and - operations on delegates. Here is how the syntax looks –

delegate_name reference_name;
reference_name = method1_name;
reference_name += method2_name;

Now when reference_name is called, both method1_name and method2_name are executed one after another.

Delegates also allow methods to be passed to other methods using lambda expressions, which can be written in the method call itself. Go through the following example which shows how to use delegates for method passing and how lambda expressions are useful –

Delegates are very useful in event handling, for defining callback methods like a customized sort, etc.

Simulation Using Interfaces in Java

Ok, now coming to the fun part. How can I get the same effect in Java which has neither Function Pointers nor Delegates?

The approach which have discussed above can be simulated in Java using single method Interfaces. The single method interface can be implemented and the class can become an argument of the method. The concrete class passed to the method is used to call the one and only method of the interface.

However, there are three major drawbacks in this –

Every developer using the method is forced to create a class implementing the interface
The name of the function is fixed, the implementation will change but not its name
We are not passing the method anymore but instead passing an object which has the required method

Similar to C#, the interface implementation can be done in-line to the method call using anonymous classes.

Here is a Java program which achieves the same result as the above two examples –

As we know, C# was heavily influenced by Java. So, almost everything that we can do in Java can be done in C#. The interface technique discussed for Java can also be applied in C#, but I guess it’s more easy to use Delegates for such a requirement than creating Interfaces.

Deploying Servlets & JSPs

2010-01-11T10:08:00.022+05:30

Java Servlets & JavaServer Pages (JSPs) form the backbone of Web Application Development in Java. Java Servlet Technology and JSP are a part of the Java Platform, Enterprise Edition (JEE). The latest release of JEE (version 6), which was released a few days ago supports Servlets 3.0 and JSP 2.2. I am not going to emphasize the changes made in these versions here, but a quick Google search should give you an idea on the enhancements made.

A Java Servlet is primarily a class which conforms to the Java Servlet API, a protocol by which a Java class may respond to HTTP requests. A servlet may be used to add dynamic content to a Web Server using the Java platform. The generated content is commonly HTML, but may also be other data such as XML, etc. Similar non-Java technologies are CGI and ASP.NET.

JSP is a server side technology similar to that of Servlets. Like Servlets, it is also used to create dynamically generated web pages with HTML, XML, etc. in response to Web client requests. Architecturally, JSP may be viewed as a high-level abstraction of Java Servlets.

Though Servlets and JSPs are used to achieve the same goal, they were designed for two different profiles – developers and designers respectively. A well designed JSP may serve dynamic content using Java without any actual Java code in the JSP; this is achieved using other technologies of Java EE like Expression Language, Custom Tags, etc. Such a model was built to help Web page designers, who are good at HTML, build JSP pages without any need to understand the Java code involved. The developers can support these designers by building custom tags, developing the servlets in patterns like MVC, etc. If you are new to the world of Web Application Development in Java, this concept may seem a little overwhelming in the beginning, but as time progress you will understand this approach better.

To accept HTTP request and to give the users the required responses, a web/app server is used. A web server primarily accepts request and gives responses along with optional data content like images, etc. An extension to the web server is the app server. An app server can also expose business logic and business processes for third-party applications. Further, app servers have features like transaction management, security, etc. Apache Tomcat is a popular web server with Tomcat as the servlet container and GlassFish is a popular app server. Servlets and JSPs have to be deployed on these servers for the outside world to communicate with them. This post will be covering both these servers.

In this blog-post, I will be covering only the deployment phase of Servlets and JSPs. It is assumed that the reader is comfortable with Java and is well acquitted with the basics of JSPs and Servlets. I won’t be explaining any code in this post as most of it is self-explanatory.

Software needed –

Java EE 6 (http://java.sun.com/javaee/downloads/index.jsp)
Apache Tomcat 6.0.20 (http://tomcat.apache.org/download-60.cgi)
GlassFish v3 (https://glassfish.dev.java.net/downloads/v3-final.html)

Note – Installing Java EE 6 will also install GlassFish v3.

To help the readers get a better understanding of the entire process, I will be developing a simple Hello World Application with a Hello World JSP and a Hello World Servlet here.

Here are the source codes of the JSP and the Servlet –

Compile the servlet using the javax.servlet.jar available in glassfishV3\glassfish\modules directory, which is obtained after installing JEE 6 with the following command –

javac HelloWorld.java –classpath install_path\ glassfishV3\glassfish\modules\javax.servlet.jar

Understanding the directory structure

Every web application has a typical directory structure. The JSPs and Servlets along with the required descriptors have to be placed in this directory structure. I will emphasize this structure using the Hello World example. The structure is as follows –

Any file/folder present in the root of the Web Application (like helloWorld.jsp) here is directly available to the client. Even folders present here (except WEB-INF and META-INF) are available directly to the users.

The root also contains a directory called the WEB-INF. This is a required directory and contains three important sub-folders – classes, lib and tags. Every web application also has a deployment descriptor (web.xml). This is also placed here.

The classes directory contains the .class files. The servlet class files are also placed here (like HelloWorld.class).

The lib directory contains any external JAR files that are used in the web application. In this example we have no files in this directory.

The tags directory contains the TLD along the .tag files. As this is an introductory example, we will keep this directory empty. If there are any custom tags being developed in the web application, they should be placed here.

The deployment descriptor defines the mapping between the servlet name and the servlet class.

Download the entire application here.

Deploying the application in Apache Tomcat

Copy the directory HelloWorldApplication built in the above step to the webapps directory of Tomcat i.e. install_path\Apache Software Foundation\Tomcat 6.0\webapps.

Start Tomcat from install_path\Apache Software Foundation\Tomcat 6.0\bin\tomcat6.exe.

To view the JSP page, type http://localhost:8080/HelloWorldApplication/HelloWorld.jsp in the browser and to view the servlet page type http://localhost:8080/HelloWorldApplication/HelloWorld in the browser.

Shut down tomcat6.exe to stop the server.

Deploying the application in GlassFish V3

Start GlassFish using install_path\glassfishV3\glassfish\bin\startserv.bat.

Open http://localhost:4848/ in the browser.

Login with the admin password and navigate to Applications Task in the left-side panel. Click on deploy and select “Local Packaged Directory” and specify the directory built above.

Select the type as “Web Application” and click on “Deploy”.

To view the JSP page, type http://localhost:8080/HelloWorldApplication/HelloWorld.jsp in the browser and to view the servlet page type http://localhost:8080/HelloWorldApplication/HelloWorld in the browser.

Stop GlassFish using install_path\glassfishV3\glassfish\bin\stopserv.bat.

That’s it. We have written a web application and deployed it on Apache Tomcat and GlassFish. Still there is one more catch – what if I have to move the web application from one physical server to another physical server? Do I have to build the directory structure again? Well look for the solution in my next blog-post – Building Java Web Archives (WARs).

Remote Desktop Services Using RDP

2009-12-16T09:27:00.013+05:30

If you love the data on your desktop, and want it on the move, then this blog-post is for you. In this post, I will emphasize the Remote Desktop Protocol (RDP) of Microsoft using the Remote Desktop Services/Terminal Services.

Remote Desktop Protocol (RDP) is primarily a proprietary protocol developed by Microsoft, which focuses on providing user with a graphical interface to another computer.

Notable features of RDP include -

32-bit color support
A 128-bit encryption algorithm and protection from vulnerabilities like the man-in-the-middle
Audio redirection
File System Redirection
Port Redirection
Support for Aero Glass Theme and ClearType font smoothing technology
Support for Transport Layer Security
Multiple monitor support

Remote Desktop Services, formerly known as Terminal Services, is one of the components of Microsoft Windows that allow a user to access applications and data on a remote computer over the network. It is built on the RDP protocol.

The RDP Desktop Services segregates the systems into two groups – the servers and the clients. RDP Servers and Clients exist for several versions of Microsoft Windows, Linux, UNIX, Mac OS X, etc.

This article will focus on configuring both, the RDP Servers and RDP Clients. The configuration steps mentioned here are restricted to the Windows line of Operating Systems – XP, Vista, etc; and for illustration purposes, I will be using Windows 7 as my server and Windows XP running on VirtualBox as my client.

Besides Windows, RDP servers are available for the UNIX Operating System in the form of several open-source projects. UNIX based RDP clients also exist, like the rdesktop.

Configuring RDP Servers

A RDP server is the heart of the RDP protocol. Once a system has been configured as a RDP server, any user with sufficient privileges can log into the system from any terminal and perform his/her tasks.

Configuring the RDP Server on Windows 7 involves the following steps –

Right-click Computer and select Properties
Click on Remote Settings link present in the left panel
If you want to allow connections from any version of Remote Desktop, select the second option. This is a less secure configuration. However this will allow users from other versions of Windows and UNIX to connect to the system. Eg. if a system with Windows 7 has been setup as a server, this option will allow older versions of Windows like XP and 2K to access it
On the other hand if you are sure that you want users to connect from the same version of Remote Desktop, select the third option. This is a more secure configuration

Configuring RDP Clients

Once the server has been setup, any RDP Client can hook up to it from any system connected to it in the network.

Establishing a connection to a RDP Server from a system running Windows XP involves the following steps –

Go to All Programs -> Accessories -> Remote Desktop Connection
If the RDP Server has a computer name, enter the name. Else enter the IP address of the RDP Server
Login with the proper username and password; and you are ready to work
At the end, remember to log off and not shut down, because shutting the system down would require a physical startup the next time whereas logging in again can be done remotely

Remember – According the EULA of Microsoft Windows, only a single user can use the copy of Windows at a time. So there can be only one RDP Client active for a particular RDP Server. If another RDP Client logs in, the existing user will prompted to log off.

Facts and Features of RDP

RDP uses presentation virtualization to enable a much better end-user experience, scalability and bandwidth experience. RDP plugs into the Windows graphics system the same way a real display driver does, expect that, instead of being a driver for a physical video card, RDP is a virtual display driver
RDP usage of bandwidth is far less than expected. This is important as bandwidth is a very big constraint in networking. However, the bandwidth usage varies from the application to application being used. Eg. A slideshow in PowerPoint will drive more bandwidth than a simple movement of the mouse
RDP can be tuned as per the requirements of the user. Factors like user-experience can be compromised to reduce the usage of bandwidth. RDP can be configured to give better performance too
Color depths have no effect on the user-experience of RDP. Though the initial versions only supported 8bpp (bits per pixel), the newer versions support 32bpp, and in fact Aero needs 32bpp to function properly
RDP is highly secure as it supports strong encryption and uses Keberos or TLS/SSL for authentication
RDP is not only used in Remote Desktop Services, it is used in several applications like Windows Media Center Extenders (including Xbox 360), Windows Live Mesh, etc.
The RDP protocol is completely publicly documented. To understand the internal working of RDP, you can visit - http://msdn.microsoft.com/en-us/library/cc240445(PROT.10).aspx

Well that’s it for a simple RDP Server-Client setup. Do check back soon for my next article on Windows Meeting Space, which is another part of the Remote Desktop Services using the RDP.

Reset Linux Root Password Using The GRUB

2009-12-03T09:50:00.008+05:30

Before I start the central aspect of this article - resetting the Linux root password, let me quickly introduce you to boot loaders and the GRUB.

A boot sequence is the initial set of operations that the computer performs when the power of a computer is switched on. A boot loader typically loads the main Operating System for the computer.

A computer’s central processor can only execute program code found in the Read-Only-Memory (ROM) and Random-Access-Memory (RAM). However, when the computer is switched on, it does not have an Operating System in its ROM or RAM. So a computer initially executes a small program stored in a ROM, which in-turn loads the required code and data into the RAM for execution.

This small program which performs this process is known as a bootstrap loader, bootstrap or a boot loader. This program is generally not the Operating System, but a miniature program which will load the required Operating System into the RAM from the non-volatile storage.

There are several popular boot loaders used today – GRUB, BOOTMGR, LILO and NTLDR. The GNU GRUB (GNU GRand Unified Bootloader) is a boot loader package from the GNU Project and is one of the most popular boot loaders available today. LILO (LInux LOader) is a generic boot loader for Linux. NTLDR (NT Loader) is the boot loader for all releases of Microsoft’s Windows NT Operating System. In later versions of Windows like Vista and Windows 7, NTLDR was replaced by the Windows Boot Manager (BOOTMGR).

In this article, we restrict ourselves to the GRUB loader. Typically, a few dual-boot environments and a few Linux based Operating Systems use the GRUB as their boot loader. Here is a screen-shot of the GRUB loader of Red Hat Enterprise Linux 5 –

There are many scenarios where we might need to reset the root password of our Linux system. Consider you have been assigned to a Linux system to work with and the previous owner forgot to give you the root password; maybe you are in the middle of an important project and you don’t have the root password of the system when you need it urgently and the worst part – the system administrator is not in sight; or maybe you just forgot it. The possibilities are limitless.

But remember, before you attempt to change or replace the password of any machine, make sure you have the necessary permissions from the management authorizing it. If not, it can be mistaken as an attempt to hack into the machine, which is not ethical.

Start the system, when the selection screen comes up, navigate to the line for Linux and press ‘e’
Now, select the entry that begins with the word – ‘kernel’ and again press ‘e’
Append ‘single’ to the end of the existing line. Make sure there is a space between the existing content and ‘single’
Press ‘b’ to boot into Linux as the root

You are now in the special mode called the “Single-User Mode”.

If prompted for the root password here, restart the system and in the previous step, append ‘init=/bin/bash’ after ‘single’

Use ‘passwd’ to specify the new root password

I am sure that reading this procedure would have caused apprehensions in the minds of several readers about the security of their systems. Using this method, anybody can hack your system. So if you want to be careful and avoid such situations, you will need to restrict any modifications to the GRUB. This can be done by protecting the GRUB by using a password.

Open the shell prompt and login as the root
Use the ‘grub-md5-crypt’ command to get the MD5 hash of your GRUB password
Open ‘/boot/grub/grub.conf’ and add ‘password -md5 <hash>’ below the timeout field
Save and exit

From next time, if you want to edit the GRUB, you will have to press ‘p’ followed by the GRUB password. The downside of this is that there is an extra password for you to remember. Well, accessibility has always been a trade-off in security.

Note – Changing passwords of a system without proper permissions is unethical and illegal, which may lead to legal complications. So always follow a proper authorization channel before changing the passwords.

Three Years Of Vivacious Blogging

2009-09-23T23:47:00.009+05:30

It’s been three years I started this blog and wrote my first article.

With a great apprehension on my mind whether I can write public articles or not, I took a bold step and began my online endeavor on 21st September 2006. To describe my blogging experience till today in one line, I would call it a “Roller Coaster Ride” – filled with twists and twirls, but on a whole, exciting and exuberant.

Like any blogger, my biggest question was “What to write in my blog?” Initially I was clueless and wrote all kinds of articles ranging from my personal experiences to casual stories. But as time progressed I realized my strength and decided to make this a technical web-log. (Yes, I know I am violating my principle with this blog-post :P).

From then my life became simpler and the number of my blog-posts increased. As time progressed, several technical topics like “Play-Station Emulators”, “The Towers of Hanoi” and “w32.USBWorm” were emphasized in my blog. My blog became a focus point of various presentations I gave in these years. Presentations like “Service Oriented Architecture”, “Globalised Solutions” and “Programming with Qt” were highlighted.

As time moved on, I became the Sun Campus Ambassador of my college. Then I started a new blog at http://blogs.sun.com/gautam/. I stuck to my resolution of making this a technical blog and continued my technical articles here and wrote my personal experiences in the other blog. Topics like “NetBeans” and “OpenSolaris” became a part of my blog after this.

On a whole, there are 85 blog-posts on this blog and 22 blog-posts on my Sun blog till date.

I am sure a lot of you are thinking “Who visits this blog?” I also used to contemplate over this question a lot. Then on 8th September 2009 I took a daring decision, decided to track my blog and signed up at Google Analytics. I was shocked by the results. From September 8th to September 23rd (16 days), my blog had 470 visits with 761 page-views. The visitors had a massive geographical diversity, spread across 42 countries, 112 cities and covering all the continents. As Google Analytics results cannot be displayed, I put a ClustrMap here for the visitors to see, so do check it out if you would like to view the regional diversity of the visitors of the blog.

If you are a blogger like me, do sign-up for Google Analytics, you will be surprised by the results. For more details have a look at my previous post.

During these three years I was fortunate to see the blogs of several of my friends come up and it was very exciting to read their magnificent articles. So I decided to create a network of these blogs here, do check them out after you finish reading this article.

It would be inappropriate to end this blog-post without thanking everybody who encouraged me to start this blog and contributed to this blog with their constant feedback and guidance.

Thanking them from the bottom of my heart and hoping more and more blog-posts come up here, Adios, Au Revoir, Sayonara and Good bye till my next blog-post.

Web Analytics - Boosting Performance

2009-09-17T21:32:00.008+05:30

Every web-site/blog has visitors. Understanding the regional spread of these visitors and analyzing which articles (pages, products, etc.) bring in more visitors (customers), is vital for improving the business of the web-store or attracting more visitors to the blog/web-site.

In this blog-post we are going to emphasis two popular web-site tracking tools – ClustrMaps and Google Analytics. In the next few sections I will refer blogs and web-stores as also web-sites. The principle is same for all of these.

Google Analytics

Google Analytics is a brilliant innovation from labs of Google. It helps you analyze the traffic feed of your web-site in various perspectives. As Google describes it –

“Google Analytics is the enterprise-class web analytics solution that gives you rich insights into your web-site traffic and marketing effectiveness”

It has some really cool features that a web-site manager would love. There are four major components on Google Analytics –

Visitors Overview – This component keeps track of every visitor that visits your web-site. It provides complete information on the number of visits, number of absolute unique visits, page-views, total time spent by visitors on the site and a percentage of new visits. One important parameter it keeps track of is the bounce rate. Bounce Rate is a measure to see how appealing the web-page was for the visitors. High percentages of bounce rate indicate the visitors moved out of the web-site quickly. It maintains complete information of the browsers used by the visitors and their connection speed.

The geographical aspect of the visitor overview is marvelous. It shows a comprehensive analysis of the visitor’s geographical location. It pin-points the city from where a visitor has come.

Traffic Sources Overview – This component gives an overview of the sources of the traffic. It also provides a report on the sites which led the visitors to your web-site. For people targeting search engines, it provides a comprehensive analysis of the keywords which led the people to the web-site.

Content Overview – This component provides a detailed analysis of individual pages viewed by the visitors. It provides us with the total number of page-views, unique page-views and the bounce rate. It also provides us with the list of the pages which brought in the most visitors. It also shows us how many times each component of the web-site was clicked and the navigation patterns of the visitors.

Goals Overview – This component helps us to understand our objectives and keep a track of how far we have reached them. Goals can be setup with respect to every traceable unit of the blog like the page views, keyword patterns, etc.

Signing Up for Google Analytics

So if you are excited by these features and would like to add Google Analytics support to your web-site, follow these steps –

Go to http://www.google.com/analytics/sign_up.html
Sign in with your Google account
Sign up for Google Analytics by providing the URL of your web-site and few other details
After filling in the form, you will be provided with a JavaScript code snippet. Copy this code to your web-site. For blogger, paste the code before the closing head tag in the Edit HTML component of the layout tab.
After a few hours, if the process was carried out properly the Google Analytics service will be running on your web-site. You can view the status by signing in at the Google Analytics web-site.

ClustrMaps

Google Analytics is good for analyzing your web-site behind the screen. But it does not allow visitors to see the geographical diversity of the other visitors. So if you are interested in showing the visitor count along with their geographical location to the public, go for ClustrMaps.

To register your web-site with ClustrMaps, follow these steps –

Go to http://www.clustrmaps.com/
Provide the URL of your web-site and give your email id.
Select the style which suits your web-site.
Copy the code which is provided to your web-site.

Well that’s it for this post. Hope this post helps in increasing the visitors to your web-site. :)

Symbian Operating System

2009-09-16T19:33:00.006+05:30

The Symbian Operating System is an embedded Operating System developed by Symbian Ltd. It was built primarily for the ARM processor architecture. Though Symbian isn't completely open sourced, parts of its code-base have been made public.

I recently gave a presentation on this and the topics covered were –

The Symbian Foundation and a brief history about it
The notable features of the Symbian Operating System
The Operating System structure
Memory management
Process and thread management
Issues related to security and malware
The success stories of the Symbian OS
Application development in Symbian using Symbian C++ and Java ME

Download the presentation here.

The presentation was followed by two demos – one covering Symbian C++ and the other covering Java ME. The software used in the demos –

Active Perl 5.6
Symbian SDKs
Java Development Kit 6.0
Carbide.c++ 2.0
NetBeans 6.7.1
Sun Java Wireless Toolkit

Download the installation guides for these software here. (They contain screen-shots which are self-explanatory). Download screen-shots for the Hello World demos here.

Visit the Symbian foundation web-site at http://www.symbian.org/

If any discrepancies are found in the presentation or in any one of the guides, please post the problem in the comments section.

Synchronous And Asynchronous Database Replication - Resources

2009-07-22T00:42:00.008+05:30

Check out the dedicated web page of "Synchronous and Asynchronous Database Replication - An Application Framework" at http://mysql-clustering.appspot.com/.

The project is a part of MySQL Forge at http://forge.mysql.com/projects/project.php?id=348.

Download the entire project here.

Synchronous And Asynchronous Database Replication - Project Technology Summary

2009-07-22T00:32:00.008+05:30

The demo framework not only showcases the MySQL capability but also demonstrates a variety of Sun Technologies and Industry Standard Interfaces.

The implementation has been modular so that the demo can be downsized but still the features can be demonstrated.

The various components that have been utilized are listed below -

Hardware – Intel Quad Core Desktop with 4GB RAM
Virtualization – Sun VirtualBox
Operating Systems – Windows Vista, Windows Server 2003, Fedora Linux, OpenSolaris
Database – MySQL
Web Servers – GlassFish and Internet Information Services
IDEs – NetBeans and Microsoft Visual Studio
Web Service Layer – Java API for XML Web Services
Front End GUI - Java Swing, HTML, JavaScript, Visual Web Java Server Faces, Java Micro Edition, C# and ASP.NET

Synchronous And Asynchronous Database Replication - Project Approach

2009-07-22T00:28:00.012+05:30

As per the advice of Sun Team, the project has been implemented in a staggered model as outlined below with a use case that covered a Telephone Enterprise Customer Database wherein each Customer is uniquely identified by phone number (country code + phone number) -

Database Administration

This Phase covered the Hardware Setup, Operating System Setup, and Installation of MySQL. The major focus during this phase was to setup Replication features of MySQL using two different approaches – Asynchronous and Synchronous.

Both the replication approaches were implemented against two MySQL engines – InnoDB and MyISAM.

Implementation and comprehensive testing was performed at this stage which also covered failures of databases and scalability under the available hardware configuration.

Business Logic Development

This Phase covered the business logic requirement where the stress and focus was on standard database interfaces. The demo implemented Hibernate, an ORM model and JDBC to connect to MySQL database.

The connection to the database using these technologies is achieved through a Web Services layer. CRUD functionality has been implemented using Web Services.

Graphical User Interface Development

The focus of this phase is to demonstrate how an end-user application would interact with MySQL database using the Web Service Layer. The demo implemented various client-side GUIs in the form of front-end technologies like Java Swing, Visual Web Java Server Faces (JSF), Java Micro Edition and ASP.NET.

Exhaustive test cases have been written to demonstrate the functionality covering both success and failure situations.

Synchronous And Asynchronous Database Replication - Project Design

2009-07-22T00:03:00.014+05:30

Project Goals

The goal of the project is to provide a snapshot capability for three types of audience -

Database Administrators - Installation, Replication and Clustering of MySQL databases both in standalone and virtualized Operating System Environments covering Windows, Linux and Solaris.
Business Logic Developers - CRUD (Create, Retrieve, Update, Delete) operations using Web Services to interact with the MySQL database adopting JDBC and Hibernate interfaces.
Client Side GUI Developers - Provide sample codes to access and implement data management through above Web Services. The Client interfaces are diversified covering J2ME, JSF, Java Swing, and ASP.net to demonstrate the versatility of the seamless interface to MySQL database.

Project Architecture

The project as depicted below implements the Model-View-Controller (MVC) architectural pattern, with the database layer representing the model, the business logic layer representing the controller and the font-end GUI representing the view.

Synchronous And Asynchronous Database Replication - Project Backdrop

2009-07-21T23:53:00.008+05:30

Industry Association Program

To provide students with an exposure to industry practices and work environment, Osmania University started the Industry Association Program (IAP), as a part of the curriculum, wherein the third year students are encouraged to work in a professional organization.

As a part of IAP, we (J. Kamala Ramya, K. Laxman Bharadwaj and me) had been assigned to Sun Microsystems Inc.

Organization Profile

Sun Microsystems Inc. is a multi-national vendor of several software and hardware products. The Headquarters of Sun Microsystems is at Santa Clara, California, United States. It has branches in several countries covering APAC, America and Europe.

Its contribution to the field of hardware has been marvelous, especially with the SPARC architecture.

Sun has several software products to its credit, which include Solaris, Star Office, VirtualBox, MySQL, etc. The most significant contribution of Sun Microsystems to the field of computers and electronics has been the “Java programming language”, which is widely used in several devices, which include computers and mobile phones.

Sun is a big supporter of Open Systems and is one of the major contributors of Open Source Software.

Project Identification

Our initial interactions with Sun Team was to identity a task which would benefit Sun as an organization and for us to improve capability and be industry ready after our BE course.

After evaluating various product lines and discussions with Sun Team, a decision was made in concurrence with Sun Team to focus on a Demo Framework which would showcase MySQL capabilities and how it would interface with various layers in a typical application environment.

After the $1 billion acquisition of MySQL, Sun has been actively propagating the product to its clients. It was felt that a demo framework encompassing standard frontend interfaces, standard database interfaces and standard database functionality would help the clients to make a knowledgeable assessment of the product.

The demo suite proposed was expected to cover the replication features of MySQL to demonstrate how MySQL can fit in a complete commercial application involving various layers like – Databases, Business Logic and GUI.

Globalized Solutions - Summary

2009-07-21T22:11:00.004+05:30

For every new program that is being developed fresh, it is recommended that it should follow the MVC pattern and that it satisfies the criteria for an internationalized program. Going forward, internationalization is an unspoken requirement that every application in global markets should satisfy.

Using translation and transliteration features to the maximum reduces the requirement of a language expert and there-by obtain project profitability.

Whichever project is being worked upon, development, migration, enhancement or QA, thinking of ways to apply the concept of Globalization will improve the robustness of the application.

Database Internationalization

2009-07-21T22:10:00.004+05:30

Besides GUI, an application has two other parts – Business Logic and Persistence. Typically the Business Logic is isolated and no language changes would be required. For globalized applications, the Persistence is typically a database like Oracle, MySQL, IBM DB2, Microsoft SQL Server etc.

The advancements in Databases Technologies have simplified the support for multi-languages. Most of the databases today support internationalization using Unicode characters. Restrictions on the languages that can be a part of the database can also be imposed. However the availability of this restriction is dependent on the DBMS being used.

Each database management system provides its own procedure to implement this multi-lingual data processing on their database but many times a language parameter setup during installation would suffice.

Translation And Transliteration

2009-07-21T22:07:00.009+05:30

Though not directly a part of internationalization, translation and transliteration provide the basis for I18n.

Translation

Translation is the process of converting a fragment of text from one language to another language. Translation is done by either by human translators, or by translators which involve artificial intelligence. In applications where perfect translation is required, human translators are employed.

However in applications where perfection of translation is not the at-most priority, AI translators are used. Examples of such translators include, Yahoo Babel Fish and Google Translate.

Transliteration

Transliteration is the practice of transcribing a word or text written in one writing system into another writing system. In the case of I18n, this provides a method of converting the keyboard language to a desired language.

Popular sites like Orkut make use of this service to create messages in languages like Hindi, Telugu, Tamil, etc. Several services related to translations and transliterations are available on the internet. In fact, Google provides APIs to directly implement these features in our applications.

Usage

If there is an existing product where a locale change is required and it does not follow the MVC structure, the developer can use the concepts of translation and transliteration and there-by migrate the application to the required locale. The language part is then reviewed by a language expert.

Even during internationalization, the resources bundles can be created for various languages using these concepts and they can then be offered to review by a language expert. These concepts are also useful when developers are interacting with users who do not know English through mails or documents to get an initial feel of the requirements.

Support for a product can also be made cost effective where the user logs issues in native language and the person supporting can understand the issue at high level using translation concepts. Reducing the time requirement of language expert is a significant cost saving in projects as these experts charge very high.

Internationalizing Mobiles Using J2ME

2009-07-21T22:05:00.003+05:30

Unlike desktop applications and web application, mobile applications cannot utilize resource bundles. Internationalizing mobile applications follows a slightly different approach.

In such devices, internationalization is achieved using a user-defined resource class. This class holds all the strings required by the application in various languages. Depending on the locale, the required set of strings is returned to the main application, and that application in-turn displays the locale-specific content.

Generally the resource class obtains the locale of the mobile device and returns the locale-specific set of strings to the main application. However the languages supported by the mobile-device are entirely device-dependent. So there is a huge possibility that the internationalization efforts may not be completely perceptible in all the targeted mobile devices.

Internationalizing Web Applications

2009-07-21T21:58:00.013+05:30

There are two important ways of internationalizing Web Applications – Using Resource Bundles and Using locale specific JSP pages.

Using resource bundles

Internationalization can be achieved by using resource bundles in Web Applications like Java Server Pages with the Java Server Faces framework. In such applications, the resource bundles created are similar to those created in the desktop applications. To use these resource bundles, they are registered with the web application in the form of a JSF config file with the required XML content.

Using locale specific JSP pages

Another way to achieve internationalization is to use different sets of JSP pages for different languages. This method mainly maintains a mirror copy for each of the language and, the locale specific JSP set is sent to the client on demand. However this method would result in more number of JSP pages but would provide greater customizability.

Internationalizing Java Desktop And Console Applications

2009-07-21T21:48:00.011+05:30

Internationalizing a Java application mainly uses the concept of resource bundles. The User-Interface code interacts with the resource bundles to extract the required information, thereby forming the User-Interface on the screen in the desired language.

The various message labels, messages in dialog boxes, button text, etc. are to be translated to make these components for a non-English speaker. So these strings are separated from the program into a central external repository. These repositories are called as resource bundles in Java. They contain the appropriate content for the text messages in various languages for the targeted locales.

These resource bundles many contain icons, pictures, actual UI elements like menus and buttons and even new window layouts, besides messages and other user-visible strings.

The resource bundles are a collection of properties files. A properties file exists for each locale targeted by the application. A properties file consists of key-value pairs. As the language changes, the key does not change, but the value changes. The components in the User-Interface code are referenced by the keys of the properties file. So as the language changes, the UI code need not be modified, the application will find the required properties file and use the corresponding value for each instance of the key in the program. The properties files of the resource bundle follow a naming convention which is of the form – bundle-name_language_country-code.

E.g. consider a file which uses a key called greeting to welcome a user
For English the properties file would contain greeting = hello
For French the properties file would contain greeting = bonjure

So whenever the programmer wishes to welcome the user, the greeting key might may be used. If the locale is set to English (United States), “hello” is displayed. Else if the locale is set to French (France), “bonjure” is displayed.

Internationalization Support In Java

2009-07-21T21:47:00.004+05:30

The entire Java platform is internationalized. Java provides an extensive library of classes and functions to help in internationalizing programs. Built-in I18n for Java comes with support for over 70 languages. I18n support comes for free or at very little cost.

All text in a running Java program is Unicode. Unicode was a brave effort to create a single character set that included every reasonable writing system. As a result the Unicode character set has support for almost every language script used in today’s world. Using this Unicode character set, Java provides a platform for Internationalization.

In Java the primitive type char is a single Unicode character. Similarly a String is a collection of these Unicode characters. All internal processing on text assumes the text to be in Unicode format.

Globalized Solutions - Basic Application Structure

2009-07-21T21:24:00.015+05:30

Any application can be divided into three primary components – Front End, Business Logic and Persistence.

Internationalization primarily applies to the front end GUI and back-end data persistence. Business Logic need not be modified during the localization of the application. In frameworks like MVC, Struts, Spring, the business logic is completely separated from the GUI and in such frameworks, internationalization is easily implementable.

Internationalizing Programs

2009-07-21T21:21:00.004+05:30

An internationalized program has the following characteristics –

With the addition of localized data, the same executable can run worldwide.
Textual elements, such as status messages and the GUI component labels are not hardcoded in the program. Instead they are stored outside the source code and retrieved dynamically.
Support for new languages does not require recompilation.
Culturally dependent data, such as dates and currencies, appear in formats that conform to the end user’s region and language.
It can be localized quickly.

Globalization Terms

2009-07-21T21:10:00.010+05:30

The most commonly used buzz-words in the Globalization market are Globalization, Translation and Localization and Internationalization. This article demystifies these terms.

Globalization [G11n]

Globalization addresses the business issues associated with making a product global. In the globalization of high-tech products, this involves integrating localization throughout a company, after proper internationalization and product design. This also involves marketing, sales, and support in the world market.

Globalization is mainly realized at the architecture level. There are two ways of achieving globalization – Internationalization and Localization.

Translation [T9n]

Translation is the process of converting text in one language to text in another language.

Localization [L10n]

Localization involves taking a product and making it linguistically and culturally appropriate to the target locale (country / region and language) where it will be used and sold.

Localization involves two operations – Translation and Engineering. This process primarily focuses on translating the various locale-specific data, like pictures, colors, text, etc. and then making required changes in the application code to meet the requirements of the locale.

Internationalization [I18n]

Internationalization, on the other hand, is the process of generalizing a product so that it can handle multiple language and cultural conventions without the need for re-design. It guides the developers to write program code with anticipation of locale change.

Internationalization takes place at the level of program design and document development. This is achieved by the concept of resource bundles. This approach is primarily driven by MVC architectures. The focus is on separating the GUI so that the multi-language support is easily implemented while keeping the Business Logic and Persistence as standard for a variety of users. Today Internationalization capability for any solution that is being developed is a mandated requirement.

Acronym Rules

Following the standard rules for abbreviating these words, the following acronyms will be used for the above terms in the rest of the series.

Globalization – G11n
Translation – T9n
Localization – L10n
Internationalization – I18n

These acronyms are built using a simple philosophy. The acronym consists of the first letter and the last letter with the number of characters between them as a numeral.
Eg. Consider Internationalization. It starts with I, ends with n and has 18 characters between I and n. So it is abbreviated as I18n.

Application Developers And Globalized Applications

2009-07-21T21:08:00.004+05:30

Considering the factors mentioned in the previous blog posts, it is evident that organizations will focus on people with globalized application development or management skills. Hence it is very important that the developer community is enabled with this skill.

Requirements in future could be to globalize an existing product or develop new product for a global market. The subsequent posts provide the various facets of globalized applications leveraging the skills that are already known to the developer community.

The Case For Globalized Solutions

2009-07-21T20:48:00.011+05:30

Globalized Solutions are becoming more important today due to some of the key trends like GDP by Region, World Population Distribution and Increased Investment in Emerging Markets. This post will emphasize the effect of these trends on Globalization.

GDP by Region

Here is a graph of the world GDP distribution. As evident from the graph, though North America is the largest part, it is still only a third of the entire GDP. The other markets like European Union, Japan, China together form a large chunk of the GDP graph. People in these countries obviously don’t speak English natively. Even small percentage penetration into these markets can improve margins significantly for companies.

World Population Distribution

Here is a graph of the world population distribution. Notice how radically the ranking change from the GDP graph.

Observe that more than half of the world’s population is in Asia, where a large chunk of non-English speaking population exists. China is fully dominated by Chinese language. India is dominated by multiplicity of languages each having a potential business opportunity.

Increased Investment in Emerging Markets

Many companies are creating business units around emerging markets like China and India as they see their future business coming from these markets. There is a significant push in these countries to modernize right now and this is moving at a significant pace.

Several real-life examples can be seen like - Usage of Mobile devices, Usage of Bank ATMs etc. As one can see today ATMs in India offer solution using Local Language / English. Mobile companies are offering solutions that allow messages to be sent in different local languages.

Emerging Markets – As good as Developed Countries

Business conglomerates, similar to developed countries are evolving in emerging markets. Companies like Bharti Airtel, Vodafone, BSNL are comparable to Verizon, AT&T etc, Banks like ICICI, SBI are no smaller than Bank of America, Citibank etc. Retail channels like Reliance Fresh, Future Bazaar, etc are similar to Wal-Mart, Radio Shack etc. Similar situations exist in China. In addition many of the multinational organizations are setting up operations in emerging markets. However customer reach can increase in these markets if offerings are expanded in different local languages.

Globalized Solutions - Introduction

2009-07-21T20:43:00.003+05:30

In order to manage the impact of economic recession and stay profitable, many software organizations today are looking at expanding their offerings beyond the traditional US markets. Emphasis on reaching customers across the globe especially those who are located in emerging markets like European Union, China, India etc. is gaining momentum. One of the main criteria in reaching to these markets is to understand their culture and deliver products in their native language. Organizations are evaluating at models and methodologies to enhance their existing and futuristic solution portfolios to cater the global audience.

Globalized Solutions - Breaking The Barriers Of Language

2009-07-21T20:37:00.010+05:30

Many Software Organizations today are looking at expanding their product sales, solutions and services towards emerging markets. Instead of relying on only the traditional US markets essentially dominated by the English language, companies have increased their focus on expanding business in language sensitive countries like European Union, China, India etc., One of the main criteria in reaching to these markets is to understand their culture and deliver products in their native language.

In such a scenario and also in falling job markets, specialized skills become important and knowledge of Internationalization of Applications would be one such key skill. This series of blog posts provides approaches for quick learning and building this capability.

Various techniques like Translation and Internationalization are applied with respect to communication, document reading and Application Development.

Internationalization provides a mechanism of simplifying the requirement of locale-specific applications, without losing the existing big English speaking markets like US, UK, etc. Developers can leverage programming languages like Java which internally support Internationalization for various desktop, web and mobile applications.

View the paper here and the presentation here. Download the sample applications here.

SOA Live Demo - Web Services

2009-02-23T13:53:00.030+05:30

Download the source codes from here.

Requirements - Java Development Kit, NetBeans 6.5, GlassFish v2, Visual Studio 2008, Internet Information Services.

Follow the below steps to get the projects running in Java and .NET Environments. There are four projects in the download archive - Palindrome_WebService, Palindrome_Java, Palindrome_JSP and Palindrome_J2ME.

Open the downloaded projects (Palindrome_WebService, Palindrome_Java, Palindrome_JSP and Palindrome_J2ME) in NetBeans 6.5.

The Palindrome_WebService project has the source code for the web service. Deploy it in GlassFish.

The Web Service can be tested by a built-in Web Service tester of NetBeans/GlassFish. The tester gives the method parameters and return values, along with the request and response SOAP messages.

This Web Service can be hooked to a Java client with a GUI. Open the Palindrome_Java project and run it.

Similarly, the Web Service can be also used in a JSP page. Open the Palindrome_JSP project and run it.

The Web Service can also be used in a J2ME mobile device. Open the Palindrome_J2ME project and run it.

All these projects are primarily implementations of Java. However this Java Web Service can also be connected to an entirely new language (if it has XML support). Open the remaining projects from the downloaded archive (Palindrome_CSharp and Palindrome_ASP.NET) in Visual Studio.

Consider a C# client which accesses the Java Web Service. Open the Palindrome_CSharp project in Visual Studio and run it. Remember GlassFish needs to be up and running with the Web Service deployed, for this to work.

Finally consider an ASP.NET page, using C# hosted on IIS, accessing the Java Web Service hosted on GlassFish. Open the Palindrome_ASP.NET project in Visual Studio and run it to achieve this.

Well, that's it. So we have used a Java Web Service in a Java client, JSP page, J2ME mobile device, C# console application and in an ASP.NET page.

SOA Live Demo - Java Native Interface

2009-02-23T12:49:00.021+05:30

Download the source codes from here.

Requirements - Java Development Kit and Visual Studio.

This article focuses on how to connect a C++ Dynamic Link Library to a Java program using the Java Native Interface. To run a C++ function in a Java program, we would require the C++ function to be in a DLL and this DLL to be loaded at run-time into the memory by the Java program.

Load the library from the Java program using the full path with the load function or let the JVM load the DLL using the system path with the loadLibrary function.

The C++ function is declared native in the Java program. Compile the file to generate the class file using the javac command.

Create a C++ header for the native function using the javah command on the generated class file. A declaration for the function is generated following the syntax java_<class>_<function>.

Create a new project to generate the DLL in Visual C++. The project consists of the header generated from the previous step, a C++ file using the function declaration generated in the header and a header consisting of the required function that is to be used in the Java program. A DLL is generated from this project.

Any C++ application can be created normally which uses the existing function.

Copy the DLL generated from Visual Studio to the path specified in the Java application and run the Java program using the java command.

As a result, the same function was used in a C++ program as well as in a Java program.

SOA - Adapters, Benefits And The Future

2009-02-23T12:28:00.011+05:30

SOA Adapters

Adapters are interfaces to connect to heterogeneous systems. Several vendors provide adapter solutions for creating web services around existing applications. Typical adapter solutions cover Database adapters, File (Local, FTP) adapters, ERP Application adapters, Polling adapters, etc.

Benefits Of SOA

SOA offers business solutions across platforms
It is location independent
Search and connectivity to other services is dynamic
Enhances reliability
Leverages existing development skills
Enhances ability to quickly meet customer demands
Lower costs associated with acquisition of technology
Leverages existing investments

What's Next?

SOA and BPEL
SOA Implementation using JBI and OpenESB
SOA Integration Scenarios
SOA and Integration Patterns/Frameworks
Security, Scalability and Reliability of SOA Solutions
Sun, IBM and Microsoft, etc., specific SOA offerings

Organizational Approach To SOA

2009-02-23T12:17:00.008+05:30

SOA plays an important role in organizations. If an organization is starting fresh in terms of IT solutions, it can implement the concept of SOA directly.

The challenge comes up in those organizations that have existing applications and these applications being heterogeneous in nature. A typical organization can have ERP applications (SAP, Oracle), Java applications, .NET applications and LAMP applications. To avoid complex maintenance activities and address future requirements, organizations are taking the following steps –

Detailed study of applications
Creating services of common nature around these applications
Implementing new applications around these services as a SOA model

One of the key aspects on which organizations focus in terms of services is the Governance. Primary objective of SOA governance is tracking all the available services and ensuring controlled creation and avoiding duplicates. Typical organizations classify their services into

Intranet (for internal usage)
Extranet (for the outside world, like Suppliers, Consumers, Banks, etc.)

Composite Services Using SOA

2009-02-23T11:45:00.015+05:30

Services are generally created from scratch or are formed from existing services. One of the key concepts of SOA is the creation of composite services.

SOA facilitates reuse of existing services to provide complex services, thereby avoiding redundancy of a particular service.

Case Study

Consider an educational institute with these existing services -

Given a minimum aggregate score, a list of all student IDs is generated
Given a student ID, the students name is generated
Given a department name, a set of all Student IDs belonging to that department is returned

Now consider the demand for two additional services -

Given a minimum aggregate score, a list of all student names is needed
Given a particular department, a list of all student names is to be generated

The required services can be obtained from existing services as follows -

From the first service, a list of student IDs is generated and each ID is fed to the second service to obtain the composite service

Similarly, the next composite service is obtained by obtaining the student list from the third service and feeding them to the second service

SOA - The Web Services Model

2009-02-23T11:03:00.017+05:30

The latest trends of SOA follow the Web Services model for implementing the Service Providers. However, the first question which arises here is - "What's a Web Service?"

According to W3C, A Web Service is a software system designed to support inter-operable machine-to-machine interaction over a network. A Web Service has an interface described in machine-processable format, specifically WSDL (Web Service Description Language). The services provided by the Service Providers are maintained as a list by a Service Broker which interacts with Service Providers and Service Consumers using UDDI (Universal Description Discovery and Integration) Inquiry and Publish.

Other systems interact with the Web Service as prescribed by its description using SOAP (Simple Object Access Protocol), typically conveyed using HTTP requests with XML serialization.

A typical Web Service is implemented as -

The Service Providers are generally Java Web Services or .NET Web Services.

The Service Consumers can be implemented in -

Java, JSP and J2ME (using NetBeans)
C# and ASP.NET (using Visual Studio)

The Service Consumers can actually be written in any language which can understand XML and interact through SOAP messages.

SOA - The Simplified Model

2009-02-23T10:47:00.007+05:30

For several college students and graduates, the concept of SOA can be well comprehended with traditionally taught languages in several of the educational institutes – C++ and Java. A C++ function can be created to provide a service, and this function (service) can be used in a C++ program as well as in a Java program.

In terms of SOA, a C++ service is being utilized by a C++ consumer as well as a Java consumer.

The C++ function can be used in a Java function using the Java Native Interface (JNI). The JNI is a programming framework that allows Java code running in the Java virtual machine to call libraries written in other languages, such as C, C++ and Assembly.

JNI allows Java developers to add functionality to their Java applications that the Java API can't provide. It is used in time critical calculations or operations where the native code is faster than the JVM code.

The SOA model using JNI can be represented as follows -

The Philosophy Of SOA

2009-02-23T10:01:00.013+05:30

SOA is not a product; instead it is an architectural approach for building solutions. SOA is primarily a concept of Service Providers and Service Consumers. SOA refers to the architectural style in which Service Consumers use the services offered by Service Providers. The essence of SOA lies in consumer centric behavior, and in ensuring that services can be located dynamically on need basis.

In any application, there are three parts – Front End, Business Logic and Persistence. In SOA they are mapped as below –

While SOA concepts are reasonably simple to understand and apply, they require a phased roadmap which takes some time. The vital starting phase of SOA is not technology but identifying the business-specific services in an organization.

Services are generally provided using concepts like -

Functions
APIs
Components
Web Services

The first three concepts, stated above are language dependent to a very large extent. However Web Services provide a language independent approach, and are one of the most popular approaches for SOA in today’s world.

Service Oriented Architecture - Bringing Versatility To Business

2009-02-22T22:36:00.010+05:30

According to a survey, a search made in Google for SOA would yield about 8 million entries. This clearly emphasizes the popularity and demand for SOA in today’s IT market.

Judging this huge demand for SOA, I decided to take up a short series of blog articles about SOA and how SOA can be implemented as a programmer.

Here are a few topics the subsequent blog-posts are going to cover -

The Philosophy of SOA
SOA - The Simplified Model
SOA - The Web Services Model
Composite services using SOA
Organizational approach to SOA
SOA Adapters

Finally, these are the live models that will be implemented -

JNI
Web Services

The presentation has been uploaded here and abstract has been uploaded here.

The Web Services source codes are available here and the JNI source codes are available here.

PHP In GlassFish

2009-01-31T16:31:00.015+05:30

GlassFish is an App Server written in Java. So GlassFish does most of its work with the help of Java Servlets.

GlassFish does not have built-in support for PHP. Actually it can support PHP if a Java implementation of PHP exists for GlassFish. This was made available by Quercus Caucho at http://quercus.caucho.com/. Download the binaries and source of Quercus from the site.

Assuming that GlassFish is installed and its directory path is represented as “glassfish”, proceed with the following steps -

Extract the contents of the archive downloaded from the Quercus Caucho website
Copy quercus.jar, resin-util.jar and script-10.jar from the WEB-INF/lib directory which is obtained from extracting the zip file to glassfish/lib directory
Open the file glassfish/domains/domain1/config/default-web.xml and add the following lines

<servlet>
<servlet-name>Quercus Servlet</servlet-name>
<servlet-class>com.caucho.quercus.servlet.QuercusServlet</servlet-class>
<init-param>
<param-name>ini-file</param-name>
<param-value>WEB-INF/php.ini</param-value>
</init-param>
</servlet>

<servlet-mapping>
<servlet-name>Quercus Servlet</servlet-name>
<url-pattern>*.php</url-pattern>
</servlet-mapping>
Though the above lines of code seem to very complex, they can be simply interpreted as follows -

The first set of code indicates that there is a servlet available under the name Quercus Servlet and the second set of code indicates that the servlet is to be run whenever a file with php extension is encountered

That’s it, restart GlassFish and it should be now be compatible to understand PHP.

Configuring C, C++ In NetBeans 6.5

2009-01-31T16:10:00.014+05:30

In Linux and Solaris NetBeans 6.5 configures itself using the gcc/g++ compiler which is available in several flavors of Linux to run C/C++ programs. However, in Windows, there isn’t any C/C++ compiler pre-installed, so we need to manually install a C/C++ compiler and configure NetBeans 6.5 with the compiler.

To achieve this, we use Cygwin – A Linux like environment for Windows. It contains several popular tools like gcc, g++, gmake, gdb, etc. Cygwin can be downloaded and installed from http://www.cygwin.com/.

Once the setup file is downloaded from the above mentioned site, it can be run as a normal .exe file. Cygwin supports three installation types -

Online installation
Downloading the installation files without actual installation
Offline installation form a local directory

Mention the directory path for the installation files. Also mention the directory where the downloaded files were placed. Offline install requires the packages to be downloaded and stored as a directory. The installer will collect information from the parse-file and list all the packages that are available for install. In online install, this will list all the packages that are available to be downloaded and installed.

The installer will collect information from the parse-file and list all the packages that are available for install. In online install, this will list all the packages that are available to be downloaded and installed. Select the required packages to be installed and proceed. After some time, the installation completes.

Once Cygwin is installed, NetBeans automatically recognizes it and configures its C/C++ compilers. However if it does automatically recognize Cygwin, go to Tools->Options. Under the C/C++ tab, set in the parameters by mentioning the path of the base directory (the bin directory of cygwin), C compiler (gcc), C++ compiler (g++), make command and the gdb command.

That’s all; NetBeans is now configured to run your C/C++ programs.

NetBeans 6.5 Installation

2009-01-31T15:25:00.011+05:30

Installation of NetBeans 6.5 requires Java Development Kit 5 or Java Development Kit 6 as a pre-requisite. You can download the required JDK from http://java.sun.com/javase/downloads/.

The installation procedure of NetBeans is the same in Windows, Linux and Solaris. Since NetBeans is written in Java, it is platform-independent and the installation User-Interface is also same in any operating system. NetBeans 6.5 is available as binaries for all the three Operating Systems – Windows, Linux and Solaris. Download it from http://www.netbeans.org/.

Start the installation by either double-clicking the .exe file in Windows or running the .sh file in Linux and Solaris from the Terminal. This starts the GUI based installation of NetBeans 6.5. Initially it takes a few seconds to configure the installer. The best part of NetBeans is its flexibility. It allows the user to install whatever is required, instead of installing everything. There are few runtimes which are selected by default.

Click on the customize button to select the runtimes which you need. The customize button also gives brief information about each component which is being installed. Also the GlassFish app-server and the Apache Tomcat web-server can also be installed as a part of NetBeans. Accept the license agreement.

Specify the installation directory of NetBeans. Also specify the directory where JDK is installed, the JDK directory is generally recognized by the installer itself. If you customized the installer to install GlassFish v2, the installer will prompt for the required parameters for GlassFish v2. These include the directory path, the admin username and password and the 3 ports – HTTP, HTTPS and admin. All these parameters are initialized to their default values.

Similarly, if you customized the installer for GlassFish v3, specify its directory path. Also, if you customized the installer for Apache Tomcat, specify its directory path.

The installer finally gives a summary of all the components which are to be installed, if you are satisfied with the customized components, start the installation. The installation will take some time depending on your system configuration and the components which are being installed.

Once the installation is complete, the installer will prompt you for registration. It is recommended that users register as there are a lot of offers available for registered users. However the choice of registration is left to the users. That’s it, NetBeans 6.5 is up and ready to use.

Run OpenSolaris 2008.05 In VirtualBox

2009-01-31T12:59:00.018+05:30

This article emphasizes on how to load the OpenSolaris 2008.05 VDI image which was distributed as a part of a resource DVD distributed for college students by Sun Microsystems Inc.

The article is broken down into two parts - Installing VirtualBox and Loading the VDI image in VirtualBox.

Installing VirtualBox

VirtualBox is available in two versions on the resource DVD – 1.6 and 2.0. To install version 1.6 follow these steps -

For Windows go to virtualbox → 1.6 → win32 → (depending on your processor) amd64 / x86
For Linux go to virtualbox → 1.6 → linux → (depending on your linux flavor) select the required package
For Mac OS X go to virtualbox → 1.6 → macosx → run the file present in the directory

To install version 2.0 follow these steps -

For Linux go to virtualbox → 2.0 → linux → (depending on your processor) amd64 / x86
For OpenSolaris go to virtualbox → 2.0 → OpenSolaris → (depending on your processor) amd64 / x86

The installation is simple and is similar to the other software that we generally install.

Configuring OpenSolaris 2008.05 in VirtualBox

Copy the “OpenSolaris_2008.05.vdi.gz” file from the opensolaris directory of the DVD and copy it to your hard-disk (This step isn’t necessary but will reduce the time taken for extraction of the final image).

Extract the contents of the file to a directory of your choice using software like Winzip (or) Winrar (or) IZArc.

You will get an *.vdi image which is nearly 8 GB in size (Caution – make sure your partition isn’t a FAT32 partition, as the extraction will be terminated at around 4GB if it is a FAT32 partition). Start VirtualBox by selecting Start → Programs → Sun xVM VirtualBox → VirtualBox. Select New Icon on the screen, a wizard will open which will guide you through the creation of the virtual Operating System, click on Next.

Type a name for the Operating system; it can be any name, no restrictions. Also select the type of the OS that is being used. In this case OpenSolaris. Specify the memory which you want to provide to the new Operating System. Remember your present Operating System is still running, so split the total available RAM accordingly so that both the Operating systems can work comfortably.

Next you will be prompted for a hard-disk to work with, select existing there. A screen, called the virtual disk manager, will appear where we are supposed to add our OpenSolaris image. Click on “Add”, then browse through the folders and select the *.vdi OpenSolaris image (i.e. the extracted image). A new entry will be in the added in the virtual disk manager. Click on that entry and then click on Select.

The screen will come back to the hard-disk point. Now go to the next step. Finally a consolidated sheet of the selected options will appear. Select “Finish” here. Now as you can see there is a new Operating System waiting, under the name of OpenSolaris. Double click on it to get OpenSolaris working.

PPPOE Internet Configuration For OpenSolaris 2008.05

2009-01-31T10:58:00.013+05:30

One of the first things I had to learn when I moved from Windows to OpenSolaris was to get my Internet up and running. I had an Airtel broadband connection which followed the PPPOE (Point to Point Protocol Over Ethernet) network protocol. I had to experiment a bit and due time got a proper process established for network configuration. So if you are also planning to setup a broadband connection in OpenSolaris, edit the following files accordingly -

/etc/ppp/pppoe.if

INTERFACE
And reboot.

/etc/ppp/peers/ISP

sppptun ( what device to use )
plugin pppoe.so ( initialize the )
connect “usr/lib/inet/pppoec INTERFACE” ( connect string )
persist ( if the connection dies, bring it back )
user “USERNAME” ( username )
noauth ( do not make the other side authenticate itself )
noipdefault ( let them give you what IP they want to give you )
noccp ( no compression )
novj ( no compression )
noaccomp ( no compression )
nopcomp ( no compression )
defaultroute ( add an appropriate default route )
usepeerdns ( for dns )

/etc/ppp/chap-secrets

“USERNAME” * “PASSWORD”
Remember these are tabs and not spaces.

/etc/ppp/pap-secrets

“USERNAME” * “PASSWORD”
Remember these are tabs and not spaces.

Check your work by executing the following command at the terminal -

sppptun query

Sample Output
INTERFACE:pppoe
INTERFACE:pppoed

Execute the following set of commands to finalize the procedure -

rm /etc/resolv.conf ( remove the resolv.conf file from /etc )
link /etc/ppp/resolv.conf /etc/resolv.conf ( instead link the resolv.conf from /etc/ppp to the one in /etc )
vi /etc/nsswitch.conf ( make sure “hosts” and “ipnodes” resolve through “files dns” )

Start the internet connection by the following commands -

/etc/init.d/pppd start
/usr/bin/pppd call ISP

Remember many of these files require root privileges, so login as super user using the su command.

INTERFACE is found out from ifconfig from the terminal. Eg. e100g0
ISP is the service provider you are connected to. Eg. airtel
USERNAME is the user name with which you login. Eg. 04040142943@touchtel.india

Triple Boot A System - Windows, Fedora, OpenSolaris

2008-11-18T22:14:00.012+05:30

Install Windows on the system by creating a primary partition (termed C, also known as hda0 for Linux). Then create an extended partition where you can then split it into logical drives (like D, E, F, etc. - the entire extended primary partition is recognized as hda1 in Linux).

Next Install Fedora 9 taking care that the MBR is installed at the first location of its corresponding drive (hda2, as hda2 is the newly created primary partition).

Note - This is a reference image and the name of the drive, sda1 may vary.

This is taken care during the installation where we have a choice either to install the MBR at the first location of the hard disk, or at the first location of the Fedora partition; select the later
Fedora creates the swap partition also as a primary partition, so avoid swap as Windows can recognize only three primary partitions (Windows C + Fedora hda2 + Fedora swap) and we won’t be left with another primary partition to install OpenSolaris. Else create the swap partition of the Linux as an extended partition
Now don’t get panicked if Fedora doesn’t load, just keep on going because we have not allowed Fedora to update the MBR

Install OpenSolaris 2008.05 on the system, and complete the installation without any hassles on another primary partition (hda3).

Boot the Solaris and got to /rpool/boot/grub/menu.lst, this is a privileged file and it requires to be logged in as the root.

Add these lines to the grub of Solaris at the end of the file -

title Fedora
root(hd0, 2)
chainloader +1

Google Chrome - First Impressions

2008-09-05T19:16:00.013+05:30

As many of you have already heard about it, Google has finally released its own web browser. Google Chrome is a free and open source web browser developed by Google. A Beta version of Chrome was released 3 days ago i.e. on 2nd September 2008. Download It From Here

The Android team of Goggle played a significant role in the development of Chrome. Chrome fared well in Acid1 and Acid2 tests but couldn't clear the Acid3 test and scored an overall rating of 78/100 which is far higher than Internet Explorer 7 and Firefox 3.

Chrome uses the WebKit rendering engine and it was primarily assembled from 26 different code libraries from Google and other third parties such as Netscape.

Well let us see a few important features of Chrome in the following sections

Security

Chrome primarily maintains security in the form of two blacklists - one for phishing and the other for malware. Further each tab in Chrome is sandboxed into its own process to avoid offensive activities of one tab on another, such as a malware in one tab accessing the credit card number in another tab.

A private web browsing feature call Incognito mode is provided as well. This mode prevents the browser from storing any history information or cookies from the websites visited.

Speed

Main focus on speed was made in the JavaScript Virtual Machine. A new engine named the V8 JavaScript Engine was developed with features such as Hidden Class Transitions, Dynamic Code Generation and Precise Garbage Collection.

Tests have shown that with the help of V8 JavaScript Engine Chrome performs faster than all its other competitors.

Stability

Following a lot of study, Chrome was implemented as a multithreaded browser with a multiprocessing architecture. It should be noted that all the existing web browser implementations are inherently single-threaded.

A separate process is allocated for each tab and for each plug-in, so that even if an attacker gains access to one tab, he won’t be able to access the others at once, causing failure to his motives.

However the pop-ups are restricted to their tab scope, they won’t appear outside the tab unless dragged by the user. And a separate process isn't allocated for the popup.

Further Chrome features a process management utility called the Task Manager which allows people to see which websites are using the most memory and identify the plug-ins which are exploiting the system resources. And terminate them if necessary.

User Interface

The main UI consists of the traditional buttons like the back, forward, bookmark, go, refresh and cancel buttons. The Minimize, Maximize and Close buttons look similar to Vista.

The entire UI is based on the WebKit rendering engine with features such as auto complete for the URL box.

Besides these Chrome concentrates on the developer too, with features such as

Show Source - A common utility to show the HTML code of the web page
JavaScript Debugger - Used to debug the JavaScript if any bugs are present
JavaScript Console - A JavaScript console where commands can be written and executed
Task Manager - Shows the allocation of resources

Further movement of tabs between different instances of Chrome is also possible. Of course relative positioning of the tabs is also possible.

Inspect Element

Well this is a feature in Chrome which I found useful being a web developer. Right click any part of the screen and select inspect element, a screen pop-ups called the Inspector with the page layout.

You can explore the CSS, DOM and HTML and other stuffs here. Also, on the lower left corner, there's an icon named Show Console. Click on this and it brings up a console where you can type commands and the DOM elements and nodes and other stuff.

Besides these you can edit the web page offline using the Inspector with a little knowledge of HTML and DOM. Here is a small example where I could change the web page offline using the Inspector.

Chrome has a hidden feature which actually invokes the pipes screensaver present in Windows XP in the web browser. Check it out yourselves by entering about:internets at the URL Box.

Well that’s it. I recommend you to download Chrome and do try it out. It might make an impression on you. And before I end here is the comic book released by Google on its Chrome release.

Will Google Chrome affect the usage of Microsoft Internet Explorer? That's a question we all have to wait and see!!!

Qt - Conclusion

2008-08-05T10:54:00.012+05:30

Strengths of Qt

The resource editor of Qt is very powerful. The message loop of Qt can be coded manually, unlike several other widget toolkits. It has a powerful layout manager to simplify work.

Qt consists of several powerful features such as Controls, XML, Regular Expressions, Platform Independence, Template classes, memory management, Network API, Database API, OpenGL API. It also has a very good documentation, both online and offline.

Future of Qt

Qt aims at further simplification of UI designing for various platforms. It is now concentrating on extending itself to embedded systems such as mobile phones and PDAs.

Better services are expected for music, video, television, imaging, games and business mobility for mobile devices with the help of Qt. Better cross-platform independence is to be achieved and further extension of Qt into other languages is expected.

Qt Designer

Qt Designer is a GUI based Qt programming tool to make UI programming simpler. It is based on the concept of dialogs which is further built on XML.

Several looks can be previewed using it like Motif, Windows, etc. Simplifies the concept of Signals And Slots using GUI. Supports creation of complex widgets and user-defined slots.

Download the entire presentation here.

Code Less ...
Create More ...
Deploy Everywhere ...

Qt - Gaming In Qt

2008-08-05T10:32:00.011+05:30

The previous article covered a simple GUI application, let’s extend this concept to a game, written completely in Qt. Here is the screen-shot of the game. This game is popularly known as "Pocket Tanks" in the gaming market.

I won’t be explaining the entire code here, but let me give you a description about it. Like before, lets first split the entire setup into simpler components.

Three buttons – Quit, Shoot, New Game
Two LCD Numbers – Hits, Shots Left
Two LCD Numbers connected to sliders – Angle, Force
A Screen consisting of a cannon, wall and a brick

Download the source here.

First let’s construct the complex widget – LCD Range where a LCD Number is connected to a slider. A LCD Number is created and a slider is also created with specifying a certain range. These two are connected by generating a signal from slider that the value has changed to the LCD Number slot display.

Two of these complex widgets are created – Angle and Force.

Now let’s design the gaming area itself. Here we will be using a very powerful tool known as the QPainter. It provides us with tool for drawing almost anything, lines, arcs, circles, etc.

The wall and the brick are rectangles each with their own dimensions and color. Now comes the cannon, we use a circle here with a rectangle covering a part of it corresponding to the angle. As the angle varies, the position of the rectangle will also vary. Also the brick is placed at a random to make the game more challenging.

Once the UI is done the next step is building the AI (Artificial Intelligence) for the game. Going back to physics, for a body projected at a certain angle, the following formulae exist

Vx = V * cos(angle)
Vy = V * sin(angle)
X = x + Vx*t
Y = y + Vy*t – ½*g*t*t

where,

Vx – starting velocity in x- direction
Vy – starting velocity in y- direction
X – position in x direction of the cannon-ball after a time t from firing
Y – position in y direction of the cannon-ball after a time t from firing
g – acceleration due to gravity

Now these objects are placed properly and set as the main widget to the application. Compile it and run it. That’s it, happy gaming.

Qt - A Simple Example

2008-08-05T10:12:00.013+05:30

Enough of the theory; let’s get into the action. Here is a sample window which will take a name and displaying a message. Before we get into the coding part, it is more important to analyze how the window works.

Basically this window can be broken down into 4 components

A Text Label
A Text Field
A Button
A Message Box

Now let’s see how the system works. A user keys in his name, then clicks the button, once the button is clicked a message box appears which reads from the text field and displays a message. Download the source from here.

Primarily an application is created from the QApplication class, and then a complex widget is created and assigned as the main widget of the application and then is displayed after resizing it.

As there are many simple widgets in the application, a complex widget is created from them, and then set to the application. Here the class ComplexBox represents the complex widget. Remember every widget is derived from the QWidget class.

Firstly the components are to be created and then placed on the screen; this is done by using a layout, namely the grid layout. Where the component is placed based on the co-ordinates of the layout. For example the text label is placed at position (1, 1) extending to (1, 2), that is it occupies 2 columns and 1 row starting from (1,1). Similarly all the other components are placed.

Next we have the inter-actions between various components. As we can see, clicking the button leads to display of the message. This is the perfect situation of an action listener; this is implemented in Qt by a signal-slot relationship. The signal and the slot are primarily functions. Here the signal is generated by a pre-defined signal called the clicked() of the button, as a result an action is performed by the call() slot of the ComplexBox object itself. As seen the slot is declared in the header.

That’s it; our first Qt program is over. Run these commands to compile it

qmake –project
qmake
make
./dir-name

Qt - Programming In Qt

2008-08-05T09:43:00.005+05:30

The primary prerequisite of learning Qt is C++. As already stated that Qt builds on the libraries of C++, it is vital to know the concepts of C++ like classes; private, protected and public members; inheritance, etc.

Like any traditional C++ program, the execution of a Qt program also starts from the function main(). A few enhancements do exist for Qt such as Signals And Slots. These are primarily responsible to establish connectivity between various widgets of the application.

Every Qt program consists of an application and several widgets built inside it.

Main Classes of Qt

Qt is based on widgets and intercommunication. A widget is any component with which a user can interact. It can be a button, a text box, anything. Complex widgets can be created from simpler ones.

Like any GUI toolkit, even Qt has several predefined widgets, namely QPushButton, QRadioButton, QCheckBox, QLabel, QLineEdit, QLCDNumber, QSlider, etc.

An entire list of Qt classes can be found in the help documentation of Qt, under the section Qt’s classes.

Writing A Program

The primary steps to be followed while writing a program are

Define the problem properly
Make sure what the widgets used will be, and how they are interconnected

Every Qt program is an application and is created from QApplication class. Further widgets are created and are attached to this application. And later the application is displayed. Generally simpler widgets are combined to form a complex widget, which is then used in the program.

Qt - Introduction To KDE

2008-08-05T09:34:00.007+05:30

KDE stands for K Desktop Environment. Qt can be significantly experienced on a KDE desktop. The Qt toolkit was used for the KDE project. Every window available on the KDE desktop is a part of the Qt design.

Actually KDE is primarily built on several technologies such as

KHTML- an HTML engine
Plasma - desktop and panel widget engine
Phonon - multimedia framework
Solid - device integration framework

On top of this the entire UI is built on the technology of KDELibs, which is in turn built on Qt.

Qt - Introduction And Working

2008-08-05T09:16:00.007+05:30

Qt is a cross-platform application development framework, widely used for the development of GUI and non-GUI programs. Originally Qt was developed by a Norwegian company, Trolltech. It is presently being acquired by Nokia.

Examples of GUI applications using Qt are the VLC Media Player, Opera, Adobe Photoshop Album, Google Earth, Mathematica, etc. Non GUI applications include console tools and servers.

Qt is primarily based on C++ with several non-standard extensions. That is Qt was built by modifying the traditional C++ so as to achieve easier GUI programming. It uses an additional preprocessor that converts this code into standard C++ code before compilation.

Notably, Qt isn’t restricted to UNIX, it is also extended to various platforms such as Windows (98, NT, ME, 2000), Macintosh (Mac OS X). Further, Qt can be used in several programming languages such as Ada (QtAda), C# (Qyoto), Java (Qt Jambi), Ruby (RubyQt) and several others. Qt is also available for embedded systems such as cell-phones, PDA’s and others under the name of Qtopia.

Coming to the working of Qt, Qt uses the native APIs of the underlying platform so as to draw the Qt controls, achieving platform independence. It also offers SQL database access, XML parsing and threads management.

Further a new concept was introduced to C++ on a whole, which was that of intercommunication, under the name of Signals and Slots. This was possible with a tool known as the Meta Object Compiler. This tool handles the mechanism of signals and slots, run-time type information and dynamic property system. However this concept has been greatly criticized for the absence of type safety.

Qt - UI (User-Interface) Designing

2008-08-05T08:58:00.007+05:30

Technically UI design refers to the design of computers, applications and websites with the focus on the users experience and interaction. There are several tools for UI design.

Windows API specific to only Microsoft Windows. This is achieved by primarily including “windows.h” and using its functions to create windows
Java and Swing. The Swing package of Java can be used to create any UI required. However the entire Swing package is based on Java, and to run any of these windows, a JVM is required

Coming to UNIX, several toolkits have been designed for the X Window System. The most popular of them being -

GTK+, standing for “The GIMP Toolkit” – Examples of applications using this is the GIMP, Terminal and others
Qt, pronounced as cute

The KDE desktop environment is built on Qt. And the GNOME (GNU Object Model Environment) desktop environment is built on GTK+.

VirtualBox

2008-07-23T01:07:00.015+05:30

VirtualBox is an x86 virtualization package originally created by Innotek, and now being developed by Sun Microsystems.

VirtualBox helps us to load and run an operating system on an existing operating system. The operating system on which VirtualBox is installed is called the host OS, and the OS running on the host with the help of VirtualBox is called the guest.

For example, consider a machine with the Windows XP operating system loaded on it, VirtualBox can be installed on this, and another OS, such as Fedora or Solaris can be loaded via the VirtualBox. Here Windows XP is the host OS and the other OS (Fedora, Solaris) becomes the guest.

A free copy of VirtualBox can be downloaded from here.

Further VirtualBox manages the guest OS on the host OS using the concept of a Virtual Machine. Well here comes the tricky part, any OS requires primarily three things.

A Processor to run the various tasks
A memory unit, commonly known as the RAM
Some storage space, basically available on the hard disk

Whenever a guest OS is installed on a host, the VirtualBox takes care that the guest receives these three resources whenever the OS runs.

VirtualBox manages the processor, without any user-interference, however coming to the RAM and the Storage Space, user discretion is required, as we will be seeing a little latter.

Steps for starting up a virtual OS

Create a new VM using Machine->New or the New icon available on the screen.

Follow the wizard, which will be first asking for the name and type of the OS being installed, this will entirely depend on guest OS which you will be installing.

Next the amount of RAM to be reserved for the operating system will be asked, this will depend on your machine and how much you would like to spare.

Remember! The RAM which is reserved here will not be available to the host, when the guest is running. That is if you reserve 512 MB from a 2 GB RAM, the available RAM to the host will be only 1.5 GB as long as the guest is running, however this will be returned once the guest is closed.

Caution!!! Your host will also be requiring memory while the guest is running, never lower the RAM for the host significantly, this will lead to insufficient memory for the host, and as a result it might lead to errors.

Now comes the best part that VirtualBox has to offer. It allows us to create a virtual hard-disk, more specifically reserve some space on our hard-disk for the guest OS. Here an *.vdi image will be created at the specified place.

Here an existing *.vdi can be mounted by clicking the Existing button and then adding it to the list via the Add button and then Select it.

Or a new *.vdi image can be created by clicking the New button. The wizard will ask you whether a static image or a dynamic image is to be created. A static image is one where the entire memory is allocated at one go, whereas on the other a dynamic image is one where a maximum amount is specified, but the size increases as the data is added onto the guest OS. For example consider 25 GB is allocated for the guest. In static the entire 25 GB will be a single *.vdi image, where as in dynamic the basic installation will take some space, and latter as files are added the size will increase.

And don’t forget to mention where you want the image to be, otherwise it will written onto a default directory. Here dynamic memory occupies only required amount of space, and is beneficial if you a normal user and if you are not sure how much you will using, as the host will lose the space which is not being used by the guest if created statically.

Once you finish this you will taken back with the new hard-disk selected. Finally click Finish, and you will be able to see your image on the left-hand side of the screen. Now right-click the image on the left and select Start, or left-click and click the Start button.

Next it will ask you for the media type, where you can you either give an *.iso image or a CD/DVD/Floppy to load from. And then continue the regular process of installing the Operating System.

Once the installation is completed, you can turn on the guest OS by starting it as told above, and shut it down normally as done in that OS.

Important Tips after Installation

Once the VM is setup, the RAM occupied can be changed by right-clicking the image on the left hand side, and selecting Settings and changing the RAM accordingly. You can change the focus of the mouse and the sensitivity of the keyboard from the guest to the host by using the right-ctrl key.

The next important thing is to establish a connection between the guest and the host. This is done primarily by creating a shared folder. Before we create a shared folder, certain software called the VBoxGuestAdditions is to be installed. This is done by starting the OS, Devices->Mount CD/DVD-ROM and select VBoxGuestAdditions from the drop down menu, it is present there by default, otherwise search for it on your host. Immediately you will a CD available on your guest and install the appropriate executable for your guest. Next go to Devices->Shared Folder, add the folder to be shared between the guest and host to the machine folders. Then click Ok. That’s it, a shared folder is created. Search for it on your guest and you will find it in no time. For Example a shared folder in a UNIX type OS will be available in /mnt of the root. However this might vary from guest to guest.

Another way of achieving connectivity is via a pen drive. Once the pen drive is connected it will be automatically detected by the host. To gain access of the USB drive from the host, firstly go to the Settings menu of your guest OS. There from the USB tab Enable USB Controller. Now filters may be added for easy recognition of the USB drive. Now start the VM. From the Devices->USB menu, select the required USB drive, the required drivers will be installed on the host the first time it is done, and the USB drive will be available on the guest after some time. The USB drive may be removed from the guest by going back to Devices->USB and deselecting the USB.

I think these points are sufficient for a beginner to VirtualBox, however more advanced features can be easily explored by putting in a little effort.

Java 2 Micro Edition - Conclusion

2008-06-10T17:18:00.003+05:30

The Good

J2ME is small, actually very small; writing programs for devices with very limited memory capabilities has been made into a reality by J2ME. J2ME allows the programmer to customize his program to the utmost possibility, right from the configuration he wants to work with to the very profile he is using.

Further, the future versions of the KVM will have the capabilities of integrating the present programs with further memory hungry operations.

The Bad

The very strength of J2ME is its biggest weakness. In order to make the KVM small, a lot of compromises had to be made in the Java language itself. Writing complex programs for J2ME requires higher skill and technique than writing one for computers and servers.

Further because of the configurations and profiles, the basic fundamental principle of portability had to be compromised. That is, a program written for a particular profile is portable with other devices following the same profile.

Future Of J2ME

J2ME is still in its blooming stages, and definitely the platform will be evolving. Many more configurations and profiles will be introduced. Further several technologies, such as Jini (network architecture for distributed systems), will arise with the help of J2ME, improving the capabilities of the mobile devices. Needless to say there will be many more devices following the J2ME technology in future.

Java 2 Micro Edition - Case Study

2008-06-10T17:00:00.018+05:30

Extending one’s knowledge of Java to J2ME is very easy. Every program in J2ME is called a midlet and extends from the midlet class. Here is a sample program in NetBeans using the CLDC configuration and the MIDP 2.0 profile.

As evident from the screen-shots, the constructors in both the programs are very much similar. A few differences exist in the both such as the import statements in J2ME where two packages - midlet and lcdui are imported. Further an alert object is constructed to display the message.

Three important functions are present in every J2ME program. They are -

startApp	Called whenever the application is started
pauseApp	Called whenever the application is paused
destroyApp	Called whenever the application is terminated

Java 2 Micro Edition - Profiles

2008-06-10T16:49:00.005+05:30

A Profile primarily defines the type of device supported. Profiles are built on top of configurations, since they are specific to the memory available. They add an additional layer on the top of the configuration layer providing APIs for a specific class of devices.

Profiles are specific to the configurations selected. For different configurations, different profiles are available.

CDC Configuration

For CDC configuration, a foundation profile is available, which is primarily a skeleton profile over which we can create our own profile.

CLDC Configuration - MIDP, KJava And Doja

For the CLDC configuration, predefined profiles such as MIDP, KJava and Doja are available. The KJava profile is one of the popular profiles for the Palm OS. It consists of Sun specific APIs. Further it's not a standard J2ME profile.

The Doja profile is another popular profile, though not widely used in our mobiles; it is a rapidly growing profile, because of its simple user interface and as it easy to understand. This profile is popularly used in Japan for their local cellular phone companies. However its influence on the entire mobile network is still a long way ahead.

The most popular profile used these days in the Mobile Information Device Profile (MIDP). It is mainly based on the CLDC configuration and is widely used in cellular phones and pagers. Currently there are two versions of MIDP that are available for programming - MIDP 1.0 and MIDP 2.0. Mainly the differences between these two profiles are the fact that the MIDP 2.0 has extended features when compared to MIDP 1.0 such as audio and 2D gaming. On the other hand MIDP 1.0 has greater portability when compared to MIDP 2.0. Many of the cellular phone brands such as Nokia, LG, Samsung, and Motorola use these profiles.

Java 2 Micro Edition - Configurations

2008-06-10T16:40:00.004+05:30

Configurations define the basic run-time environment as a set of core classes. They add the classes required for the program to be compatible with the virtual machine.

J2ME has two main configurations – Connected Limited Device Configuration (CLDC) and Connected Device Configuration (CDC). These configurations actually specify the main type of the device, which defines how much memory is available for the operations to be performed.

CLDC requires less memory whereas CDC requires at least 2MB of memory to perform its computations. The CLDC configuration consists of classes and a set of libraries more specific to the mobile devices. The CDC configuration is basically a stripped down version of J2SE with the CLDC classes added to this.

The CLDC configuration is supported by KVM and the CDC configuration is supported by CVM. Configurations decide whether optional features such as multi dimensional arrays, threads, JNI and others have to be included or not.

CLDC configuration is used when the memory available is low, such as the case of PDAs and cell phones. CDC configuration is used when the memory available is more than 2MB but less than that available on our computers, such as the case of set-top boxes.

Java 2 Micro Edition - Virtual Machines

2008-06-10T16:34:00.003+05:30

A virtual machine is the immediate layer overlying the operating system and is mainly responsible for running any program written in Java. This is the main reason that codes written in Java are highly portable. The virtual machine interprets the Java byte-code and converts into native system calls. Further as every program runs in the confinement of the virtual machine, no penetration is possible into the operation system, reducing the risk of viruses.

J2ME offers two different virtual machines, namely CVM (for higher end mobile devices) and KVM (for lower end mobile devices). CVM is used for devices which have higher memory capabilities and which are closer to computers whereas KVM is used for devices which have lower memory capabilities, such as mobile phones. KVM and CVM are primarily nothing but the subset of JVM. They can be thought as just shrunken versions of the JVM and are more specific to J2ME.

Java 2 Micro Edition - An Overview

2008-06-10T16:02:00.010+05:30

Mobile devices have become a part and parcel of almost everybody’s life. By mobile devices, we don’t mean just our cell phones, but also devices such as pagers, personal digital assistants (PDA’s) and small retail terminals (devices such as set-top boxes).

To use these devices more effectively and more efficiently, programming was introduced into these devices. Every mobile device has a basic operating system which co-ordinates the various tasks to be performed by the device itself. Examples of these operating systems are the Symbian operating system, Windows operating system, Linux operating systems and many others. Many of the primitive models had a PROM built in them, instead of an operating system, so as to start the mobile device without any hassles.

Different file formats have been developed for these mobile devices. Many of these are basic extensions of a high level language so as to perform properly even at the availability of less memory. Examples of this are the *.sis and *.sisx file formats which are basic extensions of C, *.jar and *.jad which are basic extensions of the Java 2 Standard Edition.

Bringing J2ME Into The Picture

One of the popular languages used in the development of these mobile programs is Java, more specifically the Micro Edition of Java called J2ME. As known, Java is divided into three segments J2SE, J2EE and J2ME, while the former two are used for servers and higher end computers, J2ME is used for mobile devices.

At first J2ME was intended as a platform for game development, but now-a-days J2ME is used for developing almost every kind of application. Following the fundamental principle of Java, J2ME also follows the principle of "Write Once Run Anywhere (WORA)" to a large extent. Also the security of these programs is high as it runs in the confinement of the virtual machine itself. Further the possible users of this technology are estimated to be very high, making it popular as a whole.

J2ME Architecture

J2ME runs mainly on virtual machines, which actually runs the Java byte code on the device. Before the implementation of any byte code, every program written in J2ME should specify its configuration and its profile. They are layers immediately above the virtual machine layer, as shown in the figure. These layers form the very bone structure of the J2ME program and selecting these layers properly in the key of writing a suitable program for a particular device. The first and foremost layer is the Operating System layer which co-ordinates the tasks of the entire device itself.

Hidden Files Not Shown

2007-10-03T20:03:00.002+05:30

This is another problem associated with the w32.USBWorm seen in the previous post. Sometimes this problem occurs even independently, without any association to the mentioned virus. This is basically due to a wrong registry key value.

The following steps have to be taken so as to restore hidden files and folders.

Go to Start --> Run, then type Regedit
Navigate to the registry folder HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Folder\Hidden\SHOWALL
Find a key called ChekedValue
Double click CheckedValue key and modify it to 1. This is to show all the hidden files

Now you should be able to view all the hidden files, and also to alter its status from folder options.

Removing Orkut Hater - w32.USBWorm

2007-10-03T19:53:00.007+05:30

I don't hate Mozilla but use IE or else
Use Internet Explorer U Dope
Orkut is banned you fool, The administrators didn't write this program guess who did?? MUHAHAHA!!

These are not any statements to encourage the use of IE or defame Orkut, but the indications of a virus infected machine, yes Virus. This virus is basically a malware named as w32.USBWorm and spreads primarily through pen drives. Well on the brighter side, this virus is a decent one and does not affect any of your files or damage your system.

Now coming to its removal, unfortunately many of the anti-virus software today are not in a position to detect this virus. So it has to be removed manually, the following steps have to be followed for its removal,

Press CTRL+ALT+DEL and go to processes tab
Look for svchost.exe under the image name. There will be many but look for the ones which have your username under the username
Press DEL to kill these files. It will give you a warning, Press yes
Repeat for more svchost.exe files with your username and repeat. Do not kill svchost.exe with system, local service or network service!
Now open My Computer
In the address bar, type C:\heap41a and press enter. It is a hidden folder, and is not visible by default
Delete all files here
Now go to Start --> Run and type Regedit
Go to the menu Edit --> Find
Type "heap41a" here and press enter. You will get something like this "[winlogon] C:\heap41a\svchost.exe C:\heap(some number)\std.txt"
Select that and Press DEL. It will ask "Are you sure you want to delete this value", click Yes
Now close the registry editor

Now the virus is gone. But be sure to delete the autorun.inf file and any folder whose name ends with .exe in the pen drive.

Download Your Favorite Videos

2007-07-05T17:07:00.002+05:30

Every day, we see thousands of videos being uploaded in many of the video hosting sites like Dailymotion, Youtube, Veoh. These sites are very interesting as there is something in every genre - Science and Technology, Gaming, Music.

In fact any video can be found with a proper search. However a small problem exists with these videos, they can be seen but cannot be downloaded straight from the website as there is no download facility in most of these sites. So the storage of our favorite videos is not possible. But as usual, there is always a solution to a problem.

Let me explain this with an example. Consider this video, It is from Dailymotion from the games genre. It is the preview of the latest Need For Speed game - The Prostreet (I know I can embed the video here, but I want you to go to the original site).

Now, you can see the video being buffered so that it can be viewed; scroll down a bit in the page. Here two important links will be given. One is the permanent link and the other is the embeddable player. The embeddable player code can be copied into an html page for the video to be embedded onto the webpage. However we are aiming to save it on our system. This is now possible with a few websites that help us to download video content. A few of them are KeepVid, ClipNabber.

Consider I am downloading from ClipNabber. I paste the permanent link in the space given there, which is right below the logo and click the download button. Now scroll on the same page a bit, and just after the logo you will find a "download link" button. Click on that and select save, select the folder where it is required and the job is done. The video will be stored in the computer. Whatever maybe the format of the downloaded video, change the extension of the file to .flv. You will need Flash Player to play files with this format.

Better players can be found with a little bit effort. The beauty of the flv format is its small size, that is in this example 45 seconds of video was only of about 1.5 MB, which is very less when compared to other formats. This video can be converted into other formats with the help of video converters also if required.

This solves a large part of our initial problem, but not the entire problem. That is because this works with videos that are available directly without any registration. Now what if a registration is required, we cannot use any of these sites for download. Generally registration is required for some websites and a few videos of the above-mentioned sites. However this problem was solved by the latest version of Real Player that was released. This player can download video that can be watched by us. For example, if there was a video which can viewed only after registering, all we have to do is register and go to the video, immediately a small pop up will appear above the video saying "Download this video using Real Player". Click on this and the video will be downloaded on to the system. However Real Player 11 is still a beta version and its limitations cannot be told yet.

Before I conclude this article, I would like people to know that this article is not for supporting piracy, but only for videos which have proper rights. After all an original will always be an original.

Have fun!

Thermoelectric Power

2007-05-12T18:28:00.006+05:30

The Seebeck Effect is the conversion of temperature differences directly into electricity. In other words, it is the generation of electricity in a circuit containing two different metals, or semiconductors, by keeping the junctions between them at different temperatures. This effect is due to two effects - Charge Carrier Diffusion and Phonon Drag. This principle is used in thermal diodes and thermoelectric generators.

The Seebeck Voltage is the voltage produced between the two junctions of a ferrite material, when they are maintained at two different temperatures. This voltage is produced due to the fact that when two junctions are two different temperatures, the majority charge carriers (holes/electrons) are diffused from the surface having high temperature to a surface having relatively low temperature.

This voltage can be mathematically expressed as V = (integral)(T1 to T2) [SB(T) - SA(T)]dT where SA and SB are Seebeck coefficients of two different metals A and B, T1 and T2 are temperatures of hot and cold junctions. Generally, V = (SB - SA)(T2 - T1).

The term Thermoelectric Power is a misnomer since it measures the voltage in response to temperature rather than power. It is also known as Seebeck coefficient. It is defined as the open circuit voltage produced between two points on a conductor, where a uniform temperature difference of 1K exists between those points. It is a measure of the magnitude of an induced thermoelectric voltage in response to a temperature difference across that material. It has units of V/K. It is also a measure of entropy per charge carrier in the material.

Mathematically it is represented as S = Thermoelectric Voltage / Temperature Difference. In terms of electric field, it is written as S = E / Temperature Gradient. If m is the Thompson coefficient of an material, then S = (integral) [m / T]dT.

Thermoelectric power determines the efficiency of a thermoelectric material. More the Seebeck coefficient better is the efficiency. Materials with high Seebeck coefficient are Bismuth Telluride and Uranium Dioxide.

One of the important applications of Seebeck coefficient is the determination of Fermi Energy Gap. For a n-type semiconductor, QT = Eg - Ef + 2KT and for a p-type semiconductor, QT = Ef - 2KT where,
Q - Seebeck coefficient
Eg - Energy gap of the ferrite semiconductor
Ef - Height of fermi energy level from the top of the filled valency band
2KT - the term, which accounts for the transfer of KE of the ferrite to a cold one

For certain materials, the conduction takes place in exceedingly narrow bands or in localized levels, so the KE term can be neglected, so for a n-type semiconductor, Ef = Eg - QT and for a p-type semiconductor, Ef = QT.

Another important application of the Seeback coefficient is the determination of Carrier Concentration. In the case of low mobility semiconductors such as ferrites, the activation energy is often associated with the mobility of charge carriers. They are considered as localized at the ions or vacant sites and the conduction occurs via a hopping type process, which implies a thermally activated electronic mobility. In such cases, it is appropriate to consider small polarons as charge carriers rather than electrons or holes. Further, it is known that the concentration (n) is given by Q = - (K/e) [ lnb(N-n)/n + St/K ] where,
St - Entropy transport term, which is negligible for ferrite materials
N - density of states or number of available sites
K - Boltzmann constant
e - electronic charge
b - degeneracy factor which includes both spin and orbital degeneracy and its value is taken as 1

Considering n << N, we can reduce the above formula to n = N exp (Q e/K). If V is the volume of the sample and the value of K/e is found to be 86.4, so we get n = N/V exp (Q / 86.4). In the case of ferrites having exceedingly narrow bands or localized levels, the value of N, the density of states can be taken as 10^(22) cm^(-3).

In the case of n-type semiconductor material, the hot junction becomes positively charged, as it loses some of its electrons. The cold surface of the semi conductor becomes negatively charged due to the diffusion of free electrons from the hot portion. Conversely in a p-type semiconductor, the hot surface becomes negative, and the cold one positive. Thus the type of conduction in a given semi conducting material can be determined from the sign of the thermo emf.

Solar Cells

2007-04-22T21:40:00.001+05:30

A solar cell or photovoltaic cell is a device that converts light energy into electrical energy. Sometimes the term solar cell is reserved for devices intended specifically to capture energy from sunlight, while the term photovoltaic cell is used when the light source is unspecified.

Fundamentally, the device needs to fulfill only two functions - Photogeneration of Charge Carriers (electrons and holes) in a light-absorbing material, and Separation of the Charge Carriers to a conductive contact that will transmit the electricity. This conversion is called the photovoltaic effect, and the field of research related to solar cells is known as photovoltaics.

Solar cells have many applications. They have long been used in situations where electrical power from the grid is unavailable, such as in remote area power systems, Earth-orbiting satellites and space probes, consumer systems, e.g. handheld calculators or wrist watches, remote radiotelephones and water pumping applications. More recently, they are starting to be used in assemblies of solar modules (photovoltaic arrays) connected to the electricity grid through an inverter, often in combination with a net metering arrangement. Solar cells are regarded as one of the key technologies towards a sustainable energy supply.

Thin-film solar cells use less than 1% of the raw material (silicon or other light absorbers) compared to wafer based solar cells, leading to a significant price drop per kWh. There are many research groups around the world actively researching different thin-film approaches and/or materials, however it remains to be seen if these solutions can generate the same space-efficiency as traditional silicon processing.

One particularly promising technology is crystalline silicon thin films on glass substrates. This technology makes use of the advantages of crystalline silicon as a solar cell material, with the cost savings of using a thin-film approach. Another interesting aspect of thin-film solar cells is the possibility to deposit the cells on all kind of materials, including flexible substrates (PET, for example), which opens a new dimension for new applications.

Gas Sensors

2007-04-22T21:20:00.001+05:30

Gas sensors interact with a gas to initiate the measurement of its concentration. The gas sensor then provides output to a gas instrument to display the measurements. Common gases measured by gas sensors include Ammonia, Aerosols, Arsine, Bromine, Carbon Dioxide, Carbon Monoxide, Chlorine, Chlorine Dioxide, Diborane, Dust, Fluorine, Germane, Halocarbons or Refrigerants, Hydrocarbons, Hydrogen, Hydrogen Chloride, Hydrogen Cyanide, Hydrogen Fluoride, Hydrogen Selenide, Hydrogen Sulfide, Mercury Vapor, Nitrogen Dioxide, Nitrogen Oxides, Nitric Oxide, Organic Solvents, Oxygen, Ozone, Phosphine, Silane, Sulfur Dioxide, and Water Vapour.

Important measurement specifications to consider when looking for gas sensors include the response time, the distance, and the flow rate. The response time is the amount of time required from the initial contact with the gas to the sensors processing of the signal. Distance is the maximum distance from the leak or gas source that the sensor can detect gases. The flow rate is the necessary flow rate of air or gas across the gas sensor to produce a signal.

Gas sensors can output a measurement of the gases detected in a number of ways. These include percent LEL, percent volume, trace, leakage, consumption, density, and signature or spectra. The lower explosive limit (LEL) or lower flammable limit (LFL) of a combustible gas is defined as the smallest amount of the gas that will support a self-propagating flame when mixed with air (or oxygen) and ignited. In gas-detection systems, the amount of gas present is specified in terms of % LEL: 0% LEL being a combustible gas-free atmosphere and 100% LEL being an atmosphere in which the gas is at its lower flammable limit. The relationship between % LEL and % by volume differs from gas to gas. Also called volume percent or percent by volume, percent volume is typically only used for mixtures of liquids. Percent by volume is simply the volume of the solute divided by the sum of the volumes of the other components multiplied by 100%. Trace gas sensors given in units of concentration: ppm. Leakage is given as a flow rate like ml/min. Consumption may also be called respiration. Given in units of ml/L/hr. Density measurements are given in units of density: mg/m^3. A signature or spectra measurement is a spectral signature of the gases present; the output is often a chromatogram.

Common outputs from gas sensors include analog voltage, pulse signals, analog currents and switch or relays. Operating parameters to consider for gas sensors include operating temperature and operating humidity.

Copper Oxide (CuO) thin films were deposited using a reactive DC sputtering method for gas sensor applications. The structure of the films determined by means of an X-Ray diffraction method indicates that the phase of Copper Oxide can be synthesized in the total pressure and temperature ranges of 6-8.5 mbar and 151-192 °C, respectively. The resistivity of the film synthesized at a substrate temperature of 192 °C increases from 0.104 to 0.51 Ohm-m after absorbing Carbon Dioxide gas at 135 °C. The gas sensitivity of the film synthesized at the substrate temperature of 192 °C increases up to 5.1 in the presence of Carbon Dioxide gas at 160 °C. The gas sensitivity in the presence of Nitrogen gas reaches only 1.43 even at 200 °C.

Indian Movies At Oscars - Case Studies

2007-03-27T17:29:00.004+05:30

In the previous articles we have discussed the Expectations, Causes of Failure and the Importance of Oscars. This post covers a few case studies, which could not make a successful performance at the Oscars in the past.

Mother India (1957)

Produced and Directed by Mehboob Khan, Mother India is perhaps the ultimate tribute to womanhood. Why Mother India couldn't make it at the Oscars -

The length of the movie
Apartheid was on a high during that time, which might have been another cause of failure

Salaam Bombay! (1988)

Produced and Directed by Mira Nair, Salaam Bombay chronicles the day-to-day life of children living on the streets of Mumbai. All the children acting in the movie were real street children, given proper training for the movie. Why Salaam Bombay! couldn't make it at the Oscars -

The cast was totally unknown
The movie was not properly marketed, especially in India, which retarded it's promotion in the Oscars

Lagaan: Once Upon A Time In India (2001)

Produced by Aamir Khan and directed by Ashutosh Gowariker, Lagaan is probably one of India's finest movie, mixing the British rule with Cricket. Though it was a splendid movie, it lost to “No Man’s Land”, dealing with two wounded soldiers caught in the no man’s land. Why Lagaan couldn't make it at the Oscars -

The movie was taken at a time when the British ruled India; the movie had nothing to do with the present times, which became a important cause of its failure

Rang De Basanti (2006)

Though this movie was not even nominated to the Oscars, let us even consider why it could not succeed. Produced and Directed by Rakeysh Omprakash Mehta, Rang De Basanti is one of the movies, which inspired the youth of the country to a large extent. The entire movie moves in and out of the time of freedom struggle and portraits many freedom fighters. Why Rang De Basanti couldn't make it at the Oscars -

As already said, the movie moves in and out of the past. Though the concept was good, it created a huge confusion among the viewers at times, which as a result led to its failure

These were a few movies that we can discuss now, though there are other movies still left for discussion, there's no point in doing that now. Let's move ahead and hope that we can create a movie that will put the Indian culture in front of the world, and thus succeed in getting an Oscar.

Indian Movies At Oscars - Importance Of Oscars

2007-03-27T17:12:00.002+05:30

What makes Oscars important for Indian movies?

To achieve international appreciation
To increase the market of Indian films worldwide
As we deserve it

We all know that winning an academy award is nothing but achieving international appreciation so it’s important for us to win it to prove ourselves.

And by winning this award the range of market, for our films increases, which make the film, do well at box office. And this means the producer wouldn’t be at loss due to the lack of non-commercial elements in his movie.

The important thing is that we deserve the academy award for our films, there is no doubt that some discrimination towards Indian films exists otherwise it’s ridiculous that we haven’t won it till now even though decades have passed since its inception.

Do we really need an Academy award?

As it’s just a normal award like any other
As we have a national award which is more important
As we already have a huge market for our films in abroad

We unnecessarily think about an award which is not for us and not given by someone who could understand our culture, emotions and feelings so why should we give it importance moreover we have won lots of appreciation for our films in other film festivals like Cannes film festival.

We do have a national award, which is more important for us, rather than a award which doesn’t belong to us. As many of Indian people are staying abroad, because of them there is already a huge market existing worldwide for Indian movies this is the reason for Indian movies doing well at abroad.

Does the hype created by media for Oscar’s necessary?

Every year when the ad’s for Oscars starts in television channels the media starts creating hype for it and gives it more importance than our national awards. They never telecast the national awards ceremony but they do it for academy awards. It’s the media, which is creating an unnecessary discussion about the awards and they even mention every time that we weren’t nominated even after knowing the reasons.

Indian Movies At Oscars - Causes Of Failure

2007-03-27T17:00:00.003+05:30

Politics in Indian selection committee
Differences between local film industries here
A good number of films being produced yearly
Most of the movies being the remakes of English ones
Less number of movies produced for the sake of human values

To explain the above terms briefly, let’s talk about the politics in Indian selection, we actually have a selection committee in India to select a movie among the Indian movies to send as the Indian entry to the Oscars. The committee consists of the members coming from different territories of India and they support the films of their region without looking for standards and the film from a region with more number of members will be selected irrespective of the standards. Due to this reason the film "Water" has been nominated for Oscars as a Canadian entry though being an Indian film.

Differences between the Indian film industries imply that we have many languages here in our country and each language has its own film industry. Most of the people abroad think that Indian films implies Hindi films but the actual fact is we have here films being produced in more than 25 languages and equal importance not being given to the films of all languages, every year it’s only a Hindi film that’s being selected as the Indian entry.

Yearly thousands of films are being produced in India and not even one film is being nominated for Oscars. Our films are not nominated at least for alternate years or at least for once in five years. From this we can understand the standard of our film making.

Another main reason is that famous English flicks inspire many of our films. Many of the Indian movies suffer the tag of plagiarism. Most of the popular Hindi and Telugu movies are remakes of a foreign movies or an English itself. A few of them are Josh (West Side Story), Shakti (Not Without My Daughter), Jism (Double Indemnity), Koi Mil Gaya (Extra Terrestrial). We cannot blame anyone for this fact since; it would be ridiculous if a foreign award was to be given to movie which itself is a copy of a foreign movie.

Here in India, films are produced to just entertain the people rather than for the sake of human values. The reason for this is that people here don’t show much interest towards a movie with less dose of entertainment and more of message or other stuff and due to this the films made for values doesn’t do well at the box office.

Non-realistic approach of a film implies the way we show certain things in our movies that doesn’t take place in real life. For example in an English if an actor flies in air or some thing he is shown as if he has super powers whereas in our movies the hero himself who is meant to be a common man has all the powers of a superman. Even in English they make films based on just imagination but not real but they give all the appropriate conditions to make that look true but here in our films a mother could know whatever happens to his son who is miles far away from her, we call it emotion or sentiment and they call it rubbish. But we can’t help it as our films are based on our culture and for the sake of Oscars we can’t change it.