From: deadlyhead on
Since I trust the Ada community by and large when it comes to
questions of robustness and cleanliness of code, it seems fitting that
I might cast about for opinions on choosing a version control system.

My personal preference in the past has been GNU Arch. While its
interface was a bit cumbersome, I felt it was powerful, well-built and
ahead of its time. Unfortunately its long been a dormant project,
ever since Bzr forked from it and mutated, pulling the small community
that was forming around it away. Tom Lord's intended successor, revc,
stalled as well due to other circumstances, and finding copies of that
code base is like playing Hunt the Wumpus.

Now, if going the distributed version control route (which is what I'm
going for), it seems that, these days, there are basically four
choices:
Git
Bazaar
Mercurial
Monotone

People/projects seem to like these for different reasons, but so far I
haven't gotten excited by any of them.

Git seems like it's pretty fast for source files (though chokes on
binaries?), and robust enough to handle huge projects like the Linux
kernel. But it seems not so much developed/designed as hacked
together, a hodge-podge of Linus Torvalds' special brand of C+Perl
(which just makes me shudder.)

Mercurial and Bazaar, as far as I can tell, are two implementations of
the same thing. Both are written in Python (sigh...), they have very
similar command sets, and they're very tied to the "branch" view of
version control. The scales tip in Mercurial's favor, though, as it
has decent support for pushing over SSH, and it seems, action-for-
action, to be a bit faster than Bazaar. (I could be completely wrong
about this. I haven't looked into this for some time.)

Monotone has been said to be implemented in a very "Ada-like way" by
somebody-or-other who was attempting to build an Ada OS (I think
called AdaOS. Stillborn last I heard.) I've been poking around and I
don't see it. It is written in C++ and uses the Boost library, both
of which I get a bit squirmy thinking about. I have a special
distaste for C++, and have never had any success with Boost (though I
never tried very hard to use it.)

Perhaps somebody here can give me a reason to prefer any of these, or
better yet, have a completely different suggestion. (Is there one
written in Ada? I'm there!) The amount of _biased_ information
available is overwhelming, and I'm having some trouble seeing the
forest for the yelling trees.

Disclosure: I know about darcs, and how it has its roots as attempting
to implement a new patching model on top of Arch. I like a lot of its
concepts, but when it comes down to it, I don't like it enough to
force Haskell into my development flow. I think Haskell is very
interesting and I can appreciate what it brings to functional
programming, but deep down I hack in Scheme when I'm not developing in
Ada, and just don't feel like going that route.
From: Dmitry A. Kazakov on
On Wed, 28 Jul 2010 16:18:00 -0700 (PDT), deadlyhead wrote:

> Perhaps somebody here can give me a reason to prefer any of these, or
> better yet, have a completely different suggestion. (Is there one
> written in Ada? I'm there!) The amount of _biased_ information
> available is overwhelming, and I'm having some trouble seeing the
> forest for the yelling trees.

I don't have a preferred VCS, I have ones I dislike (Perforce, MKS,
Subversion). It would be nice to have one in Ada, but more i important to
me are the features:

1. Projects support (no individual files/directories checking in/out)
2. Project dependencies support
3. Project views e.g. integrator's view (dll, exe), user's view (ads, ali,
lib), developer's view (everything) etc
4. Virtual file system (no visible local copies on the clients)
5. Automatic build-test-package support
6. No merging, no way to uncheck anything twice

--
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de
From: Ludovic Brenta on
deadlyhead <deadlyhead(a)gmail.com> writes:
> Monotone has been said to be implemented in a very "Ada-like way" by
> somebody-or-other who was attempting to build an Ada OS (I think
> called AdaOS. Stillborn last I heard.) I've been poking around and I
> don't see it. It is written in C++ and uses the Boost library, both
> of which I get a bit squirmy thinking about. I have a special
> distaste for C++, and have never had any success with Boost (though I
> never tried very hard to use it.)

That was me, actually. I explained the reasons why I prefer Monotone in
the trhead starting at [1], which included an interesting discussion
thereafter.

[1] http://groups.google.com/group/comp.lang.ada/msg/bf2f9970828367bd

Now, several people have started using Monotone to collaborate over
Debian packaging and other things like AdaOS.

--
Ludovic Brenta.
From: Stephen Leake on
deadlyhead <deadlyhead(a)gmail.com> writes:

> Now, if going the distributed version control route (which is what I'm
> going for), it seems that, these days, there are basically four
> choices:
> Git
> Bazaar
> Mercurial
> Monotone
>

I have experience with Bazaar and Monotone. I have contributed new
features to Monotone (writing C++ code), but only use Bazaar as a user.

> Mercurial and Bazaar, as far as I can tell, are two implementations of
> the same thing. Both are written in Python (sigh...), they have very
> similar command sets, and they're very tied to the "branch" view of
> version control. The scales tip in Mercurial's favor, though, as it
> has decent support for pushing over SSH, and it seems, action-for-
> action, to be a bit faster than Bazaar. (I could be completely wrong
> about this. I haven't looked into this for some time.)
>
> Monotone has been said to be implemented in a very "Ada-like way" by
> somebody-or-other who was attempting to build an Ada OS (I think
> called AdaOS. Stillborn last I heard.) I've been poking around and I
> don't see it. It is written in C++ and uses the Boost library, both
> of which I get a bit squirmy thinking about. I have a special
> distaste for C++, and have never had any success with Boost (though I
> never tried very hard to use it.)

It uses a small subset of Boost, in a fairly structured way.

It uses C macros in a creative but well designed way, providing features
that would actually be difficult in Ada.

I do wish Monotone was written in Ada, but it's simply too late for
that.

I haven't done much Python, but I get the feeling C++ is at least better
for Real Programming than Python!

The best feature of Monotone is the test set that is in the source code.
It is very thorough, and the developers keep it up to date. So you can
trust the code.

It is Ada-like in that it is very well thought-out (there is not a
formal monotone ARG, but it feels like there is). Features are
orthogonal, and do what users need. As one poster on the monotone
mailing list said, the developers are more paranoid about data loss than
the typical user is :).

Monotone keeps the local repository in a single database on your
local disk. Bazaar keeps a full copy of the repository in each
workspace; very cumbersome.

Monotone easily handles multiple heads on a branch, caused by developers
committing work in parallel. It has a very structured way to walk the
user thru resolving the conflicts that result.

Monotone has a structured 'automation' interface, giving front ends
structured text to parse rather than trying to parse the typical user
interface of other DVCs.

There is an Emacs front-end named DVC that provides a common interface
to all four of the DVCs listed above. I maintain the monotone front-end;
it is extended beyond the others to more fully support the operations of
monotone.

The monotone command-line user interface can be extended via Lua
scripts; Lua is a very nice small extension language.

--
-- Stephe
From: Thomas Løcke on
On 2010-07-29 01:18, deadlyhead wrote:
> Since I trust the Ada community by and large when it comes to
> questions of robustness and cleanliness of code, it seems fitting that
> I might cast about for opinions on choosing a version control system.


I use Git for the following reasons:

1. _Very_ easy to get up and running. Setting up a Git server is about
as easy as it gets:

git daemon --base-path=/some/where --user=git --detach

2. The documentation is superb (IMHO): http://git-scm.com/documentation

3. Branches are very cheap.

4. It is fast.

5. I feel I can trust it with my precious code. :o)

The other systems you mention might be both as easy, trustworthy and
fast, but it's been a couple years since I tried any of them, so I
wouldn't know it.

Actually this page describes my reasons pretty well:

http://whygitisbetterthanx.com/

Yea, the URL is a bit offensive/flame-baity, but the arguments are valid
enough.

--
Regards,
Thomas L�cke

Email: tl at ada-dk.org
Web: http:ada-dk.org
IRC nick: ThomasLocke