Guide Trac -an enhanced wiki and issue tracking system & history

Status
Not open for further replies.
Hi all,
First of all being a non-developer you might as well as ask me what I'm doing here discussing about something like that. But as a user I'm always interested to see when the next release with enhancements, bug-fixes are coming in. We all do (I assume ;) ). With the proliferation of net-based projects it becomes much more critical to be able to checkin & checkout releases, make changes & put it back in repository or project.

Before delving into Trac it would be better to look a little back on the history of Revision versioning systems.

Revision Control System

The first one was Revision Control System more commonly known as RCS developed in the late 1980's by Walter Fische while studying in Purdue University still maintained by Purdue University while being packaged by GNU

Official RCS Homepage

RCS - GNU Project - Free Software Foundation (FSF)
Now RCS had it own advantages and disadvantages :-

Advantages :-

  • In single-user scenarios, such as server configuration files or automation scripts, it may still be the preferred revision control tool as it's simple and no daemon needs to run for it to work.
e.g. For the reason above many wiki engines, including TWiki, use RCS for storing page revisions.

Disadvantages :-

  • Because it operates only on single files, has no way of working with an entire project, nor does it allow multiple users to work on a file simultaneously.

License :- GPL

Method of access :- command line program
Concurrent Revision Systems

Concurrent Revision Systems or CVS as its popularly known was developed by a Dutch software scientist named Dick Grune in the late 1980's.

CVS has the following features :-

  • It keeps track of all work and all changes in a set of files, typically the implementation of a software project, and allows several (potentially widely-separated) developers to collaborate. CVS has become popular in the open source software world and is released under the GNU General Public License.
  • CVS uses client-server architecture: a server stores the current version(s) of the project and its history, and clients connect to the server in order to check out a complete copy of the project, work on this copy and then later check in their changes.
  • Typically, client and server connect over a LAN or over the Internet, but client and server may both run on the same machine if CVS has the task of keeping track of the version history of a project with only local developers.
  • Several developers may work on the same project concurrently, each one editing files within their own working copy of the project, and sending (or checking in) their modifications to the server. To avoid the possibility of people stepping on each other's toes, the server will only accept changes made to the most recent version of a file. Developers are therefore expected to keep their working copy up-to-date by incorporating other people's changes on a regular basis. This task is mostly handled automatically by the CVS client, requiring manual intervention only when a conflict arises between a checked-in modification and the yet-unchecked local version of a file . This procedure is also known as atomicity .
  • Clients can also use the "update" command in order to bring their local copies up-to-date with the newest version on the server. This eliminates the need for repeated downloading of the whole project.
  • CVS can also maintain different "branches" of a project. For instance, a released version of the software project may form one branch, used for bug fixes, while a version under current development, with major changes and new features, forms a separate branch.
  • CVS uses delta compression for efficient storage of different versions of the same file. The implementation favors files with many lines (usually text files) - in extreme cases individual copies of each version are stored rather than a delta.

This was actually the big jump. Now while it isn't told anywhere why the jump happened from RCS to CVS with hindsight I guess it might be due to Mr. Dick Grune doing some large software project with some friends. Another reason which might have contributed perhaps would have been that University Campuses became large in the late 80s in most of the western Universities in terms of space as well. Also people do like to do things in their own way in their time (a human feature, weakness ? ;) ) so collaborating might have become an issue.

Projects/sites using CVS

  • Sourceforge.net (One of the bigger open source projects repository)
  • savannah.gnu.org (A repository for free software projects)
There is a philosophical difference between the two repostiories.

License: GPL

Method of access :- CLI, GUI front-ends as well as Web-based clients.

screenshot1.png


TortoiseCVS: About

SourceForge.net Repository - [pyopengl] Index of /
Subversion

Subversion is designed specifically to be a modern replacement for CVS. It used what was in CVS & improved on it. Subversion was created by CollabNet, who still maintain the project.

Features of Subversion :-

  • Commits are truly atomic operations. Interrupted commit operations do not cause repository inconsistency or corruption.
  • Renamed/copied/moved/removed files retain full revision history.
  • Directories, renames, and file metadata are versioned. Entire directory trees can be moved around and/or copied very quickly, and retain full revision history.
  • Versioning of symbolic links.
  • Native support for binary files, with space-efficient binary-diff storage.
  • Apache HTTP server as network server, WebDAV/DeltaV for protocol. There is also an independent server process that uses a custom protocol over TCP/IP.
  • Branching and tagging are cheap (constant time) operations.
  • Natively client/server, layered library design.
  • Client/server protocol sends diffs in both directions.
  • Costs are proportional to change size, not data size.
  • Parsable output, including XML log output.
  • Internationalised program messages.
  • File locking for unmergeable files ("reserved checkouts").
  • Path-based authorization for svnserve.
  • Python, Ruby, Perl, and Java language bindings.
  • Full MIME support - the MIME Type of each file can be viewed or changed, with the software knowing which MIME types can have their differences from previous versions shown.

Projects using Subversion :-

  • Sourceforge.net
  • Google Code
  • sarovar.org (Indian free software hosting service)

License :- Open Source licensed — "CollabNet/Tigris.org Apache-style license" called Subversion License

Method of Access :- CLI program , GUI front-ends as well as web-based clients. There are multiple GUI front-ends & web-based clients so will just take 1 each.


CVSTrac

CVSTrac is best descibed as a Web-Based Bug And Patch-Set Tracking System For CVS, Subversion and GIT . Simply speaking its a kind of extension
to both the Versioning Systems described above.

Features :-

  • Automatically generates a patch-set log from check-in comments
  • User-defined color-coded database queries
  • Web-based administration of the CVSROOT/passwd file
  • Built-in repository browser
  • Built-in Wiki
  • Very simple setup - a self-contained executable runs as CGI, from inetd, or as a stand-alone web server
  • Minimal memory, disk and CPU requirements - works on old hardware
  • Access permissions configurable separately for each user
  • Allows for anonymous users
  • Uses a built-in SQL database engine (SQLite) - no external RDBMS required
  • Tested under Linux - works on other versions of Unix. Also works under Windows
  • Can be run from a chroot jail for added security.

License :- GPL

As its web-based hence using the URLs only as the layout is pretty simple.

cvstrac: Directory /
cvstrac: Available Report Formats
cvstrac: Timeline

GIT

Git is a distributed revision control / software configuration management project created by Linus Torvalds to manage software development of the Linux kernel.

Features :-

  • Strong support for non-linear development. Git supports rapid and convenient branching and merging, and includes powerful tools for visualizing and navigating a non-linear development history. A core assumption in Git is that a change will be merged more often than it is written, as it is passed around various reviewers. Torvalds himself does the most merging and least direct editing, so he has made sure that it works well.
  • Distributed development. Like Darcs, BitKeeper, Mercurial, SVK and Monotone, Git gives each developer a local copy of the entire development history, and changes are copied from one such repository to another. These changes are imported as additional development branches, and can be merged in the same way as a locally developed branch.
  • Repositories can be easily published via HTTP, FTP, ssh, rsync, or a special git protocol. Git also has a CVS server emulation, which allows one to use existing CVS clients and IDE integrations to access Git repositories.
  • Efficient handling of large projects. Git is very fast, and scales well. It is commonly an order of magnitude faster than other revision control systems, and several orders of magnitude faster on some operations.[7]
  • Cryptographic authentication of history. The Git history is stored in such a way that the name of a particular revision (a "commit" in Git terms) depends upon the complete development history leading up to that commit. Once it is published, it is not possible to change the old versions without it being noticed. (Monotone also has this property.)
  • Toolkit design. Following the Unix tradition, Git is a set of primitive programs written in C, and a large number of shell scripts that provide convenient wrappers. It is easy to chain the components together to do other clever things.
  • Pluggable merge strategies. As part of its toolkit design, git has a well-defined model of an incomplete merge, and it has multiple algorithms for completing it, culminating in telling the user that it is unable to complete the merge automatically and manual editing is required. It is thus easy to experiment with new merge algorithms.
  • Garbage accumulates unless collected. Aborting operations or backing out changes will leave useless dangling objects in the database. These are generally a small fraction of the continuously growing history of wanted objects, but reclaiming the space using git-gc --prune can be slow

A tutorial introduction to git (for version 1.5.1 or newer)

Usage :- Git users include the Linux kernel, Cairo, ELinks, GNU Core Utilities, GNU LilyPond, Mesa 3D, Wine, most X.org projects, XMMS2, Beryl and One Laptop Per Child.

[BREAK=Trac : Introduction , Screenshots & Conclusion]

Trac

The newest kid on the block . Trac is an open source, minimalist, web-based project management and bug-tracking tool, inspired by CVSTrac .

Trac allows hyperlinking information between a computer bug database, revision control and wiki content. It also serves as a sophisticated web interface to the Subversion version control system.

Some sexy screenies of the same ;)


  • Roadmap of the project, major milestones showed.


  • Latest revisions or check-ins in sub-projects of a big software project.


  • Revision Logs :- Logs of the latest check-ins showing author & the log message or sign off.


  • Changeset :- View of code changes between 2 check-ins , what was added/deleted in the latest revision or check-in .


  • Reports :- Nothing much to write about at the moment but most probably would be having visualization tools as the project moves along.
  • Timeline :- One can also look at Timeline which shows all the changes, including the wiki & any updates to the repository.

License :- Modified BSD License

Special Note :- Nasa JPL uses it

Conclusion :- While its just a baby I do love it even though I'm not a non-developer. Great way to checkout what's been happening with your favorite projects . Both the developers as well as users have a very good idea as to how far the project is going.

In fact the inspiration for this article goes to seeing the boinc roadmap & seeing how cool it really is .

Roadmap - BOINC - Trac

Xiph- the Ogg vorbis people

There is also a great Demo site so as an admin you can try out the latest release ;)

God Like - Trac 0.10.4 as of writing this.

And lastly a comparision of free software hosting facilities Comparison of free software hosting facilities - Wikipedia, the free encyclopedia

Adios for now. Comments, suggestions, Additions & flames all are welcome :)
 
  • Like
Reactions: 5 people
I couldn't read this at a better time! I had just resolved to learn using a revision versioning system - tried, and failed to use Quanta with CVS for some very elementary web projects :( Now - a. I understand this better, and b. I get the recommendation that I was just going to ask for (the which-version-control-system-is-good-for-me question).

w00t, thank you for a very well written article. :hap2: That's a lot you understand and know, for a "non-developer", by the way - you would pass off as being a being from the darker sides any day! :cool2:
 
Status
Not open for further replies.