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

Do you ever test your code after it has been deployed to production ? During my first few years programming, I thought this was a bad idea and was told repeatedly told not to test anything in Prod.

After being bitten time and again by environment related problems, I decided to make it a point to perform a smoke test in Prod before handing it to users. Even if it meant a transaction with real money was involved.

Let me take a few moments to recite some of the follies that befell me when I did not test in Prod.

• Code moves to production. We find out that the SSL certificates in QA are installed in a different configuration when compared to Prod. The isSecure() flag on the HttpServletRequest returned a different value because of this and the code bombed.

• A process tries to check in and check out files from clear case. The live environment has some clear case triggers that prevent check in based on certain rules. These rules are absent in QA. Kaboom.

• A web service provider used an unsigned certificate in prod and didnt tell us about it. The cert chain hierarchy broke and the application stopped working.

• An insert into a table in DEV was done using dummy user GUIDs. When the code was moved to Prod, we found out that all production GUIDs are of length 42 but the test GUIDs were of length 30.

• And so on…

I think it is justifiable to even test code in Prod when money is involved. Just test for a transaction value of one  dollar and then roll it back. Sure beats a customer coming back to you and telling you that your system is broken.

But enough about what I think. What do you think ? Do you test your code in the live environment ? Take a small yes / no poll and if you feel the answer should be no, feel free to leave a comment.

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

Many passwords in linux are encrypted using the crypt() utility. The user is usually not aware of the difference between a crypt and a MD5 encryption. Well it can turn out to be important, especially if crypt uses the default DES-based scheme to perform the encryption.

The problem with crypt() + Traditional DES is that it truncates the password length to 8 characters. Users are not usually aware of this and assume that the entire length of the password has been saved and encrypted. Take the apache tool htpasswd for example. It uses crypt() to encrypt passwords (It may also use its own MD5 routine) into a password file. The following command creates a new user in a password file

htpasswd password_file new_user

After this command is executed, you are prompted for a password. If the password is greater than 8 characters, for example – 123456789, it will still be accepted and no warning will be provided that it was truncated. So providing the password 12345678 will also allow you to be authenticated into the system. Why is this bad ?

• The time taken to crack 8 character passwords is shorter (in relative comparison).

• It is also likely that the password was truncated in these scenarios, so an attacker may well target passwords that are exactly 8 characters in length.

• Some people have the knack of prefixing the password with the username first. Bad idea if your username happens to be 8 characters long

• The user may not even be aware of the problem, since he/she assumes that the password is strong and greater than 8 characters.

So the next time you provide a password to a system, you might want to know how they get saved into a persistence store and what encryption is used.

I came across an interesting application today. Google has released an application named Jarlsberg that is full of security holes. The intent is to make developers learn how these holes work and put them in a position to combat the security vulnerabilities.

You can visit the app to learn more. Security flaws to be detected are classified under the following categories

• Black box. You dont know the code
• White box. Requires you to see the code to understand how to break it.
• Gray box. Some code will be made visible.

I also came across an instructor’s guide that has problems to be solved in the application, graded by their difficulty level.

What better way to learn an exploit than to perform it on a test system ? Some of the exploits involve

• XSS and related challenges
• Path traversal exploits
• DOS
• Buffer overflow
• SQL Injection

and so much more. Give it a try now

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 use remote linux services often and exposing them as local services can be performed securely using SSH. For example you can access a tomcat server or email server hosted at IP 1.2.3.4 by opening a secure SSH tunnel between your local machine and the target address – 1.2.3.4.

The OpenSSH tool can be used to perform SSH related activities on your machine. Simply install it with yum, apt-get or Yast, if it is not already available. Once you have it use the following command to open multiple SSH tunnels to your services

Open tunnel and execute commands:

1

ssh 1.2.3.4 -lmyUser -L 3098:1.2.3.4:21 -L 3099:1.2.3.4:80 -L 3100:1.2.3.4:443

The command is explained below

1.2.3.4 – Your target IP

l – The user to login as

L – A local tunnel to a remote port

3098 – The local port to use when establishing this tunnel

21 – The remote port at 1.2.3.4 to which the tunnel will be established

Multiple tunnels can be opened by specifying multiple -L flags. For example http://localhost:3099 will now redirect to http://1.2.3.4:80/ That is a fancy way of saying all HTTP requests ( 80 is the default port ) for 1.2.3.4 can now be reached locally at port 3099.

Note that the above command will also log you into the remote system. If you want to open the tunnels alone, use the -N switch and the -f switch as shown below

Open tunnels only:

1

ssh -f myUser@1.2.3.4 -L 3099:1.2.3.4:25 -N

The -f switch asks SSH to work in the background and -N asks SSH not to execute any commands.