Archive for the ‘Eclipse’ Category

EclipseCon 10 years old

Thursday, April 17th, 2014

This was the tenth year of EclipseCon and my fourth time attending. I have been using the Eclipse IDE for over 12 years and so much has changed with technology and developers’ expectations. At the beginning, just having a single Java IDE that was smart enough to edit, compile, run, and debug your code was a major breakthrough. And for many years, the trend was to integrate into the IDE, with the expectation that all tools be absorbed into the IDE. Now, this trend is reversing and developers are starting to expect IDEs that can seamlessly connect to tools, allowing developers to use the tools in the way that makes the most sense for them.

The most interesting theme for me at this conference was trying to figure out how developers will be working another 10 years from now.

The future of the IDE

The Orion IDE is a prime example of this reverse-integration trend. Orion is a hosted IDE with a light-weight plugin model. One way that the plugin model allows integration with third party tools is by linking out to them in other browser pages. This allows developers to do programming tasks in the IDE, but still have easy access to external tools for deployment, testing, and monitoring. Ken Walker gave a good talk showing this, cheekily called Browser IDEs and why you don’t like them.

Another example of this is the Mylyn hosted task list, which Gunnar Wagenknecht and I introduced in our talk Unshackling Mylyn from the Desktop. The main idea is that current Mylyn task lists are restricted to working inside of a single Eclipse instance, but developers are looking to interact with tasks outside of the IDE (in the browser, on the desktop, on their phones, etc). The hosted task list provides developers with this capability using different kinds of clients that all operate on a single notion of a task list that is hosted remotely. We provide a simple API so that third parties can provide their own clients. What we presented at EclipseCon was early work and we are looking forward to showing more of this at future conferences.

Lastly, Martin Lippert and Andy Clement, my former colleagues at Pivotal, introduced Flux, a novel approach to a more flexible development environment. The main idea is that developers may want the simplicity of developing in the cloud, but also don’t want to give up the possibility to develop in a more traditional way on the desktop. Flux allows you to connect your local workspace to a cloud host that provides services like editing, compilation, and refactoring. This way, you can work in the cloud while still being able to drop down to the desktop whenever you need to. Watch the screencast.

It is still early work, but it is quite compelling and I’m looking forward to seeing how this progresses.

Java 8

It shouldn’t be surprising that the Java 8 track was the most popular at EclipseCon this year. Java 8 was released in the middle of Alex Buckley’s The Road to Lambda talk. What I thought was most interesting about this talk was that it focused on the design decisions around implementing Java 8 lambdas, why it took so long many years to do so, and why Java is now a better language because of its relatively late adoption of lambdas. I found Let’s make some 0xCAFEBABE particularly interesting with its deep dive into byte code. Lastly, API design in Java 8 showed how libraries and APIs can improve by taking advantage of new language features.


This year, I helped organize an Eclipse hackathon. It was a great experience. We had over 50 attendees, split roughly evenly between project committers and new contributors. The goal was for new contributors work on some real bugs in Eclipse, while being helped by project committers who guided them through the process of setting up a workspace, choosing a bug, and submitting a patch. By the end of the evening we had 7 contributions accepted to the code base. It was encouraging to see so much passion about working with open source.

Everyone's hacking!

There are plenty more photos from the event on the Eclipse Foundation’s Flickr stream.

It was truly a wonderful conference and there was so much more including 3 excellent keynotes and of course lots and lots of beer.

Now that I’m back, I need to catch up on sleep, but I’m already looking forward to next year!

Tasktop Dev 3.5 and Mylyn 3.11 Released

Monday, April 14th, 2014

Tasktop Dev 3.5 and Mylyn 3.11 are now available. These releases include some cool new features that result from the combined efforts of many people in the Mylyn community and at Tasktop.

Speaking as a Tasktop Dev and Mylyn user, I am already loving the new support for finding text in the task editor. It was originally contributed to Mylyn Incubator a few years ago, but unfortunately the implementation suffered from serious performance problems. Recently I had the pleasure of supervising a Co-op student at Tasktop, Lily Guo, as she reimplemented it with dramatically better performance and improved the UI. Thanks to her efforts this very useful feature is now released and the task editor supports searching for text within the comments, description, summary, and private notes.

Screnshot of Find in the Task Editor

Another long-awaited feature in this release is task-based breakpoint management, which extends the concept of task context to include Java breakpoints. This was implemented as part of a Google Summer of Code project by Sebastian Schmidt, a graduate student at Technical University Munich. It provides several important benefits for Java developers. First, the debugger will not stop at breakpoints that aren’t related to the active task. Second, only breakpoints created while the task was active will appear in the IDE – when working on a task, the breakpoints view and Java editors are no longer cluttered with dozens of irrelevant breakpoints. Because the breakpoints related to a task are only present while that task is active, there is no need to delete or disable these breakpoints – which often contain valuable information such as which lines of code and which runtime conditions trigger a defect – when a task is complete. Finally, breakpoints can be shared with other developers as part of task context.

Screenshot of the context preview page showing breakpoints in the context

In a single view, the Hudson/Jenkins connector provides quick access to status information about selected builds across multiple build servers, even when you are offline. This includes information about build status, build stability, and test failures. But one thing I realized was missing was a quick summary of how many builds are passing, unstable, and failing. This information is now displayed at the top of the Builds view and, when the view is minimized, in a tooltip, making it really easy to tell when there’s a change in the number of failing or unstable builds.

Screenshot of builds view showing summary of build statuses

This release also includes a number of bug fixes and enhancements to the Gerrit connector. Among them are support for comparing images, buttons for navigating to the next/previous inline comment in the compare editor, and a code review dashboard that lets you see which of your changes have been reviewed and whether they have passing or failing builds. The connector also remembers your previous votes on a patch set, so that posting additional comments doesn’t reset your vote. Thanks to Jacques Bouthillier and Guy Perron from Ericsson for their work on comment navigation and the dashboard.

Screenshot of the Code Review Dashboard

To help you prioritize the tasks you are responsible for, a “Show only my tasks” filter has been added to the task list, and the tooltip uses the gold person icon to accentuate those tasks.

Screenshot of the task list showing the new filter button

Tasktop Dev 3.5 is built on Mylyn 3.11, including all of the above features. This release includes a number of bug fixes as well as support for VersionOne 2013. We have also upgraded Tasktop Dev for Visual Studio to support Visual Studio 2013, bringing the benefits of a unified task list to users of that IDE.

For more information, see Tasktop Dev New & Noteworthy and Mylyn New & Noteworthy, or try out Tasktop Dev and Mylyn for yourself.

Mylyn 3.10 Released

Monday, November 18th, 2013

We are happy to announce that Mylyn 3.10 has been released. This release includes a number of enhancements to improve the user experience as well as support for the latest versions of Gerrit and Hudson.

In June, Eclipse upgraded to Gerrit 2.6 in order to support a new, more streamlined IP process. This makes it much easier for committers to accept contributions to Eclipse. Unfortunately, the Gerrit connector did not support Gerrit 2.6 at that time, so Eclipse contributors had to use the Gerrit web UI. Thanks to the efforts of Tomasz Zarna and others, we were able to support Gerrit 2.6 in a service release, Mylyn 3.9.1, which was released as part of Kepler SR1. Mylyn 3.10 includes this support for Gerrit 2.6 and also supports Gerrit 2.7.

In Mylyn 3.10, we released some enhancements to the task list and task editor, including addressing some shortcomings that have bothered me personally for a long time. To improve the initial experience for new Mylyn users on Windows, by default, attachments are now opened with the Eclipse editor for that file type if one is present, or with the system editor if not, instead of opening in a web browser. This removes an unnecessary and annoying window switch and browser prompt. Without needing to configure anything, you can open attachments without leaving the IDE.

On many occasions, I have marked a task read and then immediately regretted it. Sometimes I’ve even marked several incoming tasks or a whole query read, and then realized I should have looked at the incomings more carefully first. Until now, there was no way of knowing which tasks I had marked read, meaning that I would never know what incomings I had missed. Now, I’ll be able to easily undo marking the tasks read by using the standard undo/redo mechanism.

I like to think of user interface design as a delicate balance of providing useful information and affordances without creating clutter or overwhelming users. Unfortunately, this means saying “no” to a lot of cool ideas. But one of the great things about working on an open source project is that anyone can voice their opinions, and it really does help to determine which features get released. After some debate on bugs and code reviews, some important information has been added to the task list and task editor to make it more readily available:

At the top of the task editor, just below the summary, the date of the last comment is displayed, allowing users to quickly judge the relevance of the task without scrolling down to the end of the comments.
The task list decorates tasks that have private notes with a yellow pencil icon, so that you don’t need to open the task editor to find out if there are notes.
The task list tooltip now indicates how many incoming and outgoing tasks each query or date bin contains.

In addition to supporting Hudson 3.1, the Hudson/Jenkins connector now allows you to quickly open a build in the web UI if you need information that is not available through the connector. When clicking a link to a build, the build editor opens immediately while the build is downloaded in the background. Users can click the “Open with Web Browser” button in the toolbar to access the Hudson/Jenkins web UI.

Finally, I think heavy Gerrit users will really appreciate this small change: when adding an inline comment to a review, it’s now possible to resize the dialog, and to select text in the compare editor and copy it without having to close the dialog and discard your comment.

You can find more information about the Mylyn 3.10 release in the New & Noteworthy. You can get the release here.

Mylyn 3.9: Improved Code Review Tooling

Thursday, October 3rd, 2013

Two years ago I claimed that contributing to Eclipse is a tedious process and I’m happy to say that this no longer holds true. The migration from CVS to Git last year and the adoption of Gerrit for code reviews by many Eclipse projects, combined with the arrival of contributor license agreements (CLAs), has made it incredibly easy to contribute to Eclipse.

Gerrit is great news for contributors since anyone with an account can now propose changes as Git commits. It’s no longer necessary to attach patches in Bugzilla; changes can be pushed directly to Gerrit. In Gerrit it’s easy to work with the changes and, if the CLA has been signed, merging contributed changes only takes committers a few clicks.

I have highlighted in previous posts how the Mylyn Gerrit Connector integrates code reviews in the IDE. When added CLAs and upgraded to Gerrit 2.6 (which the Mylyn connector didn’t support at the time), I realized how much I rely on the seamless Eclipse integration. Thanks to Tomasz Zarna contributed over 20 changes and didn’t shy away from using the browser Gerrit 2.6 is now supported in the latest Mylyn service release and will soon be available as part of Kepler SR1.

In addition to supporting the latest Gerrit, Bugzilla and Hudson version, Mylyn, and the Gerrit the connector in particular, have seen a number of improvements in the last major release. The code review editors are now complemented by a Review navigator. The navigator view shows all comments in a structured view that simplifies keeping track of parallel discussion streams as code review progress.

Global comments are now embedded in the review editor, with support for spell checking, and comments can be saved as drafts and edited offline. Conveniently, the editor now also supports all patch set operations including rebase.

The Mylyn New & Noteworthy has an overview of all enhancements in the latest release which is available here.

Viva Eclipse Kepler!

Monday, July 15th, 2013

Say what? Another Eclipse DemoCamp at Tasktop? That’s right, and it was something to brag about! Tasktop Technologies, the Eclipse Foundation, and Pivotal hosted Eclipse Kepler DemoCamp at Tasktop HQ in downtown Vancouver for Eclipse enthusiasts, faculty and students who work with the Eclipse IDE.

The evening began with networking and snacks. We opted for delectable aliments doigt, with fine cheeses, le sandwiches, stuffed mushrooms and seafood, instead of pizza and pop that has become the staple food of many a developer (not you, of course, we know you have a more sophisticated palate).

David Green and Andrew Eisenberg then kicked off the evening with event intros and warm welcomes…

…followed by an icebreaker game…

This year, we played Big Data, where each participant was asked to gather data about other attendees. We thoroughly enjoyed it, maybe because we’re all geeks.

After the game, the data was collected and collated. It is now ready to be map-reduced by Hadoop. Here are the resulting statistics of the make-up of this year’s DemoCamp participants:

Yes No
Attended EclipseCon? 6 31
Commiter? 8 16
Student? 10 19
Created plugin? 21 9
Raised a bug? 8 7
Contributed? 10 13
Program daily? 40 5
Java? 21 8
IntelliJ? 0 29
Netbeans? 0.5 47
CS degree? 16 4

Note: these results reflect the skills of first time data-collectors (ie: numbers may not approximate reality).

…with all the attendees warmed up and well fed, the presentations followed…

David Green (Tasktop) Showed off the new super-secret tooling in Eclipse for working with GitHub.

Nieraj Singh and Kris De Volder (Pivotal) showed some of the new features of Spring Tool Suite 3.3.0, including the new Quick search feature and getting started guides.

Rafael Chaves (Abstratt) presented Cloudifier, a platform for rapid application development/deployment built on Eclipse Orion.

Deepak Azad (UBC) demoed new features in Eclipse JDT for the Kepler release, mostly new quick fixes and null type inferencing improvements.

Robin Salkeld (UBC) introduced holographic JVMs and a way to debug Java heap dumps. His technique allows you to attach a Java debugger to a heap dump and then execute queries against it using the Java debug interface.

Brendan Cleary (UVic Chisel) showed off Atlantis, which is a file viewer for massively huge files (60 Gb+). He described how Atlantis is used by the Canadian government for analyzing trace files to look for potential security breaches.

After the last presentation, everyone headed out for drinks to celebrate another successful Eclipse DemoCamp. Cheers!

AndrewA warm thank you must got out to Andrew Eisenberg for co-authoring this blog, as well as to all other organizers, sponsors and speakers who contributed their time and energy to making this event a success. If you’d like to be a speaker during a future Eclipse DemoCamp, please contact us. It’s a wonderful opportunity to show your stuff in a supportive circle of other Eclipse enthusiasts and have some fun while you’re at it. See you all next year!

Talking about ALM ? Why EclipseCon ALM Connect and Executive Event is the place to be in March

Tuesday, February 12th, 2013

EclipseCon 2013 BostonHaving just returned from the fantastic ALM Summit in Redmond it is even clearer to me that there is a lot to talk about when discussing ALM. The event in Redmond is focused on the Microsoft platform, but the discussions were far broader. Technology impacts such as cloud, mobile and open source coupled with process changes driven by Agile and Lean Startup mean the very fabric of ALM is changing. The announcement of TFS and GIT working in perfect harmony is illustrative of this shift. But even after 3 busy days there is still lots to talk about, which brings me to the ALM Connect, an event that myself, the Eclipse foundation and a team of great people have been working on. The event, which is scheduled for March 25th through 28th in Boston MA has all the ingredients for an amazing conference.

Deep Dive Into Content

All the sessions in the program are great, but I would like to draw your attention to a few that caught my eye during the call for papers.

  • Moving towards ALM 3.0 by Forrester Analyst Jeffrey Hammond. Not only is Jeffrey a great speaker, but always fills his presentation with lots of data that you can use back in the office. In this talk Jeffery is highlighting the major shifts in the fabric of ALM. Looking at the data this talk is based on we might see a redefinition of the ALM category, which is very exciting!
  • What ALM knowledge you can expect from CS graduates by Gary Pollice, professor at WPI. The emerging skills crisis in software engineering is going to affect us all so I am excited to hear how you can better hire CS graduates and make them more productive. This talk also helps to remind us that ALM is more than just tools, but includes processes and people.
  • Continuous Integration at Google Scale by John Micco, Google. CI has emerged as the lifeblood of modern software delivery, and on paper seems easy, but for the majority of large organizations with complex builds, heavy dependencies and nasty test environments building a workable CI environment is difficult. In this talk John describes how a very complex CI environment can be built and maintained in a very changeable business.
  • Building Mylyn 4.0 by Mik Kersten, CEO of Tasktop. Mylyn has defined how Eclipse developers interface with systems of record such as bug trackers and project manager tools, but the underlying model has not changed for over 5 years. Mik is going to describe what needs to change to get Mylyn ready for next generation ALM.


Bring your boss to ALM Connect Executive Event

ALM Connect will provide a rich set of ideas for practitioners to take back to their teams, but without management support many of those ideas will never be implemented.

Above: EclipseCon 2012 ALM Panel with Mik Kersten, Dave West, Melinda Ballou and James Governor

Solving this problem was the motivation of running an Executive event on Wednesday the 27th of March. This event is aimed at decision makers and is by invitation only.

Get on the guest list

Content highlights include:

  • Twitter and Github kick off the event talking about the future of ALM and how the next generation of software development is being undertaken. These presentations will show how you can marry innovation, rapid delivery and complex development teams into an Agile delivery capability.
  • ALM in action case studies. Still working on the fine print, but we will have two high profile companies who are going to present their experience with ALM and how they are using ALM to form a competitive advantage. These sessions are aimed at telling all the dirty secrets of ALM, the motivation for adopting ALM and the reality of ALM in their companies.
  • The user is the center: Apps in the world of engagement by Lee Nackman from HP. Lee has been involved in ALM for many years and was one of the executives responsible for IBMs involvement with Eclipse. In this talk Lee will describe how systems of engagement have changed the face of ALM and how that is only to get worse. I expect some sneak previews of the HP’s future ALM strategy in this talk.
  • Agile 2.0 software development in the era of the social graph by Israel Gat Fellow at the Cutter Consortium. Israel a leading management light on ALM and the economics of software delivery will describe the social side of development. Describing how social graphs and other mechanisms can be used to better manage and enable software delivery.
  • Scrum – Success ends with middle management by Ken Schwaber co-creator of Scrum. Having Ken, one of the drivers of the Agile movement at the event will add a level of Agile pragmatism to the proceedings. In this talk Ken will present the audience with framework for taking Agile to the next level, but be warned this path is not for the faint of heart.
  • The future of ALM panel – This session includes Sam Guckenheimer from MS, Lee Nackman, Jeffrey Hammond and Mik Kersten on what the future of ALM looks like and how it will affect the audience. I will moderate, so expect an exciting and thought provoking session.

Get on the guest list

If you are interested in attending the executive day, or have boss who is interested then please let us know. You may also wish to view the Executive Day landing page, or the event announcement from the Eclipse Foundation for a detailed agenda. I can promise the event will be exciting, thought provoking and inspiring. It is rare to get so many leaders on ALM in one room and at one event.

Deep inside an Eclipse Hackathon, where the future Eclipse submitters are born

Friday, November 16th, 2012

Eclipse Hackathon 2012 A room full of developers and students, cans of beer loosely scattered around the room, along with bags of chips, pop and pizza. It’s a setup that would make more sense for a party, were it not for everyone clustering around power cords and loud finger tapping of engineers ripping up their laptops.

Sticking to traditional hackathon culture, there was a whole lot of coding, lots of beer, and happy chit chat mixed with serious faces betraying some heavy problem solving, in a word: hackathon-fun!

Eclipse Hackathon 2012

In attendence: several experienced Eclipse submitters, students from SFU and UBC, and other Eclipse enthusiasts. Projects hacked on: JDT UI, Scripted, Orion and Mylyn (for project details see the wiki page).

Eclipse Hackathon 2012It was great to have Ian Skerrett from the Eclipse Foundataion attend and hack away with all the others. Great many ideas were thrown around and many a bug got fixed. Newbies got to learn a lot about Gerrit & Mylyn and how to contribute to open source. Thanx to all who attended and made the night that much better!

See more photos from the event.

ALM analyst panel at EclipseCon 2012 with Dave West, Melinda Ballou, James Governor and Mik

Thursday, August 16th, 2012

At this year’s Agile ALM Connect sub-conference of EclipseCon 2012 Mik Kersten moderated a very lively analyst panel with a few of the leading analysts in ALM: Melinda Ballou of IDC, James Governor of RedMonk and Dave West (then at Forrester). Enjoy.

Mylyn 3.8 released as part of Eclipse Juno

Tuesday, July 10th, 2012

We are happy to announce the availability of Mylyn 3.8 which was released as part of Eclipse Juno! This release includes new components for creating EPUB documents, Subclipse integration, user interface improvements and support for the latest Bugzilla, Hudson and Gerrit versions.

The Gerrit and Hudson connectors have come along way since we created the Mylyn Builds, Mylyn Reviews and Mylyn Versions projects two years ago, when Mylyn became a top-level project. I want to thank everyone who provided feedback in hundreds of Bugzilla tasks and helped evolve the connectors over three versions. With this release the APIs are reaching 1.0 and the projects have successfully graduated from Incubation status to mature projects.

To make these integrations that connect Eclipse to popular application lifecycle tools, available to a wider audience we added the Gerrit and Hudson connectors to several EPP packages. For instance, the RCP/RAP package now contains all components to complete a full Mylyn contribution cycle:

  1. Querying the Bugzilla using Mylyn Tasks
  2. Activating a Bugzilla task using Mylyn Context
  3. Committing and pushing a change to Git using EGit and Mylyn Versions
  4. Monitoring the triggered build on the Hudson using Mylyn Builds
  5. Completing the resulting Gerrit code review using Mylyn Reviews

I showed this at the Eclipse DemoCamp in Zurich and Java Forum Stuttgart and never left the IDE throughout the demo. It’s great to see the tooling coming together with the Eclipse 4.2 based Juno packages covering all key aspect of the development workflow out of the box.

The connector reference implementations that are part of Mylyn enable us to validate our own frameworks but feedback that we get from users and adopters building on the APIs is also incredibly valuable to drive development. I want to thank Kiu Leung for implementing an initial prototype of a Koji connector based on Mylyn Builds and Robert Munteanu for creating an integration for ReviewBoard based on Mylyn Reviews fueling the growth of the connector ecosystem.

Likewise, the number of Mylyn projects under the application lifecycle banner has been growing. The Model Focusing Tools project provides focus when working with models reducing information overload. The initial 0.9 release is part of Juno and contains connectors for EMF, GMF, Ecore Tools and UML. Manuel Bork and Carsten Reckord from Yatta Solutions recently published an article that provides a great overview of the underlying technology.

A lot has already been said about Mylyn Intent which brings documentation, code, models and other programming artifacts closer together: “Based on Donald Knuth’s Literate Programmingconcepts and allowing collaborative work around design tasks, Intent will try to reconcile developers with Documentation.” Through tight IDE and workflow integration, Intent ensures that code and documentation stay synchronized. Intent contributes its 0.7 release to Juno.

Vex, a visual editor for XML, is another quickly evolving project under Mylyn Docs which has been releasing milestones regularly. The tooling now supports XML schema and XHTML as well as basic rendering of images. Vex is not yet part of Juno but available from a separate update site and hopefully will join the coordinated release Kepler next year.

Last, but not least, there is Reviews for Eclipse (R4E) which is a project under Mylyn Reviews. R4E supports any artifact, including models, as a review source and has built-in capabilities to conduct formalized reviews that follow IEEE standards. The first 0.10 release was published shortly before Juno and R4E is now on its way towards graduation and joining Kepler.

It’s amazing to be part of the continuously growing Mylyn community and I would to thank all the individuals and companies that have contributed to this release.

Tasktop co-hosts Eclipse Juno Demo Camp

Tuesday, July 3rd, 2012

Tasktop Technologies, VMware and the Eclipse Foundation co-hosted the Eclipse Juno DemoCamp in Vancouver. The event was a blast with great presentations, cool prizes and lots of opportunities for networking and making new friends. The event started off with an introduction from VMware’s Kris De Volder (seen on the right) and David Green, Tasktop’s VP of Engineering (seen on the left), who recapped Tasktop’s development over the last year since the last Eclipse DemoCamp.

Eclipse DemoCamp intro

The intro was followed by the main presentations:

greenbullet_icon Reverb: Dynamic Bookmarks for Developers (Nick Sawadsky, UBC, Software Practices Lab)
greenbullet_icon Collage Framework and Code Markup Tools (Alex Bradley)
greenbullet_icon AVA: Assembly Visualization and Analysis. (Jennifer Baldwin & Yvonne Coady, University of Victoria)
greenbullet_icon Rigel: A new approach to JavaScript editing based on the Eclipse Orion Editor. (Andrew Eiseneberg, SpringSource a Division of VMWare)
greenbullet_icon jimu: Build sophisticated Android apps in minutes, using building blocks. (Linton Ye, jimu Labs)

Seen below is a presentation by Yvonne Coady and Jennifer Baldwin (speaking over Skype) that proved that remote interaction can be engaging and fun:

Remote presentation from UVIC

In this photo, Andrew Eiseneberg of WMware, is introducing Rigel, a new way to do JavaScript editing:

Andrew's Rigel

The presentations closed with Linton Ye describing how jimu made Android app development easy:

Linton's jimu

After the event, the socializing continued at the nearby Library Square Pub. See More Photos from the event…