By Josef Betancourt,  Created 12/27/09    Posted 28 Mar 2010

State of affairs

You’ll modify a gaggle of information to perform one thing.  For instance, you’re attempting to get a server or community operational once more after some safety necessities.   Throughout this course of you additionally have to maintain monitor of adjustments so that you could again out of useless ends or mix completely different approaches.  Otherwise you simply merely have to briefly maintain revisions of a gaggle of information for a process based mostly challenge.

Key phrases

Model Management, Revision Management (RCS), Configuration Administration (CM), Model Management System (VCS), Distributed Model Management System (DVCS), Mercurial, Git, Agile, Subversion

Light-weight Resolution

An light-weight Advert-Hoc Model Management (AHVC) strategy could also be fascinating.  Observe that even when there are different options in place, a light-weight strategy should be fascinating.  What are the necessities of a light-weight and workable answer?

  • Automated:  Via human error a file or setting might not get versioned and even misplaced.  Thus, all adjustments have to be tracked.
  • Small:  A big sprawling system that might not even match on a thumb drive is simply too massive.
  • Multiplatform:  It ought to be capable of run on the most important working methods.
  • Non-intrusive:   Use of this technique mustn’t change the goal methods in any method.  Ideally ought to run from a thumb drive or CD.  And, if there’s a change, backing it out ought to be foolproof.
  • Easy:  Something that requires coaching or complexity won’t be used or adopted.  This reduces collaborative adoption and enhancements in instruments and course of.
  • Quick:   Needs to be quick and optimized for native use.
  • Distributed:   Since points can span “boxes”, it ought to be capable of work with community assets.  This reduces the applicability of GUI based mostly answer.
  • Scripting:  Needs to be straightforward to optimize patterns of use by creating high-level scripts.
  • Small load:  In fact, we don’t wish to seize extreme CPU and reminiscence assets from the goal system.
  • Non-Admin:  Even in assist conditions, full admin entry might not be obtainable.
  • Transactional:  Particularly in server configuration, adjustments ought to be constant.  Failure to avoid wasting or revert even one file could possibly be disastrous.
  • Agile:  Not about instruments however outcomes.

DVCS

At residence after I create a folder to work on some information, like paperwork or programming tasks, I’ll normally create a model management system proper within the folder.  This has saved me just a few occasions.  I additionally tried to do that at a previous skilled task and was partially profitable (shall be mentioned later).

I used a Distributed Model Management System (DVCS).  Because it doesn’t require a centralized server or difficult setup to make use of, a DVCS meets many of the light-weight necessities.  Although, a VCS is normally used for collaborative administration of fixing supply information it could be very best right here.  One common use case is managing one’s /and so forth folder in Linux with a VCS.

Appears contradictory {that a} DVCS is nice for native advert hoc use. However, that’s only a false impression of the idea of a DVCS.

Mercurial

A great instance of a DVCS is:

Mercurial:

“(n) a fast, lightweight Source Control Management system designed for efficient handling of very large distributed projects.” – http://mercurial.selenic.com/

One other is Git
” Git is a free and open supply distributed model management system designed to deal with every thing from small to very giant tasks with velocity and effectivity.

Git is straightforward to be taught and has a tiny footprint with lightning quick efficiency. It outclasses SCM instruments like Subversion, CVS, Perforce, and ClearCase with options like low-cost native branching, handy staging areas, and a number of workflows. ”

Observe:  I take advantage of Mercurial because the instructed system just because I began with it.  Git and others are simply as relevant.

To create a repository in a folder, one merely executes three instructions init, add, and commit.  The “init” creates a subfolder that serves because the folder historical past or true repository.  The “add” is recursive, including all of the information to model management, and the “commit”, makes these adjustments everlasting.  In fact, one can ‘add’ a subset of information and create directives for information to skip and so forth.

Earlier than:

GIZMO
+—consumer
—server

In a command shell

cd GIZMO
hg init
hg add
hg commit -m “initial commit of project”

After:

GIZMO
+—.hg
+—consumer
—server

The terminology could also be a bit of complicated.  What occurred is that now the GIZMO folder has a Mercurial repository which consists of a brand new .hg folder, and the opposite present information and folders comprise the working listing (see Mercurial docs for a extra correct description).  There are not any different adjustments!

That’s all it takes to create a repository.  No puzzling about storage, distinctive names, hierarchy, and all the small print that goes with central servers.  The Mercurial docs present find out how to do the opposite required duties, like return to a earlier changeset or retrieve file variations and so forth.  Right here is find out how to view the record of information in a specific changeset:

c:Usersjbetancourt…ctsadhocVersioning>hg -v log -r 0

   changeset:   0:f29a0b0ad03c    person:        Josef Betancourt <josef.betancourt>l    date:        Sat Jun 21 10:53:11 2008 -0400    information:       AdhocVersioning.doc   description: first commit

And, here’s a log output utilizing the optionally available graph log extension (http://mercurial.selenic.com/wiki/GraphlogExtension)

c:Usersjbetancourt...adhocVersioning>hg glog -l 2
@  changeset:   9:25f4c55e4860
|  tag:         tip
|  person:        Josef <josef.betancourt>
|  date:        Fri Mar 26 22:43:56 2010 -0400
|  abstract:     eliminated repo.bat
|
o  changeset:   8:43a33533c992
|  person:        Josef <josef.betancourt>
|  date:        Thu Mar 25 22:08:35 2010 -0400
|  abstract:     eliminated outdated information
|

For the lone particular person utilizing advert hoc versioning a pattern workflow is give at Studying Mercurial in Workflows.

Advert Hoc Sharing

A DVCS, true to its identify, shines in the way it permits Distributed versioning sharing of those native repositories.  Thus, when a group is engaged on a technical subject (advert hoc) it is extremely straightforward to share every others work. Mercurial consists of an embedded internet server that can be utilized for this.

Mercurial’s hg serve command is splendidly suited to small, tight-knit, and fast-paced group environments.  It additionally gives an effective way to get a really feel for utilizing Mercurial instructions over a community.

That is illustrated with the espresso store situation, see handbook.

A dash or a hacking session in a espresso store are the proper locations to make use of the hg serve command, since hg serve doesn’t require any fancy server infrastructure … Then merely inform the individual subsequent to you that you just’re operating a server, ship the URL to them straight away message, and also you instantly have a quick-turnaround strategy to work collectively. They’ll kind your URL into their internet browser and shortly evaluate your adjustments; or they will pull a bugfix from you and confirm it; or they will clone a department containing a brand new function and take a look at it out.

In fact, this is able to not scale and is for “on-site” use between process centered group members.

See also  1. Finding Your Way Around Elements - Photoshop Elements 8 for Windows: The Missing Manual [Book]

An important workflow picture by Leon Bambridge for group sharing.

One other easy situation is taking just a few file paperwork from one location to a different with a flash drive (in lieu of utilizing a Cloud storage service). As an alternative of doing a replica or cp one can merely create a DVCS repository on the work listing, then clone it on the flash drive. Then at residence one pulls to the DVCS repository at residence. When completed enhancing the information, one then pushes to the flash repo, and does the reverse course of on the work website. Not solely are you not lacking any information, you’re additionally preserving monitor of prior variations. Observe, for safety causes, not everybody has unfettered internet entry or ought to they.

Revisiting the flash drive situation above; in case you plan to make use of a flash drive for transport a number of occasions and the group of information are giant, utilizing the “bundle/unbundle” hg instructions are a great instrument, see Speaking Modifications on the Mercurial website.

Safety
Each connection have to be safe and each file have to be encrypted, particularly if on flash drives. The safety insurance policies of the employer come first. Even when solely in your personal private ad-hoc use, you need to be cautious with exposing your information.

Benefits

  • Straightforward to make use of.The instructions wanted to carry out regular monitoring of adjustments are few and easy.  The conceptual mannequin can be easy, particularly if one will not be fixated on use of centralized Model Management System.
  • Some file adjustments could also be depending on or lead to different file adjustments.In a DVCS, commits or check-ins create a “changeset” within the native repository.  This naturally retains monitor of associated adjustments.
  • It’s possible you’ll have to work on completely different working methods.Mercurial runs on many methods together with Home windows.
  • You don’t wish to change the present system, low intrusion.  Mercurial could be deployed to a single folder, and the repositories it creates don’t pollute the goal folders.  For instance, within the Subversion VCS, “.svn” folders are created in every subfolder within the goal.  Not a disadvantage however complicates issues down the road, equivalent to when utilizing file utilities and filters.

Points

Sadly, using a DVCS will not be good and has its personal complexities.  For Mercurial, within the context of this publish, these are dealing with binary information, versioning non-nested folders, and possibly for any VCS is the semantic hole between the challenge process based mostly view and the versioning mindset.

1. Binary Information

Mercurial is absolutely for monitoring non-binary information.  That method the benefits of versioning are realized.  Diffs and merges usually are not usually utilized to Binary information. Additional the scale of binary information affect efficiency and storage once they attain a sure dimension.  But, for advert hoc use, binary information should be simply tracked.  Binary information could possibly be photographs, libraries, jars, zips, paperwork, or information.

Giant binaries are an issue with all VCS methods.  One writer mentioned a way to permit Git to deal with them in lieu of his continued use of Unison.  He mentioned use Git’s “–shared” possibility:  git clone –shared /mnt/fileserver/stuff.git stuff

Observe that Mercurial extensions exist to deal with binary information.  Certainly one of these is the BigFiles extension.  In essence, BigFiles and different related approaches, deal with giant binaries utilizing versioned references to the precise binaries that are saved elsewhere.

Replace Oct 29, 2011: Seems like Mercurial 2.0 may have a built-in extension for dealing with binary information, LargeFiles extension.

One other subject is that since binary information might not be diffed throughout the dvcs instrument set.  In a DVCS one can set an exterior merge agent.   If one will not be obtainable, utilizing the app that created the binary diff and merge is cumbersome.    For instance, a Phrase doc is binary (despite the fact that internally it could possibly be all XML) in impact.   Thus, a diff wouldn’t reveal a usable view.  One should ‘checkout’ explicit revisions after which use Phrase to do a diff or simply manually eyeballing it.  Similar factor with a zipper, jar, picture, and so forth.

Replace 02-02-2012: Some instruments permit direct use of exterior instruments to diff “binary” information. I feel TortoiseSVN does this, permitting Microsoft Phrase, for instance, to diff.

2. Non-nested goal folders.

A situation might contain the manipulation of folders that aren’t nested. For instance, a enterprise system employs two servers and adjustments have to be made to each for a sure service to work, additional, bodily transferring these folders or creating hyperlinks will not be doable or allowed. Mercurial, right now, works on a single folder tree, and AFAIK there isn’t a method to make use of symlinks or junctions to create a community folder graph, at the least with my testing.  The ForestExtension or subrepositories experimental function in Mercurial 1.3 don’t qualify since they solely allow the dealing with of a folder tree as a number of repositories.

Certain every folder tree within the graph could be managed, but when a specific change results information in every tree, there isn’t a straightforward strategy to transactionally model them into one changeset, although there are methods to share historical past between repositories (as within the ShareExtension).

A doable answer is to permit using oblique folders.  In Mercurial, work information and the precise repository, the .hg folder, are colocated.  As an alternative the repository can level to the goal folders (containing the work information) to be versioned.  On this method a number of non-nested folders could be managed.  Observe that this isn’t a retreat to the centralized VCS because the repository continues to be native and distributed utilizing DVCS operations.   Under, the person has created a brand new Mercurial repository in folder “project”.  This creates the precise repo subdirectory “.hg”, and the oblique precise folders to be versioned are pointed to in a “repos” directive file or utilizing precise symlinks.

challenge

.hg

repos ——> src_folder1

—–> src_folder2

—–> src_folderN

Whether or not that is helpful, doable, or already deliberate for is unknown.

I discussed this “limitation” on the Mercurial mailing record and was instructed that this isn’t a use case for a DVCS. There are lots of good the explanation why all (?) VCS are centered on the only folder tree.

Replace, 2011-08-31 T 11:37
Simply discovered that Git does have an fascinating functionality?

It is usually doable to have a working tree the place .git is a plain ASCII file containing gitdir: , i.e. the trail to the true git repository

Although this doesn’t fulfill the non-nested challenge folders situation, it does assist Git be extra relevant in an ad-hoc answer. For instance, the repo could possibly be situated in a unique storage location when the goal folder is in a constrained unit.

See also  How to add more character slots in your select screen of Mugen tutorial - M.U.G.E.N Elecbyte

3. Non-admin set up

Up to date 25 Aug 2010: Within the necessities, non-admin set up of the VCS was talked about. That is the place Mercurial fails, considerably. The default set up utilizing the binary, at the least on Home windows, requires admin privileges. I received round this by first putting in on one other Home windows system, then copying the set up goal folder to the PC I have to work on. This labored even after I put in on a Home windows 7 Professional, after which copied to a Home windows XP Professional. No issues but. The Fossil DVCS doesn’t have this drawback.

4. Ignore Information

That is, maybe, a minor subject. Mercurial, as most VCS do, permit one to filter the information which can be versioned within the repo.
In Mercurial one creates an .hgignore file and inside it, one can use glob or common expression syntax to specify the ignore information. Properly, this may be tough. See newsgroup dialogue that was began by this publish. IMHO, having one other syntax declaration that permits specification of directories and information explicitly is the best way to go. How do different methods do that? Ant patternsets appear to be fairly usable.

5. Semantic Hole

There’s a semantic hole when engaged on a upkeep drawback and switching to the versioning viewpoint.   When versioning methods are routinely used, as in Software program Improvement, this isn’t a difficulty, simply a part of the Software program Improvement Lifecycle or greatest follow (wonderful that some outlets don’t use model management).   However, when one makes use of VC solely sometimes as a final resort it’s one other story.  QA, Assist, and Challenge Managers, might not be comfy with repositories, branches, tags, labels, pull, push, and so forth.

Once I first tried to make use of Mercurial for Advert hoc service professionally it shortly misplaced a few of its benefits as the duty (fixing a system) reached panic ranges (normally the case with buyer assist and deployment schedules) and easily creating and taking a look at commit messages did not comply with the workflow.  Manually monitoring which tag or department associated to which occasion of system testing was cumbersome.  Additional use would have ultimately revealed the patterns of use that will have labored higher, however that was a onetime experiment.

A partial answer, different than simply getting extra skilled with the DVCS and higher work patterns, is to implement a better stage Area Particular Language (DSL) that hides the low stage DVCS command line and repository centric view.  This might also have a GUI counterpart.  This isn’t the identical as a GUI interface to the DVCS equivalent to TortoiseHg or the Eclipse HG plugin.  What ought to that DSL  be and is it even doable or helpful?

work circulate Updates

June 26, 2011: git-flow, is an instance of offering high-level operations to allow a selected work circulate or mannequin. Maybe such an strategy could be relevant on this AHVC necessities.

Sept 17, 2011: Mercurial Movement-Extension
implements the git-flow branching mannequin.

Alternate options

Naive Method

The same old strategy is to only make copies of the effected folder or information that you can be altering.  You need to use suffixes to tell apart them, equivalent to gizmo.1.conf.   It’s quite common to see (even in manufacturing!) information or folders with folks’s initials, gizmo.jb.19.conf.

This will get out of hand in a short time, particularly in case you are multitasking or working as a part of a group and should overlook after a great lunch what file “gizmo.24.conf” solved.   This drawback is compounded when you could change a number of information, so for instance, gizmo.jb.19.conf might depend upon adjustments to “widget.22.conf”.   This additionally will get very chaotic when the information to alter and monitor are in several folder bushes and even storage system.  Most significantly this won’t face up to the throw clay on the wall and see what sticks faculty of actual world upkeep.

One methodology I’ve seen and used myself is to only clone every folder tree to be modified.  This provides a simple strategy to again out any adjustments.  This, alas, can be error susceptible, useful resource intensive, and might not be doable on giant file units or very constrained methods.

Consumer-Server VCS

A Conventional client-server VCS like Subversion can, in fact, be used for Advert Hoc Versioning.   With Subversion one can run svnserve, its light-weight server, in daemon mode.  Then create a process based mostly repository:

svnadmin create /var/svn/adHoc

And, import your tree of information:

svn import c:UsersXXXDocumentsprojectsadhocVersioning file:///var/svn/adHoc/challenge

Plus, Subversion helps offline use.  I feel.  Haven’t used Subversion shortly.

One other efficient Subversion function is using native repositories utilizing the “file:// protocol”.

Administration consoles

Many methods are managed by varied types of administration consoles, graphical person interfaces.  These are consumer or internet based mostly and could also be a part of the system or a third-party answer.  This can be a massive benefit from a hands-on administrative standpoint.  Nevertheless, from an automation and scripting viewpoint this isn’t optimum.  Thus, there may be hopefully a API or instrument based mostly methodology of accessing the precise configuration information or databases of the system.  So on this sense, these methods are throughout the scope of this dialogue.

This isn’t at all times the case.  One utility server involves thoughts that was (is?) so advanced that there was no strategy to script it.  Thus, no strategy to automate the construct and launch course of and versioning of the system.  Consequently, there was additionally no strategy to automate the assorted QA assessments that had been at all times panic pushed and manually utilized.

Managed Method

The proper or extra tractable methodology is to make use of a managed strategy.  This can be a software program configuration and distribution system that’s normally beneath the management of the IT employees, for instance Microsoft’s System administration Server (SMS) or System Heart Necessities (SCE) for SMB.  Non-Microsoft options are in fact obtainable, equivalent to these from IBM Tivoli’s product lineup.

Why is that this not at all times one of the best strategy?  There could also be conditions the place a subset of a managed useful resource have to be modified.  For instance, you’re a area service engineer and should journey or remotely connect with a consumer’s system to deal with a service name.   This course of might also entail making adjustments to different hosted apps and system configurations, equivalent to community configurations.  Making an attempt to get the IT division to collaborate or change the configuration or schedule of the managed answer might not be doable or well timed.  In actual fact, this is able to be discouraged (rightly so) since it might probably wreak havoc on a manufacturing system.  Thus, even altering some useful resource might entail admin of a number of methods, not only a push of some information and run of some batch information.  It may require interactive set and take a look at.  Image the Mars Rovers and the way the OS reset drawback was lastly solved.

See also  [Top 10] Minecraft Most Cursed Seeds

Carefully associated to the managed strategy is to make use of a centralized model management system (VCS) or backup assist.  Fortuitously many working methods have versioning capabilities in-built or available.  For instance, within the Home windows platform one could make System Restore factors or use the supported backup subsystems (as present in Home windows 7 Skilled).  Many *nix’s even have built-in versioning assist within the type of installable Model Management Programs or differential backup.  In high-end virtualized methods there are services for backup or making snapshots and even transport of dwell methods.

Whereas these work, there’s a specific amount of complexity concerned. Additionally there are points utilizing the identical strategy on a number of working methods.  One other essential disadvantage is that one can’t at all times modify the goal system and, for instance, set up a VCS, even briefly.  The widespread think about these approaches is that there’s a central “server” and related repository for revision storage.  That is effective when obtainable however not very conducive to advert hoc use.

Versioning File System

A VFS could possibly be of some use.  So far as I do know there are not any common file methods that assist versioning (as used right here).  Digital Gear’s VAX system had single file versioning and now openVMS.  Microsoft’s Home windows was presupposed to have this sooner or later winfiles, however is not within the plan(?), although Home windows 7 and present servers can permit entry to earlier file variations as a function of its   system safety function.  Plan 9 has a snapshot function. ZFS has superior stuff too and I might not be stunned if one can set a folder to be ‘versioned’.

Nevertheless, a VFS wouldn’t assist in process based mostly versioning since as mentioned beforehand, there could also be a necessity to alter a number of subsystems and monitor these adjustments as “change sets”.  Thus, a VFS will not be a Revision Management System.

In fact, utilizing a scripted answer (mentioned subsequent) together with a file change notification system (inotify), one may cobble collectively a folder based mostly VCS.  Nevertheless, that is exterior of our light-weight necessities.

Scripted Resolution

In fact, it ought to be doable, particularly in *nix methods, to make use of the utilities obtainable and assemble a instrument chain for a light-weight versioning assist.  The wealthy scripting and glorious instruments like rsync make this doable.  Some languages equivalent to Perl or Python are perfect for gluing this collectively.

But, this isn’t optimum since these similar instruments won’t work on all working methods or require duplication.  For varied causes, for instance, it’s not at all times doable to put in cygwin on Home windows and make use of the wonderful *nix utilities and scripting strategy.  Likewise, it’s not doable to make use of the excellent Home windows PowerShell in Linux.  That is solely an issue in fact if we’re referring to empowering employees to work seamlessly on completely different OS or assets.  Having the identical instruments and workflow are precious.

One other factor about this different is {that a} customized answer will ultimately change into or have features of a model management system like Git, so why not simply begin with one?

Snapshot

One strategy doable by way of the aforementioned scripted answer is to create a snapshot system.  The DVCS offers us effective grained management of file revisions.  However, do we actually have to diff and discover out {that a} command in a single batch file used the ‘-R’ possibility or simply get the file with the specified possibility.  We might know which file we wish utilizing process based mostly snapshots.  Earlier than a process is begun, we provoke a snapshot.  That is analogous to the OS kind of restore factors, besides we do that for a selected goal set.

NoSQL Database

Lastly, there have been alternate options to the Relational Database Administration System (DBMS) for a few years.  Most not too long ago, that is the NoSQL group of tasks equivalent to CouchDB.    CouchDB claims that it’s: “Distributed, featuring robust, incremental replication with bi-directional conflict detection and management.”   These options sound like one thing an advert hoc model management system ought to have.  But, CouchDB, all?, are doc centric.  Nonetheless, value pondering.

Conclusion

Offered had been just a few ideas on an strategy to advert hoc versioning.  A DVCS was proposed as a light-weight answer and a few points had been talked about.  Alternate options had been checked out.  Extra analysis is required to guage proposal and decide greatest practices for the mentioned situations.

Updates

7/15/10:  Modified “maintain” to “accomplish” in State of affairs as per suggestions from Ok. Grover.

7/23/10:  Forgot that I visited Ben Tsai’s weblog the place he discusses utilizing Mercurial inside an present VCS equivalent to Subversion, which I’ve additionally completed, however not likely the subject I mentioned.

Additional Studying

“HgInit: Ground up Mercurial”, http://hginit.com/01.html

Organising for a Crew

“Easy Automated Snapshot-Style Backups with Linux and Rsync” http://www.mikerubel.org/computers/rsync_snapshots/

Utilizing Mercurial as ad-hoc native model management

“Intro to Distributed Version Control (Illustrated)”
http://betterexplained.com/articles/intro-to-distributed-version-control-illustrated/

Model Management, infrastructures.org
http://www.infrastructures.org/bootstrap/version.shtml

“The Risks of Distributed Version Control”,
http://blog.red-bean.com/sussman/?p=20

Subversion Re-education

“Subverting your homedir, or keeping your life in svn”
http://kitenet.net/~joey/svnhome/ (He now makes use of Git)http://microseeds.com/blog/?p=95

Dwelling listing model management notification
http://kristian-domagala.blogspot.com/2008/10/home-direcotry-version-control.html

“Managing your web site with Mercurial”, Tim Put up, http://echoreply.us/tuto/mercurial_site_management.html

SingleDeveloperMultipleComputers
http://mercurial.selenic.com/wiki/SingleDeveloperMultipleComputers

Mercurial by instance
http://www.jemander.se/MercurialByExample.pdf

Mercurial (hg) with Dropbox
http://www.dzone.com/links/r/mercurial_hg_with_dropbox.html

Mercurial for Git customers
http://mercurial.selenic.com/wiki/GitConcepts

Versioning File System
http://en.wikipedia.org/wiki/Versioning_file_system#Linux

Agile Operations within the Enterprise
Michael Nygard, http://www.infoq.com/articles/agile-operations

git-sync
http://code.google.com/p/git-sync/

git-flow
https://github.com/nvie/gitflow

Microsoft System Heart Necessities
http://www.microsoft.com/systemcenter/essentials/en/us/default.aspx

A utility that retains monitor of adjustments to the and so forth configuration folder:
http://kitenet.net/~joey/code/etckeeper/

Model Management for A number of Agile Groups
http://www.infoq.com/articles/agile-version-control#q22

DVCS
http://en.wikipedia.org/wiki/Distributed_Version_Control_System

DVCS vs Subversion smackdown, spherical 3

“Using Mercurial as ad-hoc local version control”; Tsai, Ben;
http://bentsai.wordpress.com/2008/05/30/using-mercurial-as-ad-hoc-local-version-control/#comment-24

Monitoring /and so forth and so forth

Subversion
http://subversion.apache.org/

For a extra detailed exposition, see the mecurial tutorial:
http://www.serpentine.com/mercurial/index.cgi?Tutorial

The Hg manpage is on the market at:  http://www.selenic.com/mercurial/hg.1.html

There’s additionally a really helpful FAQ that explains the terminology:
http://www.selenic.com/mercurial/FAQ.html

There’s additionally a great README:  http://www.selenic.com/mercurial/README

HG behind the scenes:
http://hgbook.red-bean.com/read/behind-the-scenes.html

Mercurial
http://en.wikipedia.org/wiki/Mercurial%28software%29

Mercurial Primary workflows
https://www.mercurial-scm.org/guide

Mercurial BigFiles Extension
http://mercurial.selenic.com/wiki/BigfilesExtension

Mercurial LargeFiles Extension
LargeFiles

Mercurial Subrepos: A previous instance revisited with a brand new method
http://playcontrol.net/ewing/jibberjabber/mercurial_subrepos_a_past_e.html

Mercurial(hg) Cheatsheet for Xen  http://xen.org/files/hg-cheatsheet.txt

A Information to Branching in Mercurial
http://stevelosh.com/blog/2009/08/a-guide-to-branching-in-mercurial/

Subrepositories
http://mercurial.selenic.com/wiki/subrepos

Nested Repositories
http://mercurial.selenic.com/wiki/NestedRepositories

hgdeps
http://ratatanek.cz/hg/hgdeps/file/ab2935095cb9/deps.py

Monitoring Third-party sources
http://www.selenic.com/pipermail/mercurial/2007-April/013002.html

TortoiseHg
http://tortoisehg.bitbucket.org/

Git
http://en.wikipedia.org/wiki/Git_%28software%29

Git as an alternative choice to unison
http://kitenet.net/~joey/blog/entry/gitless/

Leave a Reply

Your email address will not be published.