Eclipse and Java Blog by Michael Scharf

Contradicting myself with my eclipsecon submissions....

2009-12-20T19:37:00.004+01:00

If you look at my EclipseCon 2010 submissions:

1443 Declarative UI sucks? Create your own!
1480 Extensible EMF Switches
1483 Annoyed by all those similar looking interfaces: IMemento, IConfigurationElement, IPreferenceStore, IDialogSettings, ILaunchConfiguration...
1484 JFace/SWT Tables turned upside down

It seems that I am contradicting myself, because in 1443 I propose to create your own (copy) of a declarative UI and in 1483 I whine about all those similar looking interfaces. How does this go together?

Well, in the case of all the different property stores, they all do the same and having 10 different classes/interfaces is indeed annoying. On the other hand. I simply do not believe that there is "the" declarative UI that solves everybody's problems. Whenever you try to create the ultimate declarative UI you are doomed to fail because it is either simple but too restrictive or powerful but too complicated (I'd be very happy if someone could prove me wrong).

The idea of a domains specific language is to be Domain Specific! One could argue that UI is a domain and a (e.g. xml based) declarative UI is a domain specific language for creating UI. But, in reality UI is not UI. It's like creating a domain specific language for programming. You end up creating a Turing complete general purpose language. OTOH, if you want to create a domain specific language for form based UI on top of EMF you have a good chance it becomes a good abstractions. But do not expect this language to be used to create something like JDT or PDE.

I do not believe there is the ultimate declarative UI language. But I believe that saving properties is so universal (and simple) that one 'language' should be sufficient.

Future of eclipse: The Road Construction Analogy

2009-10-24T04:38:00.002+02:00

Frank Gerhard will host a session at ESE called Symposium on Eclipse Foundation 2.0. Half a year ago I burned my fingers with my "Eclipse Freeloader Award" blog entry. I got lots of negative comments and mails. I also got a few positive reactions. I decided not to continue talking about the future of eclipse.

Today, half a year later I look back and one interesting mail I wrote at that time is an email press interview. I decided to post it as I wrote it and I use it as my position paper for the symposium.

If this blog is to long just read the "The road construction analogy" section. This is the part of the interview I am most proud of....

The last months I have been heavily involved in an internal Wind River project based on eclipse and modeling, especially Xtext and I have not had too much time to work on eclipse except bug reporting and asking stupid questions on the tmf newsgroup.

I have no idea how the community will react on that (very long) post.

Disclaimer: The text below was written half a year ago. It expresses my personal opinion at that time. I have not followed the recent developments and I might change my mind at any time... ;-)

My reply to an e-mail interview on April 18. 2009:

Q: If you were ready to give the freeloader award, who would be the three finalists for the "honor." Why these guys?

A: I had no particular company in mind. However, it is the general mentality of the industry that frustrates me: the attitude to take advantage of something like open source and not give back anything to the system. This is also known as the "Tragedy of the Commons": Scott Lewis pointed out that the bigger a community is the less people participate: "The Logic of Collective Action"

From an architectural perspective, there are things to be done in eclipse that should not been driven by direct interests of some companies but in the common interest of the community. IBM somehow took this role for a while, when they put some of their best people on the core of eclipse. At that time they were interested in the overall success of eclipse. Since some years they started removing quite some developers from eclipse (and put them on the Jazz/RTC project).

I believe there should be an independent group of developers driving eclipse. In my opinion it would be best if they would be paid by the community but act independently in the best interest of eclipse.

Now the questions is: why should companies put money into something that is free? If they put money in the system and their competitors do not, they have a competitive disadvantage. They support the community but they have no direct advantage. And in fact the company I work for (Wind River) just ended their membership (which is a sponsorship of the foundation) just recently.

That is why I was brainstorming about ideas how to stimulate companies to contribute. I am really afraid that eclipse will suffer in the future because the architecture degenerates over time and there is not enough manpower to keep modernize the architecture. Yes, there is e4 (the next generation of eclipse), but I am not 100% convinced that this is the solution.

To stimulate companies to give money/resources to support the commons there has to be a benefit. If there is no positive benefit why would a company do that? So, my idea was to create peer pressure. One way to create peer pressure for companies to make them avoid negative press. A freeloader award would create negative pressure. No company would like to win the freeloader award.

Q: Other people I've spoken to, include Mike M. at Eclipse are much less concerned about the problem. Why do you see it as so serious?

A: Well, I probably have a different perspective than Mike. Mike sees the eco system and the new companies joining eclipse. My focus is more on the architecture of eclipse. So, the irony is that although eclipse is widely successful the underlying architecture ages and dissolves slowly. Partly because eclipse is stretched into so many different directions. It is never good for an architecture to go into too many directions at the same time. When eclipse started it was a platform for IDE like applications. It was later retro fitted to be the basis for rich client applications. The people ported eclipse to embedded systems. Then the it was used for the web and for servers.... All this is good for the short term success but I am afraid that the long term impact on the architecture could be disastrous. The architecture council is not really focusing on architecture. Partly because the members have never been the ones that created and drove the original architecture. And partly because architecture by committee is doomed to fail.

The road construction analogy

One analogy for the general eclipse community problem I have been thinking about recently is road infrastructure in a country. Suppose a big company (=IBM) created a basic road infrastructure and decided to make this available to the public for free (=original eclipse).

In the beginning, the big company somehow drove the journey and continued building the free infrastructure. They also had some interest in this infrastructure because they wanted to have a well accepted public road system to deliver their products. But over time they gave the roads to the public and let the other companies continue building the roads. The hope is that the market is self regulating and it would continue maintaining the road infrastructure and new roads would be build by other companies.

In the beginning the companies understood the plan of the big company and continued building in that spirit. But some companies realized that it is not in their interest to build roads for their competitors. And it makes no sense for them to maintain the highways in general. They might build junctions to their private road network but hope that others maintain the net of highways created by the big company long ago. Sure they would fix some obvious holes on the roads. One could argue that roads build like that really reflect the needs of the community. But some of companies make sure the competitors do not get access to their key roads. What happens is: many private roads are be build in parallel, instead of some new highways. Companies would build "public roads" that connect their private roads. If the companies would understand that they all would benefit form good public roads, then they could come together and hire an independent road building organization and give them money (a kind of tax) to build the roads that are in the interest of the entire eco system. But at the moment there is no authority to enforce the tax payment. Lots of the roads are public and some companies donate "public roads" to the system. Who could blame those companies? They give something free to the community but also act in their own interest. They are much better than companies that use the public roads without contributing back. But something is wrong here. The nicely designed infrastructure degenerates over time. Can we blame the ones who contribute for that? That is the key to the problem: companies are contributing, but the contributions are not really in the best interest of the eco system.

How to solve the problem? How to make sure that roads are build that are in the common interest? Would it make sense to have a "tax paid" independent organization build and maintain the infra structure? How can we motivate the community to pay the taxes? Can we blame the companies that fix the roads and add now ones?

Q: Any suggestions, besides public disgrace, to ease the problem?

A: The questions boils down to: how can we motivate companies to maintain and enhance the common infra structure?

Positive motivation: all participants understand that they have to invest into the system beyond direct interests. But do all participants understand that? And how to deal with community members that do not want to pay their taxes? If someone can get away not paying the taxes the others who pay the taxes are the stupid ones. So, positive motivation works if all participants understand that they depend on the system. It essentially requires a certain level of moral. The bigger the community (and the more anonymous) the easier it is to get away without paying the tax. And in a capitalist world companies act in their own interest. Who can blame them for doing so? How else can they survive?

Negative motivation: have a police, a pillory, public opinion (press), a freeloader award. Something that puts pressure on members that do not want to pay their "taxes"...

Q: I always prefer to quote people by name, but if you like, I can withhold yours.

A: You can quote me. Those who know me know that I can change my mind very quickly. Partly because I simply forget what I say and partly because I like to look at problems from very different angles. Therefore, I could never ever become a politician because you could find lots of statements where I contradict myself.

If I look into the eclipse world, I see that the number of people warning about the future problems is underrepresented. That is why I raised my voice. If everybody would scream and warn about the future of eclipse, I would certainly find a lot of good arguments why eclipse has a bright future and why the current eclipse eco system works so exceptionally well and why eclipse is a great example of a successful open source project.

But at the moment I think there is not enough awareness of the problems of the tragedy of the commons. And that companies think they act in their own interest, but in the long term and from an higher level, they do not act in their own interest because they "ultimately destroy a shared limited resource".

[sorry for the long reply, but this is a topic that upsets me at the moment because I can see the disaster coming]

Never put things above a user specified path

2009-09-17T21:05:00.008+02:00

If you tell a program to use a path to store something you normally expect that the program puts its data inside that path and not into the parent. Sounds simple, but in the last 24 hours I ran two times into violations of this basic principle.

1. For the next release of our Wind River Workbench product we will use p2. We have thought our customers to use the -configuration option to redirect the place where eclipse puts its "stuff" if they use a shared installation. If they have different installations or different versions installed, that worked nicely (before p2): for version 3.0 they would use -configuration /someplace/wrwb3.0 and for version 3.1 they would use -configuration /someplace/wrwb3.1. Unfortunately since version 3.4 eclipse violates the principle "never put things above a user specified path" (bug 230384) and puts things like artifacts.xml and the p2 directory above the directory specified. If customers mix different versions of our product the old way, then they get a mess because two configurations that are supposed to live side by side suddenly share the potentially incompatible information in the parent. We are thinking to change the behavior of -configuration to add implicitly one more directory (to turn a user specified -configuration /someplace/wrwb3.0 into -configuration /someplace/wrwb3.0/configuration) so that the two configurations -configuration /someplace/wrwb3.0 and -configuration /someplace/wrwb3.1 do not infer with each other.

2. I am really excited about Xtext! Yesterday I created a new Xtext language project (let's call it gr.scharf.mylanguage). The wizard suggests to call my language gr.scharf.MyLanguage. Sounds good, but it puts its files into the package gr.scharf which is not such a good idea, because it pollutes the parent name space (see bug 289780) and therefore violates the principle "never put things above a user specified path".

Conclusion: if the user gives you a path put things underneath the path and do not touch the parent!

...think twice to make sure not to violate this simple principle....

Every pixel counts! The new eclipse fullscreen plugin...

2009-06-13T19:13:00.012+02:00

A few days ago Kevin McGuire blogged with the title Every pixel is sacred (not any more!) and a follow up Eclipse UI Real Estate Wasters!. I still believe that every pixel counts and I often wanted to have eclipse in full screen mode to save a few pixel. I use full screen mode in the browser and with pdf files a lot and I really love it. I remembered that there is a new Shell.setFullScreen method in SWT. During a boring meeting, I decided to create a small plugin that would add a toolbar button and a menu entry to toggle eclipse in to fullscreen. I started with the "New Plugin wizard" and choose the Hello, World Command example and replace the handleCommand line with one line:


window.getShell().setFullScreen(!window.getShell().getFullScreen());

I changed the labels in the plugin.xml and I was done, in less than 10 munites.....

I should know that even "simple" things can be quite complicated.
I wanted to make the plugin nice and share it but that was the start of a nightmare..... but that is another story.

Download/update

You can use this site as update site or download the plugin from here: gr.scharf.fullscreen.zip

Functionality

The plugin has been written for eclipse 3.5 but it works also for eclipse 3.4 although there are some problems with the handling of the toggle state of the commands...

The plugin adds a Fullscreen command to the Windows menu and a Keybinding M3+F11 which translates on windows to Alt+F11:

When fullscreen mode is active all (main) windows are in full screen mode:

There is also a Toolbar button that can be enabled. Because the plugin uses the Commands Framework there are some unfortunate restrictions (bug 280033):

When you go to Window->Customize Perspective->Tool Bar Visibility, you will not find the Fullscreen tool bar unless you have enabled it in Window->Customize Perspective->Command Groups Availability
The Toolbar details are empty, although the toolbar contains a command:

Once you have succeeded enabling the toolbar button, it will look like this:

and

I decided to hide the button by default, because in most cases the shortcut and the windows menu command should be enough.

Why is RCP, EMF, p2, databinding... so hard to learn?

2009-05-12T02:28:00.007+02:00

There are some interesting discussions on my recent blog entry on "How to explain EMF?". The debate is between those who find it hard to learn EMF and those who have a hard time seeing the difficulty. I think there is a general pattern behind this debate. The same arguments could be made for almost any non trivial technology/framework inside and outside eclipse (EMF, RCP, p2, databinding, [your "favorite" hard to learn technology],...).

Why do many people really suffer form the steep learning curve and others master the same technology easily?

I think we have to step back for a moment from any concrete technology and we should to look at how the technology gets created and how learning and applying of the technology works.

The creators of the technology/framework have a deep knowledge in the particular domain the framework solves. They have created several software systems where they saw some reoccurring patterns. They realize by putting the common parts into a framework they can dramatically increase their productivity, because the work is then reduced to assemble the pieces and write some "glue code" (in some sense they create a kind of domain specific language for that problem). As long as the creator(s) of the abstraction are the only users of the system, there is no real problem and they can show dramatic increase of productivity, because they can focus on the business relevant part of the system.

Now comes the next phase, where others adopt the technology. Those early adopters are usually people with a similar experience background as the original authors of the framework. They have typically written such systems by hand or created their own framework and they see the value of the technology. For them, learning the system is almost effortless because they understand the underlying problems and the solution provided by the cool technology. Good candidates of successful adopters are typically consultants using the technology in multiple projects. They report impressive increase of productivity. Let's call them expert users.

Now another category of users, the normal users wants to use the technology. They see the impressive results created by the expert users. The expert users tell them how effortless this is and how quickly you can create solutions.This is where the problem starts! The expert users understood the problem before they started, they understand the solution in depth and they reapply the technology to many projects. The normal users typically have a single project where they want to apply the technology. They might have a vague understanding that the new technology fits to their problem. The "documentation" build from expert users for expert users make no sense, because there is a lot of background knowledge and experience missing. Normal users have to put a lot of effort into learning and understanding a complicated system just to apply it once.

If the normal user manages to use the technology to solve his problem, his solution is often "suboptimal", because he might be happy to have found just one solution. The expert would see that it is by far not the best possible solution, because he has a much deeper understanding of the solution space. OTOH, the normal user might have a much better understanding of his specific problem domain and the expert might propose a bad solution, because his limited understanding of the problem domain.

Let me give you an analogy: Some weeks ago, my mother told me that she has a serious problem, because her old typewriter broke. She explained me how they do their tax-declaration: my father hand-writes tables with income and expenses and my mother types them with the typewriter. Well, they have a computer (which they use to read email and browsing). The solution is clear: a spreadsheet is all the technology they need to optimize the process. Me "the expert", could just tell them that they can be much more productive by using this "new and cool" technology. All, they'd have to do is to enter the numbers directly into a spreadsheet and with a few more mouse-clicks and a bit of excel programming he would even get some cool graphics and analysis.... Do you think I did that? No way. They are in their mid 70ies, they have done it "their way" all their life. How steep would their learning curve be? Does that mean they are stupid? My father is extremely good with his hand written tables, he uses colors and creates cool graphs by hand. He has an extremely good understanding of the money flow. He even knows exactly how much money they spend on me and my brothers from our birth to now. I wish I would have 10% of his knowledge on where my money flows.

In this example we see very well the difference between "expert users" and "normal users" of the technology. This technology would work really well for me and would not work at all for my parents. And even if I would try to teach them, I would have to use a very different language to explain it to them than I would use it explaining it to you. I would have to explain them what a spreadsheet is and so on. Then I could ask them if they prefer open-office or Microsoft office. Because they have absolutely no idea, even this simple this choice would stress them a lot.... Once they would start with an empty spreadsheet, there would be so much choices and decisions to make that they would be totally paralyzed. Would examples or documentation help? Well somehow, if an example does exactly what they want to do, but then it is almost the solution. Does that mean that spreadsheets are complicated technology? Well, it depends on your background. I think it would be more efficient for me to help them doing their tax declaration and prepare a spreadsheet and every time they do it, sit with them and help them. But I think the way they do it is OK for them, all I need to do is to fix my mothers typewriter.... If they were young and they had a lot of numbers for their tax declaration, it would make sense for them to learn the technology....

OK, I stressed this example enough... What does this mean for the "complicated" technologies around eclipse?

There is a big danger that a great technology gets a "bad reputation", just because "normal users" want to apply it and they find it the technology incredibly hard to learn and to apply.
As expert user, you can cause a lot of damage it you tell some unexperienced users to use a technology without guiding them. And in some cases it might be better to tell them not to use the technology if they are not "ready". For you it might be the right choice, for them it would cause disasters at all levels.
Learning "complicated" technologies might not be worth the effort if you want to apply it once.
Ask yourself if it is more efficient to hire an expert than to learn the technology. Especially if you want to apply the technology only once in a relatively simple way. In this case the expert can be 10-100 times more efficient than you.
If you are a normal user and you still want to learn the technology, be prepared that is takes time and it is a painful process. In order to make educated decisions you have to become at least "Competent" (see the Dreyfus model of skill acquisition) or needs "Conscious competence" (see Four stages of competence).
Maybe expert user and normal user should team up to write documentation and create example. For experts it is often very difficult to understand the problems of normal users and for normal users it is impossible to come up with good examples and documentation.

This post is a bit longer than my normal posts and I kept is as draft for a while but I decided to post it. It is a bit like with complicated technology: you can't explain it in two sentences ;-)....

How to explain EMF?

2009-04-23T03:51:00.003+02:00

Have you ever tried to explain EMF to nonbelievers? I find it difficult to explain what EMF is and why it makes sense to use it. I had this a few times in my career:

In the mid 80ies when I started with object oriented programming. For procedural programmers (modula2/pascal/C/Fortran) it sounded like a lot of buzzwords and seemed to add no real value...
End of 80ies and in the beginning of the 90ies (before the GOF book was out), patterns seemed to be quite fuzzy and it was hard to explain what the value of describing "patterns" is.
Around the same time I discovered scripting languages (starting with (g)awk->TCL->perl and ending with python, which I used for a decade). It was hard to motivate why those "slow" languages are in any way useful.
Aspect oriented programming is still in the "hard to explain/motivate" phase.

The common pattern with those "hard to explain" new technologies is that they are incremental changes to existing stuff but once you understand and use them, they change the way you are thinking. If you adopt the "new technology" you feel a boost in productivity and you see better ways to solve old problems. The level of abstraction raises and you can focus more on the problem instead of dealing with low level implementation details (or reinventing the wheel). And then comes the time when you think all problems can be solved with the new "hammer"....

It is similar to converting to a new religion. For the believers it changes their life. It changes the way they see, experience and interact with the world. For the nonbelievers it looks like a stupid set of paradigms that make no sense. They learn how to block the arguments of missioners of the new religion and the more missionary the believers are the more skeptical the nonbelievers get.

So, how do you explain the benefit of EMF?
What is the best strategy to evangelize nonbelievers?
What is the best way to get the converts over the initial pain of change?

What are the typical questions and problems with EMF?
Here is a list of things I hear often:
Why to use EMF for my DSLs instead of some hand-written well tuned Java?
It generates lots of code and bloats my project.
EMF is so complicated, it takes a long time to learn -- in that time I have solved my problem twice without EMF.

What are scenarios where EMF increases productivity and where is it the wrong tool?

I have seen Peter Frieses talk at eclipsecon. I really liked it but I am not sure it helps nonbelievers to understand what EMF (and modeling in general) is. I think what is needed is a hands-on way with some real examples that show step by step how modeling and EMF can be applied to real problems.

I will post some of my experience with EMF in this blog in the next weeks and months.

The Eclipse Freeloader Award

2009-04-07T21:18:00.003+02:00

The future of eclipse in in danger: The problem is that there is no real pressure for companies to contribute back to the community and it is easy to use the eclipse "for free" for the own products. There are some interesting blogs on this topic by Doug Schaefer on the future of eclipse and Bjorn on life at Eclipse in the new world.

According to wikipedia, this is called free loading: "choosing not to do work and letting others do it".

Eclipse is open source and companies can take advantage of the open source work. There is nothing legally that can prevent them from doing so. But the eclipse community should create peer pressure to prevent the freeloaders and parasites from getting away without punishment.

A few ideas to increase the pressure for freeloaders:

Create an eclipse freeloader award
Have an "eclipse supporter" logo
Have a list of of freeloaders prominently on the eclipse page
Create an eclipse pillroy

Is this too harsh? Well, it is less harsh than to take advantage of the work of others and letting eclipse die. It seems that positive stimulus is not enough. I want eclipse to succeed in the future. But if everybody is only thinking about his own agenda the entire system will die. Eclipse has to defend itself. The eclipse foundation is to polite to upset some companies. That has to change. It has to be an honor being part of eclipse, and is has to be crystal clear that eclipse is not for free!

Disclaimer (not sure if this helps, but it seems common to add a disclaimer to anything that could potentially upset an employer): This is my personal opinion and not the opinion of my employer.

Good versus evil diversity - why the foundation must hire developers

2009-04-07T17:03:00.010+02:00

In German we have two contradiction proverbs: "Gleich und Gleich gesellt sich gern" ("birds of a feather flock together" *) and "Gegensätze ziehen sich an" ("opposites attract" *).

When applied to couples, I think both are true but for different aspects: for social status, education, religion etc, coming form similar background makes things easy. But when it comes to character, being of different kind is good because my partner might have something I don't have and together we are more "complete".

Diversity in open source is similar. There are areas where diversity is absolutely vital and other areas where diversity has a very negative impact.

Bjorn criticized the "lack of diversity" in the eclipse community because most projects are "mono-vendor". He is right, we need more diversity here!

But there is another kind of diversity that is bad: if there are many ways of doing the same thing. Excellent system are not designed by committee, but by a few people (often a single person) with strong ideas about architecture, design and the "right way of doing things" (Frederick Brooks calls this "Conceptual Integrity"). This leads to excellent systems. From my experience I learned that it does not matter much, which set of rules are applied, as long as the rules are consistent and everybody in the team believes in them and follows them.

Startup companies often get this kind of consistency "for free", because they grow form a small set of people and they hire only new people that fit into the "mind set" of the team. Open source projects, created by some enthusiasts, get it, because they attract people who believe in the system. The (original) eclipse platform is an example of such a consistent system.

I am afraid that the future of eclipse is in danger if this wrong type of diversity (I call it chaos) increases. (I wish the architecture council could help to defeat this kind of diversity, but I am afraid that the council is already way too diverse when it comes to "architecture")

It would help a lot if there would be a set of developers paid by the foundation coming form different backgrounds but with a common mind set when it comes to technology. If the foundation would hire people, I am sure we could find a great team of people that would be able make eclipse ready for the future.

Having a "vendor neutral" team of developers dedicated to the future of eclipse would give eclipse a boost. Else, I am afraid, eclipse is "auf dem absteigenden Ast" ("heading south" *)

New Book: Eclipse für C/C++-Programmierer

2009-03-20T03:18:00.006+01:00

I just got a copy of Eclipse für C/C++-Programmierer by Sebastian Bauer, the first German CDT book. The first impression is very good. This book is ideal for C/C++ developers who are new to eclipse and new to CDT, but it also has a few gems for more experienced users. It covers a wide range of topics (see the table of contents), it is well written and takes a very good route to get started with CDT. Although it has a lot of screen shots, I don't have the impression there are too many, because they complement the written text in a very good way. It has a very good balance between practical tips and explaining the concepts and ideas behind CDT.

This book is the missing manual for CDT! It should be delivered with each copy of CDT. I wish it would be available in English because it deserves a wide audience.

eclipse 3.5M6: linked extension locations now require a .eclipseextenison file

2009-03-15T17:02:00.008+01:00

UPDATE: the problems have been solved/explained (see below)

There is a hot debate between the community and the p2 team on supporting extension locations. A few weeks ago I described a simple procedure to use and maintain extension locations with p2.

In eclipse 3.5M6 links file do not work anymore, unless you add a .eclipseextension marker file next to the plugins and features directories of the extensions location (see bug 268673).

This marker file was required by the classical update manager in order to be able to add a directory as product extension from the UI. Until 3.5M6 link files just worked when pointing to a directory containing a plugins directory (or a eclipse directory containing a plugins directory). No .eclipseextension file was needed.

Ironically, the classical update manager in M6 cannot be used to add extension locations anymore. (To enable the classical update manager: Preferences...->General->Capabilities->Classical Update)

Is this a sign that the p2 team wants to discourage extension locations and link files? Or am I believing in a stupid conspiracy theory?

-------------------
Update! Both problems have been solved
1. bug 268673: p2 tries to be clever: when it detects a artifacts.xml in the extension location it needs a .eclipseextension marker file to believe that this is really an extension location. Normal extension locations are not affected by this bug.

2. bug 268674: This happens only if you never have started eclipse from the installation location (and always start with the -configuration option.

==> no conspiracy :-)

p2: how I install plugins in extension locations...

2009-02-20T15:34:00.012+01:00

The following procedure explains how I install plugins into different extension locations and share those extension locations between different eclipse installations using the p2 update manager and link files. For a lengthly discussion see bug bug 224145

I keep a set of different extensions locations in C:\eclipse\extensions (each extension location is in a subdirectory of that directory). Suppose I want to install foo into the new extension location C:\eclipse\extensions\foo.

I start eclipse with:

-configuration C:\eclipse\extensions\foo\eclipse\configuration

I install foo using the update manager.
Now I can use the extension by creating a foo.link file inside the links directory of an eclipse installation (you might have to create the links directory) containing:
```
path=C:/eclipse/extensions/foobar
```

That's it :-)

Note: You have to the forward slashes on windows in the links file.

Note: This procedure works for eclipse 3.4 and 3.5.

Note: You don't have to create any directory specified by the -configuration parameter. Eclipse will do that for you.

Note: It is important to follow the pattern EXTENSION_NAME/eclipse/configuration for the -configuration parameter because p2 will put the plugins one directory above the configuration directory and link files require that the directory that contains the plugins is called eclipse.

Note: With this structure I can update plugins into the extension locations by running eclipse with the -configuration and then do the update.

Advanced use: If I want to install bar based on my foo extension, I create a link file to foo in the bar extension location links directory:

C:\eclipse\extensions\bar\eclipse\links\foo.link

and follow my standard procedure described above (the links directory can be populated before the first run of eclipse)...

Note for eclipse 3.4: If you are using eclipse 3.4 and you want to use the eclipse default update sites, you have to run eclipse without -configuration and export them (Help->Software Updates->Available Software (tab)->Manage Sites->Export), so you can import them into the -configuration eclipse.

Note for eclipse 3.5M6: You have to add an (empty) .eclipseextension file next to the plugins and features directory of the extension location.

When the runtime Application uses the wrong plugins...

2009-02-03T04:17:00.014+01:00

Today I run into a problem that can cause a lot of frustration: a runtime eclipse launch that runs with he wrong plugins. The frustration comes form the fact that your application behaves strangely and it is hard to guess that this is caused by loading some worng plugins. Those plugins might even be closed or deleted from your workspace!

Here is what happens: PDE (eclipse 3.4) does some hidden magic when you run an eclipse application (lets call the launch configuration foo): it creates a directory in .metadata/.plugins/org.eclipse.pde.core/foo. This directory is used with the -configuration flag when running the application to store the runtime configuration of your application. But, there can be cases when this directory is not updated correctly, like when you switch between "launch with all enabled and workspace plug-ins" and "plug-ins selected below". It can happen that the runtime application still uses all plugins although you have selected to run with some specific plugins. I have not tested the exact conditions when this happens, but it happened several times to me in the last months.

Unfortunately the "Clear workspace" flag does not help, because it clears the workspace but not the configuration area! It took me several hours to figure that out....

As Chris points out in the first comment, here is the solution: On the "Configuration" tab of the launch configuration check the option "Clear configuration area before launching".

Chris also recommends to use -clean -consoleLog -debug -console as arguments for plugin development launch configurations. In this case, the -clean option takes care of cleaning the configuration area.

Tip: you can set -clean -consoleLog -debug -console as default in Preferences->Plug-In Development->Target Platform->Launching Arguments->Program Arguments

I hope this tip saves someone some wasted time...

.

Finally, I found a good book on JavaScript!

2009-01-22T17:10:00.008+01:00

For some years I have been looking for a book on JavaScript that would explain the language to someone who already knows programming. But all I have seen until recently are books for beginners or books that talk a lot about web programming, web browsers, DOM, XML, HTML etc, or books that explain all the different versions of JavaScript implemented in different browsers (many of these books have 1000 pages or more).

The book I read is a 180 page book called JavaScript: The Good Parts by Douglas Crockford. The idea of the book is: JavaScript is a messy language but here is a subset and some best practices how to use JavaScript in a manageable way. And that is done on 100 pages (the rest are interesting appendices). I read it last week on a flight and it was a kind of eye opener for me.

I finally understood that the object system of JavaScript is not class based like in C++/Java/Python/Ruby but it is prototype based like in Self/Perl/Lua. This prototype based approach is not supported by a special syntax. There are many ways of creating and dealing with objects. But be book makes some suggestions and explains some best practices for creating objects.

The other eye opener was how closures can be used to build objects with private information.

An interesting design decision of JavaScript is that there is essentially one data structure, called Object, with string keys and any object as value. It can be used as hash map, array or object. Even functions are objects and you can associate information with them or add methods to one or all functions.

If an object is used as array, the index is converted to a string key -- I find this very strange -- but it seems to work. The array.lenght attribute is defined as the "largest integer property name plus one", which means it looks for string keys that look like positive integers and takes biggest one, provided it is less than 4294967295.

If you want to learn JavaScript as a language I would highly suggest to read JavaScript: The Good Parts. After you finished the book, you might not be able to read any bad JavaScript programm, but you might be able to write your own "clean" scripts. I really like that approach.

If you are interested in E4, knowing JavaScript might be useful, because E4 will be scriptable with JavaScript.

Eclipse summit europe -- no more hotels

2008-11-16T16:51:00.002+01:00

OK, I admit, it is a bit late to look for a hotel for Eclipse Summit Europe 2008. Today I tried about 30 hotels. It seems all hotels in Ludwigsburg are booked out. Well, I thought no big deal: I would follow the S-Train line and book a hotel close to any S-train station. Well, all hotels are booked out along the S-train lines, including the hotel close to the Stuttgart main station!? I finally found a hotel not far from Ludwigsburg, next to the S-Train station in Asperg, but it turned out that the address was listed wrongly in google maps and the hotel is not even close to any train station....

It's not that bad -- with public traffic it is 1h30 to 1h45 from my home in Heidelberg to the "Forum am Schlosspark". The only bad thing is that my latest train is around 9:30PM, and the good discussions are usually late in the bar....

That means waking up early (it's really early for me, since I "virtually" live in the EST time zone -- I go to bed at 6AM and wake up at 1:30PM)...

If you found a hotel in <30 min distance to summit, let me know.

ConcurrentModificationException: Why do Java collections not have robust iterators?

2008-10-10T19:41:00.008+02:00

Ever got a ConcurrentModificationException? It just hit me. How does this happen? It happens when one method iterates over a collection while another method (that bis recursively called from the for loop) modifies the collection.

Note: ConcurrentModificationException has nothing to do with threading! (Well, this is a bit too strong statement, as Rafael points point out in a comment: it might occur due to a threading race condition (but in such cases you probably have other problems as well)). A ConcurrentModificationException may have nothing to do with threading!. Here I am talking about about the non threading related case.

Here's a simple example to show the problem. We have a class that can register new listeners and when fireChange is called it calls changed on the listeners. So the test listener here removes itself on the change call and boom, we get the ConcurrentModificationException:


public class IteratorTest {
 final Collection fListeners;
 public IteratorTest(Collection listeners) {
  fListeners = listeners;
 }
 static class Listener {
  public void changed(IteratorTest subject) {
   subject.removeListener(this);
  }
 }
 public void addListener(Listener listener) {
  fListeners.add(listener);
 }
 public void removeListener(Listener listener) {
  fListeners.remove(listener);
 }
 public void fireChange() {
  for (Listener listener : fListeners) {
   listener.changed(this);
  }
 }
 static void test(Collection coll) {
  IteratorTest t = new IteratorTest(coll);
  t.addListener(new Listener());
  t.fireChange();
 }
 public static void main(String[] args) {
  test(new ArrayList());
 }
}

The problem can happen if you call out to "other code" (code someone else has written) and "other code" can change the collection while you are iterating. One solution is to iterate over a copy of the collection:


 public void fireChange() {
  Listener[] listeners=(Listener[]) fListeners.toArray();
  for (Listener listener : listeners) {
   listener.changed(this);
  }
 }

That helps. But there is a lot of code out there that iterates over a collection and calls "other code" and there is always a chance that the "other code" calls back to modify your collection and you get a ConcurrentModificationException....

The good news is: Unlike threading race conditions it happens deterministically. The bad news is: if you are the client it is often not easy to find a way out.

15 years ago, ET++ (the cool framework created by Erich Gamma and Andree Weinand in the 80ies) suffered form missing robust iterators. "Robust iterators" means robust to changes of the underlying collection. At that time, making a copy of a collection seemed an unacceptable overhead. So, Thomas Kofler added robust iterators to ET++ (the PDF has the pages on reverse order -- here is a readable version). The implementations are efficient and robust.

Robust iterators are so fundamental, I am really surprised that Java does not have them....

.

The bridge between Interaction Design (IxD) and Domain Driven Design (DDD)

2008-10-10T17:30:00.007+02:00

Some time ago I read Alan Cooper's book on About Faces 3. I am currently reading his book "The Inmates Are Running the Asylum: Why High Tech Products Drive Us Crazy and How to Restore the Sanity". He makes a strong point that interaction design has to be based on research and that is has to be made by interaction designers and not engineers. Engineers think too technical and therefore will create too complicated solutions. Engineers don't know how "normal users" think. And he is right! But I think, it's not enough to have some "interaction designers" designing the interactions and then let the programmers write the code. That might be important. But it is equally important if not more important that the the developers deeply understands the problems domain and goals the users have.

There is a great one hour talk I really enjoyed: Martin Fowler and Dan North Point Out a Yawning Crevasse of Doom (I had to look up the words Yawning, Crevasse and Doom -- those British guys speak hard to understand English ;-)). Their point is that there has to be a bridge between developers and users in order to communicate as apposed to a ferry, where information is transported from one side to the other by someone like the interaction designer, marketing person or analyst.

The solution requires what Eric Evens describes in his book as Domain Driven Design (DDD) (BTW: Domain Driven Design Quickly is a 100 page book available online describing the essentials). One of the central ideas is to have a dialog between the developers and users to come up with a "ubiquitous language" to describe the "core domain". That is: use the same language when talking to the users as when talking about the code. Create classes and methods that model the domain using the same terminology used by the users when they talk about the problem domain.

To get better software we have apply the techniques of interaction design and we have to have a dialog with our users to be able to create models that match their mind sets.

Yes, I am guilty myself of not doing this. So, this post is a reminder for myself....

P.S.: After writing this post, I did some search on ("DDD and IxD") and I figured that about a year ago I started a discussion on this topic on the IxD mailing list. I wish I would have a better memory....

Emfatic downlowad and update site available...

2008-08-01T01:39:00.007+02:00

I like Emfatic a lot. It is a very cool textual representation of EMF ecore files. The Emfatic has a nice text editor for .emf files. Much easier to edit than the graphical ecore editor. It was originally created by Chris Daly and made available at IBM alphaworks under a restrictive license. Some time ago it became an eclipse project.

Unfortunately, I could not find a download or update site for the open source emfatic (which has quite some enhancements over the alphaworks version). Only some build instruction. I build it following the "instructions" (which is a simple screen-shot of the projects in cvs, enough for "experts"). Then I realized it also needs org.antlr-2.7.7, which cannot be hosted at eclipse.org because of IP (copyright) issues. I could not find the org.antlr-2.7.7 plugin. I had to create it.

I am sure I am not the only one who simply wants to download emfatic. So, I decided to make my build available.

Here is my emfatic download site it has a zip with emfatic and antlr file that can be dropped into an p2 drop-in folder or used as extension location (it already contains the .eclipseextension file).

And for those who like to use the update manager, I created an update site with emfatic and antlr: http://scharf.gr/eclipse/emfatic/update/

Note the emfatic plugins it require Java 1.5!

Looking for a JavaVM with the weakest possible memory model

2008-06-07T03:33:00.006+02:00

The Java Memory Model gives some minimal guarantees about what happens if two threads are accessing the same variables. Brian Goetz describes this in chapter 7 of Java Concurrency in Practice. And here is a good summary of the new (1.5) Memory Model. Doug Lea describes the old memory model. If you really want to dig into it read some more formal specs.

The essence of the java memory models is: If one thread modifies a variable another thread may not see the change unless "some synchronization" happens (a synchronized block, a shared lock etc). But most real java VMs implement a much stricter memory model, that means if one thread modifies a variable the other thread sees it even without synchronization. And that is the problem. It is almost impossible to find those threading problems without a java VM that implements only the minimal memory model guarantees.

My favorite "theoretical threading bug" is NullProgressMonitor.cancelled should be volatile. If a java VM would implement only the minimal memory model the code would not work, but as John points out: "This is true in theory, but never happens in practice. In practice, the thread calling isCanceled may obtain a stale result for a short period of time, but the thread cache is soon synchronized. It is common practice to omit synchronization in cases where obtaining a stale value is acceptable.". This is unfortunately true. At least I could not construct an example where one thread would not see the changes made by another thread.

Getting threading right is extremely hard. Deadlocks often occur only if you have a bad day. You can get away with obviously wrong code just because Java VMs are so gracious.

I wonder if there is java VM that implements only the minimal memory model? It would be cool if it would be possible to force the VM to behave like the worst possible memory model. For example: it would not make changes visible to other threads unless the data is synchronized. This would be extremely helpful for testing and debugging purposes. I wonder how well eclipse would behave on such a "minimal memory model VM"....

Is OSGi the enemy of JUnit tests?

2008-04-17T15:40:00.000+02:00

I wrote a set of JUnit(3.8.1) tests for the terminal. Originally those were normal unit-tests. To be able to test non public methods and non public classes, I put the tests into the same package but into a separate test plugin. I also added the test plugin as friend plugin of the packages I want to test. This works fine if I run the tests as normal JUnit tests. But if I run the same tests as JUnit Plug-in Tests I get java.lang.IllegalAccessError. The reason is simple: each OSGi bundle runs it's own class loader and therefore the classes appear not to be in the same package.

There are different solutions:

Make all methods and classes you want to test public (really bad idea)
Put the unit tests into the same plugin as your code and make the dependency to JUnit optional (not a good separation of concerns).
Only test public classes and methods (I think this is to restrictive and often to coarse grain)
Make your test plugin a fragment. One problem is that other plugins cannot access classes defined in fragments (as Patrick Paulin points out in a more detailed discussion about fragments in unit tests). Another problem is that plugin.xml in a fragment is ignored. And therefore you test plugin cannot contribute

I tried out turning a plugin into a fragment. It is as simple as adding adding a line following line to your MANIFEST.MF

Fragment-Host: org.eclipse.the.plugin.you.want.to.test

and removing the plugin you want to test from the required plugins. As long as your test plugin is not part of a bigger test case and it does not need to contribute extensions Patrick Paulin describes a solution for that using reflection, fragments are a good solution.

A good way to avoid having to use extensions (plugin.xml) in your test plugin is to use dependency injection for your classes.

But I think there should be a better way to write a test plugin that can access non public classes and members. I understand why the security concept of OSGi introduces those problems, but I am still looking for a solution for my JUnit tests.

Any ideas?

Databinding Tutorial and Sample Projects

2008-03-18T23:48:00.003+01:00

I promised I'd add the sample projects and the slides add our "Understanding JFace Data Binding" tutorial. I added them yesterday to the eclipscon web page, but it took a day to show up. I also added a zip file with the presentation and the sample projects here.

As Wayne suggested, the projects also show it the "hard way". The best way to follow the tutorial is to use "compare with each other" between the projects. The projects are numbered and the "nodatabinging" projects show it the "hard way". But I gave up at the end doing it the "hard way" because it simply was not trivial. I'd be happy if someone could do the master detail the hard way (without binding), so we could add it to the sample projects...

A month ago, my blog was hijacked by spammers for a few days

2007-09-10T00:19:00.000+02:00

About a month ago (just before my vacation), several people notified me, that my blog has been hijacked by spammers. Wassim Melhem even created a bugzilla entry (which was a great idea!).

Spammers replaced my blog with their stuff including a new pink layout. If you want to see it: scharf.gr/hijacked_blog (I don't link it from here, but you can paste the link into your browser).

Google/blogger.com recognized that my blog was spam and they locked my account (I was still able log in but I could not add new blog entries). All my old bog entries were gone. I send some mail to Google and after a day or so they restored my old blog and apologized.

But how could they get into my blog? I don't think they were able to guess my username/password, because it was pretty safe. Else I guess, they would have changed my password. Looking at the spam blog, I just realized that the same content is there two times (looks like pasting it two times). I think, they just replaced the entire blog template with their crap. I see two possibilities how they could have done it:

They hacked into the blogger server and did it from inside. In this case other blogs would have been hijacked too.
They used some clever javascript that navigated to my blogger template site and they dumped their stuff. Because my blogger account is my google account and I was lazy logging out, a script could possibly have done that. Changing the template is much simpler than creating a new blog entry, because there is no "enter the text from the scrambled image" type of verification needed.

Do you have other theories how this could happen?

There is a interesting new type of spammer attack: they use pieces of real blogs in their spam blogs to make their spam blog appear "real". Marko Schulz has sent me a link, but that spam blog is fortunately gone....

Talking about spam: since a week I get much less e-mail spam (on some of my accounts) than I used to get (tens instead of hundreds per day). Maybe spammers started thinking about spam efficiency: to get most out of their spam bot nets they concentrate on Internet newbies. Therefore it pays off for them to eliminate e-mails that are in their lists for years. The probability that someone who is new to the Internet believes the spam is much higher than for experienced users. If they would mostly attack new e-mail addresses, they would also get out of focus of the experts who are fighting spam and therefore have a much higher success rate in delivering spam. In addition, if spam is sent in low volume, spam defense would probably miss new variations of spam. Or is there another explanation for this decease in spam?

Eclipse is worse than any commercial IDE (in an ideal world)...

2007-07-05T02:22:00.000+02:00

At his keynote at EclipseCon 2007, Robert Lefkowitz made the following provocative statement: "Eclipse is probably worse than any commercial IDE!". Why? Because it's free! In an ideal (capitalistic!?) world you don't pay for anything that you can get for free. Any tool that is worse than a free tool would just run out of business (if both tools would cover the same market). Well, and we have seen quite some commercial IDEs die, since eclipse is available.

One implication of this observation is, that when eclipse increases it's quality, competing commercial products have to increase their quality to survive. But wait! Instead of improving the quality of your commercial product, you could just prevent eclipse from become better. I know, this is very provocative. Fortunately, making (and saving) money is not the only force in our world. And fortunately, the way eclipse is organized, this will not happen:

Although, most of the work on eclipse is sponsored by companies that sell products based on eclipse, the work is done by individual committers. And the human factor is very important. Everybody can see what committers do. It's not anonymous hackers that do the work, because unlike wikipedia, anonymous users cannot change eclipse. Eclipse is a social community with a focus on individual responsible committers. This is very important for the survival of eclipse. That's why new committers have to be voted into protects after they have shown credibility. That's why new projects must have committers from multiple companies. Eclipse committers are humans with emotions. Nobody wants to be accused of being destructive.

It is an honor to be an eclipse committer.

My favorite 3.3 feature: Quick Access

2007-06-30T05:08:00.000+02:00

I just looked into Eclipse 3.3 - New and Noteworthy. Lots of cool new things! My favourite is Quick Access. This essentially allows you to type commands instead searching the command in the menus. If you have customized your perspective, to get rid of annoying tool-bar buttons, you still have access to commands that are not visible in any menu or tool-bar!

I have bound Quick Access to ESC-X (like in emacs) and it feels a bit like the emacs minibuffer.... Very cool!

BTW: I wish eclipse would allow links into the "News and Noteworthy" pages (see bug 194993), that's why I created my own copy of "News and Noteworthy"...

I don't like XML! But what are the alternatives?

2007-06-18T17:58:00.000+02:00

I think XML is one of the worst formats for data. It is extremely ambiguous. There are so many ways to put a simple data structure into XML. For example:

<book 
    title="The Return of the King"
    author="J.R.R. Tolkien"/>

<book>
  <title>The Return of the King</title>
  <author>J.R.R. Tolkien</author>
</book>

And in the second case, can there be more than one author? And more titles?

XML is not self describing. Look at the XML below. It is very ambiguous (if you don't use one of the many schema descriptions (DTD, XML-Schema, XMI, DSD, ...)).

<data
 x="null"
 y="true"
 z="42">
 <a>NULL<a/>
 <a>false<a/>
 <b>TRUE<b/>
</data>

What is a String? What is Boolean? What is a number? Is x a list? You simply can't infer it from the XML. When you want to write the data, which fields are written as tags which are written as attributes?

There is also a huge problem with IDs and references. From a plain XML file there's no way to figure out what an id of an object is and what references are. A good example are plugin.xml files. They are full of IDs and references but it is so hard to know which string refers which other XML element. Control-click does not work. Why? Because references are difficult to resolve!

Are there any good alternatives?

JSON is much simpler, self-describing, less verbose and much better suited for data storage and exchange. But it has no notion of IDs and references. And it does not name object (record) types (it has only lists, maps, strings, numbers and boolean).

What else is out there? I want something like JSON + an ID/Reference model + named Records...

Customize Perspective is annoyingly inflexible...

2007-06-16T06:19:00.000+02:00

I just read Kims post about removing removing the default visibility of the menu and toolbar Working Set items. It triggered once again one thing that annoys me from time to time, the inflexibility of the Customize Perspective dialog:

You can either enable both, Menubar and Toolbar items or nothing. That is very annoying, because it breaks the principle that the toolbar items are optional. Unless the provider of the actionSet defines two action sets, one for the toolbar and one for the menubar, you have the choice between all or nothing.... But providing two action sets would duplicate the number of item on the command tab, which is already overloaded.

I think it is not the responsibility of the plugin writer to decide which items the user wants to see in the toolbar! (See bug 182714)

Surprises in eclipse 3.3: double click instead of single click

2007-05-12T05:10:00.000+02:00

Since some time, the 3.3 patch editor (Team->Apply patch...) does not work for me anymore. Well, I was using patched milestones (we had some enhancements for the patch editor in our product). So, I was not surprised that it did not 100% work. What went wrong? If I select a file to patch, nothing is shown in the compare area below:

Since the problem remained even with an unpatched 3.3m7, I filed bug 186481 and after some discussions, it turned out that I have to double click instead of single click to select the patch. That was not obvious to me! In 3.2 a single click was enough! After double clicking the patch it looks like this:

Now I see exactly what I expected! But why double click? Well, because calculating the diff is expensive and doing that by simply selecting a file may not be a good idea... Another reason is that there's now a context menu on the items in the "Patch Contents" pane and you don't want to do the expensive calculation of the diff just to get to the context menu. Therefore, the paradigm changed from master-detail to open semantics.

But this is not without drawbacks! First of all, I'm sure I'm not the only one stumbling over this problem. Actually the semantics has changed in other compare related views too. If you set Preferences...->General->Single Click, you get the old master-detail behaviour.

Second drawback, is that the selection and what you see easily may get out of sync. Look at this screenshot:

What happened? I have selected (not double clicked) the plugin.properties file but the difference of a java file is shown. The bad thing is there is no indication which java files is shown here! Unfortunately it's too late in the game to change this (see bug 186481 for further details)...

Take-home message: Report bugs early enough....

No real support for dynamic extensions (aka dynamic plugin.xml)

2007-02-21T16:49:00.000+01:00

Eclipse allows (theoretically) to add extensions dynamically (see "Leave Eclipse plug-in headaches behind" or "Contributing items to a toolbar dynamically"). Unfortunately, there's no way a normal plugin can do this without using internal classes :-(. Here's the proposed hack how to do it:


  IExtensionRegistry reg = RegistryFactory.getRegistry();
  // ExtensionRegistry is internal!!!!
  Object key = ((ExtensionRegistry) reg).getTemporaryUserToken();
  Bundle bundle = Activator.getDefault().getBundle();
  IContributor contributor = ContributorFactoryOSGi.createContributor(bundle);
  try {
   //  I have the content of my dynamic plugin in a file 
   // called dynamicplugin.xml
   InputStream is = FileLocator.openStream(bundle,new Path("dynamicplugin.xml"), false);
   reg.addContribution(is, contributor, false, null, null, key);
  } catch (IOException e) {
  }

Unfortunately ExtensionRegistry is an internal class and getTemporaryUserToken() is not exposed in any official way. Bug 112954 asks for a way to get to getTemporaryUserToken(). The solution is to use null as the key (token). Well, almost. In order to make this work, the system property eclipse.registry.nulltoken has to be set to true (Bug 112954 comment 25). But a normal plugin cannot set a system property before OSGi starts....

This effectively means: there is no way a normal well behaving plugin can provide a dynamic extension. Therefore I filed bug 174967 to fix that problem....

java.net.URL.equals and hashCode make (blocking) Internet connections....

2006-11-11T04:16:00.000+01:00

Sometimes simple calls have unexpected side effects. I wanted to update some plugins, but the update manager was hanging my UI. Looking at the stack trace reveals:


        at java.net.Inet4AddressImpl.lookupAllHostAddr(Native Method)
        at java.net.InetAddress$1.lookupAllHostAddr(Unknown Source)
        at java.net.InetAddress.getAddressFromNameService(Unknown Source)
        at java.net.InetAddress.getAllByName0(Unknown Source)
        at java.net.InetAddress.getAllByName0(Unknown Source)
        at java.net.InetAddress.getAllByName(Unknown Source)
        at java.net.InetAddress.getByName(Unknown Source)
        at java.net.URLStreamHandler.getHostAddress(Unknown Source)
        - locked <0x15ce1280> (a sun.net.www.protocol.http.Handler)
        at java.net.URLStreamHandler.hashCode(Unknown Source)
        at java.net.URL.hashCode(Unknown Source)
        - locked <0x1a3100d0> (a java.net.URL)

Hmm, I must say that it is very dangerous that java.net.URL.hashCode (and URL.equals) makes an Internet connection. java.net.URL has the worst equals/hasCode implementation I have ever seen: equality depends on the state of the Internet. Well in the javadoc of URL.equals it says: "Since hosts comparison requires name resolution, this operation is a blocking operation.", but who reads the documentation of equals? There is a general contract around equals. Joshua Bloch writes in Effective Java: "Don't write an equals that relies on unreliable resources" (Chapter 3, page 34). Hey Sun, as far as I know, the Internet is not reliable ;-)

Do not put java.net.URL into collections unless you can live with the fact that comparing makes calls to the Internet. Use java.net.URI instead.

URL is an aggressive beast that can slow down and hang your application by making unexpected network traffic.....

I wonder if other people find this behaviour as shocking as I do....

Tip: debug (and patch at runtime) an installed eclipse

2006-10-07T06:18:00.000+02:00

Today I had a problem that occurred only in my installed eclipse but not in my runtime workbench.

How to start eclipse so you can attach a debugger?

You have to add the following to the vmargs: -vmargs -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=9009
The 9009 is used later to attach to eclipse.

How attach to eclipse?

create a new Debug->Remote Java Application.
Set the port to to 9009 (or whatever you use as the address argument in your eclipse launch)
On the Sources tab add the projects that you want to debug..

How to "patch" the running eclipse?

Just modify the code. Actually, I discovered this by accident. My problem was an obvious bug (missing check for null), so I fixed in during the debug session. And the usual eclipse "magic" fixed the bug in my running eclipse. It's the hot code replacement that normally happens. I (falsely) though that would only work when I start a runtime eclipse from within eclipse. But it works in any case.

Now I can fix my running eclipse while I'm normally working. The only downside is, that the two eclipse must use two different workspaces. Too bad.

Here's a flash demo video that shows how to do this step by step.

Help! How to manage multiple (RCP) applications in one installation?

2006-10-03T03:08:00.000+02:00

Maybe someone reading my blog can help me. I posted essentially the message below to the equinox newsgroup and the platform newsgroup with zero response. Maybe RCP in the headline will help getting someone to read my post ;-)....

How to restrict the plugins visible to an application?

We have several applications (some of them are headless) that run from within the same eclipse installation. The problem is, that all plugins are visible from the applications. This cause problems, if extensions are used that load plugins that cannot run in the context of the headless application.

To illustrate the problem I use a simple example. A headless application that uses the org.eclipse.core.variables plugin to expand a variable. The org.eclipse.core.variables is UI free and therefore no problem. But some plugins that contribute to the variables plugin are not headless. To illustrate this, I use the ${selected_text} variable that is defined in the org.eclipse.debug.ui plugin. This causes the application to fail.


  public class MyApplicationWithVariables implements IPlatformRunnable {
    public Object run(Object arg) throws Exception {
      IStringVariableManager vm=VariablesPlugin.getDefault().getStringVariableManager();
      String message=vm.performStringSubstitution("Hello ${selected_text}!");
      System.out.println(message);
      return EXIT_OK;
    }
  }

   <extension
         id="HelloWorldWithVariables"
         name="Minimal Headless with variables"
         point="org.eclipse.core.runtime.applications">
      <application>
         <run class="gr.scharf.minimal.headless.MyApplicationWithVariables"/>
      </application>
   </extension>

Is there a way to restrict the plugins visible or loadable to an application?
Or is the only way to have a copy of the installation containing only the "good" plugins?

Michael

How the eclipse update manager could look like...

2006-10-03T02:38:00.000+02:00

One of the features I don't like about eclipse is the update manager. A few weeks ago, I looked at different alternatives of eclipse update managers. Today Chris Aniszczyk blogged about the FireFox update manager. Interestingly, a few days ago, I created a small flash video on the FireFox update manager, because I think that shows what a user expects from a simple to use update manager.

One of the central paradigms of eclipse the idea of plugins. However from a user perspective, managing plugins is a nightmare. The eclipse update manager is way too complicated, too slow, not robust enough.

Few weeks ago I bought Eric Evans book "Domain Driven Design". I'll blog about it separately. One of the central ideas is what he calls "ubiquitous language" (e.g. read chapter one). The basic idea is to come up with a language to describe the problem domain, in our case the installation and update of plugins. The language is not only used in conversations but also represented by a formal model. The formal model is implemented in code. You can start reasoning and discuss about the model.

If I look at the eclipse update manager, the model used is a very technical model that is totally implementation centric. It is not a model a user of the update manager can simply understand. I think this is the root of the problem. We have to come up with an update manager domain model that represents the problems and tasks a user of eclipse faces and not a model that is focused on the implementation. The current implementation could be used to implement the user model, but in it self it seem not the right abstraction for users.

The FireFox update manager has an easy to understand domain model that is shown in the UI. There are extensions. An extension has an icon, a description and a set of preferences (yes the preferences of each extensions is available directly from the "Extensions" dialog. In eclipse there's no way to find out what an extension contributes to eclipse. See my blog entry "When seamless integration becomes a nightmare..."). Anyway, hit a simple button to check for updates. It's done in seconds (not minutes like eclipse). Once downloaded, you can update the plugins you want to update.

If you don't like an extension you can select an extension and "Uninstall" it. Something that is not possible with the eclipse update manager. Eclipse is a grow only system -- no way to remove features. Like windows in the old days. Once you have installed a feature there's no way to get rid of it. Only, if you regularly do backups (like I do), you can revert a previous version of eclipse by reverting a backup. But eclipse itself is grow only (*). If you have installed a few features you don't like and you cannot get rid of, you will start thinking twice if you want to install a new plugin. That's very bad for the eclipse ecosystem.

Eclipse must solve the update manager problem soon and provide a simple to use and understandable update manager that solves the problems of eclipse users.

Domain Driven Design could help come up with a update manager domain model that is relevant for eclipse users...

Michael

(*) You could also use separate extension locations for each feature you install and simply delete the location if you want to uninstall the extension. But that's a hack. The update manager (UI) does not even support dropping of extensions. I tried that for a while, but it requires a lot of discipline.

When a system becomes corrupt....

2006-09-27T03:30:00.000+02:00

Have you ever had a system running stable for years and suddenly everything goes wrong?

It started last Saturday, when one of my usb-backup drives died. No big deal. I have two external backup drives with at most one attached to my system. I do weekly full backups and daily incremental backups on important data. I swap drives from time to time (I should swap them every day) and keep some old backups.

On Monday my DSL connection died. No problem, I have a ISDN USB modem I can use in those cases. The modem was cheap but the driver sucks: it uses 100% CPU even if nothing is going on. Well, no problem, I downloaded a new driver, created an XP system restore point and installed the driver. Well, I tried different versions of the driver. No one really helped, the last one crashed my system. OK, I did a "system restore", but during shutdown the driver crashed my computer. Restart, login ... baang! Windows forgot my user settings! It created a new profile. All settings lost!

No problem, I first create a backup (it's always a good idea to backup the entire system, even if is corrupt, before you mess around!) and then I wanted to back the last full backup...

Big problem! The last backup is corrupt, and the most recent backups are on my dead drive...

...for the last 12 hours I have been playing back different versions of backup trying to restore my user data. In between I have between googling for the potential problem of my setup, with little success. Whenever I restored my latest user data in C:\Documents and Settings\<username>, windows decided to create a new profile for me. I got very very frustrated and finally accepted the fact that I have to live with a new profile and I have to set up my environment from scratch. I copied all my user data into the new profile....

...Firefox, Thunderbird, cygwin, eclipse are applications that did not loose data and were running as before. But my desktop, internet explorer and many other applications that depend on the registry lost their settings. The worst case was Outlook, it wants to be reinstalled and looses all setting that are not on the exchange server...

So, I asked myself, is there a way to get my personal registry settings into my new profile? Finally I stumbled over the important files: the C:\Documents and Settings\<username>\ntuser.* files. From my "after the problem" backup I figured out that the file ntuser.dat file was missing.

Was that the key to my problem? Did loosing the ntuser.dat cause all the troubles? Ok, I had to try it. I copied an old version from a backup into my corrupt profile. Hmm, but how to tell XP to use my old profile directory again? A quick search in the registry revealed that the profile directory is stored under HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProfileList/*. I changed it, renamed my new profile to something else and restarted....

WOW! It works. My system is back. Outlook works, my desktop looks like always, all applications work as expected. I'm happy again....

What has my windows problem to do with eclipse?

Eclipse does not use the registry, but it has the magic .metadata directory. Over the last 5 years my .metadata directory got corrupt several times. If something goes wrong with the ..metadata (like running out of disk-space), it's very hard, if not impossible, to recover from that. You can, similar to windows, create a new workspace and import the projects. But then you have lost a lot of settings and you "start from scratch". My backups saved me several times here.

Conclusions

Backup the corrupted system before you do anything.
Make bakups. Regularly!

Michael

Mylar is very cool, however sometimes it drives me nuts...

2006-09-20T05:06:00.000+02:00

Mylar is an eclipse technology project. It makes it easy to focus on a task you are working on, by hiding the information that's not relevant to the current task.

How does it know, which information is relevant? It "looks over your shoulder" and remembers the files, classes and methods you have looked at. With some magic it puts some weight on the places you have been. For example if you get back to some place or even edit there, it gets more weight than just looking once at the file. But you can also tell mylar explicitly that you are interested or not interested in some context.

How does it hide irrelevant information? Well, in the package explorer, outline etc you see only the classes and methods in your context. There's even a mode that shows the relevance by the background color. And really important places are shown in bold. To build up context, you can disable mylar on the view to see everything. I never use the editor folding features of mylar, because I don't like folding.

If you want to learn more, I highly recommend the getting started flash demon.

There are also integrations with bug tracking systems, and it seems that this is how most people are using Mylar. Unfortunately, we use a commercial bug-tracking system that is not supported by mylar. But I find mylar very useful, even without the bug tracking system integration.

However, sometimes I hate mylar: I am working on a problem, and I find something interesting I want to look at later. So, I create a new mylar task. That's all fine. But now, when I want to add context to this task, I have to start from scratch, because mylar closes all my editors and collapses all my trees. However, if I have switched off mylar (that is: I have no active mylar task), and then create a new task and activate that new task, everything is good. In this case mylar does not close all my editors, but is clever it letting me build up my context from where I am. (I created a little flash demo to illustrate this workflow). I talked about this on the newsgroup, and it seems that my workflow is very special. I wonder if I am the only one having this workflow problem with mylar, therefore I created a bugzilla entry: bug 157933....

Don't swallow InterruptedException. Call Thread.currentThread().interrupt() instead.

2006-09-16T06:11:00.000+02:00

Have you ever written the following code?

try {
    doSomething();
} catch(InterruptedException swallowed) {
    // BAD BAD PRACTICE, TO IGNORE THIS EXCEPTION
    // just logging is also not a useful option here....
}

I have! I newer knew what the heck to do with those annoying InterruptedException when I simply wanted to call Thread.sleep(..). What is this InterruptedException? Why is it thrown? Why can't I ignore it?

Before I explain the whys, here is what you should do (if you don't re-throw):

try {
    doSomething();
} catch(InterruptedException e) {
    // Restore the interrupted status
    Thread.currentThread().interrupt();
}

What is the InterruptedException?

There is no way to simply stop a running thread in java (don't even consider using the deprecated method stop()). Stopping threads is cooperative in java. Calling Thread.interrupt() is a way to tell the thread to stop what it is doing. If the thread is in a blocking call, the blocking call will throw an InterruptedException, otherwise the interrupted flag of the tread will be set. A Thread or a Runnable that is interruptable should check from time to time Thread.currentThread().isInterrupted(). If it returns true, cleanup and return.

Why is it InterruptedException thrown?

The problem is that blocking calls like sleep() and wait(), can take very long till the check can be done. Therefore they throw an InterruptedException. However the isInterrupted is cleared when the InterruptedException is thrown! (I have some vague idea why this is the case, but for whatever reason this is done, that is how it is!)

Why can't InterruptedException be simply ignored?

It should be clear by now: because ignoring an InterruptedException means resetting the interrupted status of the thread. For example, worker threads take runnable from a queue and execute they may check the interrupted status periodically. If you swallow it the thread would not know that it was interrupted and would happily continue to run.

Some more thoughts
Unfortunately it is not specified that Thread.interrupt() can only be used for cancellation. It can be used for anything that requires to set a flag on a thread. So, ending your task or runnable early might be the wrong choice, if the interrupted status is used for something else. But common practice is to use it for cancellation. But even if it is used for something else, you code does not have the right to reset the interrupt flag (unless you are the owner of the thread).

To learn more read the nice article Dealing with InterruptedException by Brian Goetz.

Or read Java Concurrency in Practice By BriaBrian Goetz, Tim Peierls, Joshua Bloch, Joseph Bowbeer, David Holmes, and Doug Lea. It's a great book! If you program in java 5 this book is a must read!. I bought the book after I read Brians artikle. I have not yet read the entire book, but what I have read impresses me. It gives a lot of theorie and options. Very competent and complete, but I'm missing a set of simple patterns for concurrent programming. I'm looking forward to Doug Leas 3rd edition of Concurrent Programming in Java

Summary: If you don't know what to do with an InterruptedException call Thread.currentThread().interrupt()

Pitfalls of Long.parseLong/Long.decode...

2006-09-10T05:54:00.000+02:00

What is wrong with this code?

assert 0x0cc175b9c0f1b6a8L == Long.parseLong("0cc175b9c0f1b6a8",16);
assert 0xd41d8cd98f00b204L == Long.parseLong("d41d8cd98f00b204",16);

The second Long.parseLong will fail in the second line:

java.lang.NumberFormatException: For input string: "d41d8cd98f00b204"

The reason is that javas long is signed, but 0xd41d8cd98f00b204L is an unsigned long. Interesting, but annoying, if you want to parse an unsigned long in java. It makes Parsing and verifying hex, octal and decimal numbers more complicated, if you have a field that represents a C/C++ unsigned long (a 64 bit number)....

The solution is to use BigInteger:

assert 0x0cc175b9c0f1b6a8L == new BigInteger("0cc175b9c0f1b6a8",16).longValue();
assert 0xd41d8cd98f00b204L == new BigInteger("d41d8cd98f00b204",16).longValue();

However, you must ensure that the BigInteger does not exceed 64 bits. So here's my unsigned long parser

public static long parseUnsignedLong(String s, int radix) 
    throws NumberFormatException {
    BigInteger b= new BigInteger(s,radix);
    if(b.bitLength()>64)
        throw new NumberFormatException(s+" is to big!");
    return b.longValue();
}

Note: if you want to do any kind arithmetic with unsigned longs (like min/max checking) you have to use BigInteger objects.... Unless you are only interested in the bits of the long, the return value of my parseUnsignedLong is not really useful: it should better return the BigInteger!

The Dependency Injection Pattern: an alternative to Factories and Service Locators

2006-09-07T03:04:00.000+02:00

On my vacation I listened to about 30 pod-casts. Although most of what I heard was not new, it still was a good refresher and exciting to listen to. It also inspired me to order a few books and make me think more about what I am doing as software engineer.

One pattern that was new to me is Dependency Injection. It was mentioned in software engineering radio Episode 2 on Dependencies. Instead of using a Factory or a Service Locator (like OSGi), make your class have some members referring to the interfaces it uses. The Dependency Injector then uses either the constructor or some set methods to provide your class with the implementations of the classes your object needs. Read the One minute description and the Two Minute Tutorial of PicoContainer (a nice little Dependency Injection Framework) to see what I mean.

Martin Fowler wrote a long article about Inversion of Control Containers and the Dependency Injection pattern.

I was always wondering why using interfaces when you have only one implementation of the interface anyway. So, why bother? With Dependency Injection you can test your object easyly using Mock Objects. Jeremy Weiskotten wrote an Dr.Dobb's Article on why Dependency Injection is very helpful to create testable and decoupled objects.

Dependency Injection makes it very clear which interfaces your objects depend on. This makes refactoring, testing and understanding code easier. Factories and Service Locators often provide more products than needed by a single class and therefore you cannot really tell what the class depends on.

I'll play with Dependency Injection :-)

Going on vacation with a mp3 player full of geek pod-casts...

2006-08-21T00:43:00.000+02:00

I'm going on vacation for two weeks to Athens and Crete. My wife is Greek and therefore we go every summer to Greece. Going on vacation also means no laptop (that's not my deceison ;-). So usually, I take some geek books with me. This time I loaded my mp3 player with the 9 Callisto pod-casts from Eclipse Zone and a few of the Software Engineering Radio pod-casts.
I tried it on Friday. It's a almost like being in a conference call. But it's better: I can wind back if I get sidetracked and I don't have to be afraid that suddenly someone says: "And Michael, what do you think?....". I was shopping and listening to Richard Gromback on GMF. I was waiting in the queue to pay and when it was my turn, I started talking in English to the German cashier -- lost in cyberspace...

One thing I think pod-casts should do: Please say at the beginning of the pod-cast when it was recorded! If someone says: "Next month we'll release foobar..." it is annoying not to know when next month is or was...

And now, relaaaaaxxx, summer, sun, beach, fun -- for 2 weeks -- I'll be back Sep.5 late afternoon....

Blog comments, my mistakes and good feedback...

2006-08-18T15:36:00.000+02:00

Marko Schulz asked me why his comments did not appear in my blog. I checked it and I realized that I had a setup problem with my blog (my mistake). Now all comments are visible and new comments will be shown automatically! I'll check them for spam later.

Here's what I learned from the comments:

Parsing and verifying hex, octal and decimal numbers...: Several commenters pointed out that I should have used Long#decode(String) and therefore I adjusted the blog entry (and my code ;-).
Am I the only person having problems with the update manager? The answer is clearly: no!
Eclipse was hanging my machine regularly -- solution -XX:MaxPermSize=128m Surya asked if the -XX:MaxPermSize=128m can be put into the eclipse.ini files: the answer is yes.
Why is super.super illegal? is the most debated. Lots of good reasons why super.super is illegal -- but from practical point of view it is annoying...
I hate ClassCastExceptions...Marco said its fixed in 1.5 (ClassCastException is reporting the actual type of the object). I just made a test and it is true: even if compiled with 1.4 and run with 1.5 I see the ClassCastException reporting the type. I'm a bit puzzled why I don't see it in my applications -- I thought I'm using a 1.5 jre.
How to setup some plugins to use java 1.5 in a java 1.4 workspace? Neil Bartlett pointed out that step 3 (Setting the execution environment in the build path to J2SE-1.5) is not needed. I tested it and it is needed. Le ScaL pointed me to an article on execution environment in the eclipse wiki.
Update manager battle: the players Yoxos - YUM - eclipse... Wassim Melhem asks why I like yoxos though I have not seen it in action. Hmm, maybe I'm biased because its German and I know the guys or maybe because I spent some money on it and therefore it "has to be good" ;-). I hope to see an update soon....
How far are the hotels from the eclipse summit October 11-12 2006 in Esslingen/Stuttgart Germany? Gerd Castan suggested to search search hotel.de. Good idea!

I checked all comments and I found a few spams, but most comments brought up valid points. Thank you for your feedback!

MDSD/MDA framework openArchitectureWare 4.1 is available at eclipse.org

2006-08-17T09:19:00.000+02:00

I just read the announcement that openArchitectureWare 4.1 is available. openArchitectureWare is hosted at eclipse.org/gmt/oaw. It is one of the coolest projects at eclipse.org but it seems not to get much attention. If you are interested in MDSD or MDA take a look at openArchitectureWare - openArchitectureWare is really cool!

Parsing and verifying hex, octal and decimal numbers...

2006-08-17T08:11:00.000+02:00

How to parse a number that might be octal, decimal or hexadecimal. Numbers like 0xFF, 0x1e, 077, -123, -0x12, -066. This must have been solved a million times, and here's my version:

Thank you for all the comments! My code is stupid! Use Long.decode(numberString).longValue() Instead!

String sign="";
int base=10;
if(numberString.startsWith("-")) {
    sign="-";
    numberString=numberString.substring(1);
}
if(numberString.startsWith("0x")) {
    numberString=numberString.substring(2);
    base=16;
} else if(numberString.startsWith("0") && numberString.length()>1) {
    numberString=numberString.substring(1);
    base=8;
}
return Long.parseLong(sign+numberString,base);

OK, and here is my VerifyListener:

class NumberVerifyer implements VerifyListener {
    final boolean fSigned;
    NumberVerifyer(boolean signed) {
        fSigned=signed;
    }
    public void verifyText(VerifyEvent e) {
        Text text = ((Text)e.widget);
        StringBuffer fulltext = new StringBuffer(text.getText());
        fulltext.replace(e.start, e.end, e.text);
        String sign=""; //$NON-NLS-1$
        if(fSigned)
            sign="-?"; //$NON-NLS-1$
        e.doit = fulltext.toString().matches(sign+"(0?|[1-9][0-9]*|0x[0-9a-fA-F]*|0[0-7]+)"); //$NON-NLS-1$
    }
}

Vote for the eclipse 3.3 release train name. Europa is a bad choice!

2006-08-16T19:54:00.000+02:00

Vote for the Eclipse Release Train Name (2007). There has been some discussions in bugzilla.

I think Europa is a very bad choice for two reasons:

1. There are too many Google hits already if you search for eclipse europa.

2. In many languages Europa means Europe and this will confuse. Messages like the "Europa Build Workshop", sounds for many non-native speakers like "The Build Workshop Europe". If English is your native language, you might not understand this point, but for Germans this is very confusing. For the same reason you would not call a workshop held in the nice Austrian village called Fucking the "Fucking Workshop" ;-)....

Am I the only person having problems with the update manager?

2006-08-15T07:10:00.000+02:00

I wonder if I am the only person in the world using the update manager and having problems. Two weeks ago I reported a real show-stopper update manager bug: Update does not work if *ANY* error is found in configuration. I expected that it would be marked as a duplicate but I seem to be the only person having the problem. I cannot finish the updates dialog because of some mysterious errors:

The annoying thing is that "Manage Configuration" seems happy and shows no error:

The error is caused by some installed features that require a specific version of a plugin.

<?xml version="1.0" encoding="UTF-8"?>
<feature id="broken.feature" label="Broken Feature" version="1.0.0">
   <description>.</description><copyright>.</copyright>
   <license>.</license>
   <requires>
      <import feature="org.eclipse.platform" version="3.1.2" match="perfect"/>
   </requires>
</feature>

What puzzles me the most is not the bug itself, but the fact I seem to be the only one getting the bug (I get it with 3.2 and 3.3M1).....

If you want to try it, just unzip this feature in your eclipse/feature directory and restart eclipse and try to install a feature using the update manager.

Workarounds
Fix the feature.xml file by removing the required version string.
Or use another working eclipse installation and install the plugins into a new extension location and add the extension location to your eclipse using "Manage Configuration".

Update manager battle: the players Yoxos - YUM - eclipse...

2006-08-15T03:01:00.000+02:00

Yoxos

I am very frustrated with the eclipse update manager. In my opinion, it is simply unusable. But what are the alternatives? A few weeks ago, I bought a 1 year subscription of yoxos for $99. Unfortunately, since then, no new updates appeared on my yoxos update manager. The yoxos update manager is quite cool. It's a perspective that allows you to select the plugins you want:

This looks very much like the yoxos on demand site (yes, this is a screenshot of an ajax application!):

I don't know how it works, when new updates are available, but I expect it will work smoothly (well, I payed for it -- therefore it has to work ;-))

TUM - Tikal Update Manager

TUM (Tikal Update Manager) is a open source project forge project called tikal run by Tikal.

They create a dialog with some cool icons. Yoxos seems much more mature, but TUM was just announced....

The Eclipse Update Manager

The eclipse update manager seems also to be enhanced. I have not seen it (because I hope for yoxos to install it for me...), but the screenshots seem promising.

The battle shall start...

I really hope that finally the update manager gets more attention. My favorite is clearly yoxos, because they don't use annoying blocking dialogs, but a perspective. The funny thing is, that eclipse 1 used a perspective as well, and in eclipse 2 it became wizard based...

How far are the hotels from the eclipse summintOctober 11-12 2006 in Esslingen/Stuttgart Germany?

2006-08-07T17:51:00.000+02:00

I'm about to register for the The eclipse summit 2006 October 11-12 in Germany. On the web page there are 4 hotels suggested, but no clue how far they are away from the actual summit (are they in walking distance?). The summit seems to be at Ebershaldenstraße 12, 73728 Esslingen, Germany. I called all of them to ask for the price for the eclipse summit. The hotels all seem to be in the 100 Euro category. I think breakfast is included in all cases.

Best Western Premier Hotel Park Consul Esslingen
Grabbrunnenstr. 19
73728 Stuttgart/Esslingen am Neckar
Tel: +49(0)711-41111-0
Fax: +49(0)711-41111-699
Distance: 150 meters
Email: marcus.schlaich@consul-hotels.com
Single Room: 110 Euro

Hotel Linde Berkheim
Ruiterstraße 2
73734 Esslingen am Neckar
Tel: +49(0)711-345305
Fax: +49(0)711-3454125
Distance: 4 km
Email: info@linde-berkheim.de
Single room: 85 Euro - Double room 114 Euro (until Sep. 8th)

Hotel Am Schillerpark
Neckarstr. 60, 73728 Esslingen am Neckar
Tel: +49(0)711 931 33-0
Fax: +49(0)711 931 33 100
Distance: 1.2 km (walking distance 800 meter)
Email: info@hotel-am-schillerpark.de
Singe Room: 89 euro (20 rooms for the summit)

Ringhotel Rosenau
Plochinger Straße 65
D-73730 Esslingen am Neckar
Tel: +49(0)711 315 45 60
Fax: +49(0)711 316 13 44
Distance: 1 km
Email: info@hotel-rosenau.de
Prices: The lady at the reception did not know about the "Eclipse Summit". I should call tomorrow before 4PM.

How to quickly add a new repository location to CVS...

2006-08-07T01:46:00.000+02:00

The eclipse Add a new CVS Repository dialog allows you to quickly fill the form, if you drop a string like :pserver:anonymous@dev.eclipse.org:/home/dsdp into the Host: field. If you see a string like

cvs -d:pserver:anonymous@foo.cvs.sourceforge.net:/cvsroot/foo login

at sourceforge, grab the highlighted part (including the colon before pserver)...

You can also select a location in the CVS Repositories view and "Copy to Clipboard" and send it to someone. The receiver can then drop it into the Add a new CVS Repository.

Eclipse was hanging my machine regularly -- solution -XX:MaxPermSize=128m

2006-08-05T18:50:00.000+02:00

I have quite some plugins installed in my eclipse installation. Since a few weeks, eclipse was running mad from time to time, my XP laptop was totally starving, I was not even able to get to the task manager to kill eclipse (keyboard and mouse barley reacted). The only solution was to kill my machine :-(.

Well, but how to find out who is the bad guy? Which of the many plugins I have installed "killing me"? I was using Stack Trace, a cool application that lets you attach to eclipse and get a stack trace.

Most of the time the stack traces of the wild application ended in:

 at java.lang.ClassLoader.defineClass1(Native Method)
 at java.lang.ClassLoader.defineClass(Unknown Source)
 at org.eclipse.osgi.internal.baseadaptor.DefaultClassLoader.defineClass(DefaultClassLoader.java:160)
 at org.eclipse.osgi.baseadaptor.loader.ClasspathManager.defineClass(ClasspathManager.java:498)
 at org.eclipse.osgi.baseadaptor.loader.ClasspathManager.findClassImpl(ClasspathManager.java:468)
 at org.eclipse.osgi.baseadaptor.loader.ClasspathManager.findLocalClassImpl

Hmm, the class loader puts the class files in a special area of the garbage collector, (perm generation). The starving (100 % CPU and being really bad) seemed to be caused by not enough memory in the perm space. To fix this, I added -vmargs -XX:MaxPermSize=128m to the shortcut that starts eclipse. That solved the problem! The sun default seems to be 64MB (I could not find information for java1.5).

But how much is the perm size really? How to find this out? Today, I found a blog entry by Igor Shabalov describing a cool tool called jconsole, that comes with jdk1.5.0, that allows you to inspect memory related information of your java applications life. All you have to do, it to add -Dcom.sun.management.jmxremote to the eclipse -vmargs. Then you can attach to eclipse and see life the different garbage collection pools and the loaded classes and threads -- pretty cool...

How to create apply a patch that contains changes in multiple projects?

2006-08-04T01:01:00.000+02:00

Eclipse has a nice feature to apply patches (context menu of a project: Team->Apply Patch....). If you have multiple projects under CVS control, then you can create a patch that contains changes from multiple projects. The patch looks slightly odd, because id adds some additional lines that tell eclipse which projects a file belongs to. This has is new in eclipse 3.2 (bug 110481).

However if you have a patch created with diff outside eclipse that contains files from multiple projects, eclipse cannot apply the patch.

To apply my multi project patches I wrote a small Eclipse Monkey script that converts a patch on the clipboard to a Eclipse Workspace Patch 1.0, by adding some additional lines.

To install and run the script:

Install Eclipse Monkey (if you have not already installed it)
Copy the script below (including the odd lines at the beginning and the end) to the clipboard
In the Monkey menu do Paste New Script
Now you can convert patches to Eclipse Workspace Patch 1.0, by copying that patch to the clipboard and running Monkey->Tools->Convert patch in clipboard to workspace patch


--- Came wiffling through the eclipsey wood ---
/*
 * Menu: Tools > Convert patch in clipboard to workspace patch
 * Kudos: Michael Scharf(eclipsemonkey @ scharf . gr)
 * License: EPL 1.0
 */

// pseudo imports
var ArrayList=Packages.java.util.ArrayList;
var Pattern=Packages.java.util.regex.Pattern;
var StringBuffer=Packages.java.lang.StringBuffer;
var BufferedReader=Packages.java.io.BufferedReader;
var StringReader=Packages.java.io.StringReader;
var ResourcesPlugin=Packages.org.eclipse.core.resources.ResourcesPlugin;
var MessageDialog=Packages.org.eclipse.jface.dialogs.MessageDialog;

var dnd=Packages.org.eclipse.swt.dnd;


function main() {
  var patch = getFromClipboard();
  if(patch == null) {
    showMessage("The clipboard does not contain a string!");
  } else {
    // is this already a workspace patch?
    // the (?m) makes sure that the ^ matches the beginning of a line
    // and not just the beginning of the string!
    var pattern=Pattern.compile("(?m)^### Eclipse Workspace Patch 1.0");
    if(pattern.matcher(patch).find()) {
      showMessage("This is already a Workspace Patch!\n" + 
                  "It contains a line beginning with:\n" + 
                  "\"### Eclipse Workspace Patch 1.0\"");
    } else {
      var messages =  new StringBuffer();
      patch = convertToWoskspacePatch(patch, messages);
      // has it been converted?
      if(patch == null) {
     showMessage("The clipboard does not contain a valid patch.");
      } else {
        // OK let's put it on the clipboard
        putOnClipboard(patch);
        showMessage("Patch converted to clipboard\n\n" + messages.toString());
      }
     }
  }
}

// show a simple message dialog
function showMessage(message) {
 MessageDialog.openInformation(
     window.getShell(), "Convert patch to workspace patch", message);

}
function convertToWoskspacePatch(patch, messages) {
  var reader =  new BufferedReader( new StringReader(patch));
  var patchBeginPattern = Pattern.compile("^(---|[+][+][+]|RCS file:)\\s+([^\t\n,]+)");
  var result =  new StringBuffer();
  result.append("### Eclipse Workspace Patch 1.0\n");
  var projects = ResourcesPlugin.getWorkspace().getRoot().getProjects();
  var guessedProjects =  new ArrayList();
  var patchFound = false;
  var line;
  var prevLine = null;
  var hunkFound = false;
  while((line = reader.readLine()) != null) {
    var m = patchBeginPattern.matcher(line);
    if(m.find()) {
      patchFound = true;
      var fileName = m.group(2).trim();
      var pathSegments = fileName.split("[/\\\\]");
      var segment = 0; // the segment in the path that is the project
      var projectName = null;
      for(var i = 0; i < pathSegments.length; i++) {
        var name = pathSegments[i];
        if(isProjectName(projects, name)) {
          projectName = name;
          segment = i;
          hunkFound=true;
          // report every guessed project only once
          if(!guessedProjects.contains(projectName)) {
            messages.append("Guessed Project: ");
            messages.append(projectName);
            messages.append("\n");
            guessedProjects.add(projectName);
          }
          break;
        }
      }
      if(projectName != null) {
        result.append("#P ");
        result.append(projectName);
        result.append("\n");
        result.append("Index: ");
        // concat the remaining path segments
        for(var j = segment + 1; j < pathSegments.length; j++) {
          if(j != segment + 1) result.append("/");
          result.append(pathSegments[j]);
        }
        result.append("\n");
        result.append("===================================================================\n");
      }
    }
    if(line.startsWith("+++")) {
      if(!hunkFound) {
        messages.append("No project found for: ");
        messages.append(fileName);
        messages.append("\n");
      }
      hunkFound = false;
    }
    if(prevLine != null) {
      result.append(prevLine);
      result.append("\n");
    }
    prevLine = line;
  }
  if(prevLine != null) {
    result.append(prevLine);
    result.append("\n");
  }
  reader.close();
  if(!patchFound) 
    return null;
  return result.toString();
}

function isProjectName(projects, name) {
  // is the name a name of a project? 
  for(var i = 0; i < projects.length; i++) {
    if(projects[i].getName().equals(name)) 
     return true;
  }
  // ok let's guess...
  if(name.startsWith("com.") || name.startsWith("org.")) {
    return true;
  }
  return false;
}
function putOnClipboard(str) {
  var clipboard =  new dnd.Clipboard(window.getShell().getDisplay());
  try {
    clipboard.setContents([str], [dnd.TextTransfer.getInstance()]);
  } finally {
    clipboard.dispose();
  }
}
function getFromClipboard() {
  var textTransfer = dnd.TextTransfer.getInstance();
  var clipboard =  new dnd.Clipboard(window.getShell().getDisplay());
  try {
    return clipboard.getContents(textTransfer);
  } finally {
    clipboard.dispose();
  }
}

--- And burbled as it ran! ---

Why is super.super illegal?

2006-07-28T16:54:00.000+02:00

Well, from time to time I have the need to call super.super. I wonder why this is illegal. Doing some research on the Internet, the best answer I can come up with is, that it breaks encapsulation of the super.super class. Hmm, probably true in a clean world, but sometimes you really want to call back back the original functionality:


class A {
    protected void foo(){..}
}
class B extends A {
    protected void foo(){
        super.foo();
        doSomethingStupid();
    }
}
class C extends B {
    protected void foo(){
        super.super.foo(); // it is illegal to omit the stupid stuff of class B
        doSomethingUseful();
    }
}

Yes, B should not do stupid things. But why can't C undo what B does? In real software systems, that's exactly something that is somtimes needed. The answer that B should provide access to A.foo() if B thinks C would need it does not really satisfy me...

Come on, if java would really be concerned about encapsulation, all methods would default to final unless otherwise specified. Does everybody think about the fact that any non-final public or protected method can be overridden? No! We live with this accidental breakage of encapsulation and why is the small breakage of encapsulation that super.super does forbidden? Hey, a subclass can just override any non-final method without calling super at all, right? And C can call any method on B or A, but not super.super.foo()....

But maybe someone can give me an explanation that can convince me....

I hate ClassCastExceptions...

2006-07-28T05:50:00.000+02:00

...because they don't tell me what the class of the "wrong" object was. No message, just empty. Where is the difficulty in telling me, what the actual type of the object was that caused the class cast exception? I rarely see them, but when I see them it's not informative enough -- I have to run the debugger but those rare class cast exceptions are often hard to reproduce...

Sun, please add runtime type of the casted object to the ClassCastExceptions message

How to setup some plugins to use java 1.5 in a java 1.4 workspace?

2006-07-28T01:16:00.000+02:00

Most of the eclipse projects use and require java 1.4. Sometimes you want to create a new project to use java 1.5. If you simply install and select a java 1.5 in the Preferences->Java->Installed JREs, that would work, but cause potential problems. One problem is that you might accidentally use 1.5 features in 1.4 projects. A simple statement like:

string.replace("foo", "bar")

complies in this setup but will not run with a 1.4 jre, because

replace(CharSequence target, CharSequence replacement)

is new in 1.5.

The solution is to setup only the plugins that really need 1.5 to use 1.5 Eclipse has the concept of Execution Environments to specify which java JREs a plugin is compatible with.

1. set in the preferences an 1.4 jre as default and have an 1.5 installed:

2. In the project properties set the java compiler 1.5 (which is Compiler complience level 5.0 -- how I love the ever changing java version naming...):

3. Set the execution environment in the build path to J2SE-1.5:

4. In the plugin MANIFEST.MF, set the execution environment to J2SE-1.5 as well:

You could also directly add the following line to the MANIFEST.MF file

That's it :-)

How to start the OSGI console?

2006-05-05T06:06:00.000+02:00

Yesterday, I posted two bugs for 3.2. For both bugs I got the reply I should use the osgi console to get some information. In one case to get the loaded plugins and in the other case to get a stracktrace of all threads. So, how to start the osgi console?

I found the Gathering Information About Your Plug-in page.

On windows you have to start eclipse with java.exe (instead of javaw.exe) in odrer to ge a console window. Therefore, add -vm C:\YOURVMPATH\bin\java.exe tho the eclipse start command (or shortcut). To get the OSGI console -consol as startup parameter.

Now to see all plugins (and the state of the plugins) simply type ss into the console. To get a stracktrace of all threads hit ctrl-break in the console window (I had a hard time finding the break key on my keyboard. it's the top right key on my keyboard)

What does eclipse API freeze mean?

2006-02-23T02:18:00.000+01:00

The eclipse 3.2 APIs have been frozen. John Arthorne has send a mail to eclipse-dev@eclipse.org:

Between now and the 3.2 release, all changes to API require the following action before releasing any code:

A bug report describing the change, and the reason it is required.
Approval from a PMC member (in the form of a +1 on the bug report).

Also, if it is a breaking API change, you should search for references across the SDK, and coordinate the release with any clients that have already adopted the API being broken.

The PMC has asked Boris Bokowski and I to track API changes during this period. Please also CC either Boris or myself on the bug so we can keep track of the changes.

SWT/JFace integer flags and constructors

2006-01-30T17:27:00.000+01:00

SWT/JFace is pretty cool. But one thing I will never understand is why the heck are the flags in the constructor of widgets integers. Let's take TableViewer as example: TableViewer(Composite parent, int style). When you want to set style parameter, code completion does not help. So you have to read the (3.1) javadoc of TableViewer it says: @param style SWT style bits. Great, but not very helpful. Ok if you are clever, you know that TableViewer passes the status flags directly to the Table constructor. The documentatios there there indicates that the following flags can be used SWT.SINGLE, SWT.MULTI, SWT.CHECK, SWT.FULL_SELECTION, SWT.HIDE_SELECTION, SWT.VIRTUAL
Ok this gives you a hint, what to use. But if you follow the link to SWT.MULTI, you read: "Used by Text,List and FileDialog"... Hmm, no mentioning of Table....

I don't want to blame the documentation. The problem comes from the design choice to use integer bits constants in the first place. If you look into the class SWT, you are simply overwhelmed by all the integer constants. I see two solutions (in Java 1.4): >

eclipse supports structured comments for code completion, and the javadoc would reflect the flags correctly.
Use some classes representing the flags:

If Table would have a public static inner class like this:


 public static class Style {
  int flags;
  public Style(){}
  protected Style(int flags) {
   this.flags=flags;
  }
  public Style multi() {
   return new Style(flags|SWT.MULTI);
  }
  public Style full_selection() {
   return new Style(flags|SWT.FULL_SELECTION);
  }
  ...
 }

Then the constructor of TableViewer and Table would take this class. You would have all the benefits of code completion and documentation. Internally, SWT could still use integer bit flags, but as a user I would have a fully typed constructor: Instead of new TableViewer(parent,SWT.MULTI|SWT.FULL_SELECTION) I would use the fully typed construct new TableViewer(parent,new Table.Style().multi().full_selection()). Code completion would help me. No more wrong flags! I would love to see additional constructors(and methods) with typed versions....

Two projects approved: Mobile Tools for Java (MTJ) and Native Application Builder (eWideStudio)

2006-01-26T01:34:00.000+01:00

Yesterday I attended the the creation review of two projects, both are part of the DSDP (Device Software Development Platform) top level project:

Mobile Tools for Java (MTJ): The project provides tools for java development on mobile devices. A kind of PDE for mobile devices. It does not provide any library on the devices, but tools for developers to create software on those devices. It deals with deployment to a development target (emulator or real target), device emulators, the build process and debugging. Nokia, from Finland, is the driving force.
Native Application Builder (eWideStudio): There is a cool Japanese open source UI library called WideStudio/MWT. It runs on all kind of operating systems but is also tuned for mobile devices. If you have ever been in Japan, you might know that Japan are far ahead when it comes to mobile devices compared to US and Europe. This project will integrate this library into eclipse and CDT. There's also a UI builder for eclipse (I should have asked if it is integrated into VE or if it is independent). There is some overlap with eRCP and eSWT, but this is a C/C++ library. Since it's Japanese (sponsored by Fujitsu), you don't have to worry about problems with 16 bit characters ;-).

A List of all Component Areas of Platform UI

2006-01-25T03:41:00.000+01:00

Platform UI is divided into more than 50 areas, like JFace, KeyBindings, ProgressBar, Viewers, Wizards, IDE etc. In bugzilla, bugs are tagged with square brackets in the bug report subject headings to indicate the affected area.

TheComponent Areas for Platform UI lists the name, a short description, a link to the related bugs and the owner of the component area.

It's also a cool starting point to understand what is in the eclipse platform....

Eclipsecon recommendations...

2006-01-24T03:01:00.000+01:00

Eclipse-con allows you to write your personal recommendations which talks you think are interesting and what you want to attend. Just look at this, at the bottom you can choose which recommendations you want to highlight. It's a cool idea. So, I did it. I created an new eclipsezilla entry of type "Recommendation". Then I read the program and I wrote down my thoughts while deciding which talks I want to attend. Just use the eclisezilla id of the talk (the ...id=123) and put cite it as 'submission #123' in the text. My recommendation got be accepted :-)

How to speed up eclipse on a Laptop: disable virus-scanner, partition disk, upgrade memory

2006-01-21T05:19:00.000+01:00

I have a Dell Lattitude 600 with 1GB of memory. Starting eclipse and building workspaces is slow. So I was looking for ways to improve speed. Here is what I did over time:

Disabled the virus scanner for the eclipse directory and the workspace. McAfee's on-access-scan scans the entire file when a process accesses it. When eclipse starts is only reads small fractions of .jar files. However McAffee scanned the entire file which really slows down start-up by a factor of 2: cold start-up (=newly booted machine) 95 sec without versus 215 secs with virus scanner on.
Partitioned my disk: I tried all kinds of defragmentation (oodefrag and diskkeeper), but nothing really helped, some made it even worse.. However one problem is that compiling creates new files and that leads to new fragmentation. Now I created a relatively small partition with my workspace. Even if this gets totally fragmented, the disk head in confined within the partition. It gave me some speedup, but I have not measured it, but it was dramatic. I wish there was a defragmentation tool, that could observe the startup of eclipse and then rearrange the files so that the access is optimal. I know such tools exist for the startup .exe files, but we need something for the startup of a system like eclipse....
Upgraded the memory to 2Gb and disabled the page file: Yesterday, I did the upgraded and it's great. With 2 eclipse open, outlook, trillian, thunderbird, firefox, and a few other programs, I use about 1.5Gb of memory with enough space for the disk cache. That's a real blast: because no application gets paged out anymore, I don't have to worry about switching between applications. No more long interruptions when eclipse garbage collects. It's so new, I still can't believe that I don't have to wait anymore when I switch between applications. And 2 workspaces open in parallel is no problem anymore....

In a nutshell: It's all about minimizing disk access.

MDSD: A European Phenomenon?

2006-01-17T01:28:00.000+01:00

Yesterday, I wrote about my confusion with the 4 metamodel layers of MOF. Ed Willink )GB!) pointed me to a nice (French) paper about MOF. Their application of the layer is very similar to my understanding :-).

When searching for concepts around MOF and MDSD there very many European hits:

Is this a European Phenomenon? There is a kind of pattern: many new concepts are invented and researched in Europe, but commercial success often comes when American companies pick it up....

I am confused by OMG MOF 4 layers applied to MDSD and UML...

2006-01-17T01:05:00.000+01:00

Today I tried to explain to some colleges the 4 layers of the OMG Meta-Object Facility (MOF). At first it sounds quite trivial:

Level M0: User Object Layer (Instances)
Level M1: Model (DSL – Domain Specific Language)
Level M2: Meta-Model (Schema description Language)
Level M3: Meta-Meta-Model (The Schema of the Schema)

Surprisingly applying the levels to concrete problems is not always obvious or straight forward.
I used the plugin.xml file as an example. I take here a MDSD centric approach, by assuming that the plugin.xml file "generates" the plugin....

Level M0: (Instance) The deployable component
Level M1: (Model) The plugin.xml file itself
Level M2: (Meta-Model) The extension point schema description (.exsd) files
Level M3: (Meta-Meta-Model) Schema of the .exsd files (implemented somehow in the .exsd editor)

Someone (a compiler person) asked me, how I would apply this to a programming language like C.

Level M0: (Instance) Executable code
Level M1: (Model) .C file (or a AST (Abstract Syntax Tree) representation)
Level M2: (Meta-Model) C language syntax definition (e.g. in yacc)
Level M3: (Meta-Meta-Model) Yacc language syntax definition

In this case, the meta model describes the constraints on the are AST (that's what the CDT does). This shows, that it makes sense to have a DSL (Domain Specific Language) at some levels. The DSL of C is simply the c syntax. The DSL of the c-syntax is yacc (or EBNF)... It is also interesting to have transformation between different representations of a model at the same level. C versus AST, yacc versus EBNF... The "code generation" happens between M1 and M0 (compiling). Another code generation happens between M2 and M1 when using a compiler-compiler like yacc.

But whenever I read about UML and MOF I get confused. This might have to do with the fact that I never really used UML....

Level M0: (Instance) Generated C/Ada code
Level M1: (Model) Concrete UML diagrams
Level M2: (Meta-Model) UML "language"
Level M3: (Meta-Meta-Model) ??

Again, a generator/transformer is applied between M1 and M0. Is this a correct application of MOF to UML?

But explaining both (the MDSD and the UML approach) to someone who has not been exposed to modeling gets very confusing.

So, in "my world" I prefer to see the MOF hierarchy very MDSD centric. I wonder if the MDSD centric view is confusing for UML experts is is the a natural way to see the world....

The new jface.databinding needs users....

2006-01-14T01:44:00.000+01:00

Yesterday I met Boris Bokowski. He is member of the core UI team in Ottawa and he worked on the jface.databindings framework. The databinding frameworks simplifies linking between UI elements and data models. You essentially link an attribute of a model with a widget, like a text field, checkbox or a tree ore table viewer. The framework registers listeners to the model and the widget and when one changes the other gets updated. It has also support for validation.

It is not clear if it will be API or experimental in 3.2. Feature freeze is soon, and users of the framework are needed.

One interesting idea in jface.databinding is that UI elements and data models are treated the same. That means, the same mechanism (IUpdatable) is used to talk to the UI and to the data model. IUpdatableFactory creates an IUpdatable for an Object. Default IUpdatableFactory for SWT widgets and java classes (using bean properties) exist. This makes jface.databinding very flexible. But this flexibility makes it too complicated for my taste. I think it suffers a bit from trying to solve too many problems. If it would be limited to provide binding needed for typical dialogs (standard SWT elements), it would cover the 80% case. Getting 100% and being very simple is probably not possible.

I have created several similar databinding frameworks in my career. The first ones were based on ET++. Later I create a binding framework for swing and recently one for SWT. The major difference between my binding frameworks and the jface.databinding is that there are widgets on one side and a datamodel on the other (no attempt to unify data access and UI access). A "ValueAccessor" represents an attribute in a model. ValueAccessor provides information typically needed for dialogs: value, valueAsString, isEnabled, isDefault, default, labelProvider (jface.databinding.IUpdatable in contrast, does not model enablement nor defaults nor label providers). My bindings is much less generic but it is much more targeted to bind a model to a UI. You then essentially bind a widget with a valueaccessor. My Binding class knows how to bind SWT widgets to ValueAccessors.

There is already a kind of very simple databinding in eclipse: The preferences.FieldEditor classes. This is limited to binding to preferences and it also provides some automated layout. And it is not flexible enough to be a general binding fremawork. But I wish the jface.databinding would have some simplicity of the FieldEditors...

Maybe a simple layer on top of jface.databinding could help....

Anyway, I wonder what others think about the jface.databinding framework...

Resources:

Stop Windows Update to Reboot Nag Dialog: sc stop wuauserv

2006-01-12T05:50:00.000+01:00

When installing updates on Windows XP SP2, sometimes there is this annoying dialog that forces you to reboot your system. If you say "No" it will come up after a few minutes again and again....

To stop this, run the command sc stop wuauserv. This will stop the update service. After the service is stopped, the nag message stops, too. Then you can reboot when you have time. The service will restart when you reboot.

When seamless integration becomes a nightmare...

2006-01-12T03:39:00.000+01:00

Eclipse is a great integration platform. There are many plugins that work together very nicely. As a user you don't have to worry where a menu item, a new wizard, a preference page, a view or an editor, etc comes from. You install a plugin (or add-in or extension) , and it's integrated. Great!

However, the dark side is, that it's very hard to figure out what a particular "plugin" is contributing to eclipse. Just make the experiment: install 30 plugins you have never used before from eclipse-plugins.info into your eclipse installation. Now you have new views, editors, context menu entries, toolbar items, menu items, new wizard items, export/import wizard entries, preference pages, perspectives, help pages, cheat sheets, property pages, keyboard shortcuts, perspectives... But you have no idea which contribution belongs to which plugin. But without a map in your mind what a particular plugin is contributing it is very hard to use and it's hard to understand what to expect from a new plugin.

My personal strategy is to install plugins one by one into a well known eclipse environment. I take some time trying to figure out what the contributions of a plugin are. That's tough enough for me as an experienced eclipse user. It must be a nightmare for someone who starts using eclipse, because he typically starts with a "product" that consists of a set of pre-installed plugins (just like installing 30 plugins at once)... I also install each "plugin" in its own eclipse extension location so I can easily uninstall it later (but that's another story). Really problematic are contributions to wizard pages and context menus of some objects in tree views. Unless you have selected the right obeject you don't see the contribution. I often install a plugin and then I ask myself: "And now? How do I find out where it contributes?". This is particularly problematic with small not well documented plugins: I install it and I have no clue where search for its contributions.

What could be done to help users identifying the things that have been added by a plugin? Maybe a kind of plugin inspector (feature inspector), that lists in a view all the contributions of a plugin (feature, add-in, extenison).

Windows highlights newly installed programs in the start menus. Maybe there could be a setting to highlight the contributions of a particular feature.

Any ideas how to solve the problem?

"Plugin": an overloaded and confusing term in eclipse

2006-01-12T03:29:00.000+01:00

When people talk about "plugins" in the context of eclipse, they mean two very different things:

Technically speaking a "plugin" is an installable OSGi plugin, which ends up in the plugins direcory of an eclipse installation (or one of its extension location) and gets loaded when eclipse starts. It can either be a directory or a .jar file. It must contain a MANIFEST.MF and/or a plugin.xml file. Multiple plugins can be assembled into an installable "feature". (Which is also confusing, that a "feature" consists of a set of plugins. As a navive person I would expect a plugin to have multiple features).
Eclipse users think of "plugins" at a higher level of granularity. If you go to eclipse-plugins.info, there are over 1000 "plugins" to install. But those plugins usually consist of multiple OSGi plugins and installable features...

You often hear: "Oh, if found this new and cool eclipse plugin, you should install it and try it". In this case the speaker rarely means a single OSGi plugin, but an "eclipse extension". If you hear: "My plugin depends on plugin org.foo.bar", we are talking about OSGi plugins.

Therefore it can be very confusing to talk about "plugins". And I think "user plugins" should be called eclipse extensions or add-ins or something that can not be confused with technical plugins.

Any ideas how to resolve this confusion?

Future Trends (for C/C++): AOP and MDSD...

2006-01-11T05:50:00.000+01:00

I think two trends will change the way we develop software in the future: Aspect Oriented Programming (AOP) and Model Driven Software Development (MDSD). Being an OO programmer for 20 years and working on Java and eclipse, that's not surprising. Eclipse hosts the AspectJ project and there is a AspectC/C++ plugin. The eclipse Generative Model Transformer project (GMT) is an interesting research ground for MDSD. OpenArchitectureWare also provides eclipse plugins for MDSD.

However, most of the programmers that only develop in C have no clue what's coming. It might sound for them like another hype (similar to OOP) and they feel it won't change their world because it's so far away and esoteric. But AOP and MDSD is closer to their world than they think. In some sense AOP and MDSD act like an "advanced" C preprocessor. Adding "aspects" today is often done #ifdefs and complex macros are used to "generate" code. Those lost in #ifdes and #defines might find it helpful to get new tools at their hand that allow them to do what they always did but at a higher level....

Simplified resource bundle handling with osgi.util.NLS

2005-12-26T00:25:00.000+01:00

In eclipse 3.1 there is a new package org.eclipse.osgi.util.NLS. This class allows you to have simple access to a resource bundle.

public class MyMessages extends NLS {
 private static final String BUNDLE_NAME = "gr.scharf.MyMessages"; //$NON-NLS-1$

 public static String HELLO_WORLD;
 public static String HELLO_SOMETHING;

 static {
  // initialize resource bundles
  NLS.initializeMessages(BUNDLE_NAME, MyMessages.class);
 }
}

And in the file gr/scharf/MyMessages.properties I put:

  HELLO_WORLD=Hello world!
  HELLO_SOMETHING=Hello {0}!

Then access to the properties is very simple:

    System.out.println(MyMessages.HELLO_WORLD);
    System.out.println(MyMessages.bind(MyMessages.HELLO_SOMETHING,"world"));

Pretty cool, I think, because it loads the strings from the .properties file into the Messages class transparently. This also helps searching for strings in the code, because it is the same name as in the .properties file.

When workspaces don't build correctly....

2005-12-25T19:23:00.000+01:00

I have some workspaces that are quite 'old'. They have been used with several versions of eclipse. It happens quite often, when I add or remove a project that those workspaces do not build. Eclipse complains that some project should be build first and I should clean the workspace. Well, cleaning the workspace does not help. So, I opened and closed some projects until I got it to work. Very frustrating! It seems that the build order is wrong.

Today, I had the problem again. But I looked at Preferences->General->Workspace->"Build Order". There nothing was set and "use default build order" was unchecked. I checked use default build order and now it works!

Am I the only one having this problem? I wonder if something has changed between two versions of eclipse and the "Build Order" setting did not migrate well and caused that problem.

How to split eclipse plugins into features?

2005-12-15T03:29:00.000+01:00

At the eclipse council meeting this week, we discussed pluging dependencies. There was some controversy on how to split features.

I think installable features should minimize external dependencies. If possible, put plugins that have no external dependencies (=depend only to the platform) into a feature. And put plugins with external dependencies into other features.

Some (bad) examples to illustrate the problem, of what happens if you create features that contain everything:

At the level of features EMF requires JDT. This means: although you can have a meaningful set of plugins (that is the EMF runtime) that do not require JDT, there is currently no way to properly install EMF without installing JDT (else you get some kind of errors in the error log).

The other bad example is the PDE error log: If you want to use the PDE error log, you have to install PDE and JDT. In practice, you can simply install org.eclipse.pde.runtime, and it works fine. However, if someone installs PDE in another extension location, eclipse will complain.

Therefore, installable features should allow you to use a "meaningful" set of plugins without pulling in the rest of the world...

Take-home message: When you create features ask yourself if there is a useful subset of plugins that has minimal external dependencies and create a feature for those. Others using these plugins will not be forced to install the rest.

eclipse news and findings 2005-12-05

2005-12-06T03:55:00.000+01:00

Eclipse planning meeting highlight: discussed options with UA to embed help/cheatsheet in dialogs
TPTP 4.1 (Eclipse Test & Performance Tools Platform Project) released: Tool vendors can now build TPTP-based performance tools for applications in C/C++ and other compiled languages. The TPTP data model has been expanded to support application performance data from non-Java applications, such as C/C++.
Ward Cunningham and Bjorn Freeman-Benson are working on eclipse monkey (adding scripting to eclipse(java script)). They also proposed a technology project 'Dash' for eclipsemonkey.
ListenerList and other classes moved in Eclipse 3.2 runtime: (eclipse is reducing copied code...)

HTMLSave saves files as HTML

2005-11-01T04:20:00.000+01:00

htmlSave saves editor contents as HTML. It needs access to the text to extract the style information...

CDT: Mike Milinkovich starting talk

2005-10-25T15:44:00.000+02:00


 - eclipse fondation does not dictate what to do
 - next june 9 projects will ship at the seame time next
   year
 - last 13 month committers doubled
 - 3 * startegic membership
 - cdt should become over-night sensation
 - escape the java ghetto
 - eclipse is not only about java
 - eclipse ia about more language and platforms
 - even microsoft regognizes eclipse: do you know how
   expensive it is to use eclipse?
 - eclipse commiters work for companies
 - being predictable is very important
 - eclipse wants to be predictable
   - as apposed to GNU
   - at appache it juts happens
 - fundation wants to make the life of projects easy!
 - commiters now live in silos
   - Ward Cunningham will be the "free radical"
   - break walls between projects
   - about dev. process
   - nurture committer culture
   - we want people to feel proud to work for eclipse 
 - eclipse needs more successes
   - cdt should become more successfull
   - software takes time...
 - php projects will be part of eclipse
 - eclipse acts as a bridge to other OS
   - linux
   - mozilla as scalability
 - big value of eclipse is how to embrace commercial
   adoption 

Q: have a session for managers about eclipse
A: business track at eclipsecon. There was also a panel.

Examples of eclipse RCP projects

2005-10-17T21:16:00.000+02:00

A PDF document with screenshots of many RCP apps.

Ian Skerrett gives great insight into open source marketing

2005-10-17T21:10:00.000+02:00

Ian Skerrett wrote a great article on open source marketing. He starts with: "Fire the marketers..."

Eclipse press release guidelines.

2005-10-17T21:04:00.000+02:00

Eclipse press release guidelines. It explains, when a press release is triggered. Ian Skerrett, thinks fewer press releases is better....

Blog of Eclipse foundation members

2005-10-17T20:57:00.000+02:00

Mike Milinkovich, Executive Director of the Eclipse Foundation..
Ian Skerrett, Director of Marketing with the Eclipse Foundation.
Bjorn Freeman-Benson, Technical Director, Open Source Process and Infrastructure for the Eclipse Foundation.

Eclipse liveliness map

2005-10-17T20:48:00.000+02:00

Bjorn Freeman-Benson created an nice life page that shows lifeliness of eclipse projects.

Eclipse Map of committers

2005-10-17T20:45:00.000+02:00

Ther's a nice world map of committers. You can see where how many committers are located.

A wiki at eclipse.org: Eclipsepedia

2005-10-15T06:12:00.000+02:00

eclipsepedia is online. Feedback and comments can be given in bug 87949. Unfortunately, you have to be an eclipse committer to contribute. So, it's not really a wikipedia.....

Carbide: Nokias CDT based C++ tools for Symbian OS

2005-10-13T20:07:00.000+02:00

Nokia announces new Eclipse-based IDE for Symbian OS called Carbide.c++ (or Carbide Mobile Studio). It seems to be CDT based.

The Symbian OS company announced they have joined the Eclipse Foundation as an add-in provider.

IBM contributes the "Eclipse Process Framework Project"

2005-10-13T17:11:00.000+02:00

IBM announces the Eclipse Process Framework Project (Beacon). It focuses on best practices for software development. The goal is to provide tools to support the software development process (part of the Rational Unified Process).

Chris Recoskie adds macro support to CDT managed build

2005-10-13T17:08:00.000+02:00

Chris announces that he is adding macro support to CDT. He created a bugzilla entry for discussion.

eclipse developres journal

2005-10-12T02:08:00.000+02:00

Just stumbled over the Eclipse Developers Journal. A little bit too much advertizement for my taste, but interesting stories... Hmm, very american "The Leading Eclipse Magazine for the Open Community"... what about the nice German Eclipse Magazin???

Why freeing SWT resources follows "the fundamental rules of java"...

2005-10-12T01:01:00.000+02:00

From time to time, I see complains like this:

"SWT controls cannot be garbage collected. If SWT were being used in C++ that wasn't a problem. But this design decision for a Java API/Framework is a terrible flaw....This is IBM which is not adhering to the most fundamental rules of Java."

I think, it is a terrible flaw to do resource cleanup using the garbage collector.

Sun uses a similar policy for resources allocated outside the garbage collector. For example in JDK 1.4.2 they changed the policy to free native resources. Originally channels were garbage collected. But now you have to explicitely close them. It was for performance reasons, but th problem is the same: external resources are not seen by the garbage collector, and therefore it cannot trigger a collection if the system runs out of resources.

Just think of a simple object that allocates a megabyte in a native call and holding it in a pointer. The pointer is freed in the finalize method of the object. 1000 of those objects are are nothing to the garbage collector, but it takes 1 GB of your system resources. The simple loop:

for(int i=0;i<5000;i++)
    new My1MbObject();

Will not work on most systems, becuase you allocate 5000 "small" objects .....

I think that's a general good rule to close resources that are created outside the garbage collector explicitely.

Therefore it is a good thing, that SWT relys on explicit disposing of native resources.

Migration to flexible workspaces (EFS)

2005-10-12T00:22:00.000+02:00

John Arthorne wrote a document that describes how clients can transition towards supporting these more flexible workspaces (see also my previous blog entry "Restrictions of the eclipse workspace concept")

A guide to the workbench internals -- how workbench works

2005-10-11T04:13:00.000+02:00

Stefan Xenos explains how the Eclipse 3.1 workbench works. He describes the infrastructure that makes views and editors work. The goal is to make the reader familiar with important classes in the workbench, and how they interact. It is assumed that the reader is already familiar with using the workbench APIs and with creating views, editors, action sets, etc.

Content-type-based editor lookup

2005-10-11T03:58:00.000+02:00

Explains the retionale behind Content-type-based editor lookup.

Here is a paper with the details.

To have project specific content matcher, 3.1 added IProject.getContentTypeMatcher()

Here is a document that describes the BinarySignatureDescriber (for binary content types) and XMLRootElementContentDescriber. They can be used in the org.eclipse.core.runtime.contentTypes extension point to define a content type.

Plan for 3.2 core debug

2005-10-11T03:49:00.000+02:00

The overall themes for platform debug 3.2 are:

Scaling Up

Design for Extensibility: Be a Better Platform

Simple to Use

Breaking up of platforn for better OSGi separation

2005-10-11T02:51:00.000+02:00

Jeff McAffer explains how will be split into more plugins to better support OSGI. This will be done without breaking existing code.

org.eclipse.osgi
org.eclipse.core.common - some common base support classes like IStatus, etc. We'll look to take into account the JFace uses here as well as other. This will NOT be a dumping ground.
org.eclipse.equinox.registry - the extension registry mechanism
org.eclipse.core.jobs - job support
org.eclipse.core.preferences - preferneces support
org.eclipse.core.contenttypes - content types
org.eclipse.core.runtime - the original runtime layer with things like Platform, Plugin, ...

It will require and reexport all of the above plugins. Make this optional if possible.

Restrictions of the eclipse workspace concept

2005-10-11T02:01:00.000+02:00

There is an old paper nicely describing the problems and another with possible solutions (it also contains an analysis what other IDEs do).

Bugzilla entries:
- Allow editors to open files outside workspace
- Support logical model integration
- Problems with opening external files
- Allow a search to be done on external directories, outside of the workspace
- Rsource exclusion filters
The discussion about tne new eclipse virtual file system (EFS) in here: Provide more flexible workspaces. In 3.2 resources will probably be based on EFS.

Note: There might be problems with code that assumes IResource.getLocation().toFile() does not return null, if the resource is not a file!

Eclipse remote development (paper from 2002)

2005-10-10T21:28:00.000+02:00

There are many environments where the primary tools reside only on a remote system distinct from the developer's workstation, called remote development.

This document explains how the Eclipse Platform can also be extended by plug-ins to support a remote development paradigm, and provides recommendations and guidelines for plug-in developers building remote development support.

Eclipse 3.1 statistics

2005-10-10T21:21:00.000+02:00

- Java source files: 11,548
- Lines of Java source code: 2,425,709
- Lines of XML source code: 57,533

.. and more

Testing CDT with OpenOffice

2005-10-10T21:04:00.000+02:00

Doug Schaefer is testing CDT with OpenOffice (35000 C/C++).
It's double the size of Mozilla.....

YourKit Java Profiler alternative to Optimize It

2005-10-10T20:51:00.000+02:00

I'm not really happy with Optimize it. Here's another (commercial $500) profiler YourKit Java profiler. I should give it a try....

eRCP M4 with eSWT RC2 available!

2005-10-10T20:42:00.000+02:00

eRCP is the embedded version of the eclipse rich client platform.

JUnit 4 will use java 1.5 annotations @Test

2005-10-10T17:06:00.000+02:00

An early look at JUnit 4

Wayne Beaton is the new eclipse evangelist.

2005-10-10T16:39:00.000+02:00

Wayne Beaton is the new eclipse evangelist. His job is to promote eclipse (talk at conferences etc). In an interview
he explins that many eclipse core developers come from smalltalk (like himself).

Eclipse and Java links

2005-10-10T15:31:00.000+02:00

Eclipse.org

New Eclipse plugins

Eclipse Zone

Tech Forge

Java news