12 Sep 2005No Shared Vision, No Ant2
My involvement with the Ant project started out with just helping people on the Ant mailing list. I was a convert to Ant the moment I used it and evangelised Ant to any who would listen. As soon as it was upgraded to a Jakarta sub-project I started lurking and later helping users out on the mailing list. Ant was far from perfect at this time and had a collection of warts and gotchas but it was much better than the alternative make.
Eventually someone (Stefan Bodewig? or Sam Ruby?) asked me if I wanted to be a committer and I joined up. However it was rare for me to actually modify any of the source code outside of applying patches or occasionally fixing bugs identified when I was helping someone. The source code was a jumble of cruft inherited from many people who had implemented things in different styles and without understanding how Ant really worked. “How Ant really worked” was a more of a moving target back then as well. I just found the source code ugly and unpleasant to work with and I much preferred helping end users anyway. Last time I checked Stefan had made a herculean effort in cleaning up the codebase and I assume others have continued the job. But back then …. shudder
After helping out on the mailing lists you started to see the same problems or at least symptoms of the same problem over and over. A lot of people saw ways in which we could improve Ant and stop these problems from popping up all the time.
During this time I had started to develop a proposal for the next generation of Ant based on the ideas generated on the mailing list. Before I had got it to a first-cut state the original ant developer came back and announced that he had developed a proposal for Ant2 named AntEater. I was unsure whether it would be useful to continue to develop my proposal (Myrmidon) so I emailed James Duncan Davidson (and someone else who I forget…) asking if he wanted me to table it. Fatefully, he suggested we go forward with and see how things developed. Unfortunately this lead to a lot of friction within the Ant community with little real benefit. Some time later Conor proposed another codebase for Ant2 named Mutant. In the end none of the proposals were adopted and all those who submitted proposals ended up leaving the Ant community.
So what prevented any of those proposals being adopted? I don’t think it was the personalities involved as when it came down to it I think everyone wanted to get to Ant2 and we were usually reasonable people. Nor do I think it was really about whether we chose to use a revolutionary or evolutionary path to get to Ant2. I think that the real problem was lack of a shared vision. I don’t think we all agreed about where we should be heading or even what each other was proposing.
My vision for Ant2 was for a fully componentized system where developers could take components from the Ant2 suite and integrate them into other applications. The regular Ant2 users would see no difference but someone could take the Ant2 task execution layer and integrate it into a cron-like system (this is something I did with the Myrmidon proposal). I also wanted to to develop the tasks as lightweight wrappers around java beans or non-Ant specific “services”. In this way an application developer who needed to parse CVS changelogs or get files from Subversion repository could just use the bean that the ant tasks wrapped. This was not a vision shared by the other developers and the Myrmidon proposal seemed too complex by those who did not share my vision or did not understand it.
The most successful FOSS projects I have seen have had a strong vision of where they wanted to go. This is helped when the project is an implementation of a standard such as HTTP servers or servlet containers. If an issue relating to the technical direction of the project arises, the developers can often look to the appropriate RFCs, JSRs or even at how alternative products are implemented. In some cases it is even possible to look at research done in universities and try to apply it to the problem at hand.
Ant did not have this luxury and thus a lot of our communication bandwidth was spent on discussions about where we wanted to go. There was no specification that we could use to short-cut discussions about potential features and nor was there any similar products that we could contrast and compare with. Many of the Ant developers were familiar or at least aware of Make, Jam and Cons but none of these tools were similar enough to what we are doing that direct comparisons could be made.
The Ant developers were scattered through different time zones from North Amercia, Europe to Australia, so communication through higher bandwidth mediums was not common. It may have been useful if we could have had a few big design sessions over IRC, VOIP, IM etc. but we never did. Our communication budget was spent on high-level discussions that proved to be little more than hot air.
If I had a time machine to go back in time to change things I think that there are lots of things that we could have done better. Personally I think I would have never touched the codebase as helping users was what got me involved in Ant and thats what I liked doing.
In terms of Ant2 I think we should have decided as a project whether we wanted to move in that direction and if so the timeline for for when we expected to make the change. This would give people more of an incentive to actually work on a proposal. If we had decided to move to Ant2 we should have started from a subset of the then current Ant trunk and aggressively refactor until we were happy. We could have maintained a shared task library between the two branches until we decided that Ant2 was ready for prime time. That may have been a more successful approach and ultimately more inclusive of the whole Ant community.
Anyhoo, I guess you live and learn.