Using Version Control System (henceforth VCS) has now become an essential part of the development life-cycle. One cannot visualize life when it comes to managing project/product releases without having well established VCS. As per my experience (and since got chance to work with only VSS and SVN, I feel SVN is the better choice – simple, easy and most important free!!!).

Well but there is one problem with both the listed VCS, both of them work pretty well on Text based files and are not meant for storing non-textual files. In day to day development environment where developers write thousands lines of code, they also make use of already written libraries to reduce the development effort and use what is already tested & proven. (In Java world the libraries are available in JAR file format). While libraries are in compiled format, using VCS for storing them doesn’t sound to be good idea. In fact when it comes to following mavenised structure of branches, tags and trunks, the decision to store JAR files becomes critical and SVN seems to be not a right choice to store them. Unnecessarily copying JAR files in tags and branches would simply end up increasing repository size. Hence using special repositories like Apache Archiva for JAR files along with Maven POM scripts seems to be right choice.

While one can handcode the POM script using any text-based editor, it would be good to use User Interface to manage the Scripts and locate the Maven artifacts like plugins, dependencies etc. Here comes the rescue from M2Eclipse (sonatype), which provides Eclipse plugins to manage POM scripts. Well if you think, it just provides a form based interface to manage scripts and does nothing, then you must have a look at the features provided by M2Eclipse plugins.

Most of the time, I see developers running here and there to find out the required libraries for the project to get compile and run. The reasons could be the libraries are not stored in VCS or they are not aware of which version should be used. The chaos and time spend in resolving such issues is pretty high and unnecessary. Maven addresses these issues with the help of POM scripts which can be versioned as per release and one can be assured of versions to be used in project. But Maven alone can’t help you to manage libraries when it comes to using POM scripts while developing application in IDE like Eclipse. It cannot add libraries to project on its own and define classpath. Surely you need a plug-in which can manage the project dependencies using Maven Scripts and also free you from configuring them in project. Fortunately there are plugins which can help you to accomplish the same. Add following URL to Eclipse update manager and install the Maven Plug-in http://m2eclipse.sonatype.org/sites/m2e/

It won’t be possible to explain all the features provided by this plug-in in this article, there are so many sections and configurations available that one can write a book for their explanation. Lets understand the important sections required to use this plug-in in Eclipse. Once the plug-in is installed, you should see “Maven” as one of the item in Eclipse > Window > Preferences window.

Eclipse Preferences for Maven

The next step is to configure the Maven installation in Plug-in and it can be done in Preferences window using Maven > Installations and click on Add button. Point to the directory location where you have unzipped/installed Maven (I am using Maven 3 along with Apache Archiva).

The last step is to configure the Maven settings file in Eclipse Plug-in, so that Plug-in can use the settings that you have customized in settings.xml rather than using predefined settings. This can be done using Maven > User Settings and then select the settings.xml file. (In my case the file is available in Maven installation folder > conf. It is recommended to use local repository server like Apache Archiva as after the Eclipse maven plug-in is configured, it starts to index the repository to tune the search operation. If one uses default settings, the plug-in will query repo1.maven.org everytime it starts and that will take too much of time).

Once above configuration is done, you should be able to use Maven Eclipse plugin for your project. Create a Project using Eclipse > File > New > Project. Note that this project should not be associated with any builder and hence I have selected “Project” instead of “Java Project”, Maven plug-in will automatically configure the required nature and builders for this project. Next step is to right click on created project and select New > Other option. Search for “Maven”, you should see following options.

Maven options

Select “Maven POM File” and click “Next”. The dialog will ask to configure POM script with options like artifactId, groupId etc. Enter the required values and choose “Jar” as packaging option. A POM.xml file will be created in your project. Double click on the POM.xml file and Eclipse will now open “Maven POM Editor”. You will find many tabs below editor screen to configure various POM Script configurations. Go to “Plugins” section and in “Plugins” panel, click Add button. You should now see a dialog box. Enter “maven-compiler” and the dialog must list matching Maven Plugins to the entered text.

Maven Plug-ins

Select “2.3.2 – maven-compiler-plugin…” from given options and click OK. Now go to pom.xml tab to open the script in XML text editor mode and add following configuration to maven-compiler-plugin.

	1.6
	1.6

This is required to indicate which Java Compiler you want to use, Maven will then configure the require JRE for your project. Now create following folders one below the other “src > main > java” and then right click on project, locate “Maven > Enable Dependency Management”. Once this option is selected, you should now see that Maven will automatically configure

Enable Dependency using Maven Plug-in

1. Source Folder
2. JRE
3. Change project icon to indicate it is Maven and Java Project.
4. A library “Maven Dependencies”

Now I assume that you know basics of Maven, so go ahead and add dependencies and you should see that all those libraries are now available in “Maven Dependencies” library. You don’t have to explicitly add any JAR file for your project. (For e.g. In my POM.xml file I added “commons-logging” dependency and Maven plug-in has successfully imported the Jar in project.)

Imported Dependency

Now you can test your project by creating Java files under the package “src/main/java”. You can also execute other Maven goals on project by simply right clicking on project and from Run As options choose required option (Maven build, Maven clean, Maven package etc.)

The definite advantage of this approach is that now developers doesn’t have to run for locating required JAR files, one just need project source and its related POM.xml file. The Maven plug-in will automatically configure the required setting to compile and run your project. But still there is one problem when you want to develop Web Project and run it in Eclipse WTP environment (Pre-configured servers like JBoss, Tomcat etc in Eclipse environment). The WTP will not be able to identify the projects created using above steps. Well sonatype has also thought about it and has created one more plug-in to solve this problem. I will provide the details about same in next article.

These days I am playing lot with Eclipse and its features. Be it building plugins, reading tuts & experimenting or exploring new features, every time I visit one or the other site, I find so many useful & hidden features of Eclipse. The more I try to dig into Eclipse, the bigger and deeper it gets and I wonder if there is an end.
Had some time this weekend and thought of exploring Eclipse and luckily I came across an interesting feature of Eclipse – Rich AJAX Platform (RAP). Some may find that this feature is not new and it mostly resembles to what GWT already offers. I leave that discussion for may be yet another topic. Lets just quickly check what Eclipse RAP has stored in it.

You know only Java
If you are one of those (even if you are not) who know only Java, you will feel right at the home. Eclipse RAP development uses Java as its primary language for development. You don’t have to learn any other language while writing code in RAP.

Eclipse Plug-in Developer
If you are Eclipse Plug-in developer, you are definitely at advantage. Eclipse RAP uses SWT and Eclipse Plug-in project to develop application.

Write Once, Run in Flex/AJAX/JavaFX/Silverlight etc
Yes thats true. You dont have to write code for each technology mentioned above, just write code once in Java and using the Ports you can get the application runtime converted into Flex/AJAX/JavaFX/Silverlight etc. (Note not all of the ports are currently available but Eclipse 4 already supports ActionScript, sadly it is still in incubation stage.)

Cost
If you are one of those who hate commercial licensed software and love what open source community offers, Eclipse should definitely be on top of your list. In near future version with full fledged ActionScript Port, Eclipse is going to be strong contender for Flex Development.

To my surprise, I found that there are already few organisations who are using it for their development and offering solutions using RAP. To experiment what RAP has stored in it, one does not have to necessarily download Eclipse 4 as this feature is available with Eclipse 3.6 (Helios) and Eclipse 3.7 (Indigo). To know more about Eclipse RAP, click here.

Besides RAP, it is definitely worth checking Eclipse e4 version. Though it has been long time the e4 milestone releases has started, its new architecture, UI technology (XWT) etc are interesting. One can find entire list of e4 feature here.

Got some time to play with Eclipse and this time the experiment was with Android. Having heard a lot about this google’s OS and the way it is capturing mobile market, I was bit curious to find out the development tools and understand how quickly one can get into the development. Finally after spending few hours with installation and getting first application running with Android simulator, I found somethings that I would like to share with you. Just to make it clear, this article is no attempt to compare Android Eclipse plugin with other plugins.
To be frank, there was no clear intension of playing with Android, but I just stumbled upon Android full app part I article and thought of giving it a try.

1. Configuration and Installation
The first step involved downloading Android SDK and configuring it with Eclipse SDK. The activity was less painful and without much efforts it got configured pretty easily.

2. Development Language
I like one thing about above article, rather than getting into traditional example like Hello World, the article explains some of the basic concepts about Android SDK development using simple search application. Though the search actually does nothing but I felt it perfect example for those who don’t know anything about Android but having knowledge of Java and XML. Developers of these languages will find right at the home as the don’t have to learn any new language or syntax to start development with Android. The Android UI is developed using XML while the actual logic is handled using Java language. (Initially when I created Android project, I read the XML name as main.mxml and was bit shocked as why Android is using that extension. But no worry, It was my mistake – the file name was actually main.xml

While XML is definitely better way to define UI and much easier than writing Java Code, there are few things that definitely need to be taken care. Most of the element properties (rather all of them) are placed in namespace other than the control itself. This is definitely annoying as the default prefix for this namespace was “android” and I soon found that my 25 lines of XML code has more than 30 words as “android”. All over the XML I could just see one word as “android” and nothing else. Though one can argue that it is possible to change the prefix to something shorter version as “a” and get rid off all those extra characters. But I would rather feel better If the namespace is completely removed or just used as root namespace. (Come on guys, make my code cleaner and dont force me to type in extra characters.)

3. Eclipse Plugin
The Android SDK is not just plain Code editor, but it does come with UI designer. The designing editor contains decent list of controls to use. But there are definitely few things which need improvement in design editor.
The control bar is divided into two parts – Layouts and Views. Android seems to consider common components as Views (quite confusing term for Eclipse plugin developer).
Another notable point is that some of the items listed in Layouts tab also have prefix as View, adding more to confusion as what is the difference between View and Layout. Just to add to the list, RadioGroup is considered as Layout. (Don’t find any reason, as why it is hanging there. RadioGroup is used to define a logical group for Radio Buttons, what it has to do with Layout.)

While it is also quite evident that, there is no much effort spent on managing look and feel of the plugin – the Layout and Views bar can very well placed into other view. (Just check following Flex Builder screenshot – much better and cleaner)

The components listed in control bar, also do not carry icons and are just prefixed with Starting letter. (For a moment I thought I am reading A B C D..). The designing editor seriously needs some improvement.

The A B C D is also quite evident in XML editor and really of no help there, I will be very happy if there are no icons at all and just plain text.

4. Android Emulator
Aha, Finally it was time to test the tutorial application and see if it really works. The project was built in no time and after following tutorial steps to run the application, I found a new window popped up containing Android interface. For some time the emulator just continued to show only one word “android”, I was bit confused as whether something has went wrong with code or SDK and why my application interface is not coming up. But after noticing the console view (some may call it console tab) in eclipse, I found some activity was going on and I just waited for few minutes to see what is happening. Fortunately after some time the application screen just came and now I could test my application.

Though I liked the Emulator interface, it seriously needs some initial performance improvement and some kind of indication on emulator screen about the progress.

As mentioned in earlier post, I have been playing with FLEX builder and understand its extensibility APIs. After spending almost day crawling through various search engines and websites I couldn’t find a single site giving me details about how to work with MXML design editor APIs, I thought of giving up. But fortunately I could able to figure out how things actually work in FLEX Builder, and then I thought of publishing some of the details through the blog.

The next few paragraphs will talk about various APIs and options available in FLEX builder which can be used by anyone to build their own plugin in Flex Builder. While the title of the post says that “Building eclipse plugin”, it surely doesn’t describe basic steps required to build eclipse plugin. To learn basics of building eclipse plugin, you should visit other sites like java2s and yeah offcourse eclipse itself has plethora of information on building plugin.

The aim of this article is to give details about the editor used to design Flex layouts. You must have used plugins which can generate AS code, ident XML code etc in Flex builder but there are very few plugins which actually work on design editor.
Before writing any plugin code you need to make sure that you have the required environment set for plugin development. Though Eclipse comes with built in feature of plugin development, Flex builder doesn’t have built-in support for Java and plugin development project. So to get started with plugin development you need to first install plugin development and Java development feature into Flex builder. Keep it in mind that we need to build plugin inside Flex Builder, the simple reason behind this is to test your plugin code we will require sample workspace of Flex builder and that can be easily started through Flex builder. The installation of Java and Plugin development feature is only required if Flex Builder is installed as Standalone version. If you have installed Flex Builder in Eclipse you can skip this installation.

The next step is to add required Extensions and Jar files in plugin project. Make sure that you have added extensions listed in following image.

Apart from adding above extensions you will need 3 additional Jar files which contain useful APIs. The filenames are derived.jar, mxml.jar and mxmlmodel.jar. You need to search these files in Flex plugins. Now create a default “view” using Plugin wizard available in Eclipse.
The wizard should create all the files required to build plugin.

Lets directly jump into java code and see how you can get the reference of MXML editor itself

MXMLEditor a = (MXMLEditor)getSite().getPage().getActiveEditor();

Above statement will give you the reference of current MXML editor. You need to be bit careful while using this statement as user may not always work with MXML editor (There is action script editor or user may switch from one MXML file to another or may even switch from design view to source code). So you need to logically place this code to get reference of MXML editor.
(Hint: Try to find out details about IPartListener.)

The editor object is pretty much useful to listen to the events raised in editor. An editor instance has a method called getMXMLModel which represents an MXML instance for the editor. You can use the IMXMLModel instance returned by getMXMLModel method to manipulate MXML code. The reference also provides a convenient method to listen to the user selection in design view.
Just place below code after getting IMXMLModel reference

mm.getSelectionProvider().addSelectionChangedListener(new SelectionChangeListener())

Note that the SelectionChangeListener is custom class implementing an interface ISelectionChangedListener. A method “selectionChanged” will be invoked on the above instance whenever user select control in MXML design editor. The method has one argument of “SelectionChangedEvent” which can be used to get the reference of the component selected. I leave the part of getting reference of control using instance of “SelectionChangedEvent” to you.
For demonstration, I have created a sample plugin which displays component selected in “Sample View”, check below images.

The story doesnt end here, I would be revealing more details about API – watch this space.

One of the best feature (yes there are many more) of Eclipse is extensibility. While it has been a most preferred IDE, not just for the development in Java, but for other languages like PHP, XML, HTML etc. building plugin for eclipse is pretty easy. The readymade wizards and built-in plugin templates makes life easier of developers. There are many other IDE built on top of eclipse and one amongst them – Flex Builder (or should I call it Flash Builder – version 4 has launched in market) is fantastic example of showing what eclipse is capable of.

While Eclipse is being so developer friendly with extensions and plethora of information available on how to extend it further, I am somewhat disappointed with Flex Builder extension. Well there are few reasons behind this
1. There is no enough information OR documentation available on internet on how to extend Flex Builder.
2. Though Flex Builder help contains couple of pages documentation about its extensibility features, it doesn’t seems to be enough and informative for the developers.

I am in the process of extending Flex Builder and after spending few hours in understanding how different editors – MXML, AS work within Flex Builder, I could able to get some insight of Flex Builder.

It seems I would be spending few more days (or may be weeks) in finding some secrets of FlexBuilder. Keep watching this space and I would publish my research on Flex Builder.

Translation Plugin

To tell you frankly, this is dumb plugin which doesnt have any intelligence and purely dependent upon third party services to complete its job. I developed this plugin jus for project need and freeing some developer’s brain cells from remembering translation site name. Translation plugin acts as an agent between online translation service such as Google and Babelfish.

Translation View

Features

1. With this plugin you can translate text, property file.
2. You can select source & destination language for your text.

Limitations

It currently doesnot support UTF-16 languages due to limitations in displaying those languages.
This plugin works only with Eclipse 3.5 (Galileo)

Download

You can download this plugin here. Just copy the jar file in plugins folder. To locate this plugin go to Window ->Show View -> Other ->Translation -> Text Translator.

So what other alternate plugins are available in market and why should I use this plugin

This is not the first plugin for Eclipse which translates text from one language to another. There are various plugins which can do this job like

1. code.google.com has one plugin which gets integrated with Eclipse and provides various options to translate text. (http://code.google.com/p/google-translate-eclipse-plugin/). But this plugin is tied up with Google translation service and hence you cannot compare translation results.
2. There is one more available from eobjectsoft (http://eobjectsoft.com/product/productTranslate.htm). Again this plugin is tied up with Google translation service.

One common problem I found with these plugins is that, if you have to choose source language for your translation, there is no direct option available. You have to go to prefrences window and locate plugin section and change it. This sounds lil irritating, what if you have to frequently change source language, would you like to go through the pain of open, locate, update and press ok lifecycle and that to just specify one preference.

Areas of Improvement

1. Yes this plugin is not complete, it doesnt support integration with context menu of Eclipse (one of the feature of above listed plugin.).
2. This plugin itself is not internationalized and current version is available only in English language.

These features will be added soon.

Precautions

Dont completely depend upon the translation service as the results of translation may not be accurate and require professionals to verifty the trasnlated text.
Also there is no out of box APIs provided by Babelfish for translation. This plugin uses screen scraping technique to parse the results produced by Babelfish and hence it takes more time than its competitor to produce results. Results produced by Google translation service converts string that contains characters like {0} to (0). So be careful and review your translated text after plugin completes its job. If you have any suggestions, please use below form to send your suggestions.

Till then, happy translating.