Archive for the ‘Open Source’ Category

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.

Software Lifecycle Integration (SLI)

Monday, March 25th, 2013

Disjointed tools have inundated the application lifecycle. At its roots, tool diversity is a good thing. Over the past few years, it has transformed the way software is built via Agile methods, open source tools and differentiating vendors. But it has also wreaked havoc on the decade-old promise of Application Lifecycle Management (ALM). We need a new kind of infrastructure to deliver on that promise in a world where developers get to choose the tools that make them most productive. The time has come for an integrated lifecycle bus that allows information to flow freely between developers, testers, business analysts and administrators. This infrastructure will enable us to connect the best offerings in ALM in order to create a Lean Software Lifecycle, and implement a build-measure-learn loop that connects business idea to app store, and back again. We need a set of common data models and architectural patterns. Most importantly, we need to establish the common artifact that will connect the lifecycle. We are calling the category of infrastructure that will enable this Software Lifecycle Integration (SLI).

When outlined on a whiteboard or diagram, the architecture of today’s ALM stack resembles a half-eaten bowl of spaghetti, with meatballs corresponding to the various tools selected by stakeholders. We have two choices, either find a way back to the homogenous and single vendor solution of the 1990s, or embrace heterogeneity and come up with an infrastructure that provides end-to-end collaboration and traceability across best-of-breed tools.

Not long ago, we witnessed a similar transformation of the app dev stack. Once the services, databases and app server space enabled heterogeneity, the middleware category materialized and the Enterprise Service Bus (ESB) emerged, along with the new title of “Enterprise Architect”. History doesn’t repeat, but it does rhyme. It’s now time to create the role of the Lifecycle Architect, and to define an architectural framework for connecting the software lifecycle. Just as the notion of services was key to enabling the ESB, and file and documents abstractions were to sharing data, we now need an abstraction to connect the software lifecycle and to create a Software Lifecycle Bus. That abstraction is the social task.

Today Tasktop is a kicking off an effort to bootstrap the SLI discipline, with a series of whitepapers discussing the technical architecture, common data model, and technical tools. We are proposing the Eclipse Mylyn m4 open source project as a home for collaborating on a de facto implementation of the SLI data model, which will leverage what has been learned from the adoption of Mylyn, integrations that build on it, and new efforts around the open standards of Linked Data and OSLC. Later this week we are also launching an SLI integration patterns catalog, based on existing input from our customers, and open for all to contribute to. By the end of the week, with input from key thought leaders present at the ALM Connect subconference of EclipseCon, we plan to release a first draft of the SLI manifesto. To learn more and to participate, see:

Whitepaper: Building the Business Case for Software Lifecycle Integration
Whitepaper: Software Lifecycle Integration Architecture
Software Lifecycle Integration landing page
Eclipse Mylyn m4 Project Proposal Draft
SLI Patterns Catalog Wiki (to come)


Learn more about SLI

The Case for Integration

Tuesday, March 5th, 2013

Putting the L in ALM – Making the case for Lifecycle Integration

I think everyone agrees that software delivery is not an ancillary business process but is actually a key business process, and the ability to deliver software faster, cheaper, and of a higher quality is a competitive advantage. But delivering software is difficult, and if you believe the Standish Chaos report, anywhere from 24 to 68 percent of software projects end in some form of failure.

Even the criteria for success has been questioned by many, as ‘on time, on budget, delivering the functionality requested’ can still mean software that fulfills requirements but adds no business value. Billions of dollars a year are spent on software development tools and practices in the desire to increase project success and reduce time-to-market. Each year, development, testing, requirements, project management and deployment roll out new practices and tools. Many of these additions bring value, thereby increasing the capability of each individual discipline. But ultimately, the problem is not the individual discipline; the problem is how those disciplines work together in pursuit of common goals and how the lifecycle is integrated across those disciplines.

It has been a year since I joined Tasktop, and during numerous customer visits and partner discussions, two things are very clear: 1. the landscape of software delivery tools and practices is going through a major change, and 2. to be effective in software delivery you need to automate flow and analytics.

The ever-changing face of software tools and practices

Add Agile, Lean Startup and DevOps to a large amount of mobile, cloud and open web, and not only do you have the perfect book title, you have all the ingredients necessary for a major change in the practice of software delivery. Agile and Lean encourage rapid delivery, customer feedback and cross-functional teams focused on delivering customer value. Mobile and cloud are changing the landscape of delivery platforms, architectural models and even partner relationships. Never before have we needed to build flexible development processes that encourage both feedback and automation. Imagine spending three months writing a specification for your next mobile application when your competitors deploy new features on a daily basis. Imagine not connecting your new sales productivity application to LinkedIn, where your sales people have all their contacts. Our development approach needs to not only include partner organizations and services but also deliver software at a much higher cadence.

Automation of Flow and Analytics (reporting) is key.

I have noticed a strange relationship between increased speed, reporting and integration. When you increase the speed of delivery, traditional manual processes for reporting and analytics stop working or become an overhead. For example, one customer spent two days compiling the monthly status report spreadsheet across development, test and requirements. This two day effort required meetings with numerous people and emailing the spreadsheet around for comment and review. When the organization adopted two week delivery sprints, this work was an overhead that no one wanted to endure. Now the company had a choice: drop the status report, or look to an automated solution. Because more frequent releases meant the need to collaborate better, they opted for an automated solution that connected the test, development and requirements tools, providing a report that described the flow of artifacts among these three groups.

The automation not only resulted in creating the report but also improving the flow between these different disciplines. Suddenly there was clarity as to the state of a story or when a defect should move into test. This clarity was avoided in the manual approach, which left large amounts of ambiguity. The report drove the creation of automated flow, which resulted in a better process, which then fed the report with better data.

That means there is a sixth discipline in software delivery

Lifecycle Integration is emerging as a key discipline for ALM. It provides the glue that enables the disconnected disciplines of requirements, development, testing, deployment and project management to connect. It unifies the process and data models of the five software delivery disciplines to enable a unified approach to Application Lifecycle Management (ALM).

Without integration, many of the disconnects go unrecognized, and the flow between groups is never optimized. The larger your software delivery value chain, the more pronounced the impact of these disconnects. Factor in external organizations, either through outsourcing, application integration, service usage or open source, and these impacts can mean the difference between not just project, but business success and failure.

Perhaps we in the software industry are suffering a bit from the ‘cobbler’s children syndrome,’ with integration being a first-class citizen in the traditional processes we have integrated for our business clients for years. But the time is right to apply these lessons and build a discipline around lifecycle integration for the practice of software delivery.

Tasktop turns 6, plays well with others

Thursday, January 17th, 2013

January 17th marks the 6th anniversary of Tasktop’s inception, and has given me an opportunity to think about the past 6 years, and the next. All technological revolutions require a new kind of infrastructure. This decade will mark the shift to the software economy, with traditional companies turning into software delivery organizations. The problem is that, outside of ISVs who have glued together their own ALM processes, we’re not all that efficient at building software.

The generation before ours mastered building cars, managing just-in-time inventories of parts, as well as complex supply chains. And yet we’re still seeing software collaboration across companies and departments being done via spreadsheets and email threads, today’s equivalent of carrier pigeons. While the rest of the ALM industry sorts out the new generation of systems of engagement to make developers, Agile project managers and other stakeholders happy, Tasktop’s mission is to create the infrastructure that glues together this new breed of tools, with tasks as the new currency of planning and collaboration.

When staring out the window at our new Vancouver HQ, I often fixate on the orchestrated flow of cargo ships routing containers–the abstraction that has come to define the shipping industry. Rob Elves, co-founder of Tasktop, joins me in the picture below, as we were reflecting on our journey of the past six years. We validated the need for a layer of infrastructure between the developer and the various ALM servers by shoehorning it into the Eclipse desktop client and giving it a single and collaborative UI called Mylyn. That paved the way for our first commercial product, called Tasktop Dev, whose success was not just in laying our commercial foundation and revenues that drove our growth, but in allowing us to learn what a mess software development outside of the IDE really is. In our mission to connect the world of software delivery, the next step became overwhelmingly clear. A new infrastructure for connecting the software siloes within the organization, and increasingly across the chain of software suppliers, is now the bottleneck. Even the cars that previous generations learned to build so well now depend on dozens of software suppliers working together. Without automating the interaction between these suppliers in a way that supports collaboration and lean delivery across organizations, innovation is being stifled.

As Neelan reported in the Tasktop Year in Review, 2012 was huge for us with with 250% growth since our last birthday. A portion of the year went to thinking about what shape this new task “container” has in the software lifecycle. But it’s now clear that the problem is not the container, as the Mylyn model is nearly expressive enough, and our work with IBM in OSLC and W3C Linked Data is a good start to defining things like common query APIs. It turns out that the biggest gap is the lack of infrastructure for shipping this information between people and tools, and supporting the many previous attempts by each vendor in defining their own APIs specific to their specialization in the software lifecycle.

In 2012, Sync became the lifecycle integration platform of choice for numerous Fortune 100 companies. We got to learn what it was like to be building infrastructure and digging canals between vendors while becoming a mission critical component of the stack, which resulted in Sync’s transition to an enterprise-scale lifecycle integration bus. We’re looking forward to scaling this new kind of collaborative infrastructure in 2013, and making your software lifecycle as orchestrated as the flow of container ships through Vancouver’s magnificent harbor.

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.

EclipseCon keynote: The Future of ALM – Developing in the Social Code Graph

Thursday, April 12th, 2012

EclipseCon 2012 was my favorite to date, and I’ve been attending since the prototype—beers and demos at Thirsty Bear during JavaOne 2002. What made it so interesting was finally getting all the Eclipse devs in the same space as key folks from Agile and ALM. Developers are the engine of the software economy. But that engine is becoming part of such a complex ecosystem of vendors and open source that to scale software delivery, we need to break down organizational and departmental silos. We need to move towards what Forrester analyst Dave West has coined a Lean ALM. And that’s what my keynote was all about. Connecting devs to project managers, to testers, and eventually to @DEVOPS_BORAT.

Some have objected to my statement that Linus Torvalds’ bigger contribution to our planet is going to be Git, not Linux. Yes, Linux is everywhere. But Linux was a creative imitation, whereas I was focusing on the true innovations that are moving us towards the social code graph, and that’s precisely where Git fits in. Also, early in the talk I mention that Eclipse has gone from 1.5M to 2.5M downloads between January 2011 and January 2012. That’s monthly downloads, and with Vietnam surpassing Germany, a clear sign of the times.

Watch the keynote here, and I look forward to hearing your feedback and ideas.