Planet Eclipse

Seva Lapsha: Aptana “steals” PDT code

Mon, 05 Jan 2009 20:09:44 +0000

Long time ago I set up Google alerts to receive new search results related to myself. And today I’ve discovered that Aptana steals “prepares derivative work of“ PDT code.

The only visible “derivation” there is they changed package names, though.

EclipseLive: Upcoming Event: Introduction to Eclipse PHP Development Tools (PDT) 2.0

lynn.gayowski@eclipse.org (EclipseLive) — Mon, 05 Jan 2009 19:27:00 +0000

Event Date: January 21, 2009 9:00 am GMT-8

Register Now

Roy Ganor (Zend)

Abstract:

Fully compliant with Eclipse standards, the new PHP Development Tools (PDT) 2.0 release enables developers to leverage a wide variety of Eclipse projects, such as Web Tools Project (WTP) and Dynamic Language Toolkit (DLTK), for faster and easier PHP development. PDT is an open source development tool that provides all the code editing capabilities needed to get started with developing PHP applications.

Join Roy Ganor, Zend Studio Project Leader at Zend, as he demonstrates the tool and new features including creating a new project, source editing, code assist, type hierarchy, mark occurrences, PHP search and more.

delicious | digg | dzone

Prakash G.R.: Commands Part 2: Selection and Enablement of IHandlers

noreply@blogger.com (Prakash G.R.) — Mon, 05 Jan 2009 18:25:01 +0000

In the last tip, we saw that a Handler can be declared separately from a Command. This enables for multiple handler declarations for the same command. We can also customize when a handler is active and visible, thru plugin.xml itself. A handler that doesn't have any of these conditions is called as "default handler". When no other handler is associated with a command in a particular context, then the default handler will be the handler that gets executed. Remember, at any given point of time, there is at most only one handler is associated with a command. Lets have a look into how a particular handler is selected for a given context.

A handler can be specified with activeWhen condition using the expression language. Say for our command, we have two different handlers. One should be active when the current selection is an IFile and the other should be active when the current selection is IFolder. The expression for these would look like:

I'll save the explanation for the expression language for a separate tip, but for now a short one line desc: the first handler will be enabled when the selection current contains at least one IFile and the second handler will be enabled when the selection contains at least one IFolder. This raises to two questions.

1) What if the selection is just an IProject?

In this case, as none of the handlers are eligible, the command is disabled. This is where the default handler, if you have provided one, would be associated with the command (and the command will be enabled).

2) What if the selection contains both IFile and IFolder?

Now both the handlers are equally qualified to handle the command. But since the framework cannot pick one randomly the command is simply disabled. Even if you have provided a default handler, it won't be associated with the command, because the other two handlers are more specific than the default one.

How is the "specificness" of a handler is defined? It depends on the conditions that you give in the activeWhen expression. The order is defined in the ISources class. You can go thru the complete set there, to get a glimpse of the most commonly used ones, the order from least specific to most specific is like this:

Active Context (activeContexts)
Active Actions Sets (activeActionSets)
Active Shell (activeShell)
Active Workbench Window (activeWorkbenchWindow)
Active Editor Id (activeEditorId)
Active Part Id (activePartId)
Current Selection (selection)

If a handler has activeWhen defined with active context and the other one with current selection, the second one will be selected as the selection is more specific than the active context. The activeWhen for all the handlers are evaluated and the one that returns true for the most specific condition is selected. When two handlers return true for the available most specific condition (like the selection having both IFile & IFolder in our case), no handler will be associated with the command.

All these things are done without even loading your handler in the memory. Even without loading your plugin!

In the previous tip, we saw how a handler is selected with the activeWhen expression, when more than one handler is declared. Now assuming a handler is selected, whether to enable the command or not, is determined by the enabledWhen expression.

In our previous example, we saw the handler that is active when the selection at least contained one IFile. Now lets we want to enable it only when the total count of the selection is 2. We can specify it as:

So the handler will be active and associated with the command, if the selection contains at least one IFile. Still the command will be enabled only if selection has exactly 2 elements. activeWhen and enabledWhen are similar - with respective to the expression language and lazy loading of the plugin until the command is executed. But there is small difference - your handler might be loaded iff the enabledWhen expression returns true and your plugin is already loaded. The enablement algo works this way:

No enabledWhen specified, plugin is not loaded - command is enabled
No enabledWhen specified, but plugin is loaded - consult handler.isEnabled() and set command accordingly
enabledWhen specified, returns false, command is disabled (no matter plugin is loaded or not)
enabledWhen specified, returns true, plugin is not loaded - command is enabled
enabledWhen specified, returns true, plugin is loaded - consult handler.isEnabled() and set command accordingly

So far we saw commands, handlers and their enablements. But what about generalizing a command? That can be done by adding parameters for a command. And that would be the next tip in this series.

Doug Gaff: Tech Support for Geeks

noreply@blogger.com (Doug Gaff) — Mon, 05 Jan 2009 15:25:25 +0000

Over the holiday break, I waited on the phone 30 minutes to hear a tech support person sing Celine Dion in my ear while telling me to reset my cable modem.

Ok, let me back up a bit.

I switched to a new Cable/Phone/Internet provider last week. You know the drill – the promotional period expires on your current plan and your monthly bill goes up 30%. Fortunately, there are two Cable providers (Comcast and RCN) in my town, and Verizon FiOS is coming this year. Hooray for competition, although would it kill these companies to just make the promotional price the regular price and keep me as a customer? Oops my bad. I forgot that Capitalism = bilking money from as many customers as possible for as long as possible.

Anyway, post-install my internet kept dropping for a couple of seconds every few minutes. This "feature" really upset my Software VPN client. Plus, I was nowhere near the peak bandwidth provisioning for my new service. So I placed the dreaded call to Tech Support. After 30 minutes, I get the aspiring American (ahem) Idol contestant singing Celine under his breath while telling me to reset my modem. Um, thanks dude. Can we try something else? He says I have to call back when the connection is down. I reply that hitting a 2 second window might be tough with a 30 minute call wait time. Long story short: threatening call to salesperson, visit by computer-savvy tech, removed hardware, and things are working.

<sigh.> I hate Cable companies, perhaps even more than I hate Cellular companies.

Attention service providers of the world: I, and vast numbers like me, know more than every single one of your first line tech support people. I will pay you extra money to let me talk to a real engineer when I have a problem. Save Celine for my grandmother.

Antoine Toulme: Eclipse just had a japanese smoothie

Mon, 05 Jan 2009 12:59:00 +0000

The huge contribution made by the Blanco project, sponsored by NEC, and watched over by Mori-San, was effectively added to the Babel database today.

Thanks to everyone for your hard work on making this happen.

Antoine Toulme: The Union of The CheckBoxTreeViewer TreeItems : We shall be disabled together, or die in single combat!

Mon, 05 Jan 2009 11:20:00 +0000

Dear committer, prepare your jFace-foo !

We have a case where we have a CheckBoxTreeViewer that represents a list of elements.

The list in itself is informative. The user is going to be very interested into what is selected, and what isn’t.

It’s certain that at some point he will expand the tree to look at some nodes, come back, etc.

Right now, you cannot disable the checkboxes of a CheckBoxTreeViewer without disabling the whole tree.
So that means that your users cannot check checkboxes (that was the intent), but they also cannot expand the tree.

What if you’d like to disable some checkboxes only ? That’s unsupported too.

Unfortunately, there is no solution for this problem so far. I filed 259092 earlier today to investigate the issue, and it seems you can try to add a listener to revert the check event when the user clicks on checkboxes. Users would still see the items as enabled though, and given the complexity of the interface, adding a tooltip, a new decoration is just going to be confusing.

If you have a spare vote to cast for this bug, a comment, and idea, and ideally a patch, let’s talk about it on the bug!

Eclipse Enthusiasts Poznań: Eclipse Debugger, part III

noreply@blogger.com (Jakub Jurkiewicz) — Mon, 05 Jan 2009 10:56:41 +0000

Let's continue our tour through the features of the Eclipse debugger. In the last parts (Part I, Part II) I was writing mostly about breakpoints and this time won't be any different. When we look at the views provided by the debugger we will find

the Breakpoints view.

The main purpose of this view is to manage the breakpoints - it allows to easily (going from left to right through the buttons on the view's toolbar):

remove selected breakpoints - I guess it's self explaining
remove all breakpoints - I guess it's self explaining
show breakpoints supported by selected target - when you debug different kind of artifacts (code in java or C or ant build script) you can make the Breakpoints view show only the breakpoints that are supported by this type of the given artifact [Thanks Jacek for helping with figuring this out!]
go to the file for breakpoint - it will show the place where the breakpoint is set in the editor
skip all breakpoints - when you don't want any breakpoint to be active check this option
add java exception breakpoint - I was writing about this in the first part

More cool features can be found in the view's menu, you can:

group the breakpoint by many criteria, e.g. type, project, files, etc.
define breakpoints working set
check the option to show qualified names in the view

The view allows you also to change the breakpoints' properties directly from the context menu - just right click on any breakpoint and you would see the options to:

change the hit count value
make the breakpoint suspend the VM or suspend the thread

To finish the breakpoints story it has to be said that breakpoint can be imported and exported - you can open the appropriate wizards from the Breakpoints menu or from the File->Export->Run/Debug->Breakpoints option.

Is there anything I have missed about breakpoints? Please, share!

That's it for this week - next time I will focus on the Variables view, which is essential for efficient debugging.

Nick Boldt: The Group Of Seven

nickboldt@gmail.com (nickb) — Mon, 05 Jan 2009 06:32:24 +0000

Seven things about me, as inspired by Roy's tag:

In just under 3 weeks I've become utterly obsessed with my Blackberry. My wife, who at first was apprehensive of hers (along with all new technology), has been using it non-stop as well. It's been a good text'mas. :)
My wife and I live with two American Pointers, two horses*, three laptops, two smartphones, and many, many usb peripherals. The office is the warmest room in the house.
My day job consists of maintaining and improving the build systems for JBoss Tools and JBoss Developer Studio. My night job involves numerous Eclipse projects, including Modeling and Dash. Basically, I hibernate in the winter in front of the computer.
My parents - divorced - are of Jewish/American (dad) and German/Canadian (mom) decent. They've now been separated longer than they've been together. With the subprime mortgage crisis in the US, he recently moved back to Canada to seek more gainful employment. Unfortunately, he chose Calgary which isn't faring much better, now that gas prices are finally coming back down. My mom now lives in Scaborough near us, having returned from her self-imposed escape to Vancouver, and is more or less retired.
I graduated from the University of Waterloo back in '99 with a BASc in Chemical Engineering, having spent the balance of my last two years learning about programming, workflow design, process control, and optimization. In retrospect, it seems I was always headed for release engineering.
Much like Andi Gutmans, I too hate shaving... but as I work from home, I can get away with not doing so for days at stretch. I love my 30-second commute to work, which offsets my 8-to-10-hour workdays quite nicely. Why commute 2-plus-hours a day when you can use that time to get real work (or at least email) done? Thankfully, more and more companies are realizing this and are letting us work remotely.
I try to find time - when not working or hacking - to walk my dogs, hike, cycle, kayak & swim: sometimes several in series. One favourite route involves cycling from my house to the beach at maximum speed, swimming in the lake to cool off, then portaging the bike up the side of Bellamy ravine and home. This past season I rode over 750KM and kayaked over 75KM, mostly in and around Toronto, Scarborough and Pickering.

So, then, here are 7 more in this chain, in no particular order...

Opal Aristizabal, tech writer and Insight driver
Jamie Callingham, one of the few teacher-types I know who actually has time to maintain a blog
Alain Cloutier, graphic designer with a slightly insane blog, two great kids, and horse-addicted wife. He and I share a similar pain -- horsefolk are a special (wonderful) breed of crazy. :)
Kenn Hussey, IBM ex-pat and blogger with great frequency, especially this past Blaugust.
Wassim Melhem, overworked - but always well-dressed - project manager
Julia Raphael Morgan, opera singer sans blog at the moment...
Andrew Overholt, Linux evangelist and fellow cyclist

And here are the rules I'm supposed to pass on to the above bloggers:

Link your original tagger(s), and list these rules on your blog.
Share seven facts about yourself in the post - some random, some weird.
Tag seven people at the end of your post by leaving their names and the links to their blogs.
Let them know they've been tagged by leaving a comment on their blogs and/or Twitter.

* - The horses don't live with us, thankfully -- it's someone else's job to feed and muck them.

Doug Schaefer: Zune 30, Killed by Complexity

noreply@blogger.com (Doug Schaefer) — Mon, 05 Jan 2009 02:17:48 +0000

I first heard of it early New Years Eve, I guess. Hoards of Microsoft Zunes were committing mass suicide (a gruesome thought but the actual quote from the Slashdot article). Fears rose that some Y2K thing was happening, mind you things like that didn't happen in Y2K, at least not on this scale. Microsoft finally confirmed the issue as such though, a device driver hang on the 366'th day of a leap year. I'd love to see that code...

Well, thanks to the wonders of the internet, here it is! (I imagine this link will fall dead as soon as the Microsoft cronies make the rounds, as they should. It does have a Microsoft copyright). I actually found it through another blog where the guy put together a pretty good analysis of the problem.

The root cause? A brain fart. Either someone was in a hurry, or they couldn't handle the complexity of the algorithm once they started dealing with leap years. People blame testing for not testing all the paths. But, if you don't take the time to test all the paths, or don't have the skills to properly enumerate all the paths, testing isn't going to matter. At any rate, another great software engineering lesson learned for us all, just like the unhandled exception in the Ariane-5 rocket, except this one is recoverable and isn't as expensive (unless the Zune market share dives as a result, which could happen).

I spend a lot of my time these days working on software architectures and trying to come up with the most simple, extensible, and future proof. But none of that matters if you have code like this. And I've seen code like this all through my career. Hell, I've written some of it. But one thing I learned early from one of my great profs back at the U of S, was on code complexity. It is even measurable by counting the number of paths through your code. Complexity bad. Which implies that having more paths than you need is bad. As we see here, it becomes too difficult to test fully.

And that is certainly the case here. Too many 'if's. How do you convert days since 1980 into a time structure? Well in the Zune code (which is actually a common device driver in a number of Windows CE platforms), one of the paths leads to an infinite loop, when days is 366 and IsLeapYear is true. The author of the blog proposes a much simpler algorithm that works correctly but reduces the paths thus eliminating the bad one. I think you can make it even simpler.

One of my mantras is "I hate typing!". Of course it has nothing to do with typing (much). It's about producing simple elegant solutions to simple problems. Yes, Keep it Simple S(favorite ending here). Saves time. Saves money. Saves embarrassment. Saves your job. I'd hate to be the guy who wrote this code...

Dave Carver: 2008 Top Entries

noreply@blogger.com (David Carver) — Sun, 04 Jan 2009 21:40:28 +0000

I use Google Analytics to track visits to this blog. Mainly because I'm curious as to where in the world people come from and also what topics are of interest. So with out further ado, here are the top five entries.

Three of the top five are related to XML which isn't surprising considering that is what I've been working on and posting most about. I do find it interesting that there is much more interest in how to make/build an XML IDE with Eclipse. So the interest from the XML community is there, eclipse just needs to respond.

The sound problem is something that surprised me as well. Mainly because there are much better resources and solutions out there, but I found it interesting that my suggestions would spark an interest with others.

As much as I post or some would probably say preach about various Refactoring and Clean Code practices, or the lack there of them, I was surprised to see the topic of whether one should use Null Objects or Checks for Null Pointers. Too me personally, I'd rather deal with the Null Object pattern instead of having to check to make sure that a particular variable isn't null. It is probably one of the most annoying things about the W3C DOM is the number of nulls that are returned. The less I have to check to make sure an object isn't null, the better.

Since announcing that the VEX editor has moved to eclipse as a WTP Incubator project, entries on that have consitently rated high according to Google Analytics. I have even received a few code contributions and patches for some bugs for it from the community and potential adopters. Unfortunately I haven't had as much time to devote to it as I would like. For those that are attending EclipseCon in March, I will give a very brief demo of VEX in the XML Tools roundup short talk. I also look forward to talking to more users that are within the XML community that are using Eclipse for their development environment.

The last entry is one that I had lofty goals. It is also one of the areas that unfortunately had to be dropped down on my priority list. XSL Tools has taken up more time than I had hoped and getting VEX off the ground at the Eclipse Foundation took a lot of effort. Especially making sure that we were able to answer any IP concerns that were brought up.

I'm not going to make predictions for 2009, as I broke my crystal ball a long time ago. I'll just let Google Analytics report to me next year what readers thought was interesting. I'll still continue to post about XML related items at eclipse, and continue on my crusade for cleaner and better coding practices within the projects and code I write. So, let's see how 2009 goes, and thanks to those that find the content here interesting. I hope that at times it gives you, your own intellectual cramps.

Nicolas Richeton: Nebula Gallery widget : new features

Sun, 04 Jan 2009 16:36:19 +0000

Happy New Year to everyone !!!

During the christmas and new year holidays, I had some free time to improve the Nebula Gallery widget. Here is the list of the new features :

Animations : Expanding and closing of groups is now animated. The animation code is from SAT. Expand and collapse animations can be chosen between all existing SAT animations including Exponential, Elastic or Bounce or by any custom animation which implements IMovement. See video above (you may need to go to my blog, as youtube videos are not supported by planet eclipse or google reader).

DefaultGroupRenderer#setAnimation(boolean enable)

DefaultGroupRenderer#setAnimationLength(int timems)

DefaultGroupRenderer#setAnimationCloseMovement(IMovement mov)

DefaultGroupRenderer#setAnimationOpenMovement(IMovement mov)

It’s now easy to add additional effects, like zooming on mouse over.

The ScrollingSmoother class which replaces the default scrolling behavior by a custom effect is now included in the bundle.

Note : Only Linear animation has been included with the widget. You can get additionnal animations with this bundle org.sharemedia.ui.sat.easing.
Images and descriptions for groups : images and descriptions are now displayed for groups.

Up to 3 lines of text are supported, simply by using GalleryItem#setText( int index, String text) with id=0 for the main label and id=1 or id=2 for the two descriptions lines.
Lower quality on user actions : Since this widget can draw easily draw more than 20 images at every redraw, the framerate can become very low with large images. This new mode reduce the quality of images (disables antialias or interpolation) when the user is resizing or scrolling the widget in order to get ultra fast redraws.
While scrolling you would get this quality :

500 ms after the last action, the content is updated with a better quality :

Gallery#setLowerQualityOnUserAction( boolean enable)

Gallery#setHigherQualityDelay( int timems)
Decorators : support for decorators has been added in the widget. This allows to scale decorators differently from the main image, and solves resize problems with transparent images (reported by Justin Dolezy, see here). Decorators can be specified using GalleryItem#setData(String id, Object value) as single images or arrays of images.

All four corners are supported, and decorators are automatically resized if there is no enough room to draw all of them :
Quality settings: It’s now possible to change the quality settings for the graphic context. Previously quality was always set to the maximum (antialias = on and interpolation = high). Quality can now be reduced when needed.
public void setAntialias(int antialias)

public void setInterpolation(int interpolation)
Virtual groups: The widget supports SWT.VIRTUAL, which create items where they are first used. But as the widget needs to know the size of every group, they are all created right await while items are still created on demand.
The new lazy groups mode allows to create groups only when they get visible. Until that moment, a default value is used for every groups making the content creation even more lazy. This feature uses exactly the same code as the standard virtual mode.

public void setVirtualGroups(boolean virtualGroups)

public void setVirtualGroupDefaultItemCount(int defaultItemCount)
Set the default item count. Since changing on-the-fly the size of a group changes the size and position of the slider, using a realistic value reduces makes this update less noticeable.

public void setVirtualGroupsCompatibilityMode(boolean compatibilityMode)
This mode can cause issue with code that set the slider size programatically (like ScrollingSmoother). The compatibility mode ensure that only groups after the current group can be uninitialized.
Always expanded : : if you don’t need to expand/collapse groups, you can use DefaultGroupRenderer#setAlwaysExpanded to remove the button in the title bar and display groups as expanded whatever their state is. With this option, the Gallery widget looks like it was on the very first versions.
DefaultGroupRenderer#setAlwaysExpanded( boolean enable )

The code has been commited to Nebula’s CVS. Everyone can test this new version and give feedback. Have fun

EclipseLive: SWT Tables + Glazed Lists

emil.crumhorn@gmail.com (EclipseLive) — Sat, 03 Jan 2009 11:40:31 +0000

Emil Crumhorn

Abstract:

This article explains what Glazed Lists are and how they will forever make your sortable/filterable table implementations much easier to do. The article covers the SWT TableViewer, the Nebula Grid and the Nat Table. It comes with full code for running all examples, including a big framework implementation for the Nebula Grid and the Nat Table, where you can get a runnable table up in 10 lines of code or less.

If you ever wanted to build complex tables with multi-column sort, intricate chained filtering and multi-threaded table updates, or even just simple tables with one sortable column, Glazed Lists can do it all with amazing simplicity, and it works wonderfully with SWT.

The goal of the article is to give you an overview of the power of Glazed Lists in combination with SWT-based Grid/Table widgets and hopefully give you a "wow, I wish I had seen this before" kind of feeling.

delicious | digg | dzone

Egon Willighagen: Editing and Validation of CML documents in Bioclipse

noreply@blogger.com (Egon Willighagen) — Sat, 03 Jan 2009 09:50:01 +0000

One advantage of using XML is that one can rely on good support in libraries for functionality. When parsing XML, one does not have to take care of the syntax, and focus on the data and its semantics. This comes at the expense of verbosity, though, but having the ability to express semantics explicitly is a huge benefit for flexibility.

So, when Peter and Henry put their first documents online about the Chemical Markup Language (CML), I was thrilled, even though is actually was still SGML when I encountered it. The work predates the XML recommendation. As I recently blogged, in '99 I wrote patches for Jmol and JChemPaint to support CML, which were published as preprint in the Chemical Preprint Server in a paper in 2000 in the Internet Journal of Chemistry. Neither of the two has survived.

Anyway, the Chemistry Development Kit makes heavy use of CML, and Bioclipse supports it too. Now, Bioclipse is based on the Eclipse Rich Client Platform architecture, for which there exist quite a few XML tools in the Web Tools Platform (WTP). Among these, a validation, content assisting XML editor. This means, I get red markings when I make my XML document not-well-formed or invalid. Just a quick recap: well-formedness means that the XML document has a proper syntax: one root node, properly closed tags, quotes around attribute values, etc. Validness, however, means that the document is well-formed, but also hierarchically organized according to some specification.

Enter CML. CML is such a specification, first with DTDs, but after the introduction of XML Namespaces with XML Schema (see There can be only one (namespace)). The WTP can use this XML Schema for validation, and this is of great help learning the CML language. Pressing Ctrl-space in Bioclipse will now show you what allowed content can be added at the current character position.

Yes, Bioclipse can do this now (in SVN, at least). This has been on my wishlist for at least two years now, but never really found the right information. Now, three days ago David wrote about End of Year Cramps in which he describes some of his work on the WTP for autocomplete for XPath queries. He see[s] a brighter future for XML at eclipse over the next year. I hope that those in the eclipse and XML community will help to continue to improve the basic support, so that first class commercial quality applications that leverage this support can continue to be built.

That was enough statement for me to ask in the comments on how to make the WTP XML editor aware of the CML XML Schema. It already picked up XML Schema's with xsi:schemaLocation, but I needed something to worked without such statements in the XML document itself. David explained that me that I could use the org.eclipse.wst.xml.catalog extension. This was really easy, and commited to Bioclipse SVN as:

<extension
  point="org.eclipse.wst.xml.core.catalogContributions">
  <catalogContribution>
    <uri name="http://www.xml-cml.org/schema"
          uri="schema24/schema.xsd"/>
  </catalogContribution>
</extension>

However, that does not make the WTP XML editor available in the Bioclipse application yet. Not ever in the "Open With"... So, I set up a CML Feature. After a follow up question, it turned out that the CML content type of Bioclipse was already a sub type of the XML type (see ):

<extension
  point="org.eclipse.core.runtime.contentTypes">
  <content-type
    base-type="org.eclipse.core.runtime.xml"
    id="net.bioclipse.contenttypes.cml"
    name="Chemical Markup Language (CML)"
    file-extensions="cml,xml"
    priority="normal">
  </content-type>
</extension>

So, the only remaining problem was to actually get the WTP XML editor as part of the Bioclipse application. The new CML Feature takes care of that (I hope the export and building the update site work too, but that's yet untested), by important the relevant plugins and features. Last night, however, I ended up with one stacktrace which gave me little clue on which plugin I was still missing.

Therefore, I headed to #eclipse and actually met David of the blog that started this again. He asked nitind to think about it too, and they helped me pin down the issue. This relevant bit of the stacktrace turned out to be:

Caused by: java.lang.IllegalStateException
 at org.eclipse.core.runtime.Platform.getPluginRegistry(Platform.java:774)
 at org.eclipse.wst.common.componentcore.internal.impl.WTPResourceFactoryRegistry$ResourceFactoryRegistryReader.(WTPResourceFactoryRegistry.java:275)
 at org.eclipse.wst.common.componentcore.internal.impl.WTPResourceFactoryRegistry.(WTPResourceFactoryRegistry.java:61)
 at org.eclipse.wst.common.componentcore.internal.impl.WTPResourceFactoryRegistry.(WTPResourceFactoryRegistry.java:55)
 ... 37 more

This refered to this bit of code of Eclipse' Platform.java:

Bundle compatibility = InternalPlatform.getDefault()
  .getBundle(CompatibilityHelper.PI_RUNTIME_COMPATIBILITY);
  if (compatibility == null)
    throw new IllegalStateException();

So, the plugin I turned to to have missing was org.eclipse.core.runtime.compatibility. Apparently, some parts of the WTP that the XMLEditor is using, still uses Eclipse2.x technology.

This screenshot shows the WTP XMLEditor in action in Bioclipse on a CML file. It shows the document contents with the 'Design' tab, which also shows allowed content, as derived from the XML Schema for CML. Also, note that the Outline and Properties view automatically come for free, which allows more detail and navigation of the content.

This screenshot shows the 'Source' tab for the same file, where I deliberately changed the value of the @id attribute of the first atom. The value does not validate against the regular expression defined in the CML schema for @id attribute values. It also shows the content assisting in action. At any location in the CML file, I can hit Ctrl-Space, and the editor will show me which content I can add at that location.

This makes Bioclipse a perfect tool to craft CML documents and learn the language.

Egon Willighagen: Scripting JChemPaint

noreply@blogger.com (Egon Willighagen) — Sat, 03 Jan 2009 09:43:56 +0000

Stefan, Gilleain, Arvid and I had a JChemPaint Developers Workshop in Uppsala, to sprint the development of JChemPaint3, for which Niels layed out the foundation already a long time ago.

Gilleain and Arvid merged their branches into a single code base, while Stefan worked on the Swing application and applet. The Bioclipse SWT-based widget is being developed for Bioclipse2.

The new design separates widget/graphics toolkit specifics from the chemical drawing and editing logic. Regarding the editing functionality, this basically comes down to have a semantically meaningful edit API. This allows us to convert both Swing and SWT mouse events into things like addAtom("C", atom), which would add a carbon to an already existing atom. However, without too much phantasy, it allows adding a scripting language. This is what I have been working on. Right now, the following API is available from the Bioclipse2 JavaScript console (via the jcp namespace, in random order):

ICDKMolecule jcp.getModel()
IAtom getClosestAtom(Point2d)
setModel(ICDKMolecule) (for really fancy things)
removeAtom(IAtom)
IBond getClosestBond(Point2d)
updateView() (all edit command issue this automatically)
addAtom(String,Point2d)
addAtom(String,IAtom) (which works out coordinates automatically)
Point2d newPoint2d(double,double)
updateImplicitHydrogenCounts()
moveTo(IAtom, Point2d)
setSymbol(IAtom,String)
setCharge(IAtom,int)
setMassNumber(IAtom,int)
addBond(IAtom,IAtom)
moveTo(IBond,Point2d)
setOrder(IBond,IBond.Order)
setWedgeType(IBond,int)
IBond.Order getOrder(int)
zap() (sort of sudo rm -Rf /*)
cleanup() (calculate 2D coordinates from scratch)
addRing(IAtom,int)
addPhenyl(IAtom)

This API (many more method will follow) is not really aimed at the end user, who will simply point and click. The goal of this scripting language is, at least at this moment, to test the underlying implementation using Bioclipse. Future applications, however, may include simple scripts which use some logic to convert the editor content. For example, replacing a t-butyl fragment into a pseudo atom "t-Bu". The key thing to remember, is that this will allow Bioclipse to have non-CDK-based programs act on the JChemPaint editor content (e.g. using getModel() and setModel(ICDKMolecule)). More on that later.

A simple script could look like: Or, as screenshot:

Denis & Karl: Happy New Year!

Fri, 02 Jan 2009 20:46:28 +0000

Happy New Year to all, from the Eclipse Webmaster team. 2008 was a great year, with growth in the community (and our bandwidth), the release of Ganymede, great EclipseCon and Summit Europe conferences, new projects, new members, and new committers. Here’s to 2008 and for a great 2009 to come!

Prakash G.R.: Commands Part 1: Actions Vs Commands

noreply@blogger.com (Prakash G.R.) — Fri, 02 Jan 2009 18:25:01 +0000

As you would have seen, there are two different ways to contributing to the Workbench: Actions and Commands. Although Commands are newer and advanced, I've always preferred using Actions, simply because of my comfort level in using them. Now that I've started fixing some bugs in the Command framework, I'm forced to look into the details. The more deeper I look into the Commands, the more I'm loving it. So I decided to write a series of on the Commands and this is the first one in the series. Many of the information presented here is obtained by looking some old bugs, wiki and digging into CVS history. If I'm missing anything or wrong about something let me know.

Lets start with Actions. We are able to contribute to the menus, toolbars, pull down menu, etc. We are able to specify the UI details like label or tooltip in the plugin.xml itself, which helps in lazy loading. So whats wrong with them?

The UI and handling are always tied. There is no way you can separate each other
While Actions can be contributed to different parts of the workbench (popup menu/tool bar), all of them were different extension points and so you end up duplicating the XML in multiple places. The worst of it is that not all the extension points expect the same configuration.
Specifying Actions in multiple places is a maintenance nightmare. If you have to change the icon of an action, you need to change in all the places.
Another issue with duplicating Actions in plugin.xml is that multiple instance of the same Actions will be created in the memory

Lets see how the Commands Framework eliminates all this. Commands are defined by the org.eclipse.ui.commands extension point. A typical command would look like:
<command
         id="com.eclipse-tips.commands.someCommand"
         name="Some Command">
</command>
Yeah thats it. That defines a Command! If you want to place this in a tool bar, you have to use the extension point org.eclipse.ui.menus:
<menuContribution
      locationURI="toolbar:org.eclipse.ui.main.toolbar">
   <toolbar
         id="com.eclipse-tips.commands.toolbar1">
      <command
            commandId="com.eclipse-tips.commands.someCommand"
            id="com.eclipse-tips.commands.someCommandInToolBar">
      </command>
   </toolbar>
</menuContribution>
Now that takes of the placement in the UI. But what about the code that gets executed? That goes into a another extension point, org.eclipse.ui.handlers:
<handler
         class="com.eclipse_tips.commads.SomeCommandHandler"
         commandId="com.eclipse-tips.commands.someCommand">
</handler>

One last piece is to add an icon to the Command
No price for guessing that you need to use another extension point, org.eclipse.ui.commandImages:
<image
         commandId="com.eclipse-tips.commands.someCommand"
         icon="icons/sample.gif">
</image>

All set. Lets see the Command in action:

As you see, in the actions we would just use only one extension point, instead of the four which we have used now. Does it sounds like a round about way or doing things? Probably once we get to know about multiple handlers for a Command and context based association & enablement of the handlers etc, we will see the beauty of the framework. That would be the next in this series.

David Green: Mylyn WikiText at EclipseCon 2009

noreply@blogger.com (David Green) — Fri, 02 Jan 2009 17:06:56 +0000

WikiText will be at EcilpseCon 2009 in Santa Clara, California. The presentation time was expanded to allow for more coverage of WikiText -- so if there's something specific that you'd like to hear about please let me know.

The WikiText presentation is included in a session titled "50 minutes towards a better you". Don't ask me about the title -- I don't know if WikiText will make you a better person or not. I'm very excited to be there presenting this new technology alongside Steffen Pingel, who will be providing a Mylyn connector crash course.

Wayne Beaton: Eclipse Plug-ins, Third Edition

Fri, 02 Jan 2009 16:57:17 +0000

The third edition of “Eclipse Plug-ins” (previously titled “Eclipse: Building Commercial-Quality Plug-ins”) by Eric Clayberg and Dan Rubel is available.

Eclipse Plug-ins provides detailed, practical coverage of every aspect of
plug-in development, as well as specific, proven solutions for the
challenges developers are most likely to encounter. This comprehensive guide
covers the entire process of plug-in development, including all the extra
steps needed to achieve the highest quality results. The book has been fully
revised to reflect the powerful new capabilities of Eclipse 3.4; its 928
pages offer cookbook-style code examples, relevant API listings, diagrams,
screen shots and more.

All code examples, relevant API listings, diagrams, and screen captures have
been thoroughly updated to reflect both the Eclipse 3.4 API and the latest
Java syntax. In addition, Clayberg and Rubel have completely revamped their
popular Favorites View case study, reworking much of its content and
recreating its code from scratch. The authors carefully cover new
functionality added to existing Eclipse features, such as views and editors,
and fully explain brand-new features such as Commands, GEF, and PDE Build.

I fully enjoyed the second edition and am looking forward to the additions in this new third edition. You can find more information about the book on the companion website.

Christian Damus: Old-Fashioned Prognostication

noreply@blogger.com (Christian W. Damus) — Fri, 02 Jan 2009 16:55:52 +0000

No, I'm not making predictions for the success of Eclipse or any technology in 2009.

Another new year has arrived, and to usher it in I once again engaged in the timeless German tradition of Bleigießen: the divination of one's future (for the coming year) in the pouring of molten lead.

The idea is simple: you cut a length of lead solder and heat it, in a steel spoon, over a candle or other tabletop flame, thus:

Once the lead is completely molten and flows freely, you pour it quickly into a bowl of cold water to chill it instantly. In the resulting sculpture, you see a shape, figure, or other graphic indication of what the year holds in store for you (rather like cloud gazing):

As you can see, my first attempt didn't show much and was actually spoilt by pouring too rapidly. Am I having puppies? Or are these tears? As this attempt failed due to a bad pour, I tried again, with a smoother and steadier hand:

That's more like it. I can read something into this! I see ... on the right-hand side ... a frog? Yeah, a frog. It's sitting on a stick, readying to jump into the water. The stick is jutting out of the water from right to left, like in so many creek-paddle scenes from my canoe tripping.

Looks like Mother Nature has another great canoeing season in store for me!

Sandro Boehme: Eclipse Summit Europe 2008

noreply@blogger.com (Sandro Böhme) — Fri, 02 Jan 2009 15:48:42 +0000

I know it's a bit late, but I think might still be interesting for some people. At least to know what the outcome of the ESE 2008 was for JCRM.

++ The Preperation ++
I had two talks scheduled for the ESE. One at the symposium at tuesday and one at the usual conference at wednesday. I knew it was a tough plan but I could only start to prepare the talks in the week before the conference. The idea was to demo all the JCRM tools. While playing around with them to structure the demo the first nested Eclipse instance crashed. I thought this might be sheer coincidence. But also the second nested instance crashed a few times with an OutOfMemoryError and it started to make me nervous. Of course these kind of things don't happen when developing the tools. They only show up when preparing the talk and there is not much time for fixes. Finding the memory configuration for Eclipse on Mac isn't obvious as it's in a hidden directory. So searching for it didn't make me more relaxed. But in the end I found a memory setting that worked without a problem and I needed to skip some tool demos anyway in fovour of showing the basic concepts of JCRM. That way the people can judge these concepts or influence JCRM along the lines of it. Finally at 10 pm on monday I finished the preperation of the talk for the conference and could start to prepare the talk for the symposium. I finished it at 1am on tuesday.

++ The Symposium ++
The symposium had a quite interesting start as I was chatting with Markus Völter about not having a wireless internet connection available. After a few minutes the maintenance guy who was working in the room and oviously heared us moaning gave us the underground password for the wireless internet connection and said we should not widely spread it as the connection would be overloaded otherwise.
To be hornest I'm quite intimidated by giving such a talk so I was glad to already be the second presenter. I think I could have made the goal of the talk - handling EMF models that don't fit into the memory - more clear. But except that I think it went ok. Many other presentations were about meta model evolution. Its great that there is progress in this area. Because using JCRM it should not be too hard to use the resulting tools for the refactoring JCR node types and that would certainly be very valuable for the JCR communities.
After the presentations the open space discussions were planned. First everybody could propose an issue to discuss about later on. Then everybody could vote three times to weight the importance of the proposals. After that the three least important proposals were skipped and the others were planned how they can run in parallel and how they fit into the available time. This is an interesting community driven format. I proposed to give information about the Java Content Repository and how it could be used also in other Eclipse use cases. When it was on me to vote I saw that there was only one vote for my proposal so far so I though: "There doesn't seem to be much interest in the JCR issue. But thats ok, I will just give it one of my votes and use the other two votes for other interesting issues.". Biiiig mistake. Later on a number of other people voted for my proposal and it turned out that if I would have used my other two votes for my proposal too it would not have been skipped. Lesson learned: I could be more patriotic.
During the symposium I had some interesting discussions about JCRM with Kenn Hussey and Cedrik Brun. To integrate JCR references into EMF Kenn gave me some information about references in EMF that were very useful. We also discussed about JCRM performance [1], if it's possible to collaborate with CDO and I showed him how versioning works in JCRM.

[1] - Bugzilla: Adding objects: https://bugs.eclipse.org/bugs/show_bug.cgi?id=259674
- Bugzilla: Searching objects: https://bugs.eclipse.org/bugs/show_bug.cgi?id=259675
- Bugzilla: traversing on EMF EStructuralFeatures https://bugs.eclipse.org/bugs/show_bug.cgi?id=259676
- Bugzilla: Repository Editor https://bugs.eclipse.org/bugs/show_bug.cgi?id=259677
- Bugzilla: update https://bugs.eclipse.org/bugs/show_bug.cgi?id=259678
- Bugzilla: delete https://bugs.eclipse.org/bugs/show_bug.cgi?id=259679

++ The conference ++
At the first day of the conference I was mainly at the booth of our company and visited just the keynote and a few talks like the MTL and the CDO talks.
After that it was on me to give my presentation. Interestingly I was less nervous than the day before and better concentrated. There were 15-20 people attending. I guess the majority of the people were at the E4 talk. But I was glad to find Ed and Kenn in the audience (and later I found out that also Rich was there) because they are part of the core modeling community. It is good when they know what JCRM is about because they can judge quite good what is valueable for the Eclipse modeling community and what's not.
Event though I made time consuming mistakes that probably nobody really recognized, I think the presentation generally went good because it made clear:
- how the JCR communities and the Eclipse community can benefit from each other using JCRM,
- how straight the JCR integration into EMF is,
- that its not hard to use JCRM in existing EMF applications
This presentation got good feedback like "JCRM is Cool!" and "JCRM has a lot of potential.", "JCRM generated quite a hype." If you did not attend my talk but you are curious about Eclipse JCRM you can download the slides from slideshare, have a look at the JCRM wiki or ask me in the newsgroup (and CC me with s(dot)boehme(at)inovex(dot)de )

The conference was not only exciting for me because of my talks but also because I had a lot of interesting chats with different people:
o Cedric hacked an example for me on how to compare two EObjects of a model. This will be very valueable for the Repository Editor (formerly called Node Editor or JCR Manager). Because this would make it possible to actually compare node objects with this editor.
o After it didn't work out at the last ESE I finally found Eike to talk with him. Interestingly it turned out that we solved the same problem the same way independend from each other. For models that are bigger than the available memory we both used the EMF EStore and the java.lang.ref.SoftReference to free unused model elements from the memory and reload them on demand. Just the day before at the Modeling Symposium I talked about that. To avoid solving the same problem twice and to better integrate our projects we agreed to do some screen sharing sessions. To be honest this is not too high on my priority list right now because I would like to focus on the Repository Editor instead but I still think it's important to work on that.
I also had an interesting discussion with the people from ikv about their project, a nice chat with Wolfgang Frank and Achim Baier and a good time during the breakfast and between the talks with Lars Schneider, Xavier and many other people.

Nick Boldt: Clarifying Our All-In-Ones

nickboldt@gmail.com (nickb) — Fri, 02 Jan 2009 06:35:14 +0000

In order to make it clearer what's in the various flavours of all-in-one zips provided in Modeling, GEF, and PDT, I've concocted some new icons to better differentiate them.

This is actually moving in the opposite direction from what I'd proposed in bug 240223 regarding Simplified EMF Downloads as we're now providing more, not less... but IMHO that's okay as long as the community is well served. If you have an opinion on update site vs. update zips vs. SDK zips vs. EPP bundles, please feel free to weigh in on bug 240223.

And if you hate the new icons, please let me know. Better still, design me a replacement. Thanks to iconeden.com for the source pixels.

Dave Carver: A DOH! moment

noreply@blogger.com (David Carver) — Fri, 02 Jan 2009 04:32:08 +0000

Update 2009-01-01: The first refactoring is done and attached to bug 259853. There is still more to do to break up some overly long methods, but it is now easier to test the various pieces.

I have been working on some refactoring of the current XML formatter code. It's taking a while to break up a roughly 2000 long line Class, but it's going well. The reason for the DOH moment was when I started running into having to apply the "Replace method with Method Object" refactoring on some of the various format methods in the code. I started getting away from running the unit tests and just kept doing the Replace Methods to get things to compile. I had been working on this for a day and half, and hadn't run the tests. As I was getting compilation errors, and figured I needed to clean that up. I eventually, realized, that even if I did get all the compilation errors cleaned up I would have no clue as to where any unit test failures would have occurred.

So, I scrapped everything, and replace my content with the last known time I had run the unit tests again, and proceeded again. It's a good thing too...as soon as I did the first Replace Method with Method Object refactoring an ran the tests, they failed. I had forgotten to make sure that the Preference settings that had been set earlier were passed to the new method object. So I fixed that, and all the current tests passed. Since I hadn't even run the tests before doing these type of refactorings and I had done many of these in a day without running tests, it would have been a night mare trying to figure out what wasn't working.

Uncle Bob's latest post on Fudge anyone, reminded me of my own situation a bit. I like the morals he came up with:

Moral #1: Fudge tastes good while you are eating it, but it makes you fat, slow, and dumb.

Moral #2: Eat the damned dog food. It’ll save your posterior from your own maladroit decisions.

Particularly, I agree with Moral #2, use what you write in your day job. Ideally, if you work on an editor use that editor in your day job. You are more likely to fix things sooner if you are directly affected by it. It's why XSL Tools has become my primary XSLT Editor, it forces me to address the issues that affect my own use everyday. It's why JDT is such a good editor for Java development in eclipse. The JDT team uses it themselves to develop eclipse. The same goes for PDE.

Sandro Boehme: Welcome

noreply@blogger.com (Sandro Böhme) — Thu, 01 Jan 2009 16:15:18 +0000

"It's not the years in your life that counts. It's the life in your years."
These words of Abraham Lincoln pretty much describe my attitude to live. Thats why you can expect to read in this blog about the adventures I came across. You will mainly see short stories of what I experienced running the JCR Management component at Eclipse. But also other advantures that might be worth reading.
As it's always inspiring to discuss a controversy or to chat with likeminded people I'm very much looking foreward to your feedback.

Ed Merks: It's a Matter of Perspective

noreply@blogger.com (Ed Merks) — Thu, 01 Jan 2009 13:46:47 +0000

Have you ever noticed how much changes depending on your point of view?

Even just a very slight change of perspective can make a significant difference.

As such, two people looking at the same thing from different view points will actually see different things.

They might argue about how it's possible that other people sees things differently.

While it's so clearly green for one person...

It's so obviously blue to another.

It's best to keep this in mind when arguing about perceptions. Try to take a very close look from every point of view you can imagine.

Only then will you see reality as it actually is: a diversity of shifting sizes, shapes, textures, and colors strongly influenced by the eye of the beholder.

Doug Schaefer: Predictions for 2009

noreply@blogger.com (Doug Schaefer) — Wed, 31 Dec 2008 18:44:29 +0000

I'm not usually one to make predictions. It's hard for me to tell the difference between a prediction and wishful thinking. But this article over at the Inquirer (still the best place to get an honest take on the industry along with /.) got me thinking about a couple of things I think are going to be important in 2009. So here we go...

2009: The Year of the GPGPU

This is more a continuation of a trend but the Inq article made some great points that I think will put some spotlight on general purpose programming with GPUs. The key one, is the recent standardization of a cross platform way of programming these things, OpenCL. ATI and nVidia have already signed up to provide OpenCL support for their chips and look for Intel's Larrabee platform to come with the same. I think there is still some software and hardware architectural things that need to be done to make GPGPU more efficient and easier to program. Look for LLVM (which needs an article on it's own) to play a role, as it already is with OpenGL, and look for one of the chip vendors to put a GPU on the memory bus shared with the CPU and make these things sing.

2009: The year of WebKit

Ok, yes, I'm playing it safe with these predictions. WebKit is already the base for Apple Safari, Google Chrome, and a host of Linux based browsers, so it already has a ton of momentum. The reason I think WebKit is going to the next level, is first of all the top of the class performance of it's new JavaScript VM (and I can't imagine why Google would continue with V8 in Chrome). But also, I am impressed with how easy it is to create your own WebKit based browser, and how easy it is to create a Linux based platform that uses WebKit as it's front end (launch X, launch a simplified WebKit shell in fullscreen, done). I expect to see a lot more mobile internet devices built this way. At the very least, it gives a reason for embedded developers to care about AJAX.

C++0x won't be C++09

I think that's a forgone conclusion but no one really wants to admit it yet. But look for the vote to finish this year at least. C++0x will be an exciting evolution of C++ into the next generation. No it doesn't have garbage collection, yet, but it does have smart pointers that do the job better if you use them right. C++0x makes it easier to do a lot of things, and the introduction of closures and lambda functions and expressions will breath some life into this stalwart of the software engineering community.

Well, that's it for now. If I think of more over the next couple of days I'll post them. There are a lot of things I hope will happen, but i'm not sure they will. But one thing is for sure, open source is here to stay and is becoming a core business model that companies still need to understand and learn to use effectively and I will continue with my work with Eclipse and Wind River to help figure that out and spread the word.

Have a safe and happy New Year! See you on the other side.

Thomas Kratz: P2 deployment in enterprise applications

thomas.kratz@eiswind.de (Tom) — Wed, 31 Dec 2008 14:20:51 +0000

So many times I asked people I met, why they have choosen a browser based solution for their business applications that are never meant to appear on the internet. And, as was to be expected, most of the time I didn't hear many meaningful arguments. One of the arguments that people tell in almost any cases is "no trouble with deployment".

I remember trying different strategies for rich client apps deployment. Some years ago we used webstart with a Windows shortcut, which sometimes made some trouble (I never made it deeper into it) when it didn't get the changes and started from its cache instead of downloading the updates.

In a client server environment it's critical that clients are synced when service api breaking changes are made on the server side. So after many years I came back to the problem with my project Mango (its about publishing business btw.) which is implemented on Eclipse RCP for the sake that I believe its the best platform we have in java-land. For sometime (as with many projects) we had only a single production installation and I didn't put much effort in installation issues. I told the admins what was to do to get it running.

But times changing and installation count is rising, I noticed that I had to improve things around deployment. Typical update scenarios that eclipse mechanisms adress don't match truly what we need, because we can't update from a central point since client and server updates must be synced. As for now I decided against an automated server update (which I may rethink...).

But with some effort (had to do some minor but hard to find tweaks on the current p2 implementation) we now install the p2 repository for our client on an embedded webserver in our server installation. With again some tweaking I made the p2 installer app webstartable and you guess, it too comes with the server installation.

Now its a single selfextracing jar, that updates the server platform, and runs all needed changes (database schema changes, sometimes data needs to be converted etc). For a single turn users need to be emailed the link to the installer jnlp to get the current client installed on their boxes. From now on (it cost me some days, my wife can tell it was tricky...) whenever one of our users decides to update his installation to the current release, its a simple one liner to update the whole scenario.

As I ran out of time its a little q&d trick on the client, as it simply starts up with a null perspective and disabled menus when server api has changed. It then updates itself from the p2 repository and needs to be restarted.

Things that still need to be done is notifing running clients when the server goes down for maintenance, but that could gives us room for new ideas in any way.

So to say, what I guess I will hear now is, that in big client installation count this will still need high network traffic when on monday mornings people fire up their clients and all request an update at nearly the same time. But without having scientific proof I guess that with p2 we can update to the point what needs to be updated. So actual download size (in our case, the client code is actually quite small compared to the base platform plugins it depends on) won't be more than some megs.

So next time I stumble across the above arguments, I think I'll have something up the sleeve.

Wayne Beaton: EclipseCon Very Early Registration Deadline approaching…

Tue, 30 Dec 2008 02:41:24 +0000

The Very Early Registration Deadline for EclipseCon 2009 is December 31st. Register today and save some money!

Chris Aniszczyk: PDT 2.0 is available!

noreply@blogger.com (Chris Aniszczyk (zx)) — Mon, 29 Dec 2008 19:47:36 +0000

For those who have to hack PHP occasionally, PDT 2.0 was released today. There's a world of a difference between 1.0 and 2.0, so I recommend you give it a spin.

It's good to have access to 'Open Type' now in PHP development :)

PDT 2.1 should be released in time for Galileo so try 2.0 out and give any feedback to the PDT team if you want to see new features by the time Galileo ships.

BUG Community: OpenEmbedded Tools for Eclipse (OTE) 0.4.3 Live

Mon, 29 Dec 2008 18:39:25 +0000

After several weeks of eating my own dogfood, several critical bug fixes in the core file functionality of OTE have been addressed. Reading through the BitBake python code is not that bad actually, and the source organization makes a lot of sense. This release offers no new functionality, it just crashes less :) Next stop: "Import Recipe as Project" The updatesite is available at http://bugcommunity.com/downloads/files/ote/updatesite

Ed Merks: It's Here, it's Finally Here!

noreply@blogger.com (Ed Merks) — Mon, 29 Dec 2008 18:31:37 +0000

The second edition of the EMF book physically arrived at my doorstep today! Here she is, modeling her new improved jacket with the Ecore Tools diagram of the Ecore model as a backdrop.

What a stunningly fashionable combination! With almost twice as much meaty content that's more than twice as excellent as the last edition, I expect it will be all the rage in the new year. According to Amazon, if you order today, it will still arrive in time to ring in the new year on Wednesday night. We live in a world of instant gratification...

Eclipse Enthusiasts Poznań: Eclipse Debugger, part II

noreply@blogger.com (Jakub Jurkiewicz) — Mon, 29 Dec 2008 10:47:05 +0000

As I said in the Part I, this time I will focus on the Hit Count property and the Conditions of breakpoints. If you go to the breakpoint's properties (right click on the breakpoint and choose Breakpoint properties... option) you will see two interesting options:

Hit count

When we enable the Hit Count and give some positive integer value X the breakpoint will suspend the execution when it would be hit Xth time.
Lets illustrate this with example. If we consider the following code:

and we set the Hit count of the breakpoint (look at the picture above to see where the breakpoint is placed) to 7 we will find the following output in the Console view before the execution is suspended:

So as you can see the execution was suspended when the breakpoint was hit 7th time.

Conditions
Sometime everyone faces the situation when we want a breakpoint to be active only if some condition is fulfilled (e.g. we go in the loop through a 1000 elements list o people's names and we want to debug this loop for a particular name and we don't want to go 1000 times through this loop). To see how it works let's take the same code and let's set the condition the following way:
In this case the output in the Console view will look as follows:
The given condition is evaluated in the context of the breakpoint, so we can use all the variables that are available the context. Of course you don't have to use the numerical conditions, any expression that gives boolean answer can be used!

Doug Gaff: I’m addicted to information

noreply@blogger.com (Doug Gaff) — Mon, 29 Dec 2008 03:11:12 +0000

Over this lovely holiday break, I have decided to catch up on {everything}. Starting next year off with a clean to do list seems like a good idea. Before I left work for the holidays, I managed to get my inbox down to 3 or 4 items. (If you think you're one of those 3, you'd better remind me via email.) But email is just one of my problems, an antiquated one in fact.

Most of the good stuff comes in through RSS feeds. I counted them a couple of days ago: 97 feeds. They breakdown roughly into the following categories: Business, Culture, Humor, Software, Technology, Work, odds and ends. Unfortunately, many of these feeds have high update rates, like BoingBoing, LifeHacker, and the collection of work-related feeds. Even PlanetEclipse, my first RSS feed, has become a challenge to follow in my expanding list. I've already dropped several others because the signal-to-noise ratio was too low.

But I can't let go of my current list of 97. Every day I think, maybe I'll drop this one or that one, but then I pick up a new software utility, laugh at a good cartoon, find out about a cool tool, or learn something new about art/politics/technology/photography/music/whatever. And almost every day, I find YAF (yet another feed) that I think maybe I'll subscribe to…just for a little while…just to try out it. Dammit.

We have reached information saturation: Email, Twitter, Facebook, YouTube, podcasts, blogs, RSS, …. (I don't even turn on my TV anymore.) Either someone needs to install one of those Matrix ports into the back of my skull, or we need to move way beyond reddit, delicious, and digg to get useful, personalized information.

Oh well. Here's to a New Year and another 100 feeds.

Tonny Madsen: Screen Flows support released

noreply@blogger.com (Tonny Madsen) — Sun, 28 Dec 2008 22:32:07 +0000

It took a while longer than promised, but now I am happy to release the screen flow implementation I talked about at Eclipse Summit Europe '08 to the public.

Just go to http://code.google.com/p/screen-flows-in-eclipse/ and you should find both the presentation as well as all the needed sources. If you find any problems with the implementation or just find a way to enhance them, then please free to submit your changes.

Craig Setera: Mobile Tools for Java Release 0.9.1

Sun, 28 Dec 2008 18:25:46 +0000

Release 0.9.1 of the MTJ project is available to download from the MTJ website. You can access the release from:

Download site: http://download.eclipse.org/dsdp/mtj/downloads/drops/R-0.9.1-200812231340/index.html
Via update manager: http://download.eclipse.org/dsdp/mtj/updates/0.9/stable/

Below is a list of the main new features that are available in the new release:

Multidevice support: each MTJ project can now have several devices associated to it
Preprocessor enhancements: there is code assist on the preprocessor tags
MIDlet Unit Test Support: it is possible to create unit tests cases/suite to MIDlet classes. The tests can be packed with the MIDlet suite
MIDlet localization: There is now one option on the MIDlet suite to localize all Strings that are used on the MIDlet Suite
MIDlet suite libraries: There is a new extension point that can be used by content developers to provider libraries that can be packed with the MIDlet suite
Import Symbol Set definitions: Besides creating symbols and symbols set, MTJ users are now able to import predefined symbol sets based on Antenna format
Content assist on the JAD Editor

In this release, besides the valuable community contributions during conference calls, email discussions and bug reports, there were code contributions from the following companies:

Craig Setera (individual)
Inlogic Software ltd
Motorola
Nokia
Sybase

Thanks for the hard work of everyone that contributed to this release. The project will be scheduling a call in early January to talk about MTJ 1.0 scope.