Less testing, same great Firefox taste!

by Kim Moir (noreply@blogger.com) at April 28, 2015 06:47 PM

Running a large continuous integration farm forces you to deal with many dynamic inputs coupled with capacity constraints. The number of pushes increase.  People add more tests.  We build and test on a new platform.  If the number of machines available remains static, the computing time associated with a single push will increase.  You can scale this for platforms that you build and test in the cloud (for us - Linux and Android on emulators), but this costs more money.  Adding hardware for other platforms such as Mac and Windows in data centres is also costly and time consuming.

Do we really need to run every test on every commit? If not, which tests should be run?  How often do they need to be run in order to catch regressions in a timely manner (i.e. able to bisect where the regression occurred)

Several months ago, jmaher and vaibhav1994, wrote code to analyze the test data and determine the minimum number of tests required to run to identify regressions.  They named their software SETA (search for extraneous test automation). They used historical data to determine the minimum set of tests that needed to be run to catch historical regressions.  Previously, we coalesced tests on a number of platforms to mitigate too many jobs being queued for too few machines.  However, this was not the best way to proceed because it reduced the number of times we ran all tests, not just less useful ones.  SETA allows us to run a subset of tests on every commit that historically have caught regressions.  We still run all the test suites, but at a specified interval. 

SETI – The Search for Extraterrestrial Intelligence by ©encouragement, Creative Commons by-nc-sa 2.0
In the last few weeks, I've implemented SETA scheduling in our our buildbot configs to use the data that the analysis that Vaibhav and Joel  implemented.  Currently, it's implemented on mozilla-inbound and fx-team branches which in aggregate represent around 19.6% (March 2015 data) of total pushes to the trees.  The platforms configured to run fewer pushes for both opt and debug are
  • MacOSX (10.6, 10.10)
  • Windows (XP, 7, 8)
  • Ubuntu 12.04 for linux32, linux64 and ASAN x64
  • Android 2.3 armv7 API 9

As we gather more SETA data for newer platforms, such as Android 4.3, we can implement SETA scheduling for it as well and reduce our test load.  We continue to run the full suite of tests on all platforms other branches other than m-i and fx-team, such as mozilla-central, try, and the beta and release branches. If we did miss a regression by reducing the tests, it would appear on other branches mozilla-central. We will continue to update our configs to incorporate SETA data as it changes.

How does SETA scheduling work?
We specify the tests that we would like to run on a reduced schedule in our buildbot configs.  For instance, this pecifies that we would like to run these debug tests on every 10th commit or if we reach a timeout of 5400 seconds between tests.


Previously, catlee had implemented a scheduling in buildbot that allowed us to coallesce jobs on a certain branch and platform using EveryNthScheduler.  However, as it was originally implemented, it didn't allow us to specify tests to skip, such as mochitest-3 debug on MacOSX 10.10 on mozilla-inbound.  It would only allow us to skip all the debug or opt tests for a certain platform and branch. 

I modified misc.py to parse the configs and create a dictionary for each test specifying the interval at which the test should be skipped and the timeout interval.  If the tests has these parameters specified, it should be scheduled using the  EveryNthScheduler instead of the default scheduler.

There are still some quirks to work out but I think it is working out well so far. I'll have some graphs in a future post on how this reduced our test load. 

Further reading
Joel Maher: SETA – Search for Extraneous Test Automation

by Kim Moir (noreply@blogger.com) at April 28, 2015 06:47 PM

Collaborative Modeling with Papyrus and CDO (Reloaded)

by Eike Stepper (noreply@blogger.com) at April 28, 2015 06:35 PM

Since the beginning of this year I've been working on fundamental improvements to the user interface of CDO and its integration with Papyrus. In particular CEA has generously funded the following:
  • Branching and interactive merging
  • Support for offline checkouts
  • Interactive conflict resolution
Most of the new functionality has been implemented directly in CDO and is available for other modeling tools, too. Please enjoy a brief tour of what's in the pipe for the Mars release:

The following screencast shows how Papyrus will integrate with this new CDO user interface:

I hope you like the new concepts and workflows. Feedback is welcome, of course. And I'd like to thank CEA, Kenn Hussey and Christian Damus for their help to make this happen!

by Eike Stepper (noreply@blogger.com) at April 28, 2015 06:35 PM

JBoss Tools Alpha2 for Eclipse Mars

by maxandersen at April 28, 2015 04:22 PM

Alpha 2 build for Eclipse Mars M6 is now available at Alpha2 download.


This version of JBoss Tools targets Eclipse Mars 4.5 (M6).

We recommend using the Eclipse 4.5 JEE Bundle since then you get most of the dependencies preinstalled.

Once you have installed Eclipse, you use our update site directly:


Note: Marketplace entry and Integration Stack tooling will become available from JBoss Central at a later date.

What is new ?

Easy Import/Open of projects

We have included our incubation project at Eclipse that makes importing and opening of projects much easier than default Eclipse. No longer do you need to know or guess at which of many import wizards are the right one. With this you just use menu:File[Import Project from Folder], point it to a folder and it will auto-detect the type of project, imports ann configure it as best as it can.

easyimport filemenu

Once started it will recursively scan the selected folder and report which directories it found.

easyimport wizard

We included this incubation feature to get early feedback - please do give it a try and let us know if it works great or if we detected some projects "badly".

OpenShft v3

Our OpenShift integration now allow you to connect to OpenShift 3 in addition to the existing OpenShift 2 support.

connection wizard server type

Once connected you can browse the OpenShift/Kubernetes data for your application/projects.

view explorer v3

Note: OpenShift v3 is not available from openshift.com to try at this point in time. If you want to try use it you can follow the instructions at OpenShift Origin sample app.

Java EE 7 Batch wizards, content assist, validation and refactoring

In Alpha 1 we introduced support for Java EE 7 batch specification and now extending this support with a wizard, content assist, linked navigation, searching and refactoring of Batch elements.


WildFly 9

We’ve added native WildFly 9 runtime detection and server support. You no longer need to use the WildFly 8 adapter and detection will work correctly now.

Content assist for AngularJS Expressions

When editing AngularJS single-page html (not templates) the html editor now communicates with the preview to provide content assist for angularjs expressions.


Custom HTML Tag validation

There is now a quickfix for marking custom HTML5 elements to be ignored in validation.


Note: this is not specific to JBoss Tools, it is built into Eclipse M6

Next steps

With Alpha2 out we are heading towards a Beta1.

In Beta1 we are targeting including:

  1. OpenShift v3 support for templates

  2. Docker Tooling

  3. Better JavaScript content assist

  4. Making project imports in Eclipse even simpler

  5. And more…​

As always, ask/suggest away and we’ll keep you posted!

Have fun!

Max Rydahl Andersen

by maxandersen at April 28, 2015 04:22 PM

Screenshot of the Week: C++ Refactoring

by waynebeaton at April 28, 2015 03:08 PM

My son has just finished up his first year of software development at college. In a demonstration of what I consider cruel and unusual punishment, his first programming language is C++ and his first development environment is Visual C++. I have to assume that the version of Visual C++ that the college unleashed on these unsuspecting students is some sort of reduced-functionality version, because it seems to lack certain functionality that I consider pretty basic, like refactoring.

I learned C years ago, and did some honest-to-goodness work using it, but never did take the time to learn C++, so I used this as an opportunity to close that gap. Naturally, I decided to learn C++ using the Eclipse C/C++ Development Tools (CDT).

The CDT provides some excellent refactoring support.

Renaming a C++ method

Renaming a C++ method

Keep the just-sorting-this-stuff-out nature of the work when considering the code in the screenshot.

This screenshot shows the first stage of the Rename refactoring. As expected, this changes the name of the method (function), the declaration in the header file, and any code that calls it. There are many other refactorings available, including ones that extract constants, fields, and functions. Note the Call Hierarchy view on the bottom view stack: use this view to find out how your function interacts with the world (calls and callers). There’s all sorts of cool stuff available.

The Eclipse CDT project has participated in every simultaneous release we’ve done and so it’s no surprise that they’re an important part of the Eclipse Mars Release. Help us test Eclipse Mars by downloading and testing a milestone build.

Epilogue: To my son’s instructors’ credit, they did avoid complex memory management issues, and did get the students to produce some pretty cool and very playable games featuring two-dimensional graphics. Those students that survive the programme are probably going to do well…

Caveat: I never really took the time necessary to properly research the functionalities provided by Visual C++ or spend any significant time using it. I have to assume that it’s very functional once you get comfortable with it.

by waynebeaton at April 28, 2015 03:08 PM

@ApacheParquet Graduating and Mesos with Siri

by Chris Aniszczyk at April 28, 2015 02:52 PM

The last week for me has been fun in open source land outside of me getting two of my wisdom teeth pulled out of my face. On the bright side, I have some pain killers now and also, two notable things happened. First it was nice to finally graduate Parquet out of the Apache Incubator:

It’s been a little over two years since we (Twitter) announced the open source columnar storage project with Cloudera. It’s a great feeling to see a plan come together and see this project grow over the years with 60+ contributors while hitting the notable achievement of graduating out of the Apache incubator gauntlet. If there’s any lesson here for me, it’s much easier to build an open source community when you do it an independent fashion with at least someone else in the beginning (thanks Cloudera).

Another notable thing that happened was that Apple finally announced that they are using Mesos to power Siri’s massive infrastructure.

In my experience of building open source communities, there are usually your public adopters and private adopters. There are companies that wish to remain private about the software they use at times and that’s fine, it’s understandable when it can be viewed as a competitive advantage. The challenge is how you work with these private adopters when they use an open source project of yours while wanting to collaborate behind the scenes.

Anyways, it’s a great feeling to see Apple opening up a bit about their infrastructure and open source usage after working with them for awhile. Hopefully this is a sign of things to come from them. Also, it would be nice if Apple just updated Siri so when you ask what Mesos is, it replies with a funny response and proclaims her love of open source infrastructure technology.

Overall, it’s been a great last week.

by Chris Aniszczyk at April 28, 2015 02:52 PM

Kudos to Tony McCrary for his Eclipse JDT icon work

by Lars Vogel at April 28, 2015 07:50 AM

Tony McCrary continues his awesome icon contributions.

This time he managed to re-create the JDT icon set so that the JDT icon look good on a dark background. This work started in January 2014 (!!!) and as the JDT developer are under a high pressure, Tony even generated a gallery to compare the old gif and the new png icons to make the review easier for them.

On the left you see the old gif icons, the right are the new png icons.

JDT icons

JDT icons

See JDT icon work Bug for details.

Many thanks from me personally and the platform.ui team to Tony.

by Lars Vogel at April 28, 2015 07:50 AM

Call 4 papers - where is an open source app?

by Krzysztof (Chris) Daniel (noreply@blogger.com) at April 27, 2015 03:45 PM

I was recently submitting a number of conference proposal related to my current area of interest, and one thing that struck me was the lack of a rock-solid, easy to use call-4-paper application.

Each time I wanted to propose a talk to a conference I had to create a profile, confirm e-mail address, provide a lot of details and only then I was allowed to fill actual talk details.

"Don't reinvent the wheel!" they say.

So, why, WHY each conference organizers decide to write their OWN c4p application? That makes no sense.

The internet proposal submission is no longer a feature that will distinguish your conference.

That's why I am starting my new, open source application for accepting conference talks. It will not be fancy, but it will work.

Clone it, run it, modify it, USE it.

Contribute if you wish.

by Krzysztof (Chris) Daniel (noreply@blogger.com) at April 27, 2015 03:45 PM

Using the Xtend language for M2M transformation

by Andreas Graf at April 26, 2015 02:34 PM

In the last few month, we have been developing a customer project that centers around model-to-model transformation with the target model being AUTOSAR.

In the initial concept phase, we had two major candidates for the M2M-transformation language: Xtend and QVTO. After doing some evaluations, we decided that for the specific use case, Xtend was the technology of choice.


ComfortXtend has a number of features that make writing model-to-model-transformations very concise and comfortable. The most important is the concise syntax to navigate over models. This helps to avoid loops that would be required when implementing in Java

val r = eAllContents.filter(EcucChoiceReferenceDef).findFirst[
shortName == "DemMemoryDestinationRef"]
Traceability / One-Pass TransformationXtend provides so-called "create" methods for creating new target model elements in your transformation. The main usage is to be able to write efficient code without having to implement a multi-pass transformation. This is solved by using an internal cache to return the same target object if the method is invoked for the same input objects more than one time

However, the internally used caches can also be used to generate tracing information about the relationship from source to target model. We use that both for

  • Writing out trace information in a log file

  • Adding trace information about the source elements to the target elements

Both features have been added to the "plain" Xtend, because we can use standard Java mechanisms to access them.

In addition, we can also run a static analysis to see what sourcetarget metaclass combinations exist in our codebase.
PerformanceXtend compiles to plain Java. This gives higher performance than many interpreted transformation languages. In addition, you can use any Java profiler (such as Yourkit, JProfiler) to find bottlenecks in your transformations.
Long-Term-SupportXtend compiles to plain Java. You can just keep the compiled java code for safety and be totally independent about the Xtend project itself.
Test-SupportXtend compiles to plain Java. You can just use any testing tools (such as JUnit integration in Eclipse or mvn/surefire). We have extensive test cases for the transformation that are documented in nice reports that are generated with standard Java tooling.
Code CoverageXtend compiles to plain Java. You can just use any code coverage tools (such as Jacoco)
DebuggingDebugger integration is fully supported to step through your code.
ExtensibilityXtend is fully integrated with Java. It does not matter if you write your code in Java or Xtend.
DocumentationYou can use standard Javadocs in your Xtend transformations and use the standard tooling to get reports.
ModularityXtend integrates with Dependency Injection. Systems like Google Guice can be used to configure combinations of model transformation.
Active AnnotationsXtend supports the customization of its mapping to Java with active annotations. That makes it possible to adapt and extend the transformation system to custom requirements.
Full EMF supportThe Xtend transformations operate on the generated EMF classes. That makes it easy to work with unsettable attributes etc.
IDE IntegrationThe Xtend editors support essential operations such as "Find References", "Go To declaration" etc.

The Xtend syntax on the other hand is not a language based on any standard. But it’s performance, modularity and maintenance features are a strong argument for adding it as a candidate for model transformations.

by Andreas Graf at April 26, 2015 02:34 PM

Eclipse Hackathon Hamburg – Greetings

by eselmeister at April 25, 2015 10:35 AM

Yesterday, we had our second Eclipse Hackathon in Hamburg, Germany. It was a great meeting :-).


Stay tuned, the next Hackathon will be in approx. three month.

by eselmeister at April 25, 2015 10:35 AM

Save the date: Eclipse DemoCamp Mars June 23rd 2015

by Maximilian Koegel and Jonas Helming at April 24, 2015 10:09 AM

We are pleased to announce the Eclipse DemoCamp Munich 2015 on June 23rd.
The DemoCamp Munich is one of the biggest DemoCamps worldwide and, therefore, an excellent opportunity to showcase all the cool, new, and interesting technology being built by the Eclipse community. This event is open to Eclipse enthusiasts who want to demonstrate what they are doing with Eclipse. The aim is to create an opportunity for you to meet other Eclipse fans in Munich in an informal setting.

We are offering 110 seats, however we usually receive around 200 registrations. Pre-registration is mandatory, please be sure to do so as soon as possible. To give everyone the same chance, registration for the event will start in one week, on May 4th at exactly 2pm. There you’ll also find detailed information on the location, time and more.

We are looking forward to your registration and seeing you in June!

A big thanks to our sponsors: BSI Business Systems Integration AG, EclipseSource München GmbH, Eclipse Foundation and Capgemini Deutschland GmbH


Leave a Comment. Tagged with democamp, eclipse, democamp, eclipse

by Maximilian Koegel and Jonas Helming at April 24, 2015 10:09 AM

Lightweight Dialogs in e4 & JavaFX

by Tom Schindl at April 23, 2015 02:25 PM

I’ve just checked in the initial bits to use lightweight dialogs in your e4 + JavaFX applications. You can see it in action in the short video from below

Useage is fairly simple. First you need to have dialog implementation like this:

static class OpenProjectDialogImpl extends TitleAreaDialog {
  private ListView<Project> list;
  private final CommandService cmdService;

  public OpenProjectDialogImpl(Workbench workbench, 
    CommandService cmdService, @Service List<ProjectService> projectServiceList) {

    super("Open project", 
      "Open project", "Open an existing project");
    this.cmdService = cmdService;
    list = new ListView<>();
    list.setCellFactory(v -> 
      new SimpleListCell<Project>( 
        p -> labelExtractor(p, projectServiceList), 
        p -> cssProvider(p,projectServiceList)));
  protected void handleOk() {
    if( list.getSelectionModel().getSelectedItem() != null ) {
      cmdService.execute("org.eclipse.fx.code.compensator.app.command.openproject", Collections.singletonMap("projectId", list.getSelectionModel().getSelectedItem().getProjectId()));

and displaying it is nothing more than:

public class OpenProjectDialog {
  public void open(LightWeightDialogService dialogService) {
    dialogService.openDialog(OpenProjectDialogImpl.class, ModalityScope.WINDOW);

As you can see in the video you can choose how the dialog is opened & closed. This is done through an OSGi-Service of type LightweightDialogTransitionService:

public class FadeDialogTranstionServiceImpl extends FadeDialogTranstionService implements LightweightDialogTransitionService {
  protected void configureFadeIn(FadeTransition transition) {
  protected void configureFadeOut(FadeTransition transition) {

by Tom Schindl at April 23, 2015 02:25 PM

Developing for Cloud Foundry

April 23, 2015 02:07 PM

We are pleased to have a series of articles describing how developers can use Eclipse and Orion for developing Cloud Foundry applications.

April 23, 2015 02:07 PM

Font Icons for Eclipse Scout

by Matthias Zimmermann at April 23, 2015 09:08 AM

Today, web pages and web applications start to rely more and more on font icons. As clean and modern icons can help an application to get a professional look and feel we went through the little exercise to demonstrate how to use font icons in Eclipse Scout applications.

One of the most prominently used icon font on many web pages is Font Awesome. As the font contains hundreds of icons that are free to use even in commercial applications, it is ideally suited for demonstration purposes as well as productive use.


The reminder of the article describes the usage of such fonts for icons with Eclipse Scout.

To demonstrate the usage we added an icons and font icons form to the Scout Widget Application.


In the text below we will first talk about the general usage of icons in Scout application, and discuss how icons are provided to the application through icon provider services. Then the font icon provider services is introduced that allows to create Scout icons for individual characters from any true type font files.

How To Use Icons in Scout

Icons can be used for a number of UI components in Scout applications. They may be used for buttons, image fields, for smart fields entries, tree nodes and for table rows. To identify individual icons, its icon name/id can be used. The simplest way to figure out how to use icons in Scout applications is to follow the code of the Scout widget application.

For a concrete example we will look at the implementation for the button with the white arrow pointing to the right that is implemented in the icons form of the Scout widget application.



To find the corresponding code in the widget application, open the IconsForm and drill down to the ExamplesBox group box and locate the IconButton class. In method getConfiguredIconId the desired icon is specified as shown below. 

  public class IconButton extends AbstractButton {

    protected String getConfiguredIconId() {
      return AbstractIcons.WizardNextButton;


From this example we can see that a few icons come out of the box with the Scout framework. As every application has its own special needs, additional application specific icons may be located in the client plugin of the application. In the default case the corresponding image files may be placed in folder resources/icons of the client plugin. In the example of the Scout widget application the icon “star_yellow” is backed by image file star_yellow.png in the icon resource folder. This represents the simplest way to add your own icons to your application. Just put your icon image files into the folder resources/icons of the client plugin as in the case of the yellow_star icon.

However, designing good looking icons is time consuming and to get started quickly having a large amount of icons out of the box would be helpful. To take advantage of the fact that with the Font Awesome toolkit such a collection of high quality icons is available in the public domain, we can also write a specific icon provider that consumes the available icons from the Fontawesome true type font file at runtime.

The Font Icon Provider Service

Before we discuss the font icon provider service let us look at the general concept of icon provider service of the Scout framework. In Scout, icons are provided to the application through icon provider services. When a UI component needs to display an icon specified by its name, the Scout framework checks with the registered icon provider services to access the necessary image content.

At runtime, the icon name is fed into method getIconSpec of the first available service that implements the IIconProviderService interface. If the method returns null, the framework consults the next icon provider. This mechanism allows for the implementation of application specific icon provider services. There is one additional thing. To avoid the repeated generation of the image content, generated Icons are cached by the Scout framework. Instead of asking the icon provider services to create the content every time an icon is used, the framework first checks its cache, if an icon is already available from the cache, it will directly use this cached icon.

By writing a specific FontIconProviderService that converts characters from a true type font to Scout icons on the fly, font icons can be used along the traditional icons. To use font icons in the demo application only a few things are needed:

  • The font’s true type file (e.g. fontawesome-webfont.ttf) is located in folder resources/fonts of the client plugin
  • The alias information for the needed icons is specified in the icons.properties file (in folder resources/fonts)
  • The FontIconProvierService itself and its registration in the client’s plugin.xml

At startup of the FontIconProviderService, method initializeFonts is called through method initializeService that then loads the available true type fonts and properties file mentioned above. Using this information the icon provider service then returns the created font icons in method getIconSpec. The icon alias (IconId in the screenshot above) defined in the icons.properties file can either be used on its own or amended with various additional attributes:

  • Color (icon color, or icon background color if a background type is selected)
  • Size (true type font characters may be scaled to arbitrary sizes)
  • Background (to create inverted icons with a square or round background image)

In the example shown in the screenshot above, the icon specification is encoded into the string font:plane!#FAA635!128;fontawesome-webfont. This results in the search of alias “plane;fontawesome-webfont” in the properties file leading to the font’s character f072 that is then scaled to 128 pixels and colored using #FAA635.

To play around with the available options click on button “Sample Content” in the icons form of the widget demo application. There, you can change the icon id, the color, size and the background shape. When you switch the font from “fontawesome-webfont” to “cour”, you can also try to create an icon from a single letter (e.g. with the icon name “font:X!128;cour”).


In this post we have provided a quick introduction to the usage of icons in Scout applications and demonstrated how to use font icons in your own Scout applications. Using the provided FontIconProviderService you can now either use the discussed Fontawesome or use your own true type font files to extract font icons for your applications.

Project HomeForumWikiTwitter

by Matthias Zimmermann at April 23, 2015 09:08 AM

J2V8 2.2 New and Noteworthy

by Ian Bull at April 22, 2015 10:26 PM

I’m happy to announce the availability of J2V8 2.2 (2.2.1 actually). This release adds two important features: 1) Typed Arrays and 2) 64 Bit Windows support.

Typed Arrays

In Javascript, most arrays are untyped. That is, you can create an array and add anything to it.

var myStuff = [];
myStuff[0] = 42;
myStuff[1] = true;
myStuff[2] = "Strings";

A  few years ago, the Javascript community realized the need for a more efficient mechanism for working with binary data in WebGL. The result of this work were Typed Arrays. Typed Arrays are a continuous chunk of memory with a typed view onto it. The memory is managed by the underlying engine and they perform a lot better than regular Javascript arrays.

var buffer = new ArrayBuffer(256);
var i32 = new Int32Array(buffer);
i32[0] = 1;
i32[1] = 3;
i32[2] = i32[0] + i32[1];

In this example, an array buffer of 256 bytes is allocated. A view, rendering the data as an array of 32bit integers, is then projected onto that buffer. Because the memory is continuous and the types are known, the operations (such as add in this case) perform much faster.

J2V8 2.2 supports the creation of Typed Arrays. You can even access the contents of the arrays, in bulk, from Java using the getIntsMethod (getDoubles and getBoolean for doubles and booleans).

V8 v8 = V8.createV8Runtime();
V8Array result = v8.executeArrayScript("var buffer = new ArrayBuffer(256);\n"
 + "var i32 = new Int32Array(buffer);\n"
 + "i32[0] = 1;\n"
 + "i32[1] = 3;\n"
 + "i32[2] = i32[0] + i32[1];\n"
 + "i32;");
int[] ints = result.getInts(0, 3);
System.out.println("Result: " + ints[0] + ", " + ints[1] + ", " + ints[2]);

64 Bit Windows Support

J2V8 now supports 64 bit Windows. The binaries have pushed to Maven Central and can be consumed using the following dependency.


For more news about J2V8, follow me on Twitter.


Leave a Comment. Tagged with j2v8, j2v8

by Ian Bull at April 22, 2015 10:26 PM

Screenshot of the Week: Git Repositories View

by waynebeaton at April 22, 2015 02:40 PM

The Git Repositories view (which I tend to add to whatever perspective I’m working in) provides pretty much one-stop-shopping for most of my repository activity needs.

The Git Repositories View in Eclipse Mars

The Git Repositories View in Eclipse Mars

In this screenshot, you can see a handful of local branches that I obviously need to spend a few minutes cleaning up, and some stashed commits. Direct access to tags, references, and remotes is also provided. You can also work directly with files in the working directory if you opt to not create a project in the workspace.

I generally don’t tweak the default configuration of any software (I’m lazy that way), but I find that in Eclipse I’m starting to move the perspective launcher down to the bottom left of the window, turn the tool bar off (though not in this screenshot), and clear out views from the right side of the window (to make more room for the editor). What are your favourite tweaks?

by waynebeaton at April 22, 2015 02:40 PM

Setting profiles in the preferences dialog

by eselmeister at April 22, 2015 08:45 AM

I wondered if it’s possible to allow users to work with different profile settings. That would be beneficial, cause users then don’t have to remember different plug-in settings for various analytical scenarios. Eclipse offers to export/import *.epf files, hence there should be a way to automate this. Here’s the solution:


The preference service allows to export the currently used preferences:

public static void exportProfile(File file, IPreferenceFilter[] preferenceFilters) throws FileNotFoundException, CoreException {

	FileOutputStream fileOutputStream = new FileOutputStream(file);
	IPreferencesService preferencesService = Platform.getPreferencesService();
	preferencesService.exportPreferences(preferencesService.getRootNode(), preferenceFilters, fileOutputStream);

Importing stored preferences works similarly:

public static IStatus importProfile(File file) throws FileNotFoundException, CoreException {

	FileInputStream fileInputStream = new FileInputStream(file);
	IPreferencesService preferencesService = Platform.getPreferencesService();
	return preferencesService.importPreferences(fileInputStream);

It depends on you where to store the preference profiles. There’s only a small drawback when loading a profile within the preferences dialog. All pages are displaying the old and not updated profile values. Hence, the dialog needs to be restarted. This can be automated too from within a page.

IPreferencePageContainer preferencePageContainer = getContainer();
if(preferencePageContainer instanceof PreferenceDialog) {
	PreferenceDialog preferenceDialog = (PreferenceDialog)preferencePageContainer;
	preferenceDialog = PreferencesUtil.createPreferenceDialogOn(null, null, null, null);

The more better it would be reload all page values without re-opening the preference dialog. But I didn’t find a way how to do it. Anyhow, it works so far.

by eselmeister at April 22, 2015 08:45 AM

Making the Text Editor to be the Default One for All Unknown Files in Eclipse

by Kaloyan Raev (noreply@blogger.com) at April 22, 2015 06:16 AM

Eclipse users usually work with many different file types. Some of the file types may be opened by default in an external editor instead of in the Eclipse workbench. This happens if Eclipse has no editor available to handle that particular file type, but there is one installed in the operating system. In such case Eclipse assumes that it is better for the user to have the file opened in the external system editor.

Lots of users are quite annoyed by this behavior, especially when it comes to text-based files. They would prefer to have the file opened in the plain text editor of Eclipse instead of switching the context to the external program. Unfortunately, there is no easy way to change this in the preference settings. It's possible to associate a specific file extension with the plain text editor, but this must be done separately for every file extensions. There is no way to say "all text files of unknown type should open in the text editor".

Here comes the Default Text Editor plugin. It takes advantage of the Editor Association Override extension point introduced in Eclipse 3.8. When the plugin is installed it will change the default behavior of Eclipse and will opened all text files of unknown type in the plain text editor. Binary files like images may still be opened in an external system editor. As simple as that.

The plugin is available on the Eclipse Marketplace. It can also be installed through an update site. More info is available on the GitHub project.

by Kaloyan Raev (noreply@blogger.com) at April 22, 2015 06:16 AM

$150 Bug Bounty for Fixing a Dark Theme Issue

by Kaloyan Raev (noreply@blogger.com) at April 21, 2015 06:54 PM

Zend Studio is an IDE based on the Eclipse Platform. The dark theme is an important feature and is very popular among PHP developers. The most annoying issue with the dark theme, we have at the moment, is that the expand/collapse toggle in trees is almost invisible on Windows, because it seems to be unaffected by the dark theme coloring. See Eclipse bug 434201 for details.

We decided to put some money on the table with the hope that someone will step in and fix this bug. This will benefit not only Zend Studio users, but all Windows users in the Eclipse ecosystem who want to use the dark theme.

We created a $150 bug bounty on the FreedomSponsors crowd-funding platform. Follow this link to open the sponsored issue. Since this is a crowd-funding platform, anyone else who is ready to give some money for resolving this issue is welcome to do it, so the offer becomes more attractive.

UPDATE. The bug has been fixed within days and it will be delivered with the Mars M7 milestone. Thanks to Fabio Zadrozny for his great work. Kudos to Lars Vogel for adding $100 more to the bounty.

by Kaloyan Raev (noreply@blogger.com) at April 21, 2015 06:54 PM