a while ago I did a video on get and why

I thought get needed to get good as I

put it and wound up talking about fossil

which is normally my go-to source

control manager or revision control

system version control system or

whatever you use to refer to these

things I got a request to talk about

fossil and this was something I actually

had planned to do I have been busy and

had some other things I wanted to do but

I'm more or less prepared to do this now

[Music]

you

I'm not going to get a hardcore into

details

mostly because Richard hip already has

an absolutely great presentation on some

issues with get and why fossil has a

better approach in his opinion he's the

author of fossil so you know obvious

biases but inevitably when you are the

author of a product you designed it a

certain way because you had needs for it

to be that certain way

we'll start off with installing it if

you're on Linux or BSD or anything like

that the installation procedures fairly

straightforward use your package manager

it's going to be called fossil end of

story on Windows if you are running a

recent enough version of Windows you

will be able to use find package and

fossil

or it'll say from the chocolatey source

there is a fossil package available if

you are not on a recent enough version

of Windows and the fine package and

other package management commandlets are

not present you can install chocolaty

directly although you can also just go

to the fossil web page and download the

binary there the only thing you have to

be aware of with Windows is by default

the search path is a little not what

commandline junkies typically expect but

it's it's not particularly hard to have

it set up now in my case I have it set

up so that the anything that chocolatey

and others it wind up installing gets

automatically put in there so what I can

do is install package and fossil because

there's only one provider I don't need

the specifier for brighter and then I

can just go ahead and get this installed

and now should be good to go granted

with a very odd-looking command name but

because you can tell it gets a bit

confused but you know it still runs

exactly the same on say like Linux that

would look a lot cleaner

fossil

something a little bit different from

many other version control systems

especially distributed version control

systems that sort of confuses some

people fossil is almost like a hybrid of

the centralized version control and

decentralized version control

and it follows this in a lot of ways

one thing you'll need to keep in mind

much like with centralized version

control is that the repository is

separate from your working directory

so no the creator and the actual

repository first now I'm going to move

over to a different Drive which

apparently

yes it does why are you white why that

habit is signed to a difficult it's

different

now

oh yeah I have a issue to resolve

involving this connection not being made

initially so I was trying to connect

when I was trying to move to the drive

when the connection hasn't been made yet

it used to auto mount it and then after

an update that stopped and I just

haven't tracked down the error because

of not that big of a deal but I

obviously need to get around to doing

that so I actually want to create the

the repository itself over here and this

is done through fossil I did I think

just Newell work

I mean using get so much recently and

much as I hate yet

you

using it for all the stuff that I hope

people will contribute to is caused me

to forget some of the fossil commands

but I think it's just in it so I have

the actual repository name and what this

is actually it should be unsurprising if

you recognize who Richard hip is is

actually a sequel light database

is it just a single file is the

repository and it's obviously set up a

special way but it's just a sequel late

database I know you can name this

anything the extension doesn't matter

and in my case I'm just going to create

a repository for the spin objects I

haven't really done anything with them

so but I have a I have a test file in

that for the EBS code extension I was

developing so we can check that in there

and it should work fine

you

should not take this long

you

no I'll go yeah look like it went

through okay okay

so one of the first things you're going

to want to do of course is configure it

and this is one of the actually really

big selling points except it's free

behind fossil

you

you

you

I don't have to do anything

there's already a

websites with branches and tags and even

a ticketing system a wiki system and

configuration is done through here

assuming that it doesn't

okay we're good we're good

one of the things I'm going to do is

that's an interesting rendering err

you

I would not recommend doing this in the

majority of cases but since I am the

only developer and I don't want to mess

around with

other things and just giving myself full

permissions

in a team setting like if anybody else

winds up contributing to this which is

unlikely because the spin objects thing

is not actually going to be public then

I would scale back my own permissions

and you know assign them just the

permissions they need and and similar

but it's a very convenient way of

managing this kind of stuff and of

course contact info I'm not going to

bother with that and a password I will

deal with this later

one of the other admin tasks I strongly

recommend doing at the beginning I

believe it's here

yes but the actual project name which of

course you do not want a named fossil

project

now we'll just leave it as that it's not

really that important it's an internal

project so it's not like this would be

something that search engines would

really scan because it's internal

and that should go through Ida not

entirely sure why it doesn't go through

the very first time when you had applied

but did as you can see did did actually

go through one setting I strongly

recommend doing if you are intermixing

operating systems

is the carriage return newline glob

let's just just do that

if you're only if you're in a controlled

environment where you can guarantee that

the only checkouts and the only place

you get commits from and all the editor

settings and everything follows a

specific convention then you don't

really need to worry about that but if

you're very intermixed just just that's

going to help out a lot

other than that

this is good for now you know obviously

fill it out more as time goes on but

that's basically it

anything you want to add to the wiki did

all that stuff just do whatever you feel

like

and we can go ahead and stop that and

yes but as you notice this this isn't

really anything you can work with so

again much like with a centralized

version control which you actually need

to do is check out from this repository

now true to decentralized systems you

can actually have tons of these

repositories exist on the same machine

on different machines in

they can all you know push to each other

pull from each other all of the things

that you would expect to see with

decentralized our district yet

decentralized version control are

present they're just

you can reasonably operate fossil like a

version control as well which actually

has quite a bit of uses especially when

you have say like a team of developers

on one machine or one one server that

hosts the repository they can all have

their working directories and then just

commit to the same repository then push

out from the business on to say get well

that's not going to be github but that

that same idea they can push out to

chisel app or wherever else or in the

case of say multiple teams within an

organization they can each team can have

their own repository on their system and

then you know push and pull throughout

the entire organization as opposed to

with say get where the repository and

the working directory are the same thing

you're left with say III I've seen

somebody complain once that they had 32

different instances of the same

repository on the machine just because

they needed four but the entire team 32

different checkouts

it's a little crazy

especially trying to synchronize the

changes between all of them

so what we can do for this I'm just

going to move back over to the desktop

and we can go into the existing

directory and then it should just be

fossil open and spin optics

and then we're open

this directory just became the working

directory for this repository and I can

show that through I think its fossil

status

yes so we have a National empty check-in

now one of the things I commented on

really liking about fossil and just

finding absolutely obnoxious about git

is the way changes to existing files are

done in fossil when we want to add a

file it can be done through a simple ad

and then I can just go ahead and add the

the test object now when I want to

commit that I can go ahead and commit

and give it a message by default if you

just fossil commit it'll bring up the

system default text editor I don't want

to configure this on Windows so I'm just

passing it the the messages through the

zoo the command line which is fine

because both the command prompt and

PowerShell have what's the term for them

the command line editors anyways so

we're not talking about the really old

days where you just did in once and you

could you know move through and edit the

message

and of course because that's what it is

now even though we're in the working

directory and not on the repository

because the working directory knows what

repository it came from we can still do

this

the only difference is because we're in

the working directory it opens from the

time line because that's usually the

most interesting thing when you're

working on things so

there was nothing for me to configure

here I didn't eat need to set up a

webserver I didn't need to set up some

third-party component to display this

stuff I have a

visual representation of the timeline

you

but this doesn't really show off what I

was talking about just yet because the

file there already a you know adding

this the first time is basically the

same way as it's done in and get just

called code so Bo we open up vs code and

edit the file

nothing in here at all yet so let's just

go through and

so we've got the changes saved with get

what you would need to do is add it add

what's called staging you staged the

changes and then when you go to commit

the changes it actually commits them

with fossil it just immediately

recognized that has changed because the

file already exists in the repository it

goes through and checks like is this one

the same do I need to do anything with

it and just since it's changed

automatically knows that those changes

should be committed now this is the

default behavior it is still possible to

do staging like with git with fossil

it's just that the default behavior is

what at least hip believes is the more

common case and at least with the way I

develop this approach is definitely my

common case very rarely do I want to

only commit part of what I've actually

changed

we can go through and

now remember I didn't actually add this

back or anything so if I were to just

commit that like with yet it would not

have actually committed the changes made

you

if we gold view be

file for this specific check-in you can

see that it actually did

automatically

check this commit this

this is absolutely the single biggest

reason why I prefer fossil over yet and

over most version controls

it might just be a way I do development

but overwhelmingly I

check the the changes I make I want to

check them in all at once

I don't work on things unrelated to what

I am

checking in

that makes sense III don't ever wind up

having a need

shouldn't say that I rarely wind up ever

having a need to do partial check-ins

I've done them twice or a lot of commits

easily you know easily 600 plus commits

I've done them twice

so to have something like this where the

only time you were ever adding a file is

when it's truly a new file is just a

major help because I never wind up with

situations in fossil where I forgot to

stage part of my commit and then have to

make a committee meeting after going oh

yeah I forgot to add these things here

they are

now the UI the the automatic web

interface and that the fact that you can

actually very easily couple this into an

existing website using

CGI just absolutely huge reasons why I

prefer fossil along with like I had

mentioned the fact that the repository

in the working directory are separate so

in team scenarios you can have the team

share one repository and have several

working directories from it and then you

know all the deep decentralized

interactions that you need to can be

done based on the different repositories

for the different teams instead of a

repository for every single developer

you can get this thing kind of set up

with get although fossil has another

concept that makes it quite easier to

work with called auto-sync where if it's

enabled and

gotta remember where it was

auto-sync yep auto-sync is on

if I were to check out from the

repository I had set up and so like on

another machine create a check out based

on this repository we just set up here

if auto sync is on what happens when you

commit to it is it's also automatically

syncs with the repository that it was

cloned from I'm in cloned not checked

out checks out sorry for working

directories I'm in cloned but it'll auto

sync between the clones which is

extremely useful behavior in in the

typical way that at least I'm seeing

things are done

I would absolutely love something like

this to exist forget because I've seen

in all too often when I migrated my

stuff over to get I will commit changes

and totally forget to push them to get

hub and so I can rack up change sets to

3 I've seen six before

why they're not showing up on github I

have to realize that oh yeah I didn't

sync those as well now a lot of editors

will have a commit and sync or commit

and push button that you can press

[Music]

which helps if you're using that

specific editor but doesn't help if

you're using the command line and just

of a hack around a feature that github

would that get would benefit from but

just doesn't have

are more technical matters as well for

why I prefer fossil over get like I had

said way earlier richard hip has a great

presentation on this then that I will

link to that down in the video

description definitely check that out

it goes into considerably more detail

I'm just talking here about my biggest

reasons for preferring fossil so roughly

how things are done in fossil so that it

can be you can compare see kind of where

I'm coming from

yeah the link for richard hips talk will

be down in the video description

definitely check that out

there are a lot of lot of technical

reasons as well for why like auditing

purposes and stuff why fossil

I would say is the superior version

control now go to