Run jar file in a secure way

Often we download java tools/applications that are either from known sources or to try out their features.  Mostly they would come with either a bat/sh file to setup the path for the application and launch the jar.  Say you are logged in with an elevated user and what if the application you want to try just wipes out C drive!!

Always run the jar files (tweak the shell/batch scripts if required) to enable java security manager.  All that we need to do is launch jvm as java -Djava.security.manager -jar <jarFile>

This will use the default policy file that comes with JDK at JAVA_HOME/lib/security/java.policy, which is good enough.

Oracle jdbc driver changed since 9i

Came across this while going through the tomcat docs.  Since Oracle 9i release the jdbc driver class oracle.jdbc.driver.OracleDriver is deprecated and oracle.jdbc.OracleDriver is the new one to be used.  We use 10g and have been using the old driver since last 3 years.  Not sure if this will make any difference interms of performance though.  Will update once we have some stats.

Intro to OSGi

Came across the nice book by Neil Bartlett on OSGi while reading news on Jigsaw getting delayed and plans to include it in Java 9.

His book is so nice and I finished reading the intro, below are quick facts we should look to design for OSGi

Version Dependency
METAINF.MF could be used to declare the dependencies, but can not enforce version.

1. For example, suppose we determine somehow that a JAR has a dependency on Log4J. Which version of Log4J do we need to supply to make the JAR work?

2. Versions cause other problems. Suppose our application requires two libraries, A and B, and both of these libraries depend in turn upon a third library, C.  But they require different versions: library A requires version 1.2 or greater of C, but library B requires version 1.1 of C, and will not work with version 1.2!

Lack of Information Hiding Across JARs
Classes within a JAR need to have access to the classes in other packages of the same JAR. That means we must make those classes public, because that is the only access modifier which makes classes visible across package boundaries.  As a consequence, all those classes declared public are accessible to clients outside the JAR as well.  Therefore the whole JAR is effectively public API, even the parts that we would prefer to keep hidden.

I hope to continue and complete this book.

Moving to IntelliJ and back

Post the release of IntelliJ ver 11, I have heard lot of good things and thought of giving it a try.  I saw it is open-source and free, but realised only the community edition is free and which is way limited in its capabilities compared to the paid version.  Somewhere I read that IntelliJ is a smart Java IDE where as eclipse is a general purpose IDE, Java being one of the languages it supports or rather famous for.  The download is an exe rather than a zip.  As I do not have admin rights on my lap, I usually prefer zip versions.  But I was happy as the exe is itself can be unzipped (7-zip).

You will find the exe to run in "ideaIC-11.1.2\bin" folder, and unlike eclipse it did not ask me to choose a folder to keep the profile/settings, uses APPDATA on XP to create a folder in your user profile.  As this adds to my profile size, I always move it to my D drive if possible.  There is a file in "ideaIC-11.1.2\bin\idea.properties", where you can change the locations and tell IntelliJ to store your preferences and plugin data.  I found in the forum which says zip version is provided only for ultimate edition, not sure why !!

Once it is up and running I really did struggle to move around and code as there is no shortcut to un learn eclipse shortcuts and get to used to IntelliJ quickly.  Download and keep the shortcuts reference aside, it will help a lot in making the ide usage a pleasant one.  As I keep using I can feel the intelligence, while doing auto-fill or auto-suggestions.  But I miss the eclipse feature to insert comma or semicolon automatically at the end, need to press Ctrl+Enter to do the same.  Another good thing is its seamless support for maven, autofilling the dependency info in your pom is really good, but couldn't figure out how to run any specific goal instead of build/run available in the menu.  As an exercise I started to learn Stripes and though using maven tomcat/jetty plugins I could deploy and test my web application slowly I felt the need to have support for the server from within IDE, I actually wanted to do remote debugging.  Also felt that it eats away my battery very quickly, not sure how fast, but you can feel it.

After playing around for some more time, I went back to netbeans/eclipse.  I keep switching between them.  So finally my experience is - the IntelliJ community edition is not worth dumping eclipse/netbeans.  But if you can get to the entriprise version, I do think it will be more fun as they promise.

Eclipse workspace

I use eclipse for all development activities and started with multiple copies of eclipse for each topic.  Say I am learning JUNIT, will have eclipse installation in one folder.  Similarly I used to have a different installation for learning generics/annotations, android, webservices etc.

Over time I realized that in most cases I am using same version of eclipse and this setup is taking up lot of space (this is not really a big issue).  As I started experimenting with maven and other code quality/metric tools, I needed to do the installation of these plugins in every installation of eclipse.

Another possible option is to have single eclipse installation with different workspaces for each specific task.  This addresses the space issue, but I still need to install the plugins in different workspaces again and again.  Having unrelated plugins takes up lot of memory and slows down the eclipse itself.

How about having workspaces for different plugins (grouped logically) and use whichever plugin set is required for your task?  Not sure, but I do not have any better options at this point.  While I play around on how to manage my workspace below trick would help in identifying which workspace is currently being used:

Add -showlocation as the first line in eclipse.ini, which would show the workspace name in the title bar.

BigDecimal to String conversion

We have just realised one more non obvious issue with toString() method of BigDecimal while migrating from jdk1.4 to 1.6

Since Java 5, the toString method started printing the value in scientific form if scale is more than 6, so our messages going out have become wrong; no coding issues, its like silent killer :-)  Good lesson for me is to override this method whenever the output make a difference even though the default is enough.  The new method added is toPlainString() to get what toString() is doing earlier.

What is JIT

The Just-In-Time (JIT) compiler is a part of JVM to improve application performance.

As we all know the class files generated with javac contain platform-independent bytecodes to be interpreted by a JVM on specific OS/machine.  Due to this interpretation performance will be slow than that of a native application.  The JIT compiler compiles bytecodes into native machine code at run time and helps in improving the performance.  Below are some points to be noted:

• It is enabled by default, and is activated when a Java method is called.
• It compiles the bytecodes of that method into native machine code, compiling it "just in time" to run.
• After a method is compiled, JVM calls the compiled code directly instead of interpreting it.
• Methods are not compiled the first time they are called.  For each method, JVM maintains a call counter.  JVM interprets a method until its call count exceeds a JIT compilation threshold.
• After a method is compiled, its call count is reset to zero and subsequent calls to the method will continue to increment its count.  When the call count of a method reaches the JIT recompilation threshold, the JIT compiler compiles it a second time, applying further optimizations than on the previous compilation.  This process is repeated until the maximum optimization level is reached.
• The JIT compiler can be disabled (-Xint interpret-only mode), in which case the entire Java program will be interpreted.