Eclipse platform developer needed

We are hiring!

If you are interested to work on:

• Eclipse Platform - UI, SWT, P2,...
• Eclipse Releng - upstream (CBI) and Red Hat (RPM) 
• Simultaneous Release train - Mylyn, EGit/JGit, ....
• Integrating Eclipse and Linux ecosystems
• And other interesting projects

 ... we have a position right for you - send your application here.

GTK 3 backend becomes SWT default

GIT commit - I've been waiting for this becoming true for so long.

Join us testing, reporting and sending patches that improve the situation. This should appear in the soon to be re released 4.4 M3.

Full featured IDE in your browser and Eclipse

We all hear about the new and cool web IDEs - I looked at few of them and somehow all looked too poor for someone used to do pretty much in his IDE (that's why we have I-ntegrated in the name, right?). So I decided to take another look at the problem from different POV and here it is:

That's Anjuta running using GDK Broadway backend, sample C project created, compiled and launched(the empty window on the right) - all in the browser.
Simple instructions that work on Fedora 19:

• 1st terminal - start broadwayd 
• 2nd terminal - GDK_BACKEND=broadway anjuta
• browser - http://localhost:8080

Isn't that cool?

As an Eclipse user and developer I wanted to immediately see my Eclipse working on my development machine and being able to use it from various connected devices at home for small things like - launch hudson build via mylyn builds, comment on bug via mylyn tasks, pull from Gerrit for a quick review and etc. all via plain old http while having my setup working and no vnc or alike solutions needed (that take more time to get on your phone than few web clicks). To be honest I didn't expected it to work but this doesn't mean I have to stop dreaming. 

Broadway GDK backend is GTK 3.x feature so one first need to run eclipse on GTK 3. That's easy - `SWT_GTK3=1 eclipse` and you have it. But there is one more prerequisite to use different GDK backends - your app should not do direct X calls and here we fail - eclipse simply crashes because of the direct X calls done if one tries `GDK_BACKEND=broadway SWT_GTK3=1 eclipse`.

Allowing using different GDK backend is important for Eclipse (at least on Linux) as elliminating or changing X calls is needed to also make Eclipse run as native wayland client. The future will catch Eclipse sooner or later.

If you do want to see such future for Eclipse please test Eclipse on GTK 3.x, report bugs, help us fix the issues, provide patches and spread the word about such possibilities so more people can potentially join the fun. Also feel free to contact me directly for anything related and help my dream come true.

Javac and backward compatibility

It's a nice start of the week to read this. As a Linux distro guy this makes me really happy as it's a first step in the right direction to fix some of the long standing problems for "source-first" developers. Java programs are full of references to libraries that have been cool and state of the art ~10 years ago but it's time to let them R.I.P. 

Dropped support for old targets in javac will hopefully have the nice side effect to reducing the private patched jars many projects has in their scms. (Please stop including activation.jar with your app!)

Not to mention that it will help moving to newer JVMs - yes, I'm looking for the moment noone will ask me to compile my projects to target 1.5 as it would be just impossible. The answer would be awesome - javac don't support it anymore!

Sometimes I even wish to see something like "one plus FIVE back" for the JVM itself - aka Java 9 stop loading bytecode from pre-1.4 times. This would lead  to huge cleanup in resources used by applications by making people look forward as now it's impossible to have a coherent support for even 2 application with the same set of libraries as each of them has stalled some dependency in the very distant past to the state it becomes impossible to collaborate. And NO, shipping private copies is not OK - search for the jakarta-httpclient CVEs which would not be fixed as it is EOLed and no further releases will happen(rightfully as it has been EOLed for years already!) but many applications expose their users by shipping a private copy most of the time not even knowing.

Even if this has been standing in my mind for quite some time I never expressed it in non-private conversation and reading that there is a hope made me start the week with some joy :).

What can we(Eclipse community) learn from Libre Office?

Before reading further please watch "LibreOffice cleaning and re factoring a giant code base" from this year's FOSDEM conference. Note that reading this post without watching the video would put a lot of things out of context!

The one and single most obvious thing for me from the whole talk was "it's about the people". Watching it one will notice the amount of people that started contributing in there free time and how fast LibreOffice grows in number of contributors. As one that works almost entirely with Eclipse.org projects (especially Eclipse as an IDE) this made me ask a very basic question:

How did a pure end-user application managed to attract more developers to spend improving it in their free time than an IDE ?

 

I started to think about initial experience I had trying to improve various plugins and realized that we do fail entirely in welcoming new committers. Even after one has number of patches in, if one just opens a bug(gerrit review) and attaches his/her patch - nothing happens for months (even years!). Or the patch will comments why it can't happen now and nothing will happen for months/years again. Now I'll try to fight some of the most common myths used to explain the situation:

• there is release pressing - this is seen for milestones, SR releases, etc. But there is always something pending and most of the time people start with so small contributions that they can hardly affect the whole release train. Potential contributors might be more happy if instead of saying it can't happen now and forget it, we do comment a week later once the M-build is out (this covers most of the calendar year) and work with the contributor to get his change in.
• it gains us nothing - wrong! for at least two reasons: First: one of your users identified the need for it and cared to spend time to contribute it back, one could bet that he/she see it as important; Second: even if there will be no technical benefit immediately - that's one more contributor and this makes difference soon after that.
• old versions depend on something that this patch changes - You know there is a reason for calling a version an old one. Don't hold the new development - we have the awesomeness of git - branching, cherry-picking and so on can hardly be easier. Old way of doing something belongs to maintenance branches. Here we come to catch 22 - there are not enough people to support two ways but we don't want new contributors too. New people need new things.
• this part of the code is "tabu" - only blessed ones can touch it. Telling a potential contributor - "you're not smart enough" isn't it ? Well, I read it differently - if in my code there is something so sensible that I should be afraid is someone touches - it needs a fix (or ever rewrite?) as soon as possible so it can continue improving as normal part of the codebase. As long as someone starts spending his time on it of course.
• it's not tested with other version of third party library - this is seen really often from my point so it's like a personal rant. If someone requests a dependency range to be bigger one can think that he tried it or that even a product using the version outside of the range is shipped. And this means nothing as the project can continue ship its preferred version but you can make the life of people depending on your code easier for no cost.
• the contributor already ships a fork so he/she can continue do that - If one ships a fork and submits patches back it clearly means he doesn't want to do that but he is forced to do that because the project is not interested to grow in the area he needs.

If we want to grow as community members, everyone has to go through his projects bugzilla/gerrit see for pending patches or requests and make the easiest one come in the next release. Or we will soon get to the point where people will not even report bugs as they would not believe anyone will look at the bug opened and that would be a failure growing to disaster. Seeing even well respected people withing the community having to poke numbers of time for really simple patches to be applied makes me very sad as this is pure energy lost. One can fix few more bugs instead of rebasing patch 3 times and poking 5 times.

It's not too late for a change we need to just encourage people by accepting their changes or work with them till the change is in a good enough change. Just a bit more openness and trust to new contributors is needed. So do we actually want to grow the community?