Archive for the ‘Mylyn’ Category

Towards Lean ALM, with Dave West on Board

Thursday, April 26th, 2012

Every now and then you have a conversation that changes your view of the world. I’ve now had a dozen of those with one person, Dave West, in his role as Forrester analyst, VP, and Research Director. The common thread in our dialogue has been the need for application lifecycle glue that connects the software lifecycle stakeholders within the organization, as well as across the multi-company and increasingly open source based software supply ecosystem. Both of us realized that it would be more effective to make this vision a reality than to discuss it endlessly. So today, I’m thrilled to announce that we’ll be doing just that, with Dave West joining Tasktop as Chief Product Officer.

The very rapid growth that our products have seen lately is indicative of the need to look beyond any single tool in the evolving ALM stack, and consider the flow of information between the people that define the disciplines of the software lifecycle. Tasktop got to where we are today by placing a manic focus on the needs of the individual software developer, who was getting completely overloaded with the disconnected morass of ALM tools that failed to connect to the source code that defines delivery. That forced us to create a new model of social tasks that emphasized autonomy, transparency and integration across the increasingly diverse tool chain. With Tasktop Sync, our Task Federation has migrated from supporting Agile delivery on the developer’s desktop to connecting the rest of the software lifecycle in order to bring about a “Lean ALM”.

Driving a change in the way that software is built takes like-minded people filled with passion and purpose. Dave’s mission is to help people build software just a little bit better, and with our shared values, we expect that goal to materialize very quickly. In his role as an analyst, Dave has heard the software delivery needs and gaps of countless software organizations that build the products and services that we all rely on day-to-day. In his role as Chief Product Officer, responsible for transforming that need into our product vision and roadmap, you can expect Dave to accelerate our pace of customer-centric innovation even further as we work with our partners and open source community to connect the software lifecycle.

Read more in Dave’s post and Neelan’s post.

Watch Tasktop webinars

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.

Watch Tasktop webinars

Mylyn 3.7: Task List Search Index and Code Review Integration

Monday, March 26th, 2012

When Mylyn was still known as Mylar, our Bugzilla listed a few hundred tasks for the project. Six years later, my Task List has accumulated over 10K tasks for Mylyn alone and contains twice as many tasks in total. To help manage large task lists like that, the just released Mylyn 3.7 enhances the filtering in the Task List with an incredibly useful feature for quickly finding tasks: a Lucene based index. With the latest version, it is now possible to scope searches and instantly query over the full comment streams of all tasks.

The powerful new search options are easily discoverable through content assist (Ctrl+space). I particularly like the ability to filter based on date range. If I know for instance that the task I am looking for was commented on recently I can now find the relevant tasks with a few key strokes:

There has been a lot of talk about Gerrit, and Eclipse projects are increasingly adopting code reviews as part of their workflow. The Gerrit connector, which has been evolving in the Mylyn Reviews project, is now included in Mylyn releases, the Juno repository, and available from connector discovery bringing the first-class IDE integration that Mylyn provides for tasks to code reviews.

We have incorporated a lot of feedback from early adopters and continuously improved the connector. It now supports Gerrit 2.2 (earlier versions have been reported to work as well) and ships with support for a variety of authentication mechanisms including Open ID. The connector is tightly integrated with the latest version of EGit and extends the import wizard for simple importing of projects. When a Gerrit server has been configured, the wizard provides a listing of all Git repositories from that server. This enables simple cloning and importing of available projects.

Another noteworthy enhancement is the improved compare editor integration. The editor now shows the structure of the review. You can navigate through patch sets and add comments inline.

A key feature of Gerrit is the ability to stage multiple iterations of a change. In practice each iteration, referred to as patch sets in Gerrit, equals a commit that is tracked in a separate branch. As in the Gerrit web interface, the review editor can now show differences between patch sets to review incremental changes.

Sometimes it’s seemingly simple enhancements that add a suprisingly big benefit. We have long recognized hyperlinks as a universal way to link artifacts and made them clickable in the Task Editor. This linking now works across builds, tasks and reviews.

For example, Loading the JUnit results or reviewing the console output of a failed build that is linked from a review comment is now literally two clicks away from the review editor.

If you are at EclipseCon in Reston don’t miss the opportunity to see Mylyn 3.7 in action. Visit Tasktop at booth #25 and also attend one of the great talks that will highlight new features. A full list of new features are described in the New & Noteworthy section.

  greenbullet_icon Read the Mylyn 3.7 New & Noteworthy
  greenbullet_icon Meet Tasktop at EclipseCon

Watch Tasktop webinars

Happy Birthday Tasktop

Tuesday, January 17th, 2012

Five years ago, on Friday January 15th, I defended my PhD thesis on Focusing Knowledge Work with Task Context. The following Monday, January 17th, we incorporated Tasktop Technologies. Driven by the years of research that it took to prove that tasks are more important than files, integration is more important than features, and that focus begets flow, we embarked on a journey to bring to market a transformation in how we work and collaborate around software.

Our journey and passion have been fueled by our customers and our open source community, as to date we have not taken any external funding, and instead embarked on what’s more recently been defined as the Lean Startup approach to building a company in an Agile and customer-centric fashion. Bootstrapping, we have doubled in revenue and nearly doubled in head count each year since our inception, and now support over a thousand customers and over a million open source users. Working closely with our ISV partners, the Eclipse community and open source ALM projects, we are proud to be one of the key contributors defining the future of ALM.

In addition to the opportunity to be a part of a transformative endeavor, what’s guided our vision is a manic focus on the needs of individual software workers. Mylyn and its commercial counterpart, Tasktop Dev, materialized because the growth in complexity of software and the fragmentation of ALM tools were bringing our and our fellow developers’ productivity to a halt. Tasktop Sync was born out of the same need to give other stakeholders such as testers, project managers and business analysts, a connected and collaborative view on the software delivery process. With our focus on integration, our goal is to empower developers and other stakeholders in order to advance ALM to support the rise of the software-powered economy.

We want to take this birthday moment to thank all of the customers and partners who have made it possible for us to do what we love, which is to invent the future of ALM and to strive for our goal of doubling the productivity of software developers and managers. We hope you like the next round of innovations that we are hard at work for launching in 2012, which will be a definitive year for software, for ALM and for Tasktop Technologies.

Watch Tasktop webinars

November Mylyn events in Belgium and Germany

Thursday, November 10th, 2011

Eclipse Demo Camp

We had an awesome EclipseCon Europe with great talks and discussions that covered the latest developments in the Mylyn community. Fret not if you missed the conference. There will be more opportunities in November to see Mylyn in action.

I’ll be speaking at Devoxx in Antwerp, Belgium next week about connecting Agile, ALM and the IDE. The week after I’ll be heading to democamps in Germany to present the Git, Gerrit and Hudson integrations. The first demo is in Hamburg on November 23, followed by Kaiserlautern on November 24 and Kassel on November 29. Hope to see you there!

Watch Tasktop webinars

Experiences from migrating Mylyn to Git and Tycho

Thursday, October 27th, 2011

When Mylyn became a top-level project, the monolithic command line driven PDE build that was understood by one committer, executable on a single machine was no longer appropriate to support the modularization needs and distributed development of the project. Since we like to play with the cool kids we jumped onto the Maven/Tycho and Git bandwagon for a ride to the land where contributions merge without conflicts and sources build themselves. We are still on the road learning something new each time we hit the occasional bump. We already found out…

…and much more. While the new build system is not a silver bullet that made release engineering obsolete it’s a huge improvement over the previous configuration and enabled us to take advantage of tools like FindBugs or Gerrit that we could not easily integrate before.

If you are interested in learning from our experiences take a look at the video of the EclipseCon session.

Watch Tasktop webinars

Code2Cloud moves one step closer to open source

Wednesday, October 26th, 2011

A year ago at SpringOne 2010, Spring founder Rod Johnson announced a new technology called “Code2Cloud” during his opening keynote (skip to minute 56). Since that announcement, development of Code2Cloud has continued at a rapid pace, with a growing community of private beta users. The ideas and technology behind Code2Cloud have become an underpinning of how we see the convergence of ALM and cloud and a key building block of our vision for a more integrated and developer-centric ALM stack, outlined at a high-level in the following talk.

Many of you have been asking when Code2Cloud (or as some knew it, Cloud Foundry Code) is going to be made publicly available. Today we are announcing a key milestone on this longer-than-expected journey. Tasktop has now been tasked by VMware to bring Code2Cloud to the open source community. Tasktop’s services division has been the delivery partner for the project and Tasktop will continue to maintain and evolve Code2Cloud for the early adopters of the closed beta. Although we haven’t yet determined the specifics of how, when, and where Code2Cloud will be made available in open source, or for that matter the name of the project when it is open sourced, we are committed to making the project available in Q1 of 2012. Code2Cloud will be available via a community and commercial-friendly open source license (either Eclipse Public License v1.0 or Apache License v2.0).

We are announcing this change in the project structure because as with Eclipse Mylyn, we see a successful Code2Cloud as being built on an open and inviting charter for both individual and commercial contributors wanting to leverage the Code2Cloud frameworks and tools. We will work with our existing partners and community over the coming month to define a structure and charter for the project. We encourage any interested parties to contact us at partners@tasktop.com. We believe there are tremendous opportunities for ALM vendors to participate in and leverage Code2Cloud as an on-ramp to their initiatives and to get a step ahead in the move of the deployment destination to the cloud.

Over the past year, Code2Cloud has grown to become a developer-centric integration platform architected to connect developers to PaaS deployment destinations by way of the ALM stack. It supports CloudFoundry and builds on existing tools such as Hudson/Jenkins, Git and GitHub. It also provides a Bugzilla-compatible but cloud-centric issue tracker intended to connect the running application, CI and SCM tools to the developer’s desktop, and unifies services such as authentication via OAuth. A key opportunity that we see now is in making Code2Cloud even more agnostic of the ALM stack and in delivering its integration and Cloud deployment support to the wide variety of open source and commercial ALM tools available today.

If you have ideas or questions on bringing Code2Cloud to open source please post here. If you want to get involved in discussing the structure of the open source project please email partners@tasktop.com. For more see: http://tasktop.com/c2c

Watch Tasktop webinars

Contributing to Mylyn through Gerrit Code Reviews

Monday, October 24th, 2011

If the length of the CC list is any indication of interest in a bug, a lot of committers are looking forward to Gerrit support at Eclipse.org. The webmasters are working hard on making that happen but for Mylyn we were so eager to integrate code reviews in our workflow that we went ahead and deployed a Gerrit instance outside of Eclipse.org. Although the server has only been running for a few weeks, over 50 reviews have already been opened by a dozen people. Read on for a description how to setup your workspace to start contributing to Mylyn.

The server setup with Gerrit 2.2.1 and Hudson 2.1.2 follows the configuration described in Alex Blewitt’s tutorial. Every time an update to a Gerrit change is pushed, a Hudson build is triggered, and the result is reported back on the code review. After having worked that way for a while I would not want to miss the benefits of quick validation of staged commits and the simplified feedback process for contributions and changes proposed by committers.

Registering a Gerrit Account

To use the review server a few steps are required:

  1. Register an account at review.mylyn.org using an Open ID provider such as Google
  2. Define a username
  3. Upload your public ssh-key for authentication

Once the account has been created you need to contact me to get the account added to the trusted users group which has the required permissions to create code reviews.

Adding Gerrit as a Git Remote

On the client end, Gerrit is simply added as another remote to the local clone of a Mylyn Git repository. For example, the .git/config file for the Mylyn Tasks git repository would specify these two remotes:

[remote "origin"]
  fetch = +refs/heads/*:refs/remotes/origin/*
  url = git://git.eclipse.org/gitroot/mylyn/org.eclipse.mylyn.tasks.git
  push = HEAD:refs/heads/master

[remote "gerrit"]
  url = ssh://spingel@review.mylyn.org:29418/org.eclipse.mylyn.tasks.git
  fetch = +refs/heads/master:refs/remotes/gerrit/master
  push = HEAD:refs/for/master

If you have cloned any of the Mylyn repositories already, you can simply add the gerrit remote section. No need to clone again. Note that Gerrit uses a special ref for the push configuration called refs/for/master. This ensures that changes are not directly pushed into the master but staged in a branch first.

Additionally, I recommend adding these settings to the .git/config file:

[gerrit]
  createchangeid = true

[branch]
  autosetuprebase = always

The createchangeid flag causes EGit to automatically generate a Change-Id header for each commit. This id is used by Gerrit to track updates to existing code reviews. The autosetuprebase flag will cause all new remote tracking branches to be configured for rebase automatically which is useful when updating task branches.

Creating a Code Review

To push a new code review to review.mylyn.org, first create a local branch to track your change. This is good practice and makes it easy to modify the change based on feedback from the code review later.

$ git checkout -t origin/master -b bug#191522-provide-full-text-search

Now go ahead and commit to the branch.

The next step is to create the code review. Simply run this command:

$ git push gerrit

Instead of pushing to git.eclipse.org (origin) this will push the change to review.mylyn.org (gerrit). Note that Gerrit creates one code review per commit. In case you committed multiple times see below how to merge commits.

Updating a Code Review

If an existing code review needs be updated with additional changes or if it needs to be rebased against the current master, checkout the branch and pull:

$ git pull

Then make the desired changes and instead of creating a new commit, amend the previous commit. This retains the change id and allows updating of an existing code review:

$ git commit -a --amend

To make the update visible on the server push again:

$ git push gerrit

This creates another branch that is automatically attached to the same code review.

Pushing Changes to Eclipse.org

Once a code review is approved in Gerrit, changes are automatically merged into the master. Here comes the quirk: In the case of review.mylyn.org this does not mean much. The Git repositories on review.mylyn.org are mirrored hourly from git.eclipse.org overriding any changes that were merged by Gerrit. For good reason, only committers are allowed to push to git.eclipse.org hence a committer needs to run this simple command eventually to make changes visible in origin/master:

$ git push origin

Contributors need to go through the standard Eclipse contribution process. Once a code a review is approved a patch needs to be created and attached to a bug report to track the IP in accordance with the Eclipse process. This is very easy using EGit’s drag’n'drop support for commits.

Squashing Commits

If you committed multiple times you can always squash commits later using interactive rebase, e.g. to merge the last two commits into one commit use this command:

$ git rebase -i HEAD~2

This opens an editor to modify the commit history. If you change “pick” in the second line of the editor to “fixup”, that commit will be merged with the previous commit when you exit the editor.

Accessing Gerrit through HTTP

If you are not able to connect to review.mylyn.org through SSH on port 29418 you can instead setup a password for HTTP access. In this case the url in the remote configuration needs to be modified slightly:

[remote "gerrit"]
  url = http://spingel@review.mylyn.org/p/org.eclipse.mylyn.tasks
  fetch = +refs/heads/master:refs/remotes/gerrit/master
  push = HEAD:refs/for/master

More Information

The Mylyn contributor reference has a lot more information on how to get started. I am looking forward to your code reviews and contributions to Mylyn!

Watch Tasktop webinars

Mylyn Galore at EclipseCon Europe

Wednesday, October 19th, 2011

November will kick off with EclipseCon Europe in Ludwigsburg, Germany. It’s an excellent conference and a great opportunity to connect with the community. But, it gets even better: This year’s program is loaded with Mylyn related talks that cover a range of topics about exciting developments in Mylyn!

Wednesday

Thursday

Friday

If you would like to meet us for a chat or grab a cold beverage, please connect to @bmuskalla or @steffen_pingel or catch us at one of the talks!

Watch Tasktop webinars

Tasktop at JavaOne: Drinkup with GitHub and Continuous Integration Talk and Panel

Tuesday, October 4th, 2011

Meet Tasktop at JavaOne at Booth #5004. Tasktop team members will be happy to show you the latest from Tasktop including Tasktop Sync, Tasktop Dev and Eclipse Mylyn.

Also, if you have some time, Tasktop and GitHub are co-hosting a Drinkup on Tuesday night starting at 8pm at Jasper’s Corner Tap. Jasper’s Corner Tap is located at 401 Taylor St. We hope to see you there.

Monday’s Panel: The Future of Java Build and Continuous Integration

  • Ted Farrell, Chief Architect, Tools & Middleware
  • Mik Kersten, CEO, Tasktop, @mik_kersten
  • Mike Milinkovich, Executive Director, Eclipse Foundation, @mmilinkov
  • Mike Maciag, CEO Electric Cloud
  • Max Spring, Tech Lead, Cisco Systems
Mylyn Contribution Workflow

from Mik's JavaOne talk

We saw a great turn out at the panel, with attendees driving a discussion of how Hudson and Continuous Integration in general is becoming a central part of the modern ALM stack. Tomorrow (Tuesday October 4th), Mik will elaborate on the story in his talk titled “ALM Automation with Mylyn and Hudson”.

Tuesday’s Talk: ALM Automation with Mylyn and Hudson

Date: Tues., Oct. 4, 2011, noon – 1 p.m. Pacific
Location: Parc 55 – Divisidero

With the shift to PaaS and a new breed of open source ALM tools, the deployment loop of enterprise apps is going through its biggest transition since the creation of Java. Kersten will explore connecting the enterprise Java stack to cloud deployment via task-focused continuous integration based on Hudson. Distributed version control systems, code review and Agile planning, based on the Eclipse Mylyn interoperability platform, can be used to create a new level of connectivity and automation between the team and the running application. This talk outlines a roadmap for transforming productivity by connecting developers’ desktops to the release, and automating all the steps in between, from provisioning the IDE to monitoring the running application.

Watch Tasktop webinars