Winning most influential paper from 10 years ago, lessons learned

Posted by

Gail Murphy (Tasktop co-founder and Chief Scientist) and I were very pleased to learn that our paper on “Mylar [aka Mylyn]: a degree-of-interest model for IDEs” just won the Modularity conference’s award for most influential paper from 10 years ago. The Modularity community is near-and-dear to me as it’s where the ideas on crosscutting structure developed. I was first immersed in this novel view on software design by Gregor Kiczales, who pioneered applying crosscutting paradigms to programming languages with Aspect-Oriented Programming (AOP). Once you start thinking in terms of crosscutting structure it’s hard to stop. The core idea is that no matter how you structure information hierarchically, there will always be concerns that crosscut that hierarchy. For example, security for an enterprise application.

The trick with AOP was to come up with a model and operations for this kind of “crosscutting structure”. Over a decade ago, as a tool builder and developer, Gail and I saw an opportunity to apply crosscutting structure to the Integrated Development Environment (IDE). We hypothesized that if connected the developer’s coding activity with lifecycle artifacts such as development tasks, a new crosscutting structure could emerge. The epiphany came from the idea that no matter how large a codebase we work on, for any given user story we’re trying to implement or defect we’re trying to fix, we only care about the slice of the current or future code that’s related to that unit of user value.

To prove this out we connected lifecycle artifacts to the IDE, and integrated them to source code using developer activity-based “task contexts”. The result was that every requirement, user story, defect and support case was at the developer’s fingertips, automatically connected to the context of source code and builds the developer was working on. Eclipse Mylyn was broadly adopted via Eclipse, and its core concepts shaped the ALM functionality of other IDEs such as VisualStudio. But I learned the hard way that it would not be sufficient to achieve my vision of a 10x improvement in the way that software is built.

The problem is that at enterprise scale, coding is only one slice of software delivery. Coding activity is only relevant when connected to delivering business value and end user improvements. Yet connecting those activities seemed impossible since there was no IDE that was used across the many different stakeholders in the lifecycle. So the Mylyn trick of integrating everything via the IDE layer would not work. To address this problem, I looked again to the Modularity community for inspiration. To make crosscutting structure explicit, you need to understand the underlying models, and then create a mechanism for defining the crosscutting.

For example, in a Java program, the type hierarchy is the model, and a security concern can be defined as an aspect implemented via annotations and dependency injection via a tool like the Spring Framework. In the software lifecycle, the models are the various repositories of information ranging from requirements management, to Agile planning, to development tools and issue tracking, to support and operations. These models reside on on-prem and SaaS tool repositories. The crosscutting structure emerges from the need to flow information across the lifecycle. For example, the delivery of user value may be captured by a requirement that’s implemented by several user stories and connected to performance information and several tickets. So the problem simply became figuring out where to define this crosscutting structure. Since the Agile/ALM/DevOps repositories themselves are limited to their slice or slices of the lifecycle, it has to be defined externally. And that’s why we created Tasktop Sync.

It has been ten years since we built the initial abstractions that power Tasktop, and it is fantastic to see them recognized by the 10 year Modularity award. What’s even more rewarding is that those very same concepts are helping the world’s largest organizations deliver software at scale, and helping them leverage the latest tool and process innovations from our partners. That’s lead to a successful and growing company, and tremendous value delivered to our partner and open source ecosystems. But what’s even more interesting is what we’ve learned over the years in taking this work from the crucible of Computer Science research to companies leveraging it for connecting thousands of software practitioners. Tasktop continues to build a whole new platform based on these ideas, and one that we think will fundamentally reshape the next 10 years of how software is built.

The tremendous efforts put forth by research communities like Modularity are what make these kinds of explorations possible, as those communities provide the peer feedback and brainstorming that drives deep innovation and experimentation. Tasktop is proud to be an example of that innovation cycle, and going from a 6 person user study over 10 years ago to millions of developers and 23 of the Fortune 100 relying on our technology today. Most importantly, that innovation cycle is continuing. Over the past two years we have learned a tremendous amount on how this crosscutting lifecycle integration structure works at scale thanks to feedback from our customers pushing Tasktop Sync to scales and use cases we had not previously imagined. All of that is feeding back into a whole new way of thinking about the crosscutting software lifecycle integration (SLI) model, which we will be sharing with you over the coming months. Sign up for the SLI group to stay in touch.