An article was written a while back about how neural networks can be used to classify source code. Yes the source code that you write to feed to compilers / interpreters.

The article explains at a high level what method could be used to perform this activity. In the end the author claims some level of success and wonders how other neural-network implementations / techniques would solve the same problem. This got me curious enough and I spent a weekend trying to crack this with Neuroph, the neural network library for java. I present to you my analysis and results below. For the impatient here is the code-classifier DEMO.

Why solve this problem with neural networks ?

So where do we begin ? How about the question ‘Why do we need neural networks to solve this problem ?’. Well actually it might not be the ‘best’ way to solve the problem. A lexer is a better solution to this problem since it can scan the source file and probably give you a much better accuracy on the clasification. But neural networks are also great for this problem since they can keep learning based on the input that is provided. Add one more programming language into the bag and the network can learn about this language without a programmer needing to type extra code into a lexer.

So how do we do it ?

One of the features that differentiates one source code type from another is the keywords used by the programming language in question. So lets target that. Our neural network will try to identify if source code belongs to the java language or the python language.

It takes as its input a list of all keywords available in both languages. Mind you that there may even be some overlap between the keywords. For example the keyword ‘if’ is used in both languages. But there may be keywords that are used solely in one language alone.

Neural network viewed in graph mode: (The network is too huge to fit into this picture )

A middle layer will contain a few nodes that will back propagate anything that it learns. The output layer (just one node) will decide if the language is java / python. The value will range from 0-1, where 0 represents closeness to python and 1 represents closeness to java.

How do we train it ?

The process of training is made easy by the neuroph API. First we need a few java / python files. A program was written that reads each file and splits it based on the whitespace delimiter. Based on a known set of keywords, the network is fed the number of times a keyword appears in a source file.

1
2
3
4
5
6
7
8

for(Map<Double, Double> map : keywordStrength)
{
    Collection<Double> values = map.values();
    Vector<Double> input = new Vector<Double>();
    input.addAll(values);
    SupervisedTrainingElement supervisedTrainingElement = new SupervisedTrainingElement(input,output);
    trainingSet.addElement(supervisedTrainingElement);
}

For example, recognized keywords may be ‘public’ represented by the input index 0 and ‘static’ represented by the input index 1.  A java file may contain the word pubic 10 times and static 5 times. The input to the network in this case would be 10 5. We can now use these numbers to tell the network ‘Hey if you see this pattern it is likely that the source code belongs to language X’. Neat !. Once the network is trained you can load it and use the same process to classify source code for any given input String.

Well… show us some stats:

Before I say anything else, I did not expect this approach to succeed more than 10-20% of the time. This is because the number of files that I trained this network with was around 20. Java + Python included. But I was surprised to see the network classifying the data correctly most of the time. There were very few cases where it failed.

The real test for this network is now in your hands. I made a java web app on top of this ‘code classifier’ application and built a simple UI using Jquery. You can type in any code / junk you want and hit the trained network. If it manages to classify your code correctly at least 60% of the time, I would consider that an enormous victory (for Neuroph ?)

So what are you waiting for, take her for a spin.

How do I game the results:

This is pretty simple. There are certain rules you must follow. Not following them will give you weird results

1. Make sure that your code does not contain comments. I do not strip comments from code before analyzing them for keywords. Including java like keywords in a python file comment will confuse the network.
2. Input only those files that will compile / run correctly on Java / Python. In theory you could feed in a Shakespeare novel to my network and it will still try to classify it as source code

So does the network work for you ? Feel free to leave a comment.

I also wrote a simpler tutorial for Neuroph that is less practical and more academic. Check it out if it interests you

Here are a few more tips / tricks with which you can save time when you use the eclipse IDE.

Assign Key bindings:

Navigate to Window -> Preferences -> General -> Keys

You will find that there are many key bindings that are not assigned to actions that you might do on a daily basis. For example, when I start up on a new project, it is highly likely that I will introduce a lot of Value Objects (or Transfer / Data object, whatever you like to call them). A slick feature is to generate the ‘Getters and Setters’ for them using the ‘Source -> Generate getter and setter’ command from the Main menu.

You can either do that or you can assign a shortcut key to this action and get it done quickly. I use Alt+Shift+Q, +G (Yeah not the easiest combination. I know ). To restart eclipse I use Ctrl + F12. You might want to look at other bindings like

• Generate hashCode
• Generate toString()
• New package
• New class

And so on…

Reduce number of code suggestions:

The shortcut I use the most in eclipse is perhaps ctrl+space. Code completion is a real time saver. It can however be annoying when you press ctrl+space more than once by mistake. This by default, brings about suggestions for SWT templates among other things. You can turn this off by navigating to Window -> Preferences -> Java -> Edtior -> Code Assist.

Import preferences:

If you are like me, your hard disk probably has more than 100 eclipse Workspaces. Developers usually customize their workspaces and it can take a while to do this. When you switch to the new workspace, some of the customization is lost because they were workspace specific. You can get them back easily by exporting your preferences in the old workspace and importing them again in the new one. Use the File -> Export / Import option to do this. Preferences like code formatting, code templates, default compiler settings etc will be readily available.

Remember more workspaces: (Works on myeclipse)

Use this technique to allow eclipse to give you more drop down choices when you startup. By default eclipse remembers the last 5 workspaces used. You can increase / decrease this number by navigating to Window -> Preferences -> General -> Startup and Shutdown -> Workspaces.

Associate eclipse with an external browser like firefox :

Eclipse uses the system default browser. In most cases this is IE (gulp). You can change that by defining an external browser by navigating to Window -> Preferences -> General -> Web Browser.. This is great when you combine it with a plugin like Firebug. You get to code and debug HTML / CSS / Javascript all at once.

Work with local history:

Screwed up your java file and then saved it ? Yikes. Local history comes to your rescue. Every edit and save that you make in a file is saved as a local history in eclipse. Make use of this to revert changes when necessary.

To use this feature, right click on the file of your choice and click Compare With -> Local hisory. That should open up the entries in the ‘History’ view.

Clicking on any of the history entries will open a diff window telling you the difference between the current entry and the previous edits. Ah ! time is saved.

This is a 3 part article. If you would like to browse through the other tips, you can find them here

Eclipse tips and tricks – Part 1

Eclipse tips and tricks – Part 2

Ever visit sites like topcoder.com and solve a problem or two ? No ? You should and do so regularly. It will help find tune your programming / design skills. This is because solving the problems requires going though the following thought process

1. Understanding the problem.
2. Thinking up a solution that covers all use cases.
3. Executing your thought process through code.
4. Testing.

Now as simple as that sounds, it is not so easy to get right. Especially when you are competing with thousands of fellow coders for time. And when time is a constrain you usually select the first solution that comes to your head, which might not necessarily be the best. So there is that risk of your code timing out even if it is following the right logic. I would love to delve into a problem right about now and throw in some examples and illustration, but you get the point.

When the thought process that we follow is not well defined and we lose focus, it often leads to buggy code. Don’t believe me ? Here are some bugs I caught in a code base on a recent project.

Bug 1

Bug 2

Bug 3

There were more bugs identified after development than what is listed here. But what I wanted to highlight was that the problem was introduced into the system due to lack of focus and clarity of thought. Well, more often than not anyway. Other times the bug sneaks into the system because the number of test cases to test a method were not sufficient.

Have a look at this google research blog post about broken binary search and merge sort algorithms for example. They pretty much have the same bug as the date calculation bug that I highlighted in a different post. We are all prone to creating bugs, but we can minimize the number of ones we introduce into the system.

So what have I learned from introducing bugs so far ?

1. As long as you keep your skills sharp and practice solving problems, the number of bugs you introduce will reduce. I try to visit sites like topcoder.com or codingbat.com whenever I find the time.
2. Learning from other’s mistakes and best practices can save you tons of time.
3. Try not to cram in your work within X hours. This tends to focus the effort on finishing the code on time instead of writing it neat and bug free.

As always its easier said than done. But hey, its never too late eh ? As for finding the bugs in the first place…

1. Use a tool like FindBugs after you are done coding. You will be surprised at how many problems turn up.
2. Try to maintain a code coverage of at least 80 %. Tools like Emma can help you track this.

I ran into another sweet little bug that I thought I would share with you. This one cropped up after it passed a few tests. See if you can spot the problem. Without further delay here it is

Problem:

A record needs to be inserted with a new identity number. This number is obtained as the next maximum ID value from a set of elements in a XML file. The following code is supposed to obtain the next ID from the XML. Lets skip the XML related code since that just adds clutter.

Code:

1
2
3
4
5
6
7
8
9
10

int max = 0;
for( DataType data : someListFromTheXml )
{
    if(max < data.getId())
    {
         max = data.getId()+1;
    }
}
s_logger.info(" Max id: " + max);
return max;

See anything wrong with it ? Its got a pretty big flaw. The logic works only for odd number of elements. When the number of elements is even, it fails. Here’s an illustration

Test cases:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public class Test
{
    public static void main(String... args)
    {
        int [] input1 = new int[]{1};
        int [] input2 = new int[]{1,2};
        int [] input3 = new int[]{1,2,3};
        int [] input4 = new int[]{1,2,3,4};
        Test test = new Test();
        test.go(input1);
        test.go(input2);
        test.go(input3);
        test.go(input4);
        test.go(input5);
    }
 
    public void go(int [] input)
    {
        int max=0;
        for(int id:input)
        {
            if(max < id)
            {
                max = id+1;
            }
        }
        System.out.println(" Max id: " + max);
    }
}

Here’s the output:

Max id: 2
Max id: 2
Max id: 4
Max id: 4
Max id: 6

The logic incorrectly assigns the max to id+1. Instead it should have stored the current max and returned max+1 at the end of the loop. Sigh.

In hind sight a Xpath expression would have done nicely here. Something like max(/Parent/child/@value)+1. Still that is no excuse for the faulty logic

I often see environments where web applications use log4j for logging into files using various appenders. That is all well and good until I see that the logs are getting written into the application server’s logs. In JBOSS for example this is server.log. So why is this a bad idea ?

Why not to write into server.log:

1. An application server’s log is supposed to be used by the app server and not by your application.
2. This log is supposed to contain app server level information like loading war files / exceptions that were handed over to the container etc.
3. Weeding through the logs of about 10 applications to find a particular debug / error line is going to be crazy.
4. A PROD logging configuration should never have a console appender. The reason your application logs are getting logged into the server’s logs could be that your log4j configuration defines a console appender. This could mean you are logging the same thing in 2 places (assuming there is another file appender defined for your app).

Ideally each application should manage its own logging needs. Many developers seem to be unaware of a class named DomConfigurator in the log4j API that can load a log4j XML and configure it for your application. Here are the steps I usually take to prepare an application for logging

1. Write a custom class that implements ServletContextListener like the one shown below. The class looks for a context param named log4jFileName that is defined in web.xml. This locates the log4j XML configuration file. This will configure log4j before other classes use it.

Custom listener:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public class StartupListener implements ServletContextListener
{
    @Override
    public void contextDestroyed(ServletContextEvent arg0)
    {
        // Cleanup code goes here
    }
 
    @Override
    public void contextInitialized(ServletContextEvent sce)
    {
        Logger logger = null;
        ServletContext servletContext = sce.getServletContext();
        String log4jFile = servletContext.getInitParameter("log4jFileName");
        DOMConfigurator.configure(log4jFile);
        logger = LogManager.getLogger(StartupListener.class.getName());
        logger.debug("Loaded: " + log4jFile);
    }
}

2. In your web.xml define the listener and a context param like so

Web.xml entries:

1
2
3
4
5
6
7
8
9
10
11
12

<context-param>
    <param-name>log4jFileName</param-name>
    <param-value>
         /usr/local/app/log4j/config/log4jConfig.xml
    </param-value>
</context-param>
 
<listener>
    <listener-class>
        com.yourpackage.YourListener
    </listener-class>
</listener>

3. Now configure your log4jConfig.xml appropriately to ensure that your application logs are logged under an appropriate path. Use a file appender like RollingFileAppender to handle the retention policy for your applications.

Here is a sample log4j XML to help you

Sample log4j XML: (Customize as necessary)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

<?xml version="1.0" encoding="UTF-8"?>
<log4j:configuration xmlns:log4j = "http://jakarta.apache.org/log4j/" debug = "false">
    <appender name = "FILE" class = "org.apache.log4j.RollingFileAppender">
        <param name = "File" value = "/usr/local/path/to/application.log"/>
        <param name = "MaxFileSize" value = "5MB"/>
        <param name = "MaxBackupIndex" value = "50"/>
        <layout class = "org.apache.log4j.PatternLayout">
            <param name = "ConversionPattern" value = "[%d{dd/MM/yy hh:mm:ss:sss z}] %5p %c{2}: %m%n"/>
        </layout>
    </appender>
    <category name = "com.your.application.package">
        <priority value = "debug"/>
    </category>
    <category name = "org.apache.catalina">
        <priority value = "error"/>
    </category>
    <category name = "org.hibernate">
        <priority value = "error"/>
    </category>
    <root>
        <priority value = "info"/>
        <appender-ref ref = "FILE"/>
    </root>
</log4j:configuration>

That is pretty much it. This will ensure that your application’s logs are logged elsewhere from the server’s own logs. Makes managing log files a little easier.

I came across another silly little bug today. Take a look at the code below (assume ‘days’ is a parameter and that this snippet is part of a larger function)

1
2
3
4
5
6
7

Date now = new Date();
long nowMillis = now.getTime();
Timestamp nowTimestamp = new Timestamp(nowMillis);
long future = 3600 * 24 * days * 1000;
Timestamp expiryTimestamp = new Timestamp(nowMillis + future);
System.out.println(nowTimestamp);
System.out.println(expiryTimestamp);

Can you tell what is wrong with it ? What the code intends to do is to set an expiry timestamp to an element – X days from today. A caller called this code snippet with the value 5. Well there is nothing wrong so far. Here is the output

2010-04-27 10:37:10.497
2010-05-02 10:37:10.497

So then came along an element that needed an expiry of around 40 days. The caller calls with the value 40. Guess what the output is

2010-04-27 10:38:43.372
2010-04-17 17:35:56.076

Umm… so the expiry date is *before* the current date. Super. So what is going wrong ? The value of future in this case is -838967296. Although future is a long type, the data type that is being calculated to assign a value to it, is int. An int cannot take anything more than Integer.MAX_VALUE (2147483647).

If future had been calculated correctly, its value would be 3456000000. Instead what is being presented is the wrapped around value obtained after adding the remainder to Integer.MIN_VALUE.

I guess that just goes to show that if it aint broke you may still need to fix it later. Of course that depends on what your definition of ‘broke’ is

I moved all development activities to linux recently. Part of the migration process involved getting used to some new apps like Kopete / Pidgin / KDE Snapshot etc. It was a breeze until I started debugging my code in eclipse.

I frequently use the eclipse keyboard shortcuts to cut down the time I spend coding / debugging. One of my favorite is Ctrl + Shift + i , which will open up the inspection box for a particular variable. This shortcut just did not work. For quite a few days I did not understand why. The other shortcuts like fix imports ( ctrl + shift + o ) seemed to be working fine. That’s when I stumbled across a kopete shortcut.

The shortcut Ctrl + Shift + i was also used by kopete to read messages. According to the documentation this was a global short cut that was valid in any KDE application. I closed kopete just to confirm that it was contributing to the problem and voila, Ctrl + Shift + i started to work inside eclipse once again. So the next time a shortcut does not work in eclipse you might want to

1. Look at the Wondow -> Preferences -> Keys and ensure that the key is bound.
2. If it is bound, check other applications and make sure this is not a global shortcut used elsewhere.
3. If it is a global shortcut, change the key binding in eclipse or the other application.
4. Relax

The java neural network Neuroph was making news recently about its integration with Hadoop. Neural networks can solve some interesting problems once they are trained. This article aims to provide the baby steps necessary to writing your first java program that loads a trained neural network.

Before you even begin to read anything that follows, a basic understanding of neural network terminology and the concept behind the same is necessary. The following articles are great starting points to understanding neural networks

Neuroph and neural networks – Part 1

Neuroph and neural networks – Part 2

Neuroph and neural networks – Part 3

Intro to neural networks

Cars and Signals:

We will  simulate the scenario where cars wait at a signal and move only when the lights are green. This simple example should help get you started. Our aim is to define a neural network with the easyNeurons swing application; train it; import it into java and use it in an application.

There are 3 states for this signal

1. Red – Stay where you are

2. Yellow – Start your engines

3. Green – Go

The neural network will take 3 inputs and its architecture will be based on the multi layer perceptron setting. A hidden layer with 4 nodes will decide the output. The output itself will be based on one node, whose value will determine if the cars can move or not. This is what our network looks like so far

Create the network in neuroph: Network -> Multi layer Perceptron

Basic network with no training: View -> Graph

Now we need to train the network so that the output will be as expected when the signals change. The rules are pretty simple and are shown below.To train the network we create a training set

Neuroph training set:

Train the network to respond to the inputs:

After the training rules have been laid out, it is time to train this network. Simply press on the Train button and select the appropriate training set to use.

Set the parameters by which the network should learn:

The trained network:

Now that we have our network trained, lets try giving it an input. An input of 0 0 1 means the signal is green and the vehicles can go through. The output produced in this case is shown below. The output will vary based on the function used in the training set / error rate and other factors. But what is to be highlighted here is that the output is nearing 1 when the signal is green. Our network works as expected.

Signal is green and output is 1 (well almost ):

We can confirm how this decision was taken by the network by highlighting the weights. Additionally by representing the size of each node with respect to the activation contributed for that node, we can visualize how the input message propagates

Weight / Activation  highlighting:

So now that we have a neural network up and running, how do we actually use this inside java code ? Its pretty simple. Save the project as a .nnet file. Lets call this neural_traffic.nnet. To load the nnet file into your java project, simple use the classes provided by Neuroph like so

Loading a neural network into java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class TestTrafficNeural
{
    NeuralNetwork network = NeuralNetwork.load("neural_traffic.nnet");
 
    public static void main(String[] args)
    {
        new TestTrafficNeural().go();
    }
 
    private void go()
    {
        calculate(1,0,0);
        calculate(0,1,0);
        calculate(0,0,1);
    }
 
    private void calculate(double... input)
    {
        network.setInput(input);
        network.calculate();
        Vector output = network.getOutput();
        Double answer = output.get(0);
        System.out.println(answer);
    }
}

The code produces the following output

-1.6360230873976706E-6
-4.140786100885251E-6
0.9684448970000741

You can also define and train the network on the fly with code. But you would not want to do this for cases where large sets of inputs and nodes are involved. For simple problems the time taken to train a network is usually a few seconds. For large images ( Assuming you are trying to recognize images with Neuroph ) it can take a couple of hours.

This example is pretty easy to do and is certainly not a practical use case for real world problems. However I hope it gets you excited about using neural networks in your programs. With Neuroph doing this is pretty simple.

I had the opportunity to work with the ATOM protocol in detail recently. One of the products related to ATOM that I stumbled across is the AtomServer. If you dont already know it, ATOM is accompanied by a publishing protocol. Its called ATOMPub in short. Unlike RSS this protocol allows you to perform CRUD operations on the entries that you define under a feed.

What does that mean ? For example, you could have an entry in a feed which you wish to edit. You can edit / remove this entry using PUT / DELETE HTTP requests to an appropriate URL hosted by a server. So this protocol allows a user to interact with the feed (among other things. The ATOM XML format can be extended).

So what does the ATOMServer do and where does it fit in here ? The ATOMServer provides a RESTful interface and a RDBMS that stores the entries that the user interacts with. A user may wish to store 10 entries in a feed and then later retrieve and edit them as needed. To do this in an ATOM server the following operations would be invoked

1. 10 PUT / POST requests to store the entries
2. A GET operation to retrieve the entry.
3. A few PUT requests to edit existing entries

You can go through the protocol basics . The Google GData API uses ATOMPub as the protocol to talk to various services such as Blogger / Google spreadsheet / Youtube etc etc. Whether they use an ATOMServer like product behind the scenes is debatable. The ATOMServer is by itself made up of pluggable components. You could easily replace the RDBMS store with a custom store of your own for example.

So where is an ATOMServer useful ? If you have existing services that need to be Atom enabled, the ATOMServer can provide the framework necessary to accomplish that. The ATOMServer can act as a layer that serves feed readers. The results for a feed can initially be fetched from an external source, such as an existing API or a file.

A search query that needs to refresh a feed every 30 minutes for example can be integrated with an ATOMServer. On the first call the search results would be fetched and stored into the ATOMServer DB. All subsequent feed reader calls to the ATOMServer for the next 30 minutes can be configured to get the cached data from the DB instead of the search query (A little coding into the ATOMServer framework would be required ). It is a simple use case and I am sure many more exist.

Another way to integrate ATOM into your APIs / services is to use Apache Abdera. Abdera provides APIs that can generate ATOM XMLs. The ATOMServer is by itself built on top of Abdera. So if you need more flexibility you can go ahead and use Abdera directly.

I was testing an application today and came across a bug. A screen had some CRUD operations on a resource. The problem was, whatever I did, the system would perform the operation and tell me that the resource already existed. This left me scratching my head for quite a while. I add a resource and it says it already exists and then adds it. Delete and update also do the same.

So the debugging process started and I sat down with eclipse to get to the root of the problem. I verified that indeed the CRUD operations were reflecting in the persistence store. Then I came across these magical lines of code

1
2
3
4

public static final String S_SOMETHING_EXISTS = "something.already.exists";
public static final String S_SOMETHING_ADD_SUCCESS = "something.already.exists";
public static final String S_SOMETHING_DELETE_FAIL = "something.already.exists";
public static final String S_SOMETHING_DELETE_SUCCESS = "something.already.exists";

This left me smacking my head. It should have been

1
2
3
4

public static final String S_SOMETHING_EXISTS = "something.already.exists";
public static final String S_SOMETHING_ADD_SUCCESS = "something.add.success";
public static final String S_SOMETHING_DELETE_FAIL = "something.delete.failed";
public static final String S_SOMETHING_DELETE_SUCCESS = "something.delete.success";

The bug was introduced when I copied the first constant and pasted it three times. I forgot to change the keys . My point is, most of the bugs that I see introduced into the system are due to silly mistakes like the one above. This is where tools like FindBugs (which can be extended with your own rules) and CheckStyle and other bug finder / code review tools come in handy. A human code review is also a great tool. This little bug served as a reminder as to why we have such tools. To a developer this bug might seem small, but wait till an end user sees the message and says ‘What gives !’.

One of the things I hear often from someone wanting to try linux and leave windows is that they are afraid that they will no longer be able perform some of the things they used to do. That is so wrong. Be it from the perspective of a developer or a casual user linux offers a wide range of apps to suit your needs. Here is a table of things I used to do in windows that I can still do in linux

Application	Windows	Suse Linux – KDE desktop
Chat	Gtalk, Skype	Kopete / pidgin for gtalk Skype is supported
Development	Eclipse / myeclipse / Netbeans	All of them have linux flavours
Screenshot	Gadwin printscreen	Ksnapshot
Browsing	Chrome / Firefox / Opera	They are all supported. Chrome support is getting better
SQL Client	Squirrel SQL	Supported. Java runs anywhere
Application server	Tomcat / Glassfish	Supported
Web server	Apache	Supported
Video player	DivX , VLC	VLC is supported
Package management	None	Yast,yum, apt etc etc
Firewall	Inbuilt / Zone alarm	IP Tables. Much more flexible
Database	Postgres	Supported
Desktop customization	Not bad	Amazing. You can add widgets, multiple panels etc etc
Multiple desktop support	No	Yes
Dual screen / Nvidia drivers	Yes	Yes
Remote desktop	Windows / VNC	Supported
Windows applications	Yes (Duh)	Simulate with WINE
Office	Windows office	Open office. Not great but ok. You can use an online office suite if needed.

Application	Windows	Linux
Chat	Gtalk, Skype	Kopete / pidgin for gtalk Skype is supported
Development	Eclipse / myeclipse / Netbeans	All of them have linux flavours
Screenshot	Gadwin printscreen	Ksnapshot
Browsing	Chrome / Firefox / Opera	They are all supported. Chrome support is getting better
SQL Client	Squirrel SQL	Supported. Java runs anywhere
Application server	Tomcat / Glassfish	Supported
Web server	Apache	Supported
Video player	DivX , VLC	VLC is supported
Package management	None	Yast,yum, apt etc etc
Firewall	Inbuilt / Zone alarm	IP Tables. Much more flexible
Database	Postgres	Supported
Desktop customization	Not bad	Amazing. You can add widgets, multiple panels etc etc

The list above is just a sample of the applications I use. I am sure there are more use cases.

I have been wanting to move to a linux based environment for java development for quite a while now. Many PROD servers I deploy to run on a linux distro. So testing configuration / code changes becomes easier when you have multiple DEV environments. I deploy to CentOS among other linux flavors. I have settled on the Open  Suse 11.2 desktop. Here are some things I liked

1. Open Suse managed to detect my Nvidia driver with Yast. I guess they teamed up with Nvidia to host a repository for linux drivers. I didnt have to download kernel sources or devels to enable dual monitor support (Which is otherwise required). Nice !
2. PPP over internet setup was pretty easy. Kinternet and the Yast configuration settings together let me connect to the net with ease.
3. Community support seems good. The Suse forums are alive and kicking.
4. In general there was software by default on the desktop that turned out to be very useful. I didn’t have to download extra components unless it was specific to my hardware, like a specialized driver.  ksnapshot for example is a cool way to capture screenshots.

I am yet to try out Ubuntu. For some reason it does not detect all my hardware so it fails to install If you are still using windows to develop in java here are a few reasons you should switch

1. Looks good on your resume. Learning to work with another OS / Desktop can broaden your perspective on getting things done.
2. Not as many viruses.
3. No IE
4. If you are someone that loves the command line client, you will enjoy getting things done quickly with the shell console.
5. Firewall configuration is pretty flexible and can be bent into any shape you want provided you know what you are doing.
6. Automatic updates managed by a package manager
7. You can switch to multiple workspaces to manage your windows.
8. etc etc.

That said I did find some minor annoyances.

1. No IE. Whether I like it or not some users still use IE to access some of my apps. So my selenuim based RC test cases will not fire the IE window anymore. I have to use tools like BrowserShots or Adobe’s BrowserLab to get things done.
2. Some applications require me to run a .exe file as a plugin. This is very rare but can be overcome by simulating programs on Wine.
3. Learning new shortcuts can be a pain. So if you feel frustrated dont give up. Remember that you had to do the same with windows when you started out. So it will ease with time.

I am able to do everything that I used to do with windows and there are free tools  that support just about any software function you can think of.  Not being able to find the tools / software you need is just a myth. Almost any function you can think of that you are currently using in windows, is supported under linux. Make the switch and enjoy the stability of linux. Use another distro besides Open Suse ? Feel free to leave a comment.

Nautilus SVN, the SVN client for linux had moved to RabbitVCS a few months back. From what I have read so far, the new client, while plugging into the old Nautilus manager, performs much better and does not hang up when the number of files to manage is on the rise.

RabbitVCS differs from Nautilus by attempting to have a pluggable interface for many types of source control systems. So SVN is just the beginning. You can check out the screenshots and install it on your favorite linux distro.  Here are a few teasers

RabbitVCS:

Commit with the Rabbit:

Sun has a wide range of certifications to offer. Ever since java EE6 was released, changes have been made to the certification hierarchy and content to reflect the new specifications. Sun is also offering a discount of 10% to those that register for training / certification updates by Jan 31st 2010. Here is a comparison of the certification hierarchies

Old hierarchy:

New hierarchy:

The new hierarchy provides paths that are more specialized than the ones before. For example you can be a JSF expert. Web service + security is another specialization. Combining these certifications together can also earn you the title of a “Master“.

Apart from these changes, the core java certification – SCJP – is supposed to undergo an overhaul after the release of JDK7. Candidates are expected to code their way into passing an exam instead of selecting multiple choice questions. The exam is supposed to be renamed as SCJP plus. It was delayed after an earlier attempt to launch it was unsuccessful due to the JDK7 project taking higher priority. Whether we will see “plus” versions of developing web pages / invoking web services etc etc is yet to be seen.

Sun is about to provide an update to all its existing certifications. If you are interested in registering for training/notifications, you can do so here. At the time of this writing, there are 3 days left to register / get notifications.

I successfully installed a wave (google) server on a windows box a few days earlier. It was a great feeling. Here are the components that made up the server

• Open fire XMPP server

• Postgres database to be used by XFire.

• Wave related server jar which runs the server

• Wave command line client that runs the simplistic console client.

I started the console client and typed in a few commands to go through the waves. New, open, view waves were some commands that the command line console allowed you to execute. This client was a simple RI provided by google. If you would like to install a server on your own, take a look at the installation instructions.

Wave console client:

I also had the option of federating this server with wavesandbox.com but I held back. I wanted to test out the features of my wave server first. So, I went about hunting for a client. The GWT client that google showcased in its IO Dev preview was impressive. So surely they have an open source implementation of a decent wave client that can be installed somewhere ? It seems not.

I was a little disappointed with this. The best UI I could find that would integrate with a wave server was here. This was a java client with very minimal functionality. That said you have to thank the author for providing it. Its about the only decent looking client that can talk with a wave server.

There are other clients out there. One written in adobe AIR called Waver can be used as a desktop client for waves. However it only integrates with google wave, not other waves. Another one called WaveBoard also seems to target google wave and Macs. I don’t own a Mac so I could not check it out.

This seems like the need of the hour to me. A good wave client. Not a “google wave” client but a “wave client”. Adoption of the wave will be much better if we had a good client to go with it. How many times have you seen blog posts about google wave with comments that go like ‘Oh boy I wish I had a google wave invite right now’. These people need not wait for an invite. You can download and install a working wave server. If you had a cool looking client, people all around the world could be using wave right now without a google invite at all. Lack of a good wave client seems to be a bottle neck to wave usage. We need tools like Outlook / Thunderbird / <Your favorite mail client goes here> that help us access email, do the same for wave.

So how desperate are people to get google wave invites ? Invites are being auctioned off at ebay for anywhere between 1-15$ ! That is how desperate they are.(Search for ‘google wave’ in ebay) Now if only we had a cool looking client, these people could be waving away in another server much like google’s wave. May be there is a client out there right now and I am yet to find it. If you know of one, do feel free to comment. If there is none, a few programmers will have to get together and make a good looking one with all the features that the GWT google client has.

Wave invites at ebay: