I found this article rather insightful -Ofun
I agree with most of it. Many software projects (commercial, oss, big & small) have strict guidelines with respect to write access to soure repositories and usage of these rights. As the author observes many of these restrictions find their roots in the limited ability of legacy revision control systems to roll back undesirable changes and to merge sets of coherent changes. And not in any inherent process advantages (like enforcing reviews, preventing malicious commits). Consequently, this practice restricts programmers in their creativity.
Inviting creative developers to commit on a source repository is a very desirable thing. It should be made as easy as possible for them to do their thing.
On more than one occasion I have spent some time looking at source code from some OSS project (to figure out what was going wrong in my own code). Very often my hands start to itch to make some trivial changes (refactor a bit, optimize a bit, add some functionality I need). In all of these cases I ended up not doing these changes because committing the change would have required a lengthy process involving:
- get on the mailing list
- figure out who to discuss the change with
- discuss the change to get permission to send the change to this person
- wait for the person to accept/reject the change
This can be a lengthy process and upfront you already feel guilty of contacting the person about this trivial change with your limited knowledge of the system. In short, the size of the project and its members scare off any interested developers except the ones determined to get their change in.
What I’d like to do is this:
- Checkout tomcat (I work with tomcat a lot, fill in your favorite OSS project)
- Make some change I think is worthwhile having without worrying about consequences, opinions of others, etc.
- Commit it with a clear message why I changed it.
- Leave it to the people who run the project to laugh away my ignorance or accept the change as they see fit.
The apache people don’t want the change, fine. Undo it, don’t merge, whatever. But don’t restrict peoples right to suggest changes/improvements in any kind of way. If you end up rejecting 50% of the commits that means you still got 50% useful stuff. The reviewing, merging workload can be distributed among people.
In my current job (for GX, the company that I am about to leave), I am the release manager. I am the guy in charge for the source repositories of the entire GX product line. I’d like to work like outlined above but we don’t. Non product developers in the company need to contact me by mail if they want to get their changes in. Some of them do, most of them don’t. I’m convinced that I’d get a lot of useful changes. We use subversion which is nice but not very suitable for the way of working outlined above and in the article I quoted. Apache also uses subversion so I can understand why they don’t want to give people like me commit rights just like that.
So why is this post labelled as software engineering science? Well I happen to believe that practice is ahead in some things over the academic community (of which I am also a part). Practicioners have a fine nose for tools and techniques that work really well. Academic software engineering researchers don’t for a variety of reasons:
- they don’t engineer that much software
- very few of them develop at all (I do, I’m an exception)
- they are not very familiar with the tools developers use
In the past two years in practice I have learned a number of things:
- version control is key to managing large software projects. Everything in a project revolves around putting stuff in and getting stuff out of the repository. If you didn’t commit it, it doesn’t exist. Committing it puts it on the radar of people who need to know about it.
- Using branches and tags is a sign the development process is getting more mature. It means you are separating development from maintenance activities.
- Doing branches and tags on the planned time and date is an even better sign: things are going according to some plan (i.e. this almost looks like engineering).
- Software design is something non software engineers (including managers and software engineering researchers) talk about, a lot. Software engineers are usually to busy to bother.
- Consequently, few software actually gets designed in the traditional sense of the word (create important looking sheets of paper with lots of models on them).
- Instead two or three developers get together for an afternoon and lock themselves up with a whiteboard and a requirements document to take the handful of important decisions that need to be taken.
- Sometimes these decisions get documented. This is called the architecture document
- Sometimes a customer/manager (same thing really) asks for pretty pictures. Only in those cases a design document is created.
- Very few new software gets build from scratch.
- The version repository is the annotated history of the software you are trying to evolve. If important information about design decisions is not part of the annotated history, it is lost forever.
- Very few software engineers bother annotating their commits properly.
- Despite the benefits, version control systems are very primitive systems. I expect much of the progress in development practice in the next few years to come from major improvements in version control systems and the way they integrate into other tools such as bug tracking systems and document management systems.
Some additional observations on OSS projects:
- Open source projects have three important tools: the mailinglist, the bug tracking system and the version control system (and to a lesser extent wikis). These tools are comparatively primitive to what is used in the commercial software industry.
- Few oss projects have explicit requirements and design phases.
- In fact all of the processes used in OSS projcets are about the use of the before mentioned tools.
- Indeed few oss projects have designs
- Instead oss projects evolve and build a reputation after an initial commit of a small group of people of some prototype.
- Most of the life cycle of an oss project consist of evolving it more or less ad hoc. Even if there is a roadmap, that usually only serves as a common frame of reference for developers rather than as a specification of things to implement.
I’m impressed by how well some OSS projects (mozilla, kde, linux) are run and think that the key to improving commercial projects is to adopt some of the better practices in these projects.
Many commercial software actually evolves in a very similar fashion despite manager types keeping up appearances by stimulating the creation of lengthy design and requirements documents, usually after the development has finished.