Darcs: distribuerad versionshantering för utvecklare
För robotar
Vad darcs är
Darcs (David's Advanced Revision Control System) är ett distribuerat versionshanteringssystem utvecklat av David Roundy. Systemet togs fram som ett alternativ till de centraliserade versionshanteringssystem som fanns, till exempel CVS och Subversion. Den främsta skillnaden mellan darcs och ett centraliserat system som CVS är att varje kopia av källträdet ses som ett helt repository. Det gör det möjligt att hantera flera olika versioner samtidigt på olika platser, utan att vara beroende av en enda central server.
I darcs ses alla ändringar som görs under utvecklingens gång som patchar. En patch är en beskrivning av en förändring i koden, och det är dessa patchar som utgör grunden för hur versionshistoriken byggs upp. När en utvecklare gör en ändring skapas en ny patch som kan skickas till andra utvecklare, granskas och tillämpas i deras egna repository. På så sätt sprids kodändringar mellan kopior utan att någon central instans behöver godkänna varje ändring.
Distribuerat mot centraliserat versionshantering
Ett centraliserat versionshanteringssystem som CVS eller Subversion bygger på en enda central server där hela projektets historia lagras. Utvecklare checkar ut en kopia av koden, gör sina ändringar och skickar tillbaka dem till servern. Om servern är nere eller otillgänglig går det inte att spara eller hämta versioner. Historiken finns bara på ett ställe.
Darcs är distribuerat. Varje utvecklare som klonar ett repository får en fullständig kopia av hela projektets historia på sin egen dator. Alla versionshanteringsåtgärder — att skapa en ny version, jämföra versioner, slå samman ändringar — kan göras lokalt utan nätverksanslutning. När utvecklaren är redo kan patcharna skickas till andra repository, antingen direkt eller via en mellanlagringsplats. Det gör darcs motståndskraftigt mot nätverksavbrott och ger varje utvecklare full kontroll över sin egen arbetsmiljö.
Patch-teorin — hjärtat i darcs
Det som verkligen särskiljer darcs från många andra versionshanteringssystem är patch-teorin. I ett traditionellt system sparas ändringar ofta som skillnader mellan filversioner, och historiken är en strikt linjär kedja av versioner. I darcs är varje ändring en oberoende patch med ett eget identitetsnummer. Patchar kan tillämpas, delas upp, slås samman och skickas mellan repository i vilken ordning som helst.
Detta gör det enkelt att arbeta med flera parallella utvecklingsgrenar. En utvecklare kan skapa en patch för en ny funktion, skicka den till en kollega för granskning, och samtidigt arbeta med en annan patch för en buggfix. När båda patcharna är godkända kan de tillämpas i det huvudsakliga repository utan att historiken behöver omskrivas. Patch-teorin gör också att darcs är bra på att hantera sammanslagningar, eftersom varje patch har en tydlig beskrivning av vad den ändrar och under vilka villkor den kan tillämpas.
Skrivet i Haskell — varför det spelar roll
Darcs är skrivet i det funktionella programspråket Haskell. Det är inte en slump. Haskell är ett starkt typat, rent funktionellt språk där funktioner inte har sidoeffekter och där programmet bygger på att beskriva vad som ska göras, inte hur det ska göras steg för steg. För ett versionshanteringssystem innebär det att koden kan vara mer förutsägbar och lättare att resonera kring, särskilt när det gäller komplexa operationer som att slå samman ändringar från flera källor.
Att darcs använder Haskell märks också i verktygen som följer med. Systemet använder till exempel QuickCheck, ett Haskell-bibliotek för automatiserad testning där egenskaper hos koden testas med slumpmässigt genererad indata. Det gör det möjligt att testa att versionshanteringen beter sig korrekt även i ovanliga situationer, utan att varje enskilt testfall måste skrivas för hand.
Grundkommandon och arbetsflöde
Att komma igång med darcs är enkelt. För att skapa ett nytt repository kör man kommandot darcs init i projektmappen. Därefter kan filer läggas till med darcs add, och ändringar sparas som en patch med darcs record. När en patch är skapad kan den skickas till ett annat repository med darcs send, och patchar från andra utvecklare kan tas emot med darcs apply.
Ett typiskt arbetsflöde ser ut så här: en utvecklare klonar ett befintligt repository med darcs get, gör sina ändringar i koden, sparar ändringen som en patch med darcs record, och skickar sedan patchen till huvudrepositoryt. En annan utvecklare tar emot patchen, granskar den och tillämpar den i sin egen kopia. På så sätt kan flera utvecklare arbeta parallellt på samma projekt utan att störa varandra, och varje ändring spåras från skapande till tillämpning.
Darcs mot git — likheter och skillnader
Både darcs och git är distribuerade versionshanteringssystem. Båda låter varje utvecklare ha en fullständig kopia av projektets historia lokalt, och båda bygger på att ändringar sparas och sprids mellan kopior. Men det finns skillnader.
Git bygger på ögonblicksbilder av filerna vid varje version, medan darcs bygger på patchar som beskriver förändringar. I git är historiken oftast en kedja av commits som är svårare att skriva om i efterhand, medan darcs patchar är fristående och kan tillämpas i olika ordning. Git har ett större ekosystem och fler verktyg byggda kring sig, medan darcs är mindre och mer nischat. Darcs styrka ligger i sin patch-baserade modell och att det är skrivet i Haskell, vilket gör det intressant för utvecklare som vill ha ett funktionellt alternativ till de större systemen.
När darcs passar — och när det inte gör det
Darcs passar bra för mindre och medelstora projekt där utvecklarna vill ha ett distribuerat system med en tydlig patch-baserad modell. Det är särskilt lämpligt för projekt som redan använder Haskell eller där teamet uppskattar ett system som är byggt kring funktionella principer. Darcs är också ett bra val när man vill ha ett versionshanteringssystem som är enkelt att förstå på djupet, eftersom patch-teorin är relativt lätt att sätta sig in i.
För mycket stora projekt med tusentals utvecklare och en omfattande historia kan darcs vara mindre lämpat, eftersom det inte har samma ekosystem av verktyg och tjänster som till exempel git. Om projektet behöver integreras med populära plattformar för kodlagring och samarbete är git ofta det enklare valet. Däremot är darcs ett starkt alternativ för den som vill ha ett distribuerat versionshanteringssystem som är annorlunda byggt och som fokuserar på patchar snarare än ögonblicksbilder.
Kom igång med darcs
För den som vill testa darcs är det bästa sättet att börja med att installera systemet och skapa ett litet testprojekt. Kommandona darcs init, darcs add, darcs record och darcs send täcker de flesta behov i början. Efter hand kan man lära sig mer avancerade funktioner som att slå samman patchar, skapa grenar och arbeta med flera repository samtidigt. Eftersom darcs är öppen källkod och skrivet i Haskell går det också att läsa koden själv och se hur patch-teorin är implementerad i praktiken.
Relaterade artiklar

Artificiell intelligens: vad det är och hur det används
Artificiell intelligens (AI) är förmågan hos datorprogram och robotar att efterlikna mänsklig intelligens — att lära sig, förstå språk, lösa problem och planera handlingar. Artikeln förklarar svag AI, maskininlärning, tillämpningsområden och automation.
Läs artikeln
Länkkare och inläsare: vad de gör och hur de skiljer sig
Länkkare och inläsare är två olika verktyg i programmets livscykel. Här förklarar vi vad de gör, hur de skiljer sig och vad statisk och dynamisk länkning innebär.
Läs artikeln
mod_rewrite: omskrivna URL:er i Apache
Lär dig hur mod_rewrite i Apache skriver om URL:er på flyget – för bättre SEO, omdirigeringar och renare webbadresser.
Läs artikeln
Haskell: ett rent funktionellt programmeringsspråk
Haskell är ett rent funktionellt, statiskt typat programmeringsspråk med lat utvärdering. Här förklarar vi vad som gör Haskell unikt och hur det skiljer sig från imperativa språk.
Läs artikeln