►
Description
We're continuing our git education series with a follow up on last month's git intro. Last month we focused on committing code to your own repo. This month we're focusing on committing code to a shared repository.
Join Phil Bossman, Kevin Laux and the rest of the RTPSUG leaders as we host a hands-on, step by step tutorial of how to work with shared repositories.
Our demo this month focuses on helping build a website. Each participant will have an opportunity to add a piece to our "website" which runs from a shared git repository. You will be able to see what you added to the website live once it is committed.
We'll start off with a quick review of the fundamentals from last month's meeting and then we'll start building on top of those fundamental commands.
Follow along:
Tutorial:
https://github.com/RTPSUGMembers/rtpsugmembers.github.io/blob/master/README.md
Repo:
https://github.com/RTPSUGMembers/rtpsugmembers.github.io
Connect with Kevin Laux:
https://twitter.com/rsrychro
Connect with Phil Bossman:
https://twitter.com/Schlauge
SUBSCRIBE to learn about PowerShell!
https://www.youtube.com/c/rtpsug?sub_confirmation=1
LET'S CONNECT!
-- https://twitter.com/rtpsug
-- https://www.meetup.com/Research-Triangle-PowerShell-Users-Group/
-- http://rtpsug.com/
A
Good
evening
very
welcome
to
our
meeting
for
this
month
tonight,
we'll
be
talking
about
using
git
for
connecting
to
someone
else's
repository.
This
is
part
2
of
our
git
tutorials.
Last
month
we
did
the
intro
and
a
commit
code
to
your
own
repository.
Now
we're
going
to
be
talking
about
how
to
commit
code
to
someone
else's
repository,
I
speak
it
tonight.
Kevin
locks
will
be
taking
it
from
here.
A
B
B
So,
basically,
last
time
since
we
talked
about
kind
of
the
basics
of
working
on
and
get
your
own
get
repository,
we
thought
for
the
meeting
tonight.
We'd
do
something
where
we
kind
of
work
collaboratively
and
the
idea
we
came
up
with
was
we
have
our
RTP
sug
github
site.
We've
made
a
fork
of
that
that
we're
gonna
work
against
where
essentially
people
will
be
able
to
add
their
own
image
and
some
information
about
themselves
and,
be
you
know,
a
part
of
that
site.
B
B
One
another
way
like
so,
you
can
do
get
in
it
to
create
a
local
repository,
but
you
can
also,
if
you
set
up
a
repository
remotely
and
github
bitbucket
as
our
DevOps
repository
once
you
have
that
remote
set
up,
you
can
do
a
command
called
git
clone
git
clone
will
take
that
repository
and
you'll
see
the
the
command
here.
It's
git
clone
and
the.
B
So,
let's
say
on
your
local
system:
you
make
some
changes
or
those
changes
remotely
you
want
to
do.
An
update
to
those
changes,
get
pulled.
Will
pull
the
remote
changes
down
to
your
system.
Get
add,
will
stage
changes
so
you've
updated
a
script
that
you're
working
on
you're
going
to
get
add
the
name
of
that
script.
It'll
stage
it
commit,
will
actually
take
that
stage.
Change
and
put
it
into
a
point
in
time
commit
for
that
repository
and
then
get
push
will
push
it
out
to
the
remote
repository.
B
That's
kind
of
the
flow
of
how
things
will
work
when
you
can
get
I
know
Mike
sent
out
a
refresher,
I
think
there's
a
Thomas
Raynor,
who
yeah
put
that
together.
That's
a
really
good
thing
to
go
through.
You
know
just
to
kind
of
recap
on
the
basics,
so
we're
not
going
to
go
too
deep
into
it
right
now.
Cuz
we
kind
of
already
did
that,
but
mainly
these
commands
get
checkout
get
add.
B
A
A
B
So
when
we
do
the
destroy
I
have
setup
we'll
go
step
by
step
through
all
of
this
for
cloning.
The
report
repository
we're
gonna,
create
down
to
your
local
machine.
It's
totally
step-by-step.
You
guys
should
be
able
to
follow
on
pretty
well,
and
this
git
clone
will
be
part
of
it
and
where
to
find
it
where
it
is
on
github
and
stuff,
like
that,
the
tutorials
very
specific
to
github,
but
you
guys
should
definitely
go
follow
along
pretty
easily.
B
B
You
know
maybe
there's
bug
branches,
people
gonna
be
featured
branches.
It's
basically
the
same
thing,
just
different
terms
for
what
it
is
you're,
the
intent
of
the
branches.
Are
you
gonna
add
some
functionality?
Are
you
gonna
fix
something?
That's
broken,
but
it's
essentially
the
same
thing.
It's
a
branch
of
the
code,
you
make
your
changes,
you
test
your
changes
and
then
you
commit
them
back
to
the
master.
B
B
So
basically
going
to
happen
when
you
do
any
type
of
branch
or
anything
like
that,
that's
separate
from
your
the
master
that
you're
working
on
is
going
to
create
that
branch.
You're
gonna
check
it
out.
You
make
your
changes,
you're
gonna,
add
them
your
couldn't,
commit
them
to
the
branch
and
then
you'll
do
what's
called,
and
this
is
always
through
me
when
I
started
is
and
do
a
pull
request.
B
So
you
would
think
you
would
push
it
to
the
master
you're
going
to
do
a
pull
request
which
says
you
go
to
whoever
has
control
over
the
master.
If
it's
your
own
repository,
it
should
be
you
and
you're
gonna,
say
I.
Want
you
to
pull
these
changes
into
master
and
then
it's
going
to
go
through
a
process
of
you
submit
the
pull
request
with
information
about
what
changed
and
then
someone
approves
the
pull
request
and
merges
it
into
master.
B
B
I'll
go
I'm,
gonna
have
to
go
out
there
to
fork
it
and
stuff
anyway.
Okay,
so
those
see,
if
we'll
make
a
branch
in
that
branch,
we're
gonna
create
a
markdown
file.
That's
got
the
information
we
want
to
show
up
on
the
webpage
and
we're
going
to
either
point
to
an
image
that
already
exists.
There's
a
couple
sample
images
out
there
or
if
you
have
your
own
image
that
you
want
to
use.
You
know
nice
picture
of
your
face.
B
Then
you
can
copy
that
in
and
commit
that
as
well.
So
that'll
go
to
you
to
a
branch
rule
created
called
add
member.
Well,
port
will
do
a
pull
request
to
get
that
into
you,
our
master
branch,
which
is
where
we'll
go
test
it
and
make
sure
that
it's
showing
up
on
the
page
and
then
we'll
do
another
pull
request
to
pull
it
into
our
TP
sub
members
and
either
fail
or
Mike
or
someone
will
be
sitting
there,
approving
pull
requests
or
hopefully,
if
everything
goes
as
planned.
B
A
So
I
would
just
say
if
anybody
has
questions,
please
surface
them
up,
because
what
we're
trying
to
do
is
not
leave
anybody
behind.
So
if
you
get
lost
on
the
first
couple,
you
may
have
a
hard
time
keeping
up
on
some
of
the
future
ones.
We'd
rather
stop
keep
everybody
together.
So
just
a
reminder:
the
people
online
we're
hanging
out
and
discord
and
slack
Jill
sallows
they're,
helping
us
out
tonight.
I
think
josh
is
also
available.
Josh
King
myself
I'm
online.
B
So
once
it
something
with
the
username
before
the
domain
name,
there's
a
feature
in
github,
maybe
I
might
have
had
something
type
wrong,
I'm,
not
sure,
specifically
you're
asking
but
there's
a
feature
in
github
where,
if
you
have
a
repository
named
the
same
thing
as
you
know,
your
user
name
dot,
github
bio,
then
that
becomes
a
github
page,
and
so
you
can
go
specifically
to
that
site
and
it
will
generate
a
page
using
its
Jekyll.
I.
Think
is
what
does
it
right?
B
Yes
bill,
so
good
RTP
sect
members,
like
you,
have
done
io
you'll,
see
so
creative
one
buddy
didn't
put
an
image
there,
but
yeah
you
should
see.
You
know
our
pain.
Our
our
goal
is
so
we
have
the
our
team
section
that
we
have
from
the
regular
RTP
sub-site
to
have
an
our
member
section.
That
looks
similar
with
everybody's
picture
in
it.
B
Let's
see
here
so
I
have
a
a
test
account
that
I've
created,
which
I
can't
even
see
it,
because
the
all
this
WebEx
chat
stuff
gets
in
the
way.
So
it's
our
two-piece
OGG
test.
So
when
we're
doing
the
example,
you're
gonna
see
our
TP
star
test.
As
my
username
pretty
much
anywhere,
where
you
see
it,
says:
RTP
suck
tests,
there
are
PT's
RTP
sug
test
members,
because
I
think
I
changed
it
because
I
was
working
on
the
tutorial.
B
B
And
from
here
we're
going
to
go
ahead
and
create
our
own
Fork
I'm,
going
to
show
you
real,
quick
by
clicking
on
the
side
view,
or
it's
got
the
number
kind
of
some
information
about
this
Fork
and
you
can
see
here
in
yellow
it
shows
this
is
actually
a
fork
of
RTP
sug
github
da
daaaa.
So
that's
the
men
inside.
Do
we
have
you
created
this?
Is
you
know
something
we
can?
B
You
know
mess
around
with
and
we're
not
to
worry
about
it,
breaking
or
anything
like
that,
but
you
can
also
see
as
part
of
this
Fork
there's
other
people
who
have
forked
this
as
well.
So
it's
a
fork
of
a
fork,
and
so
it's
just
everything
that
this
everything
that
we're
doing
with
these
Forks
started
from
whatever
commit
was
the
last
commit
on
the
fork
that
it
came
from
that
make
sense.
B
Yeah,
that's
true,
so
you
basically
have
a
point
in
time
when
you
do
a
fork,
you're,
taking
all
the
files
that
are
there,
you're
forking
them
off
into
its
own
and
posit
ory,
and
now
everything
is
going
from
that
point
in
time.
So
when
I
did
this
RTP
sug
members
fort,
it
was
a
point
in
time
from
the
original
RTP,
so
I
haven't.
You
know,
merge
any
of
the
changes
in
or
anything
like
that.
B
So
one
thing
to
be
careful
of
this
in
a
fork
you
can
get
behind
the
changes
of
the
original
repository
and
we're
not
going
to
go
down
that
rabbit
hole,
but
there's
ways
that
you
can.
You
know
basically
get
yourself
back
up
to
speed
the
original
cork,
but
we
want
to
do
to
get
started.
Is
we're
going
to
create
a
fork?
And
so,
if
you
click
next
to
well,
let
me
show
you
thanks
for
getting
that.
B
That's
how
the
forks
look
if
I
scroll
down
to
the
bottom
here.
So
if
you
ever
go
into
a
git
repository
on
github
bitbucket,
that
kind
of
stuff,
if
you
have
a
file
called
readme,
markdown,
MD
I,
can't
see
here
here
it
is
this
file
here
will
be
rendered
on
the
page
and
so
I
created
a
markdown
file.
It's
kind
of
got
a
tutorial
disk
and
walk
us
through
everything
we
do
tonight
so
that
gets
generated
if
I
scroll
to
the
very
bottom
of
the
page.
B
Here
as
a
preview
at
the
bottom
here
and
you'll
see
step
by
step
everything
we're
gonna
do
tonight,
including
you
know
where
you
need
to
click
in
a
red
box.
You
know
and
all
the
different
steps
of
how
this
can
work
so
I'm
going
to
go
back
to
this
and
reference.
This
I
kind
of
have
some
notes
just
to
make
sure
I
stay
on
track,
but
you
guys
should
build
a
follow
along
on
your
screens
and
make
sure
your
own,
let's
skip
over
something.
B
A
C
B
Cough
up
and
stuff:
okay,
okay,
so
exhale
raise
we're
starting
to
forked.
So
you
click
on
the
fourth
button
make
sure
is
on
the
left
on
the
right.
You'll
get
a
listing
of
all
the
people
that
have
forked
it
on
the
left.
It
will
create
a
new
fork
and
you'll
see
a
change
here.
Actually
only
go
back,
so
you
can
see
this.
It
went
from
our
TP
sub
members,
/rt
B,
sub
members
RTP
suck
test
where
username
RTP
sug
members
that
kid
that
I
am
so
I
have.
B
This
happened
sometimes
as
I'll
go
to
repository
comm,
RTP,
SEC
members
and
that
changing
their
well.
It's
because
I'm
in
you
know
my
own
Fork
of
it
or
something
like
that
that
username
on
the
beginning,
you
know
a
lot
of
times.
Will
let
you
know
you
you're,
not
in
the
original
one
or
something
like
that.
B
So
you
guys
made
that
change
or
we've
made
the
fork.
If
we
want
the
github
page
to
work,
we
actually
have
to
change.
Your
repository
name
here
so
under
here
needs
to
go
from
RTP
select
members
github
dot,
il,
which
is
the
original
repository
name.
It
now
needs
to
be
our
user
account
name.
So
this
one
is
gonna,
be
RTP.
A
piece
of
test
yours
is
gonna,
have
to
be
whatever
your
username
is
I.
Think
github.
D
What
we're
doing
here
is
just
basically
adding
it,
so
your
own
github
account
will
be
there,
so
that
is
there.
So
it's
not
a
true
requirement
to
do
it.
You
can
do
all
some
of
this
like
all
offline,
but
you
won't
be
able
to
see
and
render
the
pages
kind
of
locally
kind
of
stuff.
So
some
of
this
is
just
that.
So
I
want
to
just
divert
from
that.
So
you
can't
do
some
of
this
thing
because
there's
a
website
we're
kind
of
modeling
that
so
you
can
basically
go
to
that
site
itself.
D
B
I
had
mentioned
I
think
in
here.
One
point:
I
think
I
had
it
as
optional,
because
if
you
already
have
your
own
site,
then
obviously
you
can't
do
that
like
right.
If
I
have
you
know
my
main
account
Kevin
locks
like
you
have
that
I?
Oh,
you
know,
I'm
not
gonna
want
to
replace
that
with
businesses
early
yeah.
B
B
Does
guarantee,
but
it
is
working
in
this
so
next
step
so
with
crayon
or
fork.
We
now
have
our
own
repository
like
Mike
had
mentioned
earlier.
We
need
to
in
order
to
clone
our
repository.
We
need
to
correct
URL
for
that.
So
here
you're
going
to
see
HCBS,
github
RTP
start
test,
and
you
know
our
whole.
A
So
this
is
probably
an
awesome
time
to
say
you
really
need
to
be
aware
before
you
do
this:
what
folder
you're
you're
in,
because
wherever
you
run
that
git
clone
command,
it's
gonna
make
a
subfolder
of
whatever
you're
currently
in
at
your
command
line.
So
if
you
made
this
in
C
Windows,
that's
where
you
that's,
where
your
repos
gonna
be
parked
right.
So
before
you
do
the
git
clone
command,
make
sure
you
understand
where
you
are
yeah
right,
yeah.
D
So
actively
you're
gonna
get
clone
the
repository
and
then,
if
you
don't
put
anything
after
that,
it
will
plead
it
will
copy
that
into
the
current
folder
or
you
could
put
the
folder
name
at
the
very
end.
It'll
create
a
folder
with
that
repo
in
it.
So
you
could
do
you
know,
define
it
to
be
something
else,
but
I
will
default
to
the
repository
name.
A
So
so
what
a
lot
of
people
do
if
you're
kind
of
new
to
get
and
you're,
not
sure
about
organization,
because
it
can
get
confusing
a
lot
of
people
will
make
like
a
git,
repos,
folder
and
then
in
that
folder
is
where
they
will
clone.
So
that
would
be
it
repos,
repo
name,
her
name,
be
her
name,
see
leapin
entity,
so
they'll
all
be
stored
in
one
folder.
B
Maybe
you
don't
have
the
ability
to
do
space
on
scene.
You
want
to
do
it
on
D
or
something
like
that
I
kind
of
did
it
as
an
example.
Here
is
create
a
folder
repo
I
didn't
set
location.
You
can
see
the
into
it
whatever,
but
what's
gonna
happen
is
when
you're
in
there.
The
main
thing
is
gonna,
be
a
git
clone
and
you're
going
to
put
in
that
path
that
we
copied
from
github.
B
So
they're
coming
here,
they'll
see
all
the
stuff
here.
You
know
all
the
folders
all
that
kind
of
stuff.
So
now
this
is
the
local
copy
of
that
repository.
So
all
the
changes
we
do
here
will
have
to
eventually
push
up
in
order
for
them
to
little
copy
em,
your
fork
version
yeah.
So
so
we
went
through.
We
create
our
folder.
We
did
our
clip
our
clone.
B
B
B
So,
let's
see
here
our
next
step
so
now
I
want
to
do
is
typically,
you
don't
want
to
make
changes
to
your
master
a
lot
of
times,
it's
easier
to
do
I.
Do
it
a
lot
of
times,
but
you
want
to
do
this
because
you're
gonna
have
something
that
you
know
is
working.
We
know
the
RTP
SOG
test
site
is
working,
so
we
don't
necessarily
want
to
commit
stuff
to
it
directly.
We
want
to
put
it
somewhere
else
in
the
case.
B
B
A
B
Work,
fine!
What
we
want
to
do
now,
though,
is
we
want
to
create
that
branch
where
we're
gonna
make
our
changes.
So,
in
order
to
do
that,
you
do
kit
check
out
it's
someone
correct
me
if
I'm
wrong
here,
if
you
say,
get
check
out-
and
you
just
say
the
branch
name,
it
will
change
to
that
branch
if
it
I
think
when
you
add
the
B
that
is
going
to
create
and
change
to
that
branch
am
I,
correct
there
right,
okay,
well,
no
one's
saying
I'm
wrong,
so
so.
D
B
B
B
I
haven't
done
it
yet
I'm
pushed
up,
but
I
was
gonna,
show
the
branch,
but
it's
not
there
yet
so
we're
gonna
start
making
change
of
this
the
things
we
need
to
change
our
we
need
to
create
the
markdown
and
we
need
to
add
our
image.
So
if
we
go
down
to
the
readme
you'll
see
there
is
a
template
under
/members
template
dot,
MD
we're
basically
just
going
to
copy
that
into
a
unique
markdown
file,
unique
named
markdown
file.
Do
your
name
do
something?
B
B
B
We
will
have
to
add
this
image
into
a
folder
that
exists
in
this.
This
path,
I
think
it's
called
images
that
slow
created.
If
you
do
not
have
an
image
or
you
don't
want
your
image
up
there,
there
are
a
couple
of
sample
images.
So
if
you
see
under
slash
images
here,
hopefully
that's
big
enough,
we'll
see
/members
there's
this
images,
folder
and
so
Phil's
already
got
his
image
up
there.
We
have
six
samples
out
there.
You
can
choose
from
so
samples,
amplitude
sample
three
dot
jpg,
and
you
can
just
put
that
in
there.
B
D
About
should
you
be
creating
the
add
member
branches?
Well,
I
think
you
should
so
one
of
the
objectives
at
this
point
is
to
you
know:
fetus's
template
environment,
and
for
you
to
kind
of
do
the
work
and
we're
kind
of
will.
Let
will
pull
your
West.
So
if
you
want
to
make
your
local
branch
whatever
you
want
it
to
be,
because
that's
the
whole
point
is
that
it
is
your
branch,
this
one
you
can
call
whatever
you
want
and
eventually
will
then
take
that
skinny
branch
and
will
merge
it
all
the
way
back
up.
D
D
No,
you
got
more
typically
with
big,
like
you
brought
up
the
idea
of
like
CIC
pipelines
and
other
things
like
that
and
in
environments
you
know.
Sometimes
people
will
create
the
branches
based
on
like
issue
lanes
and
use
all
those
kind
of
tags
like
that,
and
it
will
auto
close
things
will
do
like
that's.
You
know
deep
in
the
weeds
and
that's
version
time,
but
so
effectively.
This
game
is
just
anything
you
want
it
to
be
here.
B
C
A
C
D
At
this
point,
just
to
understand
that
you're
you're
putting
in
some
artifacts
reading
a
branch,
you're
gonna,
create
some
other
artifacts
beautiful.
You
know
JPEG
files,
some
other
artifacts
you're
gonna,
create
some
code,
is
basically
an
MD
file,
a
markdown
file,
so
you
gonna
add
some
code
and
then
eventually
we're
gonna.
Get
this
all
the
way
back
up
to
somebody
else's
repo.
What
can
we
do
with
it
and
kind
of
see
it
visually
so
effectively
to
put
a
script
there?
If
you
wanted
to
put
into
your
brand
some
other
random
code?
D
Well,
that's
up
there
and
it'll
be
finally
put
there.
You
know
it's
something
appropriate.
We
can
put
there
and
so
that's
the
kind
of
the
objective
you
were
kind
of
wanted
to
give
an
opportunity
to
actually
do
some
work,
something
you
can
visually
see
something
you
can
do
and
a
place
that
you
had.
Actually
you
know
let
somebody
pull
you
know
your
your
code
into,
but.
D
Format
so
that
it
can
then
be
rendered
out
into
multiple
things.
Cuz,
you
can
take
mark
down
into
n2
it
any
number
of
other
format,
or
at
that
point
you
can
convert
it
over
well,
it's
think
of
it.
The
other
way
around
is
that,
okay,
there
are
renderers
that
can
take
a
markdown
and
build
a
a
Word
document.
Take
a
markdown
and
build
an
HTML
document,
take
a
markdown
and
build
PDFs,
and
so
it's
it's
the
raw
that
and
then
very
well
sleep,
and
it
has
some
basic
formatting.
B
A
B
See
that
we
have
these
the
files
we
changed
or
updated,
or
added
even
are
here,
it
shows
you
I
believe.
That's
basically
just
saying
hey.
This
is
an
unstaged
change
that
you
have
over
on
the
side
here,
you'll
actually
see
hey.
These
are
the
changes
that
I
have
they're
not
staged
at
the
moment,
you
can
individually
add
them
to
be
staged.
B
Put
a
message
in
there
commit
them
all
using
the
UI
like
I,
said:
I,
don't
like
to
use
that
because
it
tends
to
be
very
slow,
so
I
want
to
do
now
is
I
want
to
take
those
changes.
I
did
and
I
want
to
stage
them.
I
want
them
to
be
part
of
the
next
commit,
so
I'm
gonna
do
a
git.
Add
you
just
do
get
add
period
or
get
add
star
and
it'll.
B
B
B
B
B
A
D
B
It
doesn't
like
do
right
now,
though,
so
I
cleared
out
my
cache
username
and
password
and
stuff
that
was
being
used
for
authentication
with
get.
The
problem
was
that
I
have
a
different
account:
Kevin
locks,
which
is
I
I'm
one
will
use
for
that.
I.
Have
this
other
account
our
TP
sub
test?
That
I
was
using
just
for
this
tutorial
now,
if
you
can't
locked
in
the
old
account
and
it
doesn't
have
access
to
the
RTP.
B
B
B
Should
see
here
is
now
we
have
this
branch,
that's
been
added
called.
Add
member
I
can
go
switch
over
to
that
branch.
I
can
look
at
under
underscore
members.
I
now
have
that
Kevin
locks,
MD
I,
do
that
under
master
I
shouldn't
see
that
it
doesn't
exist
in
that
that
branch
it
only
exists
in
add
member,
where
we
created
it
and
checked
it
out.
B
A
B
B
B
Want
to
actually
go
into,
you
will
see
a
ton
of
these
now,
because
there's
tons
of
force
going
out
there
now
our
tip
it's
like
test
that
get
up
that
IRM
and
you'll
see
the
second.
You
do
that
the
formatted
this
changes
says
hold
on
you're,
doing
a
pull
request.
In
your
same
repository.
We
don't
need
the
repository
name
for
both
sides.
So
what
branch
do
you
want
to
go
from
and
which
branch
you
won't
go
into?
B
So
now
we've
and
what
still
showed
us
a
little
bit
ago
as
he
was
looking
from
the
RTP
sub
member
site,
he
was
accepting
full
requests
and
merging
them.
We're
now
going
to
do
that
on
our
repository
because
we
own
it
so
we're
the
ones
who
are
approving
the
pull
request
and
merging
so
I'm
gonna
come
in
here.
I'm
gonna
go
ahead
and
merge
and
confirm
the
merge
and
we
should
see
I
go
back
to
code.
Oh
I've
missed
a
section
there
too.
In
that
pull
request.
B
There's
a
little
gray
box
a
week
where,
typically
you
want
to
do
that
because
you
bring
the
branch
to
do
a
change
or
fix
the
bug
or
something
like
that.
So
the
branch
is
only
going
to
exist
as
long
as
that
problem
still
exists
or
that
thing
that
you're
changing
still
exists
once
you've
fixed
it.
You're
gonna
do
your
pull
request
and
when
the
request
is
pulled
in
go
ahead
and
delete
that
branch
out,
because
all
that
work
you
did
is
now
and
master
and
there's
no
reason
to
have
that
branch
move.
B
B
So
let
me
I
want
to
do
this.
Real,
quick
I
want
to
bring
this
back
to
the
graphic
I
had
before
here's.
What
we've
done
so
far,
creating
the
for
the
fart
fork
was
our
TP
sub
test,
our
TP
sub
github.
Do
we
had
a
master
branch
there?
He
created
a
new
branch
called
I
put
it
as
add
content.
Here,
it's
actually
I.
B
Called
it
admins
er,
we
made
our
changes,
we
did
a
pull
request
into
our
master
branch
and
we
are
at
this
spot
right
here
right
now,
so
Artie
be
sarcastic
github.
That
has
our
image
in
it.
We
want
that
to
be
pulled
into
the
repository
we
forked
from
the
one
that
Phil
has
control
of
we
don't,
and
so
we're
going
to
do
is
we're
going
to
submit
a
new
poll
request
to
that
repository.
B
B
D
Like
you'd
brought
up
the
idea
of
hey
some
CICE
kind
of
thing,
so
you'd
have
some
CIE
pipeline
merging
with
the
master,
so
that
would
merge
these
long
CI
pipeline
moving
into
master.
And
you
then
do
this
idea
of
like
pulling
stuff
like
into
other
branches,
and
so
you,
hey,
I'm,
gonna,
pull
this
and
then
into
you.
So
then
you
would
then
try
and
promote
into
your
branch
and
then
the
see
I
hope
I
pull
from
you.
It's
a
bit
of
pull
request.
Yes
effectively
matters,
but.
C
B
Best
bracket
isn't
is
working
on
something
else.
You
would
pull
into
a
branch
that
people
could
from
some
testing
on
do
some
stuff
before
it
goes
into
production,
and
then
they
would
then
pull
it
typically
through
some
sort
of
automation.
Where
there's
testing
involved,
you
can
see
master
crying,
we're
gonna,
do
a
new
pull
request
and
we're
gonna
go
straight
into
the
master
of
RTP
sub
members
so
and
you'll
see
it
automatically
sets
it
up.
For
that,
like
we
did
before,
is
we
actually
switch
to
our
sub
tests?
B
A
B
C
C
D
D
Actually,
no,
it's
not
just
how
it's
gonna
story,
something
Jenkins
leg
I
started
a
thousand
thanks.
Alright,
so
we
kind
of
showed
at
this
point
so
from
here.
We
then
see
that
RTP
sub
master
is
pulled
from
his
test
from
his
master
to
you.
You
can
kind
of
see
back
from
other
ones.
I
think
I
showed
at
this
point.
You
can
click
on
the
files
have
changed.
You
can
see
he's
done
a
bunch
of
other
stuff
picture
itself.
We
can't
really
see
it
inside
this
UI
or
we
can
download
picture
everything.
Can
we
give.
D
Internal
stuff
in
checks,
we
can
comment
on
it.
It'll
then
send
it
back
to
him
to
say:
hey.
Do
you
want
to
do
this
work?
Hey
we're
gonna
comment
on
this
pull
request.
So
now
this
pool
requests
now
has
some
other
stuff.
We
can
then
comment
back
and
forth.
Saying:
do
you
want
to
do
this?
Please
make
these
changes
over
ba.
We
can
then
also
submit
for
review
or.
C
C
B
D
What
you
would
do
at
this
point
merging
the
pull
request
is
still
open,
okay,
and
so
what
I
would
lend
you?
You
could
then
hear
my
thing
so
at
this
point,
I
could
make
some
changes.
You'd
get
a
notification
back
into
your
github.
At
this
point,
we're
using
github,
then
hey
I've
made
some
an
update.
So
if
you
look
in
your
github,
you
should
see
that
hey
I
commented
on
your
pull
request.
You
would
then
make
some
more
updates.
C
C
A
D
A
D
D
C
A
D
So
now
you
see
at
this
point
is
this
now
changed
from
2
to
25
members,
so
he
pushed
he
made
a
change
to
his
master,
ok
and
so
now
I
would
have
to
accept
both
of
these
changes.
Ok,
so,
as
you
said,
hey
hinges
so
now
hey!
No,
it's
still
wrong.
There
are
too
many
files
here.
There's
this
isn't
sure,
and
so
at
this
point,
all
the
things
that
are
in
my
master
is
what
we
will
call
a
Pathan.
We
do
the
merge.
That's.
C
Where
your
tests
come
into
play,
where,
if
you
want
something
that
comes
in
without,
what's,
though,
with
100
percent
passing,
you've
run
your
test
and
every
at
every
little
bit.
You
know,
especially
with
within
a
PR,
see
if
someone's
submit
a
pull
request.
You
run
tests
against
their
request
to
see.
If
you
know
one
one
touch
that
would
run.
Is
that
a
jpg
file
for
in
the
corner
right?
If
not,
that
decline
it
or
say
no
reactive
or
something
of
that
nature
and.
D
D
A
A
D
D
D
See
at
this
point
it
is
getting
copies
of
everything.
That's
upstream
so
now
there
are
two
things
up.
So
origin
is
me.
Actually,
if
you
know
we'll
go
back
to
King
L,
so
you
can
kind
of
see
the
branch
master
is
me,
my
master,
which
is
effectively
origin,
remote
origin
and
remote
upstream,
is
our
to
be
sub
master.
D
D
D
A
A
D
Yes,
yes,
it
magically
happens
because
we
created
we
use.
We
get
up
using
it
up
to
create
the
fork
right,
thus
creating
an
upstream
okay
and
then,
when
we
cloned
our
local,
we
got
work,
not
our
local.
When
we
closed
our
personal
github
account
that
keep
the
option
came
with
it.
Okay,
if
you
wanted
to
establish
your
own,
you
can
do
get
a
dream,
get
a
drink.
That's.
A
D
There
is
the
remote,
so
this
tells
you
what
where
you
are
and
what
you're
pulling
in
so
here's
what
the
repo
of
origin
so
effectively
origin
and
upstream,
are
actually
just
random
words.
It's
like
a
standard
practice.
What,
upstream
and
origin
are
you
could
call?
You
know,
I've
seen
people
use
remote
dot.
A
A
D
D
Six,
alright,
who
else
wants
to
be
yeah,
so
I
know
this
was
a
or
I
hope
that
you
got
kind
of
some
of
this
out
of
them
with
this
is
kind
of
like
a
practical
example
of
you
know
using
this
is
2.0
using
get
kind
of
the
first
time
we
just
here,
get
kind
of
get
you
started
and
how
to
add/remove
clone,
that's
it
and
then
here
is
now
a
trying
to
work
with
some
up
somebody
else's
repository.
This
is,
you
know,
not
very
PowerShell
II,
but
it
actually
is.
C
D
D
B
D
B
I
am
not
the
best
in
get
I
know,
I,
make
things
end
up
working,
but
I
do
not
know
the
correct
way
to
do
whatever
I
want.
So
one
thing
I
always
go
back
to
it.
I
like
about
it
is
you
can
pretty
much
always
just
start
from
scratch.
If
your
fork
is
out
of
date
or
behind
line
commits,
you
can
delete
your
fork
and
do
a
new
fork
right
now.
It's
caught
up
I
know,
that's
not
the
correct
way
to
do
it,
but
it
works.
B
It's
your
local
repository,
it's
for
whatever
reason
behind
your
remote
repository
and
you're.
Having
issues
like
I
mean
dip
pool
should
pretty
much
do
it,
but
you
haven't
some
sort
of
issues
because
you
change
the
file
and
you
can't
you
know
stash
the
changes
and-
and
you
know,
commit
and
then
merge
them.
B
Please
delete
the
local
repository,
git
clone
and
be
back
to
whatever
your
master
is,
and
if
there
are
changes
you
want
to
save
there,
has
it
changed,
save
them
in
a
temporary
directory,
posit
ori
doing
your
clone,
and
then
you
know
paste
them
back
in
and
didn't
get
push
them.
So
you
can,
there
are
elegant
and
good
ways
to
do
it.
If
you
really
know
get,
you
can
kind
of
brute
force,
some
of
the
stuff
just
by
just
reclone,
in
the
repository
or
reforming
the
repository
or.
D
Of
the
things
to
kind
of
understand
is
the
gist
of
what
Kevin
just
said
there.
It's
yeah.
If
you
have
a
big
problems,
you
can
simply
just
wipe
wipe
your
your
local
repository
and
start
again
effectively.
Remember
that
git
is
a
distributed.
You
know,
file
system,
you
know
code
base,
so
there's
a
remote
copy
of
somewhere
else,
be
it
local,
there's
a
remote
copy
of
the
content.
D
D
There
are
some
positives
here:
hey
I
have
three
copies
of
my
presentation
to
the
PowerShell
on
the
river:
hey
because
I
screwed,
this
one
up
actually
I,
think
I
screwed
this
one
up
and
then
I
screwed
this
one
up
and
then
I
was
a
god
that
eventually
went
to
that
one
so
effectively.
I
have
three
local
copies,
Oh
some
up
streams
back
to
wherever
so
the
whole
point
being
that
these
all
repop.
These
are
all
effectively
the
same
local
repository
all
different
times,
but
they
eventually
became
this
one.
But
it's
just
as
easy.