►
From YouTube: Delta Hack: Making a first pull request to delta-rs
Description
In this live-coding stream Tyler will introduce you to the Rust ecosystem and walk you through creating your first pull request to delta-rs. We'll pick one of the "good first issues" for delta-rs and submit a real pull request!
A
All
right,
according
to
youtube,
we're
live
so
good
morning
or
good
afternoon
good
evening,
wherever
you
may
be
in
this
live
session
as
part
of
delta
hack,
which
is
a
delta
lake,
open
source
hackathon
that
we
are
hosting
from
now
until
the
end
of
the
week.
I
wanted
to
to
share
some
of
how
you
can
get
started
with
rust,
we'll
be
using
delta
rs
and
let
me
go
ahead
and
open
that
up
delta
rs.
A
As
the
basis
for
for
this
video,
I
wanted
to
share
how
to
create
a
pull
request,
but
sort
of
starting
from
the
perspective
of
you
know:
I've
never
written
rust
before
delta.
Rs
is
a
project
that
we
started
a
couple
of
not
a
couple,
maybe
last
year,
I'm
getting
losing
track
of
time,
but
delta
rs
is
a
project
that
adds
rust
and
python
bindings
and
has
the
potential
to
add
more
bindings
to
delta
lake,
for
you
know,
say
ruby
or
golang
or
node,
etc.
A
What
this
allows
us
to
do
is
to
really
access
delta
tables.
From
a
you
know,
non-spark
context
or,
more
specifically,
a
non-jvm
context,
so
might
as
well
go
ahead
and
get
started.
If
you've
got
questions,
I
do
have
chat
up,
I'm
looking
at
it
in
the
in
the
side.
Of
course,
if
you
have
chats
after
this,
video
has
already
been
posted
and
I'm
no
longer
live
streaming.
If
you
go
to
delta.io
and
I
think
it's
under
resources,
I
can
actually
show
you
what
am
I
thinking
you
can
join
us
on
slack
where's.
A
The
slack
button
community
get
up
good
down
here
down
here
at
the
bottom
slack
channel.
Google
group
youtube
the
slack
channel.
If
you
join
the
delta
rs
channel
you'll
be
able
to
ask
the
delta
rs
folks
any
questions
that
you
may
have
but
anyways.
So
if
you
haven't
worked
in
rust
before
the
first
place,
I
would
recommend
that
you
go
is
rustup.rs.
A
A
A
Vim
also
vim
certainly
has
good
rust
support,
so
I
recommend
vim
as
well.
I
can't
speak
to
emacs.
I
won't
get
into
that
particular
flame
war
at
the
moment,
but
once
you've
got
rust
installed
a
couple
of
resources
that
I
recommend
you
checking
out
the
the
book,
the
rust
programming
language
book
from
no
starch,
which
was
written
by
steve
and
carol
nichols
or
steve
klebnik
and
carol
nichols
it's
a
very,
very
good
book.
I
recommend
purchasing
it.
I
purchased
it.
A
A
A
A
A
A
Let's
look
at
the
cargo
tunnel
just
to
give
you
an
idea
of
what
lives
here.
Cargo
tunnels
in
most
projects
will
define
kind
of
three
things:
project
metadata,
which
you
see
up
here
at
the
stop
at
the
top
or
package
metadata.
Excuse
me,
I
wouldn't
say
I
would
say
package
the
dependencies
for
that
package.
In
this
case
we've
got
quite
a
number
of
dependencies
and
then
you'll
find
features,
there's
other
things
that
can
go
into
into
the
cargo
tunnel,
but
pretty
much.
A
These
three
are
what
you're
gonna
encounter
more
often
than
not
when
you're,
using
when
you're
using
rust.
The
features
are
a
way
for
us
to.
We
won't
talk
too
much
about
features,
but
features
are
a
way
for
us
to
have
sort
of
conditional
compilation,
so
we
can
build,
we
can
build
rust
or
the
delta
rs
package
with
the
azure
feature
and
that
will
build
in
the
azure
support
or
with
the
s3
feature,
the
s3
support,
so
on
and
so
forth.
A
So,
if
you're
coming
from
ruby,
for
example,
ruby
has
open
classes
and
modules,
you
can
actually
define
a
class,
for
example,
in
multiple
files
in
java
or
scala
or
groovy,
or
things
like
that.
There's
not.
There
is
a
little
bit
more
of
a
file
to
module
convention,
but
it's
not
as
strict
as
what
rust
has.
A
A
So
you
know
users
can't
use
them
so,
for
example,
mod
delta,
a
user
can't,
with
the
exception
of
the
things
that
we're
exposing
here,
a
user
can't
you
know,
pull
in
the
delta
light
crate
and
use
stuff
under
there,
whereas
action
or
delta
arrow
or
partitions
those
have
the
public
modifier
on
them.
Let's
go
look
at
our
issue
here,
of
course,
if
you
have
any
questions,
please
stop
me
mention
something
in
the
in
the
youtube,
chat
and
and
I'll
be
able
to
try
to
answer
those
questions.
A
A
A
A
Other
people
will
just
unwrap
if
they're
not
expecting
if
the
error
is
actually
fatal
like
what
we
have
here
but
result
is
how
errors
are
going
to
be
propagated
out
of
calls
in
rust.
So
the
problem
that
surge
was
reporting.
This
was
on
not
a
table.
It's
basically
that
not
a
table
doesn't
have
any
information
associated
with
it,
and
so,
let's
look
at
just
apply
log
as
an
example
there's
this
macro,
which
is
the
dollar
sign
bracket
syntax.
Those
are
macros
in
rust,
which
are
a
very
very
like
they're,
nothing
like
c
macros.
A
This
is
really
useful
when
wrapping
uri
error
or
other
errors
that
come
from
other
other
errors
that
come
from
other
crates.
We
can
just
wrap
it
and
say
you
know
if
we
ever
have
a
function
that
gets
you
know
a
sturdy
json
error,
then
let's
wrap
it
up
and
convert
it
to
a
delta
table
error
so
that
our
api
is
is
fairly
consistent
in
terms
of
the
errors
that
it
reports.
A
A
So
I
need
to
find
out
where,
where
serge
has
this
or
where
search
saw
this,
so
this
is
self-version.
Let's
just
see,
let
me
do
a
mark
there
mark
not
a
table,
so
there's
one
spot,
oh
we're
only
using
it
in
one
spot,
okay.
So
when
we're
applying
logs
after
current
version,
the
way
that
delta
rs
works
by
the
way
is
when
we're
reading
the
transaction
log,
we
sort
of
iterate
through
the
transaction
log
and
apply
the
different
actions,
which
is
where
some
of
this
code
is
coming
up.
A
A
All
right,
I
should
explain
what
I'm
doing
here.
So
all
of
these
errors
are
wrapped
up
in
this
enumeration.
Enumerations
in
rest
are
really
powerful.
You
can
have
sort
of
different
types
of
things
in
the
same
enumeration,
which
is
what
we
have
here
to
make
our
error
reporting
easily
more
easy
to
use.
A
Here's
my
not
a
table
and
inside
of
an
enumeration.
We
can
have
sort
of
a
struct
definition
or
what
looks
like
a
struct
definition
where
you
know
we
have.
This
is
our
symbol,
invalid
action,
and
then
we
have
one
member
of
the
name
source
inside
of
that.
That
has
this
type
that's
sort
of
a
struct
definition.
Struct
is
another
type
in
rest,
there's
another
syntax,
which
is
quite
helpful
and
we
use
it
in
in
a
number
of
enums
in
delta
rs,
which
is
basically
to
create
sort
of
like
a
tuple
type.
A
A
A
A
A
The
the
things
that
you're,
typically
going
to
be
executing
with
cargo
will
be
build
test
and
run
fairly
straightforward.
I
mean
cargo
will
also
install
packages
for
you
or
binaries.
You
can
also
do
cargo
update.
All
of
these
things
are
quite
useful,
but
build
test
and
run
I
use
when
I'm
working,
I
use
a
crate
called
cargo
watch
which
I'll
pull
up
here.
A
A
Low
low
load,
that's
not
creates
that
io,
I
didn't
know.
Crate.Io
was
a
thing.
I
suppose
that
since
it's
a
reason,
yeah
cargo
watch.
So
if
you
just
do
a
cargo
install
of
cargo
watch,
you'll
get
this
very
helpful
tool
which
will
let
you
rerun
targets.
So
these
these
cargo
targets,
just
whenever
files
change
and
cargo
build,
is
what
I'm
gonna
execute.
A
So
this
is
going
to
build
almost
all
my
stuff
and
just
take
a
little
bit.
I
haven't
built
delta
rs
in
a
while,
because
we
have
all
of
these
dependencies.
The
compilation
can
take
a
while,
but
rust
c,
which
is
the
compiler
underneath
this
does
support
incremental
compilation,
so
the
second
time
around
it's
only
going
to
build
the
the
modules
that
have
changed
basically,
but
if
you're
coming
from
python
or
ruby
or
or
javascript
rust
is
a
little
bit
more,
I
mean
it's
a
compiled
language.
A
A
A
I'm
looking
at
some
of
the
youtube
stream
and
unfortunately
this
the
rendering
doesn't
look
so
great.
It
could
be
better.
So
maybe
I'll
I'll
learn
learn
from
this
and
make
the
next
one
better.
Can
I
make
this?
I
think
I
can
just
embig
in
this
there
we
go
embiggened,
we'll
go
full
full
screen
on
this,
so
we'll
get
a
little
bit
clearer
of
text,
hopefully
from
from
obs
and
youtube.
A
A
A
Here's
a
very
good
example
of
of
we're
actually
using
when
we
do
this
delta
table
error
from
we're
actually
using
some
of
the
traits
that
are
being
defined
by
this
from
macro.
That
anyhow
is
providing
so
it's
being
used
multiple
times.
It's
only
going
to
be
compiled
once
because
it's
compiling
out
these
these
trade
implementations.
A
A
A
And
so
cargo
watch
is
obviously
going
to
be
rebuilding
it.
Oh
it's
qp
qp
is
the
original
creator
original
creator
of
delta
rs.
So
if
I
say
something
stupid
since
he's
paying
attention,
then
I'll,
let
him
correct
me
so
this
actually
compiled,
which
is
quite
helpful.
We
could
stop
here,
commit
and
make
that
the
end
of
it
and
submit
our
pull
request
and
call
it
a
day.
But
compilation
and
testing
are
different.
A
A
The
way
that
tests
are
actually
implemented
is
unit
test.
I'll,
speak
first
to
unit
test
is
at
the
bottom
of
most
files.
People
typically
put
these
at
the
bottom.
You'll
see
this
mod
tests
or
mod
test.
It
doesn't
really
matter
what
it's
called,
but
it
gets
put
behind
this
configuration
test
macro,
which
means
in
the
normal
build.
This
code
is
not
built
in
a
test
build,
which
is
what
cargo
test
is
going
to
do
for
us.
A
A
You
know
public
methods
or
private
methods
that
are
not
exported
via
the
pub
modifier
like
this
crate
version
here
is
to
actually
put
the
test
inside
that
module,
and
then
this
fancy,
syntax
of
use
super,
is
going
to
pull
those
into
the
scope
of
the
the
test
module
down
here.
Anyways
long
story
short,
let's
implement
the
thing
or
run
the
tests,
so
part
of
the
reason
I
wanted
to
run.
The
test
is
because
I
was
sure
that
there
was
a
test
that
actually
was
going
to
look
for
this
error.
A
This
test,
however,
is
in
the
integration
tests
which
are
in
the
test
directory
integration
tests
can't
use
anything,
that's
not
publicly
that
doesn't
have
the
pub
on
it,
so
it
doesn't
have
the
the
modifier
but
they're
really
useful
for
writing
tests
for
how
users
are
actually
going
to
use
the
crate,
and
so
we
have
assert
matches,
result
unwrap
error,
I
think
I'll.
Just
I
don't
actually
care
about
the
string.
We
don't
need
to
do
any
assertion
on
that.
I
think
this
will
work.
A
A
So
now
my
tests
have
passed,
not
just
my
my
unit
tests,
my
integration
tests,
so
everything
is
looking
looking
great
one
thing
that
I
like
to
do:
you
can
set
up
your
ide
or
your
editor
to
do
this.
For
you,
you
can
also
set
up
a
pre-commit
hook,
there's
a
really
helpful
command
called
cargo
format,
which
I
think
they
took
a
page
out
of
golang's
book
and
introduce
this
feature
which
helps
ensure
that
rust
code
is
all
sort
of
uniformly
formatted,
which
means
we're
no
longer
argumenting,
arguing
about
syntax
changes
and
potatoes.
A
A
The
original
code
and
I'll
go
to
the
the
original
code
was
just
this
enum,
and
so
I
think
I
may
know
what
you're
asking
about
so
we're
not
actually
that's
a
good
catch,
we're
not
actually
printing
this
out
wow.
What
is
that
so
we
we
return
the
string,
so
we
attach
the
string
onto
the
enum
variant,
the
tuple
we're
not
actually
printing
it
out,
which
is
quite
helpful,
and
I
don't
remember
with
a
tuple
variant
how
this
works.
A
A
I
don't
remem
there's
this
this.
Does
the
error
formatted
it's
that
zero
format,
so
I
actually
need
to
print
out
the
string
that
we're
passing
along,
and
so
I'm
gonna
do
what
this
readme
tells
me
to
do,
which
is
just
to
do
that
which
is
the
formatter
for
the
tuple
there
all
right.
Let
me
do
a
build
real,
quick
make
sure
I
didn't
screw
anything
up.
A
A
A
A
And
I'm
not
going
to
do
you'll
notice
that
there
are
these
other.
Let
me
go
over
to
this.
There
are
these
other
variants
here
of
this
enum
that
could
use
the
same
treatment,
but
I'm
not
going
to
do
those
I'll
leave
those
for
somebody
else
to
do
so.
I'm
not
going
to
mark
the
issue
as
fixed
as
of
yet
so.
A
A
And
then,
the
very
very
last
part
of
creating
your
first
rest,
pull
request
is
actually
making
the
pull
request
so
delta
rs.
Let
me
make
this
window
a
little
bit
bigger
where's
that
damn
delta
rs
uses
something
you'll
find
in
a
lot
of
other
projects.
We
use
a
pull
request,
template
which
is
very,
very
helpful,
and
I'm
going
to
adjust
my
pull
request
appropriately.
A
A
So
with
that,
we've
got
our
first
simple,
pull
request
in
rust.
Thank
you
to
patatas
and
qp
for
providing
some
some
help
in
the
in
the
chat.
This
is
now
going
to
have
github
actions
run
against
it.
We
use
github
actions
very
heavily
in
the
delta
rs
community
to
run
tests
on
a
lot
of
different
architectures
and
to
do
a
lot
of
things.
So
I'm
not
gonna
wait
for
all
those
to
complete
I'll.
Just
show
you
the
diff
of
what
we
did
if
you're
just
getting
started
with
rust.
A
A
Please
join
the
slack
on
delta
io
I'll
pull
that
up
again.
If
you
go
to
the
bottom
of
delta
io,
you
can
join
the
slack
our
google
group
or,
of
course
you're
following
you're,
watching
us
on
youtube
already,
but
those
are
really
great
places
to
get
help
or
learn
more
about
what
we're
doing
here
in
the
delta
lake
community.
A
But
with
that
said,
if
you
want
to
watch
me,
do
some
live
coding
more.
I
I
stream
irregularly,
I
will
say
on
twitch,
so
that's
twitch.tv
agent,
dero
I'll
go
ahead
and
pull
that
up
before.
I
call
it
a
day
and
I'm
usually
hacking
on
delta
rs.
So
if
you
want
to
learn
more
about
delta,
rs
or
the
code
that
makes
it
work
or
how
it
comes
together
or
how
it
can
be
used,
you
can
follow
me
on
twitch.