The productivity of the software industry is defined by developers, and the productivity of developers is framed by the programming languages, frameworks and tools that we use. On the language front, the past decade has brought stabilization, with statically typed object-oriented languages such as Java and C# becoming entrenched in the enterprise, and dynamic languages finding their niche. While language evolution continues in an incremental fashion, it is continuing to bring significant but diminishing returns. In contrast, the past decade has brought about a major evolution on the framework front. For example, first the dependency injection and then annotation-based REST support of Spring have made a much greater impact on how the average developer builds applications than the pending addition of closures for Java will provide, necessary as that may be.
Beyond frameworks, one of the most fascinating developments in developer productivity over the past decade has been in the area of tools. The IDE has become entrenched, Agile has come of age, and tools for planning, collaboration and application lifecycle management (ALM) have become the hotbed of innovation.
The application landscape that defines our work has changed as well. Only recently did debuggers and build tools manage to catch up to the needs of app server runtimes to provide the ease of deployment that we had with Smalltalk three decades ago. Enterprise application deployment is in the middle of yet another fundamental transition, with cloud infrastructure bringing about the next major shift in deployment architecture.
Cloud deployment will provide fundamental benefits, but as we saw with the move to app servers, development tools need to catch up with the new cloud technologies. In the meantime, without new innovation on the tools front, developers would again be burdened with constant administration and configuration of their builds and runtimes during the transition. We are all capable of setting up and administering VMs, configuring continuous integration tools to talk to deployment destinations, or hooking up issue trackers to SCM and testing tools. This can even make for a fun break from a long debugging session. The problem is that we are spending way too much time doing this busy work, and each second spent on manual configuration is taken away from what we ultimately love to do, which is creating interesting applications. Just as the success of Spring and JBoss demonstrated how important it was to evolve the framework along with open source innovations around the application runtime, it is now time to bring together the evolution of the framework, application lifecycle tools and cloud deployment.
A year ago, I was driving with Rod Johnson through the hills east of Palo Alto and we were mulling over this problem between hairpin turns. We devised a plan to combine the best open source innovations of Spring technologies on the framework side, with the progress that has been made on the application lifecycle tools front around Mylyn, and the latest in virtualization and cloud technology from VMware. By the end of lunch in La Honda, our deductive powers heightened by the adrenaline from the drive, we had what looked like a design for the next wave of developer productivity tools. It would give the developer a full turnkey experience while providing the level of control and flexibility of open source. We then created a secret open source effort to provide the missing link between the developer’s desktop and the cloud. Yes, “secret open source” is something of an oxymoron, but this next step in developer tools was a significant enough departure to require a year of focused development during which we put these technologies together and created this new layer of innovation. The result of this collaboration is the VMware Code2Cloud offering.
In summary, Code2Cloud builds on Mylyn, Hudson, Git and Google Web Toolkit (GWT) to provide a turnkey application hosting experience. Sign in from STS, start the wizard, and with a click your application, source code, tasks and continuous integration builds are hosted. Fix a defect in the SpringSource Tool Suite (STS), and a Hudson build is automatically kicked off. When successful, the build is automatically deployed at your deployment destination of choice, such as VMforce. The running application is then connected back to your application lifecycle tools, and monitoring technologies automatically create defects with the code related to runtime problems captured as a Mylyn task context.
In addition to the benefit that this will provide to application developers, Code2Cloud will provide a new platform for innovation around the intersection of application lifecycle tools and cloud deployment. The solution is designed from the ground up to be extensible and integrated. On the extensibility front, it provides the most thorough set of REST APIs for Mylyn-based IDE access, and even the GWT-based web front-end is entirely built on these APIs. In addition, we are providing full support for the Open Services for Lifecycle Collaboration (OSLC) web services specification on which Tasktop collaborated with IBM. The entire solution is open source, ensuring that developers extending the solution are free to innovate and not limited to the inherent limitations of API boundaries.
On the interoperability front, as you would expect from Tasktop’s involvement, Code2Cloud is architected to support a very broad range of ALM offerings. Want to access your sources for an existing open source project hosted on GitHub? Just add it your Code2Cloud configuration. Want to use IBM Rational Team Concert for planning tasks in Code2Cloud, or link Code2Cloud tasks to defects in HP Quality Center? Just install Tasktop Enterprise to get access to our full ALM interoperability suite. The goal of Code2Cloud is not to create another ALM suite, but to provide an innovative platform and core set of application lifecycle tool functionality designed for cloud deployment, while supporting the broad range of ALM solutions already in use.
Until today, application development and application lifecycle management tools have been disconnected. The innovation of Code2Cloud will redefine the connection between the developer’s desktop, the lifecycle management tools and the running application. In the video below you’ll see one example of the functionality this enables, with captured context from Spring Insight automatically percolating from the running application to the developer’s desktop. This is only the start.
|Tasktop VP Engineering David Green demonstrates Code2Cloud|
(Higher Resolution Video)