Either You Succeed or Explain

Eclipse Plugin Installation and Windows User Access Control

I make Eclipse Plugins and I sell them to developers using Eclipse. Most of the visitors to my web site are not Eclipse experts. One of my key challenges is getting them to successfully install and try my software. It sounds simple, but Eclipse plugin installation is somewhat complex and error-prone process.

The safest way to install a plugin in Eclipse is by using the update manager as opposed to using the Dropins folder or manually copying files. It is safer because Eclipse performs more checks to ensure everything is in order. For example, it can check that all the dependencies are met.

Lately, I got several reports from users who failed to install my plugin using the update manager. After some research and with the assistance of some devoted users, I located a major issue: Installing Eclipse plugins on Windows Vista & 7 with User Access Control (UAC) on, fails if Eclipse is installed in the Program Files folder.

It is a very common scenario: many users are already running Windows 7, the UAC is on by default and the Programs Files folder is where most of the applications are installed, especially custom Eclipse distros that come with fancy Installers. It is a frustrating issue because the plugin installation appears to be complete: it will not issue any error message and, after restarting the platform, it will even show up properly in the Installation Details box. However, the plugins and features JARs are not copies, hence the plugin in not installed.

There are several possible work arounds for this issue: (starting from the easiest)

• Before the installation, start Eclipse with "Run as Administrator" option.
• Turn off the pesky UAC (for the installation or, better yet, altogether).
• Install Eclipse in a different folder. Eclipse doesn't have to be in the Program Files folder.
• Switch to Linux or Mac.

Clearly, the way Eclipse is handling it is bogus and should be fixed. This problem has been around since the days of Vista and Eclipse 3.3. I understand that installing a plugin in this case is an issue, so the least Eclipse should do is fail the process and not mislead the non-suspecting user. If you agree, you might want to vote on this bug (there are several bugs on this topic).

PS. If you're looking for more useful tips on installing Eclipse plugins, check out this article. It was written for Galileo but still applies to Helios.

PS2. I know, I wrote an entire article on Eclipse plugins installation and never once mentioned P2. So, there, I mentioned it.

Eclipse 3.6 Hidden Treasures

Eclipse 3.6, aka Helios, was released about a month ago. It has become a tradition: this is the time I highlight some of my favorite hidden features in the new release. I focus my article on features which are less obvious, off the beaten path. Features you might not be familiar with if you didn't take the time to read the "new and noteworthy" for this release.

If you haven't done so already, you are invited to read my posts for Eclipse 3.4 (Ganymede) and Eclipse 3.5 (Galileo) (which won the Galileo Blogathon). You can probably pick up some new tricks there as well. I also took the time to reiterate on some of my favorite shortcuts, which made this article a tad longer.

As always, if you are familiar with more features which are hidden and worthy, please let me know in the comments.

The Eclipse Platform

Resource Filters

Projects in Eclipse are associated with a root folder. All the file hierarchy of this folder is included in the project. This hierarchy is visible in the Navigator view. In Helios, you may selectively filter out files and folders from your project. For example, if your operating system creates extra files (like those pesky .DS_Store files in OS X or thumbs.db in Windows) you don't need in your project, filter them out. Right click on a project or folder, select Properties and look under Resource → Resource Filters.

Opening a File from the Command Line

 Eclipse is a powerful IDE. It is a perfect companion when working on a large projects. However, for most people, it does not replace the conventional text editor for more casual work like composing HTMLs, tweaking CSSs or going over XMLs. I'm guessing that the reasons for that are rooted in the original Eclipse concept: working only on files within your projects. In older versions it was very difficult to open just any file from the file system in Eclipse for editing.

The situation today is very different. You can drop a file directly into Eclipse, but that was possible in Galileo. In Helios, there's a new addition which enables opening a file directly from the command line. This opens the door to associating files with Eclipse. For example, you can double click an HTML file in your operating system and open it in Eclipse for editing. It will require a bit of hacking, but it is worth it. To get started, visit this page.

Learn Keyboard Shortcuts with Quick Access

 The Quick Access feature is one of my favorite features in Eclipse. It acts like a universal launcher: hit Ctrl+3 (or Cmd+3) and start typing the name of a command, view, perspective or any other UI element that can be invoked. It's a very quick way for launching commands without ever leaving your keyboard.

This very handy feature just became even more useful: it now shows keyboard shortcuts within the view. This makes it a perfect tool for learning and memorizing keyboard shortcuts. For example, what is the keyboard shortcut for switching to the next editor? You could look it up in the menu or preferences, but that takes too much time. Besides, if you reach for the mouse you'll probably end up just selecting the next editor. Instead, hit Ctrl+3, type "next editor" and you will learn that the shortcut is Ctrl+F6.

Workspace Names

 Many Eclipse users use more than one workspace. I often find myself switching and even working with multiple instances of Eclipse running different workspaces. Helios introduces a handy little feature which lets you assign a name to your workspace. This name will appear first in the window title, before the perspective name and current file name. The options is available in the Preferences, under General → Workspace.

Java

The JDT (Java Development Tools) is one of the oldest projects of Eclipse. No doubt, it is getting better, not older. I do wish there was a bit more innovation. Well, that opens the door to innovative tools like nWire for Java.

Package name abbreviations

 Here's a common scenario: you are using the package or project explorer, and view the packages in a flat view. That's probably the most convenient way to look at your source tree. With one major drawback: the package names are usually too long which leads to either excessive horizontal scrolling or a wider side bar that takes too much screen real-estate.

Helios solves this problem: you can assign abbreviations and shorten the list. In the Preferences, under Java → Appearance. For example, org.eclipse.ui can be shown as [ui]. This applies to the project sources and included JARs as well.

More preferences import/export

 Copying preferences between workspaces is a challenge in Eclipse. One of the critically overlooked feature is Eclipse is the ability to export and import preferences. You start with File → Export and select General → Preferences. Now, you get a list of preferences sets that can be selected to export. Import works quite similar.

Unfortunately, many preferences are missing. In order to support this feature, each plugin need to specifically "ask" for it and not many do. In Helios, JDT adds support for exporting/importing the Java appearance, code style and compiler preferences. This is a neat feature which makes backing up and sharing preferences much easier.

Variable Instance Count in Java 1.6

 Now for a little debugger upgrade. The debugging perspective has the very useful Variables View. It is often neglected, but this view has more information to offer. The default columns are Name and Value. The view has a small drop-down menu on the top-right corner. By selecting Layout → Columns → Select Columns... you can choose which columns are shown.

Helios adds a very useful column which shows Instance Count: the number of instances corresponding to the concrete type of each variable. It requires JVM 1.6 or newer. Handy for chasing those pesky memory leaks. This joins the Galileo feature of showing a list of instances of a given type: select the type in the editor or outline view, right click, and from the context menu select All Instances.... The instance count is available from the same menu as well.

Formatter on/off tags

 I'm a big fan of Save Actions since the early days of Europa (for more information, read this article). For those not familiar with the option: it enables certain formatting rules and code clean-ups which will be executed after each save. It works really well for me and I'm simply lost without it.

As much as I like it, there are specific cases where I wish it was off. For example, if I put a little ASCII diagram in the comments and don't want the formatter to destroy it by wrapping the lines. Helios adds two formatter tags, added as line comments, that turn the formatter on and off. You need to specifically enable this feature under the formatter settings (Java → Code Style → Formatter), in Off/On Tags.

It is also interesting to note that in Helios you can no longer modify the formatter built-in profiles, you must create your own.

PDE (Plugin Development Environment)

Feature based launch configurations

 This could be a big time saver for people who are serious about plugin development. When launching a plugin for testing and debugging using PDE, the default behavior is to load all the plugins of the target platform. This has several drawbacks, mainly, performance. Loading less plugins means quicker launch and smaller memory footprint (read my article about this subject).

There are other scenarios where you might want to start with a partial feature set. For example, for testing, you might want to load JDT but not Mylyn. In previous versions, this required going over a list of literally hundreds or plugins and handpicking them one by one. In Galileo, you can create launch configurations based on features, which is a big time saver in this case. To get started, edit you Launch Configuration, under Plug-ins, in the Launch With field, select Features Selected Below.

OSGi Console

 This one is for your inner hacker. The Equinox OSGi implementation, as every plugin developer should now, is the underlying framework of the Eclipse platform. In Helios, you can open a console and tap into your running platform through the OSGi interface. To open an OSGi console, open a Console View, and from the Open Console drop-down menu (top-right button) select OSGi Console.

What can you do with an OSGi Console? Start and stop plugins, Check for plugin dependencies issues, install and uninstall plugins, list OSGi services and much more. Type ? for a list of all possible commands. Let the hacking begin.

API Use Reports

 The API use reports have been around for a while, but now they are well integrated and easy to use. These reports describe which APIs and internals are being used by other bundles. There are many options for these reports. For example, look at the report of PDE against the Helios API.

The API Use Reports are tucked away in the External Tools section. To get started, select Run → External Tools → External Tool Configurations... select the API Use Report node and click on New Launch Configuration.

Other Plugins

Quick Outline in XML/HTML/CSS

 The Eclipse WebTools project includes useful editors for many web-related file formats like XML, HTML and CSS. This was already a good editor, but it just got even better. The most notable addition is the new Quick Outline option (Cmd+O or Ctrl+O) which works much like in the Java editor, showing a hovering outline of the file with a quick search option. There are more improvements in other areas, including the content assist.

The Quick Outline may not be such a hidden feature, however, many Eclipse users are not familiar with the WebTools editors. I recommend checking them out, they are very good.

Faster PHP Resolution (plus, a tip on how to make it even faster)

Helios includes a new version of PDT (PHP Development Tools): 2.2. Apart from some new features on the surface, there are many enhancements behind the scenes. The module responsible for resolving artifacts was redone to improve performance. This affects features like code completion, Open Type, Type Hierarchy, etc. If you tried PDT before and wasn't very satisfied with the performance, you should give it another go.

nWire for PHP, which is based on PDT, also benefits from this performance boost. The new PDT uses the H2 database engine (running locally) to keep all the resolution details, a concept borrowed from nWire. If there's something we learned, is that it is imperative to turn off virus scanning on the DB files to keep the performance smooth.

Our suggestion is to disable scanning of the entire workspace folder. If you are worried about viruses, the database files are in <workspace root>/.metadata/.plugins/org.eclipse.dltk.core.index.sql.h2/. Alternatively, if you can disable scanning by file suffix, disable the files ending with .db.

Conclusion

Eclipse Helios is a worthy release, filled with hidden gems. If you haven't upgraded yet, now is a perfect time to do so. You can head over to the Eclipse downloads page and get Helios today.

Alternatively, nWire is now offering free downloads of the standard Eclipse packages over a highly optimized CDN based on Limelight globally available infrastructure. It is a mirror of the Eclipse main site, so you get the same packages, only faster. Much faster. Go get Helios today.

Eclipse Helios Gets Cozy with Your OS

Let's start with two, non trivial, claims: (a) native apps are not dead yet (OS native, as opposed to web apps), (b) people prefer the native apps. 

It's relatively easy to see that when looking at the modern mobile platforms: iOS and Android. There are so many native apps and developers even develop native apps for both platform. In most cases, this could be solved with one good web app. But people prefer the native apps. Facebook is a good example. They have a good mobile site, but people still install and use the native client.

Why? I don't have anything substantiated, but here's my guess:

• It is faster - the performance of HTML rendering and JavaScript execution on mobile devices is still sub-optimal.
• Unified experience - it fits better within the OS: it looks the same, uses the same widgets, etc.
• It works offline. 

Does this applies to the larger devices?  I believe so. On the face of it, there's a rise in web apps and decline is desktop apps. But, the desktop is not dead yet. Office apps are a good example: even Microsoft thought it would be wise to create a web-based office apps, but it still kept the Office 2010 on track (with 9M beta downloads...) and we would probably see Office 2012... 

I believe most of the reasons above still apply in the desktop world. Speed is less of an issue with the current browsers arms races. That leaves us with offline capabilities and unified experience.

Now, let's look at Eclipse. IMHO, it is the best open source framework for cross platform desktop app development. Mainly because it blends into the operating system. It feels more natural than any other solution. It blends so well, some people will never know it is Java behind the scenes. 

Eclipse Helios (aka Eclipse 3.6), which was released a couple of weeks ago takes this even further with cool new ways of assimilating your application into the operating system. I chose two new features that may look minor, but make a lot of difference to end users.

Open File Feature

 This features enables Eclipse to open files directly from the OS. This means files may be associated with Eclipse or Eclipse-based applications. For example, you can associate Java files with Eclipse and have them open for Editing within Eclipse with a simple double click. If you've always wanted to use Eclipse as a text editor, now is your chance. 

The new feature enables launching Eclipse and opening a file from the command line as well as opening a file in an existing Eclipse instance, although I found that works better on a Mac and not as well on Windows. The original Eclipse distro does not include an installer, so it does not set any file associations in the operating system. You can do it yourself, more details can be found in the Eclipse wiki. Nevertheless, it opens the door for other distributions and Eclipse-RCP based applications to provide such features with minimal effort. 

Well done.

Taskbar/Dock Icon API

The TaskItem API enables some very cool tricks that can be applied to the application icon in the Taskbar on Windows or Dock in OS X. It includes:

• Overlaying an image or text over the icon.
• Displaying progress.
• Adding custom right-click actions to the icon. 

While this works really well with Windows 7 Taskbar and the OS X Dock, other operating systems may not support all these features. Still, I think it's a worthy addition to  the Eclipse API arsenal and I hope to see more application that support it. 

The images were taken from the Eclipse Helios New and Noteworthy pages. Developers who wish to utilize those new features should look at this snippet as an example. 

         

Looking Forward

IMHO, these features, along with many more additions, makes Helios an even more compelling choice for cross platform desktop development. Once you do decide to make the leap and turn your app into a web app, check out Eclipse RAP as a possible solution (but that's a topic for a different article).

Tidbits from the Eclipse Community Survey 2010

The Eclipse Community Survey is held every year by the Eclipse foundation. You can find an accurate summery of the important trends in this post and the original report can be found here (pdf). After going over the report and the data, here are some notes I took. 

PDT doubles CDT!

In the question "What is your primary IDE?", JDT takes the lead by far with 53.7%, then PDT with 14.3% followed by CDT with 7.4%. This is a huge win for the PDT team. I think this trend will become even stronger. The new PDT 2.2 (to be released in the upcoming Helios) is a big improvement, especially in performance, and we will see more and more PHP developers upgrading to PDT. This is also an indication for the maturity of PHP.

Interesting to see that only 9% answered that they use PHP as a primary language while 10.5% are using C/C++. Almost 25% of the people answered that they allocate some time (over 0%) to PHP coding, compared with 31% on C/C++. The PDT package does include the Java tools, so that might be a reason PDT is more popular. 

Scala Anyone? Ruby?

I've said it in the past: there are some vocal minorities. Scala as a primary language got 0.4% and Ruby got 0.3%. However, 4.4% answered that they allocate some time to Scala, 4% to Ruby. Still, it is a minority. 

The following graph shows the percentage of people who allocate any amount of time to a given language. 

 

Nobody does Mobile?

There was a question regarding mobile application development. The results aside, 31 people answered it. That's about 1.8% of the people who took the survey. Is there a strong bias here?  About 13 people said they were doing J2ME. They are probably the last :-) 

Eclipse Version Being Used?

Over 75% are using Galileo. I wouldn't count on it, as it seems biased. People who answer the survey are people who read blogs, follow Eclipse rock stars on Twitter and frequent technology sites. These are innovators, hardly the mass market. It's suffice to see that over 7% are using Helios milestone build, and that's before the RC builds (release candidates). 

About 12.3% of the people in the survey are committers or belong to an organization which is an Eclipse member. That's hardly balanced. 

Windows in Decline?

From 2007 to 2010, Windows as primary operating system went down from 74% to 58%. Most users migrated to Linux, some to OS X.  While I can see the trend myself, I think the 58% number is just too low. It is probably more subtle in reality. I know people from several companies that use Eclipse, none of them (apart from Google) use Linux as their primary OS. BTW, if you were wondering, Ubuntu is the leading the Linux pack. 

Spring surpasses JEE?

In the question "what is the primary server framework you use", Spring got almost 20% and EJB behind with 19%. That is huge, BUT... There is no distinction between Spring MVC and other Spring components. So people who use EJBs with Spring MVC (I'm guessing quite a few) are in the Spring crowd. Struts is still being used more than Struts 2 and JSF: both never took off. 

Amusing anecdote: there are too many developers who don't understand the difference between a server side and client side.

Redmine is Popular!

I use Redmine to track issues (I love it!) and it seems that I'm not alone. It wasn't even an option, yet, 47 people answered other and wrote "Redmine". That's only 2.8% of the total answers, but, it's the 5th most popular after the Jira, Bugzilla, TRAC and Mantis. It should be a first class citizen in the next survey and appear as an option on its' own.

People Are Happy, But...

There is an overall satisfaction. Over 300 people chose to leave written feedback. I believe that every committer and every employee within the Eclipse organization should take a minute and go through the feedback (The last question, 38, can be found in the raw data, links in Ian's post). There's plenty of criticism and a lot we can learn from.

Personally, I found quite a few complaints around the issue of plugins. The game of mixing and matching plugins with incompatible interface and inconsistent quality seems to bother a lot of people. It makes me wonder whether there shouldn't be an approval process to plugins. You can publish a plugin, but it will only get the Eclipse seal of approval once it goes through a certain process. I think that's something worth considering.

Firefox is the Moses of Web Browsers

Moses had a very significant role in the history of the Jewish people, maybe the most significant. According to the bible, he led the exodus, the departure of the Israeli people from slavery in ancient egypt. Moses then led the people to the promised land, a journey which took 40 years. Along the way, Moses received the Ten Commandments which signify the most important convent between God and the Jewish people. Pretty much the  beginning of Judaism as we know it. 

Firefox had a similar role. We were all slaves in the hands of Microsoft. Using ancient versions of Internet Explorer which were specifically designed to be proprietary and non-standard, making sure we remain locked in the hands of our dark masters. 

Then came Firefox, stood up and said: "let my people go". The IE market share was around 99.99% at that point. It seemed like an impossible task. Many web sites didn't even work properly in Firefox, which preached for standards based internet for all and the freedom to choose your tools. It was a slow campaign, but, luckily, it didn't take 40 years. 

Moses did not enter Israel. He died in the desert after seeing the promised land from afar. This is tragic, but it is very significant. There are many stories and interpretations around this. Most people agree that this is because of a sin in his past. The whole point of walking in the desert for 40 years, was to "dispose" of the old, sinful generation (what we call "the desert generation") and start fresh and clean. No sins. Moses did his job by bringing the people to the point where they can start fresh. But he had to go, eventually, so they can start fresh. 

Firefox has done his job. Now, when the promised land is in sight, it is time for him to go. Firefox is showing its' age. It is no longer innovative, it is now lagging behind. It is slow and consumes a lot of resources. 

One of the key benefits of Firefox was plugins. True, IE had plugins, but the open nature of the Firefox community created a massive number of plugins for all purposes. Many of these plugins kept me from moving to other browsers. The same plugins are also responsible for many of the problems, or at least for making them worse. They leak memory, they slow you down and they crash. For the common user, it is impossible to attribute these problems to a specific plugin. It is perceived as Firefox issues.

Firefox played an important role in the history of the web. It did its' part. It is now time for the new generation of browsers to take the stage, the WebKit generation: Chrome and Safari. We will always cherish Firefox for its' role. Farewell old friend.