►
Description
Presented by: Sarah Kaiser
Building a new open source community can be challenging, especially when it involves cutting-edge tech like quantum computers. Building on the traditional LLVM-based technology stack, the QIR Alliance creates tools and specifications to enhance popular developer tools, from Python to C++, with access to quantum accelerators. This session will share how Codespaces can reduce barriers to development and encourage community building, so everyone can contribute to the development of quantum computing.
As always, feel free to leave us a comment below and don't forget to subscribe: http://bit.ly/subgithub
Thanks!
Connect with us.
Facebook: http://fb.com/github
Twitter: http://twitter.com/github
LinkedIn: http://linkedin.com/company/github
About GitHub
GitHub is the best place to share code with friends, co-workers, classmates, and complete strangers. Millions of people use GitHub to build amazing things together. For more info, go to http://github.com
A
A
I
am
really
excited
to
be
here
with
you
at
GitHub
universe
and
share
a
little
bit
about
how
the
open
source
Quantum
Community
develops
with
code
spaces,
but
first
hi
I'm,
Dr,
Sarah,
Kaiser
I'm,
a
senior
Cloud
developer
Advocate
at
Microsoft
and
a
qir
Alliance
core
maintainer
I've
been
a
research
pythonista
for
over
10
years
now,
working
on
all
kinds
of
different
cool,
Cutting,
Edge
Technologies,
everything
from
using
Jupiter
notebooks
to
control
satellite
Optics
to
building
VR
hardware.
And
what
we'll
be
talking
about
today
is
quantum
Technologies.
A
A
A
Somebody
said
it
was
really
hard
and
I
said:
okay,
try
me,
but
having
worked
in
the
field
for
quite
some
time
now,
I
really
don't
think
it
has
to
be,
and
what
I
want
to
show
you
in
the
talk
in
my
talk
today
is
how
the
qir
alliance,
which
is
part
of
the
quantum
open
source
Community,
uses
tools
like
code
spaces
and
vs
code,
to
reduce
some
of
those
barriers
and
make
developing
the
quantum
stack
easier
and
just
a
more
pleasant
experience.
Let's
talk
a
little
bit
about
what
some
of
these
barriers
are
like.
A
Why
is
developing
Quantum
technology
hard?
Well,
maybe
something
that's
kind
of
obvious
is
the
actual
Hardware.
The
software
is
challenging
a
lot
of
times
people
kind
of
default
to
thinking
about
the
hardware
in
this
case,
but
for
the
purposes
of
this
talk,
we're
really
going
to
be
thinking
about
pretty
much
everything
but
Hardware.
There's
lots
of
great
people
who
are
working
on
in
industry
in
Academia
that
are
working
on
developing
that
Hardware,
but
even
if
I
had
a
device
today,
I
would
need
actually
a
way
to
connect
to
it
and
use
it.
A
So
that's
where
a
new
stack
comes
in,
because
quantum
computers
are
like
a
hardware
accelerator,
we
can
kind
of
cheat
off
of
what
we
learn
from
developing
for
gpus
and
kind
of
draw
out.
This
very
high
level
stack
sort
of
diagram
where
we
have
end
users
working
in
a
very
high
level
language.
We
take
the
programs
written
there
and
we
compile
them
down.
We
transpile
them.
A
We
optimize
them
and
then
send
them
off
to
some
sort
of
cloud
service
that
handles
job
queuing
and
management,
targeting
our
programs
to
specific
hardware
and
forwarding,
then
everything
along
to
the
actual
Hardware
devices
with
the
providers
so
pretty
much.
All
of
this
is
in
common
with
some
of
the
really
specialized
GPU
resources,
except
for
the
part
where
it's
actually
running
the
the
accelerator
that
it's
running
on.
A
So
given
we're
borrowing
so
much
from
existing
technology
and
infrastructure,
it
does
kind
of
come
with
the
same
problems,
so
things
like
how
do
we
actually
integrate
new
workflows
into
tools
that
developers
are
using,
whether
that
be
Ides
or
CI
CD
pipelines?
How
do
we
make
reproducible
development
environments
as
a
maintainer?
A
That
is
something
I
really
don't
like
spending
time
on
and
I
really
want
to
make
sure
that
everyone
kind
of
can
have
access
to
this,
my
machine
and
accordingly,
when
you
start
stacking
up
all
of
these
different
layers,
it
can
be
kind
of
challenging
to
track
and
debug
everything
through
that
stack,
and
so
it
either
takes
a
lot
of
skills
and
experience
or
really
good
tooling,
to
help
you
kind
of
track
all
of
that
down.
So
these
are
you
know
some
of
the
challenges
and
on
the
technology
side,
but
they're,
honestly
kind
of
familiar.
A
The
other
main
challenge
that
we
face
in
the
quantum
Tech
Community
is
well
building
the
community.
Obviously,
most
open
source
Technologies
go
through
the
same
sort
of
growing
pains
and
I.
Think
some
of
the
challenges
that
we
have
in
Quantum
are
that
the
quantum
Community
is
extremely
broad.
We
have
folks
who
are
kind
of
almost
on
the
pure
research
side,
they're
mathematicians,
developing
new
programming
languages,
to
people
in
the
middle
who
are
developing
the
cloud
infrastructure.
You
know
that
queuing
and
job
management.
What
does
it
look
like
to
do?
Cicd
for
a
quantum
computer?
A
Do
the
folks
who
are
actually
building
the
hardware.
People
can
come
from
very
widely
different
backgrounds,
very
different
experience
with
open
source
software
and
well.
We
really
want
to
bring
them
all
together
and
actually
build
something
together.
So
some
examples
of
these
barriers
on
a
social
level
are
things
like
Hardware
access,
so
sometimes
these
big
compiler
tool
chains
or
even
just
Quantum
Hardware
access
can
be
really
hard.
A
If
you
have
a
really
old
laptop,
it's
going
to
take
a
long
time
so
being
able
to
make
sure
that
the
community
has
access
to
adequate
Hardware,
as
you
might
guess,
because
this
is
so
closely
tied
to
research.
Things
move
pretty
fast,
and
so
we
really
have
to
be
good
about
not
only
staying
on
top
of
the
developments,
but
packages
will
break.
Documentation
will
be
out
of
date,
and
so
it's
really
important
to
kind
of
keep
moving
that
along,
because
then
that
leads
to
the
next
problem,
which
is
onboarding.
A
If
someone
comes
to
your
project
and
the
docs
are
so
wholly
out
of
date,
it's
going
to
be
really
hard
for
them
to
get
started,
even
if
it's
a
relatively
simple
thing
that
they
want
to
contribute.
And
lastly,
but
not
leastly,
accessibility,
inclusion.
This
is
something
that
I
think
has
been
really
important
to
me.
Learning
from
the
broader
open
source
community
and
bringing
this
back
to
the
quantum
open
source
communities
is
making
sure
that
everyone
from
all
of
these
widely
varied
backgrounds
and
skill
levels
feels
like
they
can
be
included.
A
A
That
is
a
lot
of
words
and
a
lot
of
syllables,
but
this
is
a
Linux
Foundation
project,
Under
The,
Joint
development
foundation
program
and
it
is
an
industry-wide
Coalition
with
members
like
Microsoft
Nvidia
and
Hardware
providers
like
quantinium
and
regetti
National
research
Labs,
like
Oak
Ridge,
and
this
is
really
a
cool
effort
that
honestly
there
isn't
really
anything.
Quite
this
Broad
in
Quantum
Tech
yet
and
the
goal
is
to
really
help
build
out.
A
This
Quantum
stack
build
the
tooling
and
the
specifications
that
we
need
so
that
when
people
are
building
Cool
Tools,
they
can
actually
work
together.
So
that's
a
full
interoperability
and
right
now
there
is
a
lot
of
development
effort
that
gets
duplicated
because
you
have
tool
a
and
Tool
B.
You
need
to
make
basically
custom
connectors
between
every
set
of
tools.
So
that's
where
this
intermediate
representation
comes
in
so
qir
or
Quantum,
intermediate
representation
is
lvm
but
make
it
quantum.
A
So
lovm
is
a
low-level
machine
representation
of
regular
programs
and
so
qir
kind
of
takes
that
and
expands
on
it
to
include
instructions
that
Quantum
devices
can
also
perform.
And
so,
if
we
think
about
that
kind
of
Stack
diagram,
we
were
looking
at
before.
Qir
can
really
act
as
the
glue
between
all
of
these
different
layers
rather
than
having
to
make
custom
connectors
between
each
piece.
Uir
is
also
really
interesting
because
it
can
represent
fully
General
Quantum
programs.
A
So
that's
not
only
all
the
quantum
instructions
that
these
devices
can
execute,
but
all
the
classical
instructions
as
well,
which
is
really
critical
to
real
scalable
applications
of
quantum
Computing
and
because
we're
based
off
of
llvm
there's
a
lot
of
tools
from
that
tool
chain
that
just
work
out
of
the
box.
As
a
physicist
I
know,
we
like
to
reinvent
the
wheel,
sometimes,
but
I
really
appreciate
that
we
can
build
off
the
work
that
others
have
been
working
on
for
a
long
time
and
use
that
to
make
Quantum
development
easier.
A
Travis
humble
is
someone
who
is
a
member
of
the
qir
alliance
and
said
that
he
was
very
excited
for
Oak
Ridge
National
Labs.
That
qir
really
provides
this
kind
of
focal
point
for
the
industry
to
kind
of
start
converging
efforts
and
actually
encourage
not
only
industry
applications
but
really
good
research
and
importantly,
reproducible
research.
So
that's
kind
of
a
taste
of
the
qir
alliance
and
what
qir
is
I
think
it's
pretty
cool.
Hopefully
you
might
think
it's
cool,
but
where
do
we
go
from
there?
A
This
is
where
code
spaces
comes
in,
so
the
qir
alliance
had
been
working
on
developing
the
specification
and
started
building
building
all
of
these
tools
to
work
with
qir,
but
it
was
a
really
painful
experience.
There
were
a
lot
of
I
mean
just
setting
up
tool
chains
that
touch
all
kinds
of
different
languages
and
Frameworks
from
python
to
rust,
to
C
plus
plus
to
Julia
like
it's
kind
of
a
mess.
A
So
we
were
really
looking
for
something
that
we
could
use
to
help
get
people
in
and
get
people
developing
on
these
tools
to
kind
of
bootstrap
the
effort
we
learned
about
code
spaces
and
started
trying
out,
and
it
was
awesome.
So
if
you
haven't
heard
about
code
spaces,
it's
a
GitHub
product
that
allows
you
to
spin
up
basically
machines
on
demand
from
your
browser
right
from
a
repo,
so
you
can
just
kind
of
where
you
would
normally
click
to
clone
the
green
button
to
clone
a
repo.
A
You
now
have
the
option
to
create
a
code
space
and
that
then,
in
your
right
away
in
your
browser,
very
quickly
gives
you
a
vs
code
interface
to
directly
work
on
the
code
in
that
repo.
So
we
are
now
entering
the
demo
Zone
and
the
asterisk
or
caveat
I
want
to
add
here
is
I
am
working
with
a
lot
of
qir
Alliance
projects,
General
Quantum,
open
source
projects
as
well,
and
a
lot
of
this
is
research.
A
A
Maybe
you
can
help
contribute,
let's
actually
start
working
on
the
quantum
stack
in
code
spaces
I'm,
going
to
walk
you
through
the
entire
stack
from
writing
a
Quantum
program
in
Python,
so
that
would
be
kind
of
the
experience
of
either
a
researcher
or
user
of
quantum
Hardware
accelerators
we're
going
to
compile
that
program
to
qir
using
Python
and
rust.
Once
we
have
a
qir
representation,
we
can
use
some
C
plus
tools
and
llvm
out
of
the
box
tools
to
help
optimize.
A
You
can
see
the
GitHub
repo
for
that
there,
let's
hop
over
to
code
spaces
and
take
a
look
all
right
so
now
we're
in
a
local
vs
code
window
here
which
I
have
connected
through
the
GitHub
code,
spaces
extension
to
a
code,
space
I
already
spun
up
curly
space
doodle,
it's
a
great
name
and
you
can
see
I've
got
eight
cores
and
16
gig
ram
here.
So
not
a
bad
machine.
A
So
I'm
gonna
take
a
look
here.
We've
got
a
Jupiter
notebook
that
I'm
going
to
open
up
and
there's
lots
of
great
stuff
in
this
repo
which
you'll
get
a
link
to
at
the
end
of
The
Talk
but
you'll.
You
can
learn
more
about
all
the
stuff
that
I'm
talking
about
here,
but
let's
actually
get
started.
Writing
a
Quantum
program
in
Python.
So,
as
I
mentioned,
we'll
be
using
a
Quantum
package
called
Q-tip,
and
you
know
in
a
very
similar
way
to
how
you
might
build
up
a
program.
A
You
know
maybe
some
very
early
programming
classes,
we'll
make
sure
we
get
Q-tips
now
imported
and
you
can
see
up
here
in
my
notebook
I,
actually
picked
the
environment
or
kernel
that
I'm
running
my
code
in
and
when
I
spin
up
the
code
spaces.
It
actually
makes
this
conda
environment
for
me
called
qir
demo,
so
we've
imported
our
Q-tip
package
here
and
we're
basically
going
to
build
a
program
here.
Vs
code
is
suggesting,
with
the
type
hinting
that
I
actually
insert
these
tie
pins.
A
A
Quantum
computers
kind
of
have
a
just
like
you
would
do
ands
and
ORS
or
not
Gates
on
your
classical
computer.
Quantum
computers
also
have
a
bunch
of
different
Gates
or
operations.
They
have
different
names
but
same
sort
of
concept,
so
we've
got
Quantum
ones.
We've
got
some
classic
some
classical
ones
here.
A
Where
we're
actually
reading
out
memory
on
our
quantum
computer
and
then
we
can
even
do
other
things
like
condition
some
Quantum
operations
on
those
classical
that
data
we
read
out
earlier
and
if
we
take
a
look
at
the
state
of
our
program
after
that,
we
see
basically
the
same
sort
of
list
of
instructions,
but
this
then
gives
us
a
python
description
of
a
Quantum
program
that
we
might
want
to
run.
The
actual
program
here
is
a
teleportation
program
which
is
very
similar
to
the
C
move
operator.
A
It
basically
just
takes
information
on
one
part
of
your
device
and
moves
it
somewhere
else.
So
teleportation
isn't
weird
or
strange.
It's
just
a
move
cool.
Now
that
we've
got
our
Quantum
program
in
Python,
let's
actually
add
some
Rust
to
the
mix
and
use
Q-tip
and
the
pi
qir
package
to
actually
compile
that
Python
program
to
qir.
So
we'll
go
back
to
our
notebook
here
and
honestly,
it's
really
pretty
easy
with
how
Q-tip
has
integrated
qir
support,
I,
literally
just
import
this
circuit
to
qir
function.
A
You
can
read
more
about
it
in
the
docs
here,
but
yeah
I
just
pass
it
my
program
and
say
whether
I
want
a
bit
code
type
of
file
out
or
a
text
file
out
so
we'll
generate
those
here
and
well.
Looking
at
the
bid
code
isn't
super
interesting,
but
if
we
look
at
the
text
representation
of
it
the
file.
This
is
what
qir
looks
like
not
really
designed
for
humans,
but
that's
okay,
because
it
is
a
machine,
interchange
format.
A
So
what
I
find
really
awesome
about
this
kind
of
approach
is
Q-tip
is
actually
using
pi
qir
under
the
hood.
If
you
will
and
piquir
itself,
does
this
translation
between
Python
and
qir
with
rust
and
there's
a
rust
crate
that
is
ready
to
go
and
actually
modular
such
that.
If
you
wanted
to
write
Quantum
programs
in
Rust
and
go
back
and
forth
to
piqir,
you
could
just
use
qir
lib
directly
and
actually
write
programs
in
Rust,
and
this
is
actually
a
really
interesting
and
pretty
popular
Direction
recently.
A
So
hopefully
there
are
more
rust
developers
getting
excited
about
Quantum,
so
we've
now
written
our
program
compiled
it
to
qir.
Now
we
get
to
actually
do
some
of
the
fun
stuff,
actually
it's
all
fun,
but
we'll
optimize
our
program
with
some
lovm
tooling
and
the
cat
tool
maintained
by
the
qir
alliance.
A
So,
looking
at
that
text,
file
representation
of
the
qir
again
not
super
helpful.
If
you
want
to
debug
something
so
we
can
actually
use.
This
is
the
case
whether
it's
llvm
or
qir,
so
lvm
actually
has
a
nice
tool
here.
It's
a
command
line
tool
called
opt
that
gives
you
an
optimization
pass
that
actually
just
takes
your
program
and
generates
a
control
flow
graph.
So
I
can,
in
my
python-based
notebook
I
can
actually
run
bash
commands
by
using
this
bang
here
at
the
front.
A
But
I'll
just
run
this
command
line
tool
to
generate
our
control
flow
graph
and
I
just
move
it
because
I
don't
like
the
name
and
now
we've
got
this
kind
of
text
file,
but
I
actually
want
to
see
it
as
a
it's.
A
representation
of
an
image
so
I
have
an
extension
installed
in
vs
code.
That
allows
me
to
preview
this,
so
I
will
get
that
maximized
here
and
yeah.
A
A
But
this
is
this
is
kind
of
a
helpful
way
if
you're
just
looking
to
do
some
quick
gut
checks
or
just
inspecting
what
those
qir
files
are
describing
our
code
space
also
has
the
image
magic
tooling
installed,
so
that
you
can
also
output
that
directly
to
an
image.
If
you
want
to
share
it
that
way,
all
right,
so
we
now
have
kind
of
a
better
sense
of
what
our
qir
program
looks
like.
Let's
optimize
it
so
I'm
going
to
do
the
same
thing
here.
A
A
So
obviously
the
file
sizes
here
are
just
not
that
big
to
start
with,
but
you
can
see
that
after
we
run
cat,
our
file
size
does
go
down
and
you
can
see
a
lot
more
drastic
or
interesting
examples
of
this
in
the
actual
cat
repo
on
GitHub.
So
there's
lots
of
cool
tests
and
documentation
there.
That
gives
you
examples
that
you
can
really
see
how
drastic
some
of
these
optimizations
are
great.
So
now
we
have
optimized
our
Quantum
program.
We've
got
a
really
great
Quantum
program
now,
and
we
want
to
actually
run
it.
A
A
So
now
that
I've,
that's
basically
like
creating
the
resource
on
azure
I
will
load
up
the
bit
code
for
it's
a
slightly
different
program
than
what
we
generated
before,
but
it's
roughly
the
same
thing
and
then
it's
pretty
much
as
easy
as
just
sending
this
job
from
input
data
function
and
you
can
see.
We've
got
our
bit
code
here.
We've
got
we're
going
to
send
this
to
rigetti
rigetti
Hardware
provider
and
to
their
Quantum
Virtual,
Machine
Target,
sometimes
Q
times
for
Hardware
can
be
pretty
long.
A
A
A
So,
let's
see
if
our
job
is
done-
and
it
is
here's
our
actual,
these
were
the
measured
qubit
outcomes.
So
when
you
measure
a
qubit,
you
get
a
one
or
zero,
and
it
says
here
that
we
ran
our
program
one
time
in
reality,
we
should
probably
run
it
more
than
once,
but
yeah.
This
ensures
that
it
goes
quickly.
So
now
we've
actually
walked
all
the
way
from
writing.
A
A
user
level
Quantum
program
all
the
way
down
to
a
running
it
on
Hardware
through
a
cloud
provider,
and
it
really
isn't
spooky
or
strange
or
weird
their
Quantum
programs,
but
it's
all
pretty
familiar
and
it
all
can
be
made
really
easy
in
codespaces,
so
we've
actually
been
able
to
walk
a
Quantum
program.
All
the
way
from
user
space
down
to
running
on
Hardware
I
always
get
super
excited
about
this
and
I
hope.
A
It
seems
really
cool
and
exciting
to
you
as
well
a
lot
of
times
people
say:
Quantum
Computing
is
spooky
or
strange
or
hard,
but,
as
you
can
see
it,
we
can
make
it
a
lot
easier
with
code
spaces,
so
to
kind
of
wrap
things
up.
Code
spaces
does
make
Quantum
development
easier
and
it
reduces
a
lot
of
the
barriers
and
challenges
that
our
community
faces.
So
it
allows
us
to
get
started
coding
faster
in
the
cloud.
A
This
is
great
not
only
from
a
activating
on
people's
excitement
about
the
topic
and
getting
them
contributing
to
projects,
but
also
making
contributing
more
accessible
to
folks
who
maybe
don't
have
adequate
Computing
Hardware
to
actually
build
the
tool
chains
or
compile
what
they
need
to
code
spaces
also
makes
it
really
easy
to
spin
up
standardized
Dev
environments.
So,
as
someone
who's
a
maintainer
for
projects,
I
don't
want
to
spend
as
much
time
trying
to
play.
A
A
It's
really
popular
in
the
quantum
Community
more
broadly
and
it's
kind
of
a
really
nice
sort
of
comfort
when
you're
learning
something
new
and
you
want
to
dive
in
and
now
you
can
actually
work
in
a
tool
in
a
space
that
you
are
familiar
with
and
hopefully
build
some
cool
things.
Thank
you
so
much
for
joining
me
today
and
I
hope
this
might
interest
you
in
getting
started
in
developing
the
quantum
open
source
stack.
I,
definitely
say
hi
to
me
on
the
internet.
A
I
am
crazy
for
pi
314,
pretty
much
everywhere,
Twitter
GitHub
Etc,
and
if
you
want
to
check
out
the
code
for
this
demo,
you
can
go
to
AKA
dot,
Ms,
slash,
Quantum,
Dash,
codespaces
and
even
just
spin
up
the
code
space
and
get
going
and
if
you're
interested
in
the
Jupiter
notebook
interface
that
I
was
using
for
the
the
actual
demo.
They
work
in
a
lot
of
different
languages,
not
only
python,
but
net
R,
so
definitely
check
out
AKA
dot,
Ms,
slash,
vs
code,
notebooks,
Dash
Universe.
Thank
you.
So
much.