►
Description
This is part of an informal demonstration of the process of contributing to NRE Labs (https://nrelabs.io).
For a detailed, authoritative reference, please use the NRE Labs documentation at https://docs.nrelabs.io
NRE Labs Contribution Video Series
- Part 1: First Steps - https://www.youtube.com/watch?v=HOU5k77RQNc
- Part 2: The Antidote CLI - https://www.youtube.com/watch?v=G3sM_5rk2yc
- Part 3: Opening a Pull Request - https://www.youtube.com/watch?v=mfEVoV7FiE0
- Part 4: Previewing Your Changes - https://www.youtube.com/watch?v=c4a2PP4gJqE
A
Hello,
my
name
is
Meadows
Walt,
and
this
is
a
continuation
of
the
video
series
on
contributing
to
the
Emory
labs
curriculum
in
this
video.
We're
going
to
be
opening
a
pull
request,
so
this
in
this
in
this
video
we're
gonna
be
dealing
with
get
a
lot
more
than
we
will
in
really
any
other
video
and
if
you're
not
familiar
with
git,
we
actually
have
a
lesson
on
git.
So
if
you
just
want
to
go
through
that,
you
can
head
on
over
to
go
to
NR
Labs,
do
slash
catalog
and
search
for
version
control
with
git.
A
A
Now
for
contributing
a
lesson,
if
you
remember
in
the
previous
videos
what
we
did
was
we
use
the
antidote
CLI
to
bootstrap
a
new
lesson
and
validate
that
that
curriculum
is
still
is
still
still
formed
correctly
using
the
antidote
CLI.
So
once
we
have
a
lesson
at
least
at
least
started,
you
don't
have
to
complete
your
lesson
to
do
this.
A
Really,
the
first
three
is
what
we're
gonna
cover
in
this
video:
we're
gonna
sort
of
keep
step
four
off
for
the
next
video,
where
it
comes
time
to
preview
our
content,
because
there's
some
specifics
around
that
that
we'll
want
to
that
we'll
want
to
dive
into,
but
for
now
we'll
just
focus
on
opening
a
pull
request
step.
One
is
we
want
to
take.
We
really
want
to
take
the
work
that
we've
added
thus
far.
We
want
to
create
with
sort
of
commits
with
with
those
changes.
A
We're
gonna
push
those
commits
to
our
fork
and
then
we're
gonna
open
a
pull
request,
which
basically
says
hey
I've
got
changes
on
my
fork,
I'd
like
to
I'd,
like
you,
the
NRI
lamps
project,
to
pull
those
changes
back
up
into
the
mainstream
curriculum
and
then
finally,
we'll
make
sure
that
everything
checks
out
from
a
continuous
integration
perspective.
Once
the
pull
request
is
open.
There's
a
bunch
of
automated
checks
that
take
place
just
make
sure
that
the
sort
of
the
basics
are
covered.
A
Ok,
so
we're
over
here
again
in
our
locally
cloned
copy
of
our
fork
of
our
curriculum
fork.
So
if
we
do
it
get
status,
you'll
see
that
our
new
lesson
directory
is
here.
If
you
see
something
else
here,
that's
fine
just
be
careful
sort
of
what
you
add
in
the
next
step.
We're
gonna,
be
very
specific
and
just
say
get
add
lessons
our
new
lesson
and
that
basically
says
I
want
you
to
add
everything
into
it.
A
Basically,
I
want
to
add
everything
in
to
get
that
is
in
this
subdirectory,
and
the
good
news
is
anything
that
we
created
using
the
wizard
before
is
all
inside
that
directory.
So
this
is
a
nice
way
of
really
just
saying.
Look
I
just
want
to
add
everything
I
just
created.
Now,
if
you
do
that,
it's
always
a
good
idea,
just
just
a
quick
get
status,
just
to
make
sure
everything
that
you
intend
is
actually
in
there.
So
anything
in
green
is
going
to
be
committed,
so
we'll
do
a
git
commit
and
we'll
sign
it
off.
A
Just
because
and
we'll
say
our
new
lesson
and
we'll
say,
example:
lesson:
ok
and
that's
our
commit.
So
the
next
thing
is
we
want
to
do.
Is
we
want
to
get
push
which
basically
says
I'd
like
you
to
create
or
I
want
you
to
push
the
commit,
so
the
the
local
copy
of
the
new
lesson
branch
I
want
you
to
push
that
to
our
remote,
which
is
the
repository
in
github.
So
we'll
get
push
origin,
which
is
the
name
of
the
remote
and
we'll
do
new
lesson.
A
And
there
we
go
now
there's
a
few
things
here.
If,
since
we're
using
github
one
of
the
things
that
github
allows
us
to
do
is
it
allows
us
to
click
this
URL
to
automatically
create
a
new
pour
request?
You
can,
of
course,
do
that
if
you
wish,
if
you're,
quick
and
you
head
on
over
to
github,
you
can
also
see
that
they
have
a
button
provided
here
where
you
can
automatically
open
a
pull
request
for
any
branches
that
you
recently
pushed.
We
recently
pushed
the
new
lesson.
A
Let's
compare
it
to
the
branch
that
we've
created
called
new
lesson
and
basically,
what
this
says
is
I'd
like
you
to
take
the
changes
that
were
that
are
that
are
new
inside
of
this
branch
and
merge
them
back
into
this
base
repository
into
the
master
branch,
and
you
can
click
the
create
pull
request
button.
What
this
does
is
it
pops
up
a
form
for
you
to
fill
out?
A
So
there's
a
few
things
that
I'd
like
to
cover
here,
but
I'll
be
brief
because
most
of
its
covered
actually
in
the
text,
this
is
prefilled
really
as
a
helper,
for
you
so
definitely
go
through
and
read
some
of
this
stuff.
Most
of
it
is
commented
out.
You
kind
of
see
this
as
a
comment
block,
read,
read
through
these
things
and
and
and
provide
the
detail.
That's
required
by
this
form,
not
all
of
its
required,
but
some
of
its
just
a
really
good
idea-
and
anything
you
do
provide
here-
is
helpful.
A
A
If
you
feel
like
you
still
have
changes
you'd
like
to
make,
but
you
just
wanted
to
open
the
pull
request,
nice
and
early
a
thank
you,
that's
actually
very
helpful
to
maintain
so
that
they
can
see
sort
of
what's
coming
and
sort
of
you
know
maybe
provide
some
guidance
and
advice
early
on,
but
also
it
provide.
It
provides
a
nice
signal
for
you
to
say,
look
I'm,
not
ready
for
this
to
be
formally
reviewed,
I'm,
just
creating
it
as
a
draft
and
basically
what
that
means
is.
A
It
allows
everybody
to
sort
of
save
a
little
bit
of
time.
So,
if
you're,
not
quite
ready
for
a
formal
review
for
your
pull
request,
definitely
make
liberal
use
of
that
option.
You
can
always
change
it
back
to
a
regular
pull
request
later.
That's
totally
fine
and,
as
you
can
see,
some
of
the
diff
that
we
saw
before
is
also
contained
here.
Everything
that
we
created
on
the
CLI
is
also
here
in
the
diff,
so
we'll
create
this
as
a
draft
pull
request.
A
Of
course,
if
you
want
to
add
any
labels,
if
you
think
you
want
to
do
that,
that's
fine
maintainer
x'
may
sort
of
modify
those
if
they'd
like,
but
we
can
just
create
the
draft
pull
request
now.
This
is
just
to
create
the
pull
request.
Note
that
these
changes
haven't
actually
been
merged.
Yet
that's
sort
of
what
this
process
is
all
about,
so
creating
this
pull
request
is
is,
is
usually
a
pretty
good
idea
to
do
really
early
on,
because
it's
not
there's
not
really
anything
wrong.
A
A
That
might
help
you
out
so,
for
instance,
if
your
lesson
failed
to
validate
that'll,
be
that'll,
be
sort
of
provided
there
in
terms
of
output
and
of
course,
if
you
have
any
questions
just
say
like
you
know,
it
just
add
a
comment
that
says:
hey
I'm,
not
sure
what's
going
on
here,
can
somebody
help
me
out
and
a
maintainer
will
come
by
and
sort
of
poke
around
and
take
a
look
at
what's
going
on?
Finally,
if
you
want
to
add
more
changes
as
it's
pretty
common,
you
absolutely
can
do
that.
A
You
really
just
need
to
keep
pushing
commits
to
the
same
branch.
So,
for
instance,
if
we
were
to
edit
our
lesson
guide
and
say
like
this
will
be
a
new
lesson
guide,
just
as
an
example,
change
will
save
that
and
then
we'll
take
get
status.
We
type
get
add
lessons
get
commit.
Another
change
get
push
origin
new
lesson.
A
This
just
adds
the
another
commit
to
that
same
branch
and
the
pull
request
will
actually
get
updated
accordingly,
you
can
see
that
here,
actually
the
another
change
commit
is
added
here.
So
this
is
pretty
cool.
What
this
means
is,
you
can
keep
adding
commits
to
this
to
this
pull
request
and
anytime,
you
do
that.
The
full
pipeline
will
be
reapplied,
so
all
of
the
checks
that
are
applied
here
will
rerun
and
then,
if
those
pass
again,
another
preview
will
be
generated
and
so
on
and
so
forth,
just
be
sort
of
just
be
commuting.
A
You
know
communicate
what
your
intentions
are.
If
you,
if
you
still
like
to
make
some
changes,
even
if
you've
marked
it
ready
for
review,
you
could
just
say:
hey
look
I'm,
not
quite
ready
for
this
to
be
formally
merged.
Let
me
just
keep
making
some
changes.
Maybe
the
preview
showed
you
something
that
you
didn't
like
and
you'd
like
to
make
changes.
All
of
that
is
fine.
Just
be
upfront
about
your
communication
and
letting
maintainer
x'
know
what
you're
working
on
ok
and
that
is
it
for
now
we'll
discuss
the
preview
functionality
in
the
next
video.