Facilitating the Spread of Knowledge and Innovation in Professional Software Development

Write for InfoQ


Choose your language

InfoQ Homepage Interviews Tasktop Talks Mylyn, Code2Cloud

Tasktop Talks Mylyn, Code2Cloud


1. Can you tell me, when one considers the typical developer UI, it tends to be a very cluttered affair with every conceivable option linked to a button or menu some kind - why do you suppose this is?

Mik Kersten: That's a good question. I think what happens is there is this constant need to basically add more features into developer UIs. If you are talking about the IDE there is an overwhelming amount of integration that needs to happen in a diverse stack. The Java ecosystem is sort of differentiated from the .NET and the Visual Studio side because it had a lot of diversity with different vendors adding their own plug-ins, adding their own frameworks, adding their own runtime components, adding their own ALM [Application Lifecycle Management] technologies. We basically kept stacking those on, and the power of Eclipse is that supported that kind of extensibility and unforeseen extensibility because there has been a tone of innovation. Tools like the SpringSource Tool Suite add their own layer for dealing with the Spring Framework.

What we have tried to do is to bring some sanity to the developer by basically architecting their workflow around the tasks that they do. We can't completely simplify the Eclipse user interface. There is some necessary complexity in there because we're dealing with so many underlying tools and technologies. By orienting the workflow around task we're able to simplify the workflow pretty dramatically. For example, when you switch tasks Eclipse automatically switches perspectives. So you switch into the Java debugging perspective if that's the last thing that you were doing. I think there are some interesting challenges still in developer-facing user interfaces that we need to solve, and adding basically this orienting more and more interaction around tasks gives us just the right tool to continue doing that.

Neelan Choksi: You'll noticed on our jackets here, the "o" of Tasktop is a < [less than] sign, an = [equal] sign and a > [greater than] sign and what it stands for is less is more. We have a pretty firm belief and this is a perfect answer to your question. We have a pretty firm belief that less is more when it comes to GUIs and especially for the IDEs and things of that nature. And the really neat thing is I think the world started catch up to that thinking because Apple has kind of proven that out and in a kind of a big way that really good design often implies that less is more.

Mik Kersten: Exactly. There are two aspects to it. One is the base of esthetic design the one that you see when you look at [Mac] OS X, it's very clean. If you look at the iPhone UI, it's very clean. The second aspect to it that often gets left behind is the complexity of the interaction. How many menu navigations, how many clicks, how many buttons and strings it took you to do the thing you want to do? With a fully menu-, file-driven out, Window-driven UI, you get way too much complexity in your interactions. That's why hooking things around task, what happens is you go back to a task - currently this is only possible inside the Eclipse IDE - we've got the Tasktop standalone desktop application for product managers, more technical users.

You go back to a task everything is automatically re-opened for you and you just have fewer clicks. The complexity that is visual, very important to get right, but there is the complex of the click stream and the screens and compressing that is really a key thing to helping developers and other knowledge workers to work more effectively.


2. How does Tasktop build upon the advances that came with Mylyn?

Mik Kersten: What Mylyn did is it set out this framework for doing two key things. One is integrating the different ALM tools that we use - different application lifecycle tools. So it all started with bringing your issue tracking, and defect tracking tool, and more recently support for Agile tracking tools, into the IDE where you could access it and where it was instantly available to find. It was the framework for doing that level of integration. And its big success has been becoming the de facto standard for ALM integration. Now to the point where it's become a Top Level Eclipse project and encompasses things like SCM integration, source code management, builds system integration, continuous integration code reviews are coming as well, all that new functionality.

So there is that whole integration layer that's in Mylyn to bring that the benefits of the integration to the enterprise developer, not just to the open source of developer working with Bugzilla or Mantis or Track, one of the open source issue trackers. And using something like Subversion or Git to bring it to the enterprise where there are other application lifecycle management tools in play, Tasktop layers on commercial integrations. So integrations with systems like IBM's ClearQuest or Rational Team Concert, other tools like the best-of-breed Agile tools such as ThoughtWorks and VersionOne -- that's the integration component of bringing the successes of Mylyn that have happened in the wild into the enterprise. The other thing is the value that we layer on top of this integration, that's the other key component.

Once you've got this task focused interface, you're able to access your tasks across different repositories; you want to be able to do things like Agile planning across those things. The commercial tooling inside Tasktop built on top of the Mylyn framework to provide the whole product experience not just a framework that you configure yourself, but basically all the setup that you need. If you're in a small company it hooks up to your existing tools, it can be reconfigured for large enterprises, pre-configured with the different that connectors that you need.

And then all of the value-add features of Tasktop such as the task focusing for browsing documents and web pages, it layers consistently across those things. The automatic time tracking, which is a really key piece of Agile estimation and helping with transparency in the development process, that layers on whatever systems you have. One of the most exciting new features that we have coming, that's in Beta right now, is the Agile planner which works across repositories. If you got something in Rally, you'll be able to drag a defect from Quality Center onto Rally user story, have those things linked up automatically, and see the plan spanning across your different ALM systems.


3. Can you describe Code2Cloud and how Tasktop integrates with it?

Mik Kersten: Code2Cloud is a combination of three key things that developers are familiar with it right now, but they are struggling with integrating and forced to manually configure. There is their IDE which needs to hook up to their ALM systems, there is their deployment destination, which is increasingly becoming cloud-based. If they want to experiment with it, they can try it right now, they can try a cloud-based deployment destination, but have to do a lot of manual hook up, and then their actual ALM system itself: their issue tracker, their source code and their continuous integration builds.

What we have done is in order to avoid having developers to hook these things up manually, we have created a turnkey solution by taking the best innovations out of the open source parts of application lifecycle tools - Eclipse, Mylyn, Git, Hudson, created a Bugzilla compatible issue tracker that's specific to this cloud hosting environment. We have brought those right into the IDE by providing a very thorough set of REST APIs for working with these projects. So, from within the IDE you simply sign up to Code2Cloud. You can take source code in your work space, create a new project, a new application in Code2Cloud your issues, your source code, your builds that have been automatically provisioned.

The source gets pushed from the work space into the CI system, so into Hudson, and it is built automatically, and once built it gets pushed into the runtime destination something like the VMforce for example. The build gets promoted and automatically deployed. Then the neat thing is since all of these things are wired up together, if you have a monitoring technology installed in the runtime, say Spring Insight, which is just something that we integrate within quite deeply. A defect occurs at the runtime, so there is something like a slow database connection, not even as bad a defect, but some performance issue that gets detected.

We are able to capture that using Spring Insight and push it back into the issue tracker but capture all the context, so making a Mylyn context out that failure. Say these are all the classes responsible for that slow database connection, this is what some of the data flow was before that, attach that to the defect and then bring it back into the developer's work space. They simply activate the task, because a new task comes in, if they are watching the application's defects, in a new task, automatically the defect comes in with that payload. They activate it, they see exactly what the problem is, they fix the problem, make the commit with Git, and that gets redeployed and re-provisioned.

Not only all of that integration that the developer had to do between those systems, hooking up their CI to the deployment destination, making things work properly in IDE, managing their Git keys, all of that is just gone, because it is fun for a half a day and then it gets super annoying. And then we were able to layer on these deployment specific innovations, like hooking up modern technologies with the issue tracker and a whole bunch of cool things that we have got in the pipeline to make it much easier for the developer to deploy to the cloud and get value from all the neat open source technologies that are there.

Neelan Choksi: For a lot of enterprises who have a lot of existing tools this makes perfect, a turnkey solution sounds great but for a lot of enterprises they already have existing tools, the great thing is because Tasktop is involved, we layer on the integration on top of SpringSource's Code2Cloud. So if somebody has an existing Bugzilla repository we can point to that. If somebody has an HP Quality Center or RTC [Rational Team Concert and they want to have some integration there, that's what we do. It makes a lot of sense for an organization who wants to try this out for the first time and get active, an organization that has these open source components already, who's trying to get out of business of integrating them and then all the way up to larger enterprises who already have existing technologies that want to find solutions that make sense, that are well integrated - that's the place where this fits, where Tasktop fits with Code2Cloud.

Mik Kersten: You get the best of this new innovation coming from this offering hosted by VMware because it is all open source, everything that we've created under the GPL, you can bring it on premise and have it work through the Tasktop integration layer, have it work with your existing ALM tools as well.


4. With the automatic detection of exceptions and performance issues, it seems like there is some kind of heuristic switch to allow Code2Cloud to identify when certain issues exist in order to create a Tasktop context. What are these heuristics and is it possible to expand upon those?

Mik Kersten: We have seen a lot of innovation on the application monitoring side already. That's been happening. SpringSource acquired a Hyperic a while back and these things are getting more and more integrated. Application monitoring is just a hot space and reporting on that. One thing that's left behind is basically connecting that monitoring to the developer's desktop, to what the developer needs to work with, which in the end is code that's responsible for the failure. This is where this technology calls Spring Insight, I think this is actually fascinating, because what it uses is aspect-oriented programming technology, which is something that is dear to me since it was something I was involved in.

And it is a very useful context for seeing into the running structure of a Spring application. Aspects have a way of expressing, this point describes a particular control flow, and saying that this control flow, this entire transaction should not take two seconds to complete, it should be faster than two seconds. Spring Insight and the AOP technology under it gives you a way of expressing for your Spring application these kind of constrains. It comes with a bunch of them out of the box, but what's really interesting to me is that those can be extended and they understand both the Java and the Spring aspects of your application.

All we are doing with Code2Cloud leveraging that cool technology, while the Spring Insight team and others are developing these applications and extending those heuristics for themselves and come up with those interesting heuristics, and from the Spring Insight grabbing basically the relevant code artifacts. So not just the top frame of the stack trace, which is all we're used to seeing, but everything that is relevant and then packaging and shipping that onto the defect to the developer's desktop.


5. With the creation of an integrated stack it used several technologies which are already out there kind of glom that into one. What were the motivations behind creating Code2Cloud out of these components?

Mik Kersten: On the open source side of the application life cycle tools, we have seen some really interesting innovation lately, some that have not been touched on the commercial side yet. For example distributed version control with Git is a fundamental innovation which matches beautifully with this task-focused workflow. We've got some really neat features planned right now like for example for Git automatic shelving, once you switch a task. So you can very easily go back to your changes. Because of that fundamental value that things like Git bring, we have seen a lot of our customers are in some stage of Git deployment.

These are large organizations. Git is still not an enterprise friendly tool, in the sense that is not easy to deploy onto Windows servers, the package is not quite there. We have just heard an interesting the story from an analyst who would be way high on the scale of software developers, in terms of his experience and background, who installed the Git server and turfed his laptop in the process and the problem is that this is far too easy to do. Because if you are Linus Torvalds you'll have no problem installing Git. But to really bring the benefits of these open source collaboration tools, which is what they really are in the end, tools that the open source communities have created for themselves, to help them evolve their software.

That's why they are so interesting. Mylyn has always boot-strapped on its user community and has grown around the needs of contributors. When we added support for patches, which is like a pre-Git functionality, how easy we made it work with patches, that set of changes, that's because we were getting dozens of contributions each month that we had to manage -very similar sort of motivation and forcing function to what happen with Git. But to get the benefits of these things and to bring them into the enterprise, there needs to be other level of packaging of integration, a single sign of working with LDAP.

All of those things that are missing right now, and they are missing because there has not been a turn-key solution. So we have put them together, we have added that level of integration and right now, the interesting thing is that all the value that layers on top of it. Integration with the deployment destination and the rest. Now there is a better open source platform for building those sorts of extensions, which is why the extensibility story, the fact of making these all open source so that you can go and play with it, add your own plug-ins, things that we have not yet thought of in the API, because that's always a frustration. Any time you get an API, you're constrained to what the API designers understood about the system at the time that they build it.

Again, one of the things that's made Eclipse so interesting is because it supported unforeseen extensions. No one envisioned Mylyn when Eclipse was created but we were able to shoehorn it in because of this deep extensibility and because it was open source. One of the things I'm really excited about is that we are going to bring that level to the application lifecycle tools side and support that next round of innovations on top of that. Integration with all the application lifecycle management tools as well, since this is just a core set of that application life cycle functionality and see a lot of innovation grow on top of this.

Neelan Choksi: Every developer I've talked to at the show seems to have a horror story or some sort of story about configuring Hudson, or trying to get Git setup and installed on their machines. It just seems that this idea of a turn-key, no configuration involved, no software installation, just STS seems to have resonated very well at the show with the developers we've spoken to. The horror stories are just horrendous.

Mik Kersten: They are using it and we all laugh, but actually it's a whole bunch of wasted time. When it happens the first time it's all right, but if you are in an organization and it's the 10th time that you've done this, you get sick of it.

Neelan Choksi: The case with the analyst was perfect. We couldn't show him the slides or the demo because he didn't have his laptop, so he couldn't see it. He was getting a new one the next day, it was a temporary thing, but it's a great example. Developers do this all the time: they work on things that add absolutely zero value to the organization and they are important. Having continuous integration is really important, having repository in a task management system is really important, but that's not what they are paid to do. They are paid to solve business problems.

Mik Kersten: Exactly. You want both of benefits of the latest open-source stuff and then within the enterprise you need this turn-key solution. So we've really emphasized on putting both of those things together, working closely with the projects, being a core part of the evolution of Mylyn. We are really looking forward to providing both that layer of extensibility that's interesting and use Code2Cloud ALM hub as a new open-source component and all the integrations that come around.


6. Thank you very much.

Thank you.

Nov 25, 2010