►
From YouTube: DAML Deep Dive and Demo
Description
A recording of the Tech Study Circle hosted by Hyperledger Sweden on Friday, January 15, 2021 featuring Anthony Lusardi from Digital Asset who did a DAML deep dive and a demo of DAML's ability to be written once and deployed anywhere.
More about DAML is at: https://daml.com/
More about the event is at: https://www.meetup.com/Hyperledger-Sweden/events/ctplzrycccbtb/
----
Hyperledger – Open Source Blockchain Technologies
Hyperledger is an open source community focused on developing a suite of stable frameworks, tools and libraries for enterprise-grade blockchain deployments.
It serves as a neutral home for various distributed ledger frameworks including Hyperledger Besu, Fabric, Sawtooth, Indy, as well as tools like Hyperledger Avalon, Cactus and libraries like Hyperledger Aries, Ursa. Learn more about Hyperledger projects: https://www.hyperledger.org/use
Case Studies: https://www.hyperledger.org/learn/case-studies
Training & Certification: https://www.hyperledger.org/learn/training
Tutorials: https://www.hyperledger.org/use/tutorials
Webinars: https://www.hyperledger.org/learn/webinars
Events: https://www.hyperledger.org/events
Vendor Directory: https://www.hyperledger.org/use/vendor-directory
Subscribe to the Hyperledger Newsletter: https://www.hyperledger.org/newsletter
Follow-us on Twitter @Hyperledger
Learn about Hyperledger Membership: https://www.hyperledger.org/about/join
#Hyperledger #HyperledgerMeetups #Blockchain
A
B
Sec,
okay,
so
yeah
hello.
Welcome
to
this
hyperledger
sweden
meetup.
My
name
is
oland
and
I'm
your
guest
for
today's
session.
Today
we
have,
we
have
a
guest
speaker
and
antonio
luzavi
from
dummy,
and
he
will
give
us
an
introduction
to
the
dummy
language
and
he
will
show
us
also
how
we
can
use
stamina
in
the
world
of
fabric
and
maybe
in
the
world
of
saltwater
and
yeah.
This
is
an
open
session.
B
I
call
this
open
session
and
that
means
that
everybody
who
is
interested
and
give
a
talk
to
the
topic
to
hyper
lecture
related
topics
can
reach
me
and
then
we
can
find
an
meetups
termine
and
then
you
can
present
your
project
or
on
something
what
you
all,
what
you
learn,
and
so
yeah
and
and
today
I
am
happy
to
introduce
antonio
luzadi
and
he
will
give
us
an
introduction
to
the
word
of
dharma
okay.
So
if
you're
ready,
then
you
can
start
antonio.
A
Thank
you,
roland
yeah,
first,
big
big,
thank
you
to
roland
for
helping
put
this
together
and
for
giving
me
time
to
present
on
tamil.
I
think
it's
a
really
cool
language
so
really
excited
to
to
be
presenting,
and
thank
you
very
much
for
putting
this
together.
Just
to
give
you
a
little
bit
of
background
on
myself.
My
name
is
andrew
lusari
and
I've
been
a
developer
advocate
at
digital
asset
who
produces
the
open
source
language
demo
for
the
last
year.
A
Now
just
came
up
on
my
one
year
anniversary
about
a
week
ago
and
yeah.
You
know
I've
just
been
interested
in
this
space
for
a
really
long
time.
I
am
kind
of
a
diehard
bitcoin
or
two
on
the
side
in
the
public
space,
but
I
think
that
demo
itself
is
a
very
interesting
language
for
the
more
private
distributed
ledger
spacing
in
this
whole,
very
broad
ecosystem.
A
So
today
I'm
going
to
be
presenting
a
few
things.
We're
going
to
start
with
a
presentation.
That's
basically
going
to
say
you
know
kind
of.
Why
would
you
want
to
use
demo
and
what
cases
would
you
and
kind
of
like
what
is
it
really
and
then
I'll
be
deploying
demo
live
on
multiple
infrastructures
all
run
locally,
of
course,
on
fabric
and
sawtooth,
and
then
we'll
have
time
for
questions
at
the
end.
A
But
if
you
have
any
questions,
while
I'm
going
through
this,
if
anything
isn't
clear,
you
know
you
can
always
feel
free
to
interrupt
me.
I
really
don't
mind
and
yes,
so,
let's
get
started
so
the
first
question
I
have
here
is:
basically
you
know:
don't
we
already
have
all
the
programming
languages
we
need.
We
have
quite
a
few
that
will
run
on
blockchains
and
distributed
ledgers,
and
then
we
also
have
so
many
languages
in
this
world.
Why?
One
more
and
really
my
answer?
A
Is
we
don't
and
the
reason
that
I
say
this
is
because
we
have
a
lot
of
languages
that
kind
of
do
the
same
things
in
different
ways.
All
our
languages
that
we
work
with
today
are
largely
imperative.
All
of
them
are
largely
class-based
and
they
do
have
niceties
so,
for
example
like
if
I
were
to
write
and
go,
I
could
probably
you
know,
get
up
and
go
faster
than
I
could
in
some.
C
A
You
know
you
write
to
your
sql
database,
whatever
you
want
and
you
can
change
it
whenever
you
want,
and
you
can
even
roll
it
back
in
time
and
a
lot
of
these
fairly
common
things.
When
a
lot
of
people
come
into
this
space
and
try
to
write
programs,
they
realize
that
they
can't
do
these
things
and
the
reason
they
can't
do.
A
These
things
is
because
that's
not
the
way
that
our
data
persistence
layers
are
really
designed
here,
and
so
I
think
we
should
have
languages
that
kind
of
help
you
know
encapsulate
this
and
thus
by
encapsulating
it
will
make
our
lives
a
little
bit
easier,
so
demo
really
differs
and
what
it
does
here
and
I'm
gonna
go
into
that
a
bit
I'm
also
gonna
show
I
should
have
mentioned
some
source
code
during
right
after
this
presentation
and
before
I
actually
deploy
it.
So
what
is
donald?
A
You
know,
I'm
on
slide
six
already,
just
let's
get
to
the
point.
What
does
demo
do
and
demo
is
basically
a
portable
language
for
distributed
ledgers
and
really
a
lot
of
databases,
but
it's
designed
for
distributed
ledgers,
and
so
what
I
mean
by
that
is
that
demo
is
a
language
that
is
really
centered
around.
A
This
idea
of
you
have
a
state,
and
then
you
update
it
and
the
language
itself
handles
a
lot
of
things
for
you,
so
this
actually
that
you're
seeing
on
screen
now
is
code
that
I'm
going
to
go
through
in
a
little
bit,
but
just
to
give
you
a
taste,
this
is
kind
of
what
it
looks
like
and
how
it's
structured
and
what
this
structure
does
is.
It
enables
the
demo
driver
and
various
thermal
components
to
know
a
lot
about
your
program
without
you
having
to
be
very
explicit
about
it.
A
So,
with
this
code
here,
demo
has
encapsulated
all
the
business
logic
that
we
need.
It's
kept
track
of
read,
write
and
execute
permissions,
which
are
actually
fairly
similar
to
the
way
that
unix
does
it.
We
even
have
one
of
my
co-workers
actually
wrote
a
blog
post
on
this.
That
I
thought
was
at
a
really
good
point,
and
it
also
knows
how
to
store
the
data
all
without
somebody
having
to
tell
it,
and
so
it
still
powers
front
ends,
though,
that
kind
of
look
like
any
regular
front
end.
A
Here's
the
actual
vue.js
code
all
copied
and
pasted
to
a
slide
just
to
drive
home
the
point,
and
you
also
get
a
lot
of
nice
cities
out
of
this.
So
going
back
here,
you
not
only
get
your
data
persistence,
you'll
also
get
your
json
api
you'll
get
every
way,
you're
going
to
interact
with
your
back
end
with
your
front
end,
basically
for
free,
and
so
you
can
think
about
demo
really
as
a
consistent
language
for
distributed
and
relational
databases.
A
You
can
get
up
and
going
really
quick
in
demo,
and
you
can
do
it
without
worrying
about
which
back
end
you're
going
to
deploy
to
you
can
go
ahead.
Start
writing
your
demos
start
iterating
and
decide
whether
you're
deploying
to
fabric
or
sawtooth
or
eventually,
we'll
have
support
for
besu
whenever
you're
ready.
A
A
So
basically,
you
know
if
you
need
to
change
one
of
your
demo
models,
it's
generally
not
very
complicated,
and
because
everything
is
so
well
permissioned
when
you
go
and
start
changing
things
if
you've
changed
something
that
something
else
depends
on
and
you
haven't
updated
the
other
dependency.
Well,
it's
going
to
immediately
error
at
compile
time
for
pretty
much
every
case,
and
it's
also,
you
know,
like
I
mentioned
earlier
very
ideal
for
transitioning
from
rapid
prototyping
through
to
production
deployment
prototyping.
A
It's
quite
quick
in
and
you'll
see
people
on
our
forums
who
are
regularly
prototyping
their
their
ideas
in
demo
and
then
even
in
production
demo
is
being
developed
and
deployed
at
australian
stock
exchange
at
hong
kong
exchange
and
a
bunch
of
healthcare
and
other
financial
applications,
and
hopefully
I
think
it
should
be
deployed
in
a
variety
of
different
applications
and
there's
quite
a
lot
of
others
working
on
demo
stuff
too.
But
I
can
never
remember
who
I
can
and
can't
talk
about.
A
So
just
take
my
word
on
that,
and
so
now
I
kind
of
need
to
you
know,
prove
everything
I
said
so
we're
going
to
check
out
my
toy
production
app.
Now
it's
called
obir.
It
basically
is
a
way
to
record
on
a
distributed
ledger
who
owes
who
a
beer
who
has
an
obligation
to
who
and
then
we're
going
to
deploy
it
on
fabric
and
sawtooth
and
just
to
prove
how
portable
this
is.
A
If
I
remember
I'm
not
going
to
rebuild
my
project
in
between
when
I
deploy
it
on
fabric
and
sawtooth,
I'm
going
to
just
deploy
the
same
exact,
compiled
dar
file,
so
yeah,
let's
get
started
with
this
all
right.
So
first
thing
I
need
is
demo
on
fabric,
which
is
a
demo
driver
and
what
we
mean
by
the
term
demo
driver
is
that
this
is
essentially
the
layer
of
our
demo
application
or
really
our
dental
tech
stack,
not
part
of
the
application
that
is
responsible
for
writing
and
reading
data
from
our
fabric
instance.
A
So
we're
going
to
start
up
a
fabric
instance.
Then
we're
going
to
connect
our
demo
driver
to
it
and
then
to
that
we'll
connect
the
demo
json
api
and
so
the
way
it'll
work
is
we'll.
Have
our
front-end
application
talking
to
our
json
api,
or
it
could
even
talk
to
another
api,
but
a
more
advanced
one
that
I
won't
be
covering
today
and
after
it
talks
to
the
json
api.
A
So
that's
kind
of
the
architecture,
and
that's
also
how
we
get
this
portability,
because
in
every
single
case,
you're
starting
up
a
demo
driver
that
actually
talks
to
the
chain
and
records
data
there.
You,
the
trade-off
here
to
keep
in
mind,
is
that
you
don't
get
a
you,
don't
get
to
actually
manage
the
transactions
directly
on
your
fabric
instance,
you
couldn't
write
some
chain
code
that
reads
and
writes
them,
but
in
exchange
for
that,
you
get
this
very
portable
language,
and
really
we
should
be
thinking
about.
A
C
A
A
A
A
A
So
what
I
opened
up
over
here
is
our
deployment
guide.
To
that
I
wrote
previously.
It
basically
shows
how
to
deploy
one
of
our
example.
Applications
on
download
fabric
I'll,
be
showing
you
a
different
application,
but
let's
just
follow
through
for
the
steps.
Okay,
so
first
step
is
going
to
be
building
our
dam
lab
and
in
that
case
I'm
going
to
be
using
oh
beer,
which
is
a
really
small
little
app
for
owing
your
friends
and
enemies.
A
A
Drivers
are
apache
2,
so
if
you
want
to
check
those
out,
feel
free
and
then
we're
going
to
run
download
code,
gen
js
and
what
this
will
do
is
it'll
actually
go
ahead
and
look
at
our
model
and
generate
a
lot
of
nice
javascript
code
for
you,
and
while
I
say
that
I
just
remember
that
I
haven't
actually
shown
you
the
code
yet
that
we'll
be
deploying.
So
let
me
hop
over
there.
First
actually
I'll
show
you
this
after
we
deploy
the
first
one.
A
A
B
A
B
So
you
use
this,
we
start
the
network
script.
Maybe
in
this
script
is
because
we
have
to,
and
then
the
next
question
is,
do
I
need
a
chain
code
for
this,
so
I
need
I've
seen
the
the
genesis
block
is
created
through
your
script
and
then
we
we
need
some.
You
know
a
channel
in
the
chain
code
to
run
this
to
one
favorite
so
and
then
your
con,
your
driver,
connects
to
fabric.
So
what
is
the
point
where
we,
where
the
connection
starts.
A
Yeah
for
the
the
chain
code
itself.
Basically,
our
demo
driver
has
some
custom
chain
code
that
basically,
when
you
we
start
up
fabric
over
here
it
starts
the
fabric
network.
It
sets
up
the
channels
and
peers
and
it
deploys
our
custom
chain
code
to
that
fabric
instance
and
then
that
chain
code
is
basically
going
to
be
used
for
communication
between
our
demo
driver
and
the
fabric
instance
for
managing
the
data
for
basically
reading
and
writing
to
the
chain.
B
Okay,
so
that
means
that
I
need
a
favorite
network,
so
I
can.
I
can
make
a
docker
compose
file
with
my
favorite
network
and
then
then
I
start
your
script
and
with
the
script,
the
genesis
block
for
the
for
this
network
is
created
and
also
a
channel
is
created
with
a
default
name.
And
then
your
script
creates
a
custom
chain
code
which
will
be
installed
also
on
this
custom
channel,
and
this
is
the
way
and-
and
this
is
the
way
how
this
works,
so
we
don't
have
to
create
the
chain
code.
A
A
A
Welcome
all
right
so
now
we've
got
our
driver
set
up,
and
so
now
what
we
need
to
do
is
we
need
to
go
ahead
and
deploy
our
code.
All
right
and
deployment
is
going
to
be
the
same,
regardless
of
where
we're
running
our
demo
code.
So
now
from
this
step
forward,
it's
basically
identical,
except
ports
are
going
to
change
depending
on
how
the
demo
driver
is
configured
so
over.
A
The
fabric
network
is
acknowledging
and
receiving
it,
and
so
now
our
code
is
actually
live
and
running
on
it,
and
the
next
thing
to
do
is
to
get
our
json
api
set
up.
So
here
we'll
just
run
our
download
json
api
commands,
which
torque
supports
6865
and
gives
us
us
port
7575
as
our
rest
api.
Basically,
and
now,
the
final
step
here
will
be
setting
up
our
ledger.
So
talking
to
all
ledgers
is
very
similar.
A
A
One
thing
we
do
need
to
do,
though,
is
that
our
demo
ledger
slash
driver
cares
about
the
name
of
the
ledger
id
so
in
this
case
for
the
fabric,
one
it's
fabric
ledger,
so
I'm
going
to
head
over
into
my
ui
folder
and
I'm
just
going
to
set
an
environment
environment
variables
that
talks
to
the
fabric
ledger,
and
then
I
just
have
to
go
ahead
and
start.
My
ui.
A
A
A
So
what
we
have
here
are
basically
two
templates
and
in
in
demo,
even
though
it's
not
exactly
the
same,
you
can
think
of
a
template
as
a
class.
It's
basically
some
something
that's
sitting
around
waiting
to
get
instantiated
into
a
contract,
which
you
could
also
think
about
as
akin
to
an
an
instance
of
a
class
in
an
imperative
language.
A
And
so
here
we
have
two
of
them
beer
proposal
and
beer
down
here
and
basically
we
we
need
both
of
these,
because
one
thing
that
demo
does
is.
It
requires
us
to
think
about
our
responsibilities
and
obligations
to
other
parties
on
the
network
and
to
be
very
explicit
about
them,
and
this
is
actually
one
of
the
things
where,
if
you
were
to
try
this
out,
it
might
cause
a
little
bit
of
hangup
because
probably
less
so,
for
people
used
to
distributed
ledgers.
A
But
something
I
see
sometimes
is
that
a
lot
of
people
are
just
used
to
creating
obligations
between
people
or
between
parties
without
those
parties
having
explicitly
presented
it.
So,
for
example,
you
can
kind
of-
and
this
is
why
it's
used
a
lot
of
financial
applications
and
healthcare
and
other
things
where
you
want
a
very
strong
chain
of
guarantees
of
who's
agreed
to
what
when.
A
But,
if
you
think
about
it,
almost
any
program
we
write
is
kind
of
like
that.
So,
for
example,
if
you
were
to
want
to
send
out
a
tweet,
you
know
you
might
type
up
your
tweet
and
send
it
to
twitter
and
then
twitter
would
you
know,
accept
your
tweet
and
post
it
to
your
timeline
and
share
it
on
all
your
friends,
news
feeds
and
really
in
all
of
that,
there's
no
cryptographic
or
other
guarantee
there.
That
you've
ever
asked
twitter
to
do
any
of
this,
and
there's
also
no
cryptographic
guarantee
there.
A
And
then
it
leads
to
these
very
particularly
in
the
enterprise
space,
a
lot
of
very
costly
and
ongoing
settlement
and
reconciliation
type
of
situations
where
a
lot
where
parties
have
to
come
together
and
figure
out
which
data
belongs
where
and
who
actually
did
what,
when
and
so
here
we're
trying
to
avoid
that.
So
that's
why
this
is
going
to
be
structured
like
that.
My
rather
long-winded
explanation
of
it
anyway.
A
So
here
are
our
proposals.
What
we're
going
to
do
first
is
we're
going
to
basically
make
an
offer
of
to
owe
somebody
a
beer.
So,
for
example,
I
see
bart's
during
the
call.
So
if
I
were
to
offer
bart
a
beer,
I
would
basically
say:
okay,
here's
the
proposal
with
the
beer
that's
encapsulated,
so
this
beer
here
will
be
will
represent
the
same
type
of
data.
That's
in
the
template
down
here
and
then
we
have
our
read
and
write
permissions.
A
A
A
We
get
this
very
good
thing
where,
even
though
you
know
bart-
and
I
know
each
other
from
the
demo
forums-
and
we
trust
each
other,
I
could
never
create
a
contract
that
says
bart
owes
me
is
making
a
beer
proposal
to
me
even
by
accident,
because
demo
is
guaranteeing
that
only
the
signatory
is
the
one
listed.
So
I
can't
sign
for
bart,
because
I
I
wouldn't
beat
bart's
party
on
the
ledger
and
then
we
have
a
bunch
of
execution
options
which
are
basically,
I
is
the
recipient.
Here.
A
The
controller
of
the
accept
beer
choice
can
choose
to
accept
the
beer,
as
the
controller
rejects
your
choice,
I
can
choose
to
reject
the
proposal
and
bart
as
the
giver
can
choose
to
as
long
as
I
haven't
accepted
it
yet
to
cancel
the
offer,
and
so
the
way
all
of
these
choices
work
is
that
they
are
consuming
choices
and
that's
very
much
akin
to
a
utxo
model.
It
really
is
a
utxo
model.
A
As
far
as
demo
is
concerned,
where,
when
you
exercise
a
choice
on
a
contract,
you
immediately
archive
that
contract
and
either
replace
it
with
a
new
one
or
produce
other
contracts
or
replace
it
with
nothing,
in
which
case
it
just
gets
archived.
So
then,
you
have
this
state
where
everything
is
immediately
and
it
it's
guaranteed
to
not
have
be
called
multiple
times.
So
I
wouldn't
be
able
to
no
matter
how
quick
I
was
no
matter
how
close
to
the
server
I
was.
A
A
So
when
bart
provide,
when
I
provide
my
signature
up
here,
that
is
basically
a
permission
that,
for
all
child
contracts,
spawns
from
this
contract
are
going
to
carry
over
with
my
signature
and
then
bart
since
he's
chosen
to
accept
it,
which
creates
the
beer,
can
go
ahead
and
be
the
second
signatory
on
the
contract.
So
now
we
both
have
had
guaranteed
permission
to
produce
this
bit
of
state
on
our
ledger.
We
can
again
ensure
that
giver
and
recipient
are
not
the
same
this.
A
Actually,
I
probably
don't
need
this
one
up
here
now
that
I
think
about
it,
because
this
one
down
here
will
actually
ensure
the
preconditions
as
well.
It
just
helps
that
you
can
create
an
invalid
proposal
that
somebody
could
agree
to
and
then
result
in
something
that
can't
be
created
later
and
then
yeah
ultimately
right
down
here.
I
can
then,
whenever
I
give
bart,
the
beer
bar
can
go
ahead
and
say:
okay,
I've
received
that
and
so
really
too.
A
So
that's
the
code
and
I
know
I
talked
a
lot
about
these
few
lines
of
code,
but
it
does
encapsulate
quite
a
lot
of
logic,
and
one
thing
I
should
mention
here
is
that
when
it
comes
to
the
declarations
at
the
start,
the
width
declarations-
you
can
kind
of
consider
these
as
kind
of
columns
in
a
sql
table
and
the
templates
would
be
the
actual
tables
that
get
updated
atomically.
So
whenever
you,
whenever.
A
And
so
now
we
can
see
that
we've
done
our
beer
proposal
over
here
and
basically,
bob
and
carol
are
going
to
have
the
options
to
accept
beer
or
reject
beer
and
also
they're
not
going
to
be
able
to
see
each
other's
transactions,
because
in
one
we
have
alice
and
bob
as
the
given
recipient
and
the
other.
We
have
allison
carroll
as
the
giver
and
recipient,
so
we'll
go
ahead
and
log
in
as
bob.
A
So
carol
can
go
ahead
and
choose
to
reject
it
and
that'll
just
go
ahead
and
archive
that
proposal,
and
now
it's
it's,
no
more
and
can't
be
interacted
with,
and
so
yeah
that's
basically
the
program
and
how
we
would
deploy
to
fabric
and
get
everything
up
and
running.
But
now
I'm
actually
going
to
go
ahead
and
do
the
same
thing
with
sawtooth.
A
A
Sawtooth-
and
this
was
actually
produced
by
blockchain
technology
partners,
which
is
one
of
our
partners-
they
made
the
damon
sawtooth
demo
driver
and
also
open
sourced
it.
So
I
think
that's
really
great.
It's
really
always
nice
to
see.
You
know
people
building
on
top
of
open
source
projects
that
they
may
not.
They
work.
They
work
with
themselves,
they
use
themselves,
but
that
they
may
not,
you
know,
be
as
direct
as
digital
asset.
It's
just
good
to
see
that
you
know
our
ecosystem.
A
That's
going
to
start
everything
up
will
also
start
up
the
demo
driver
itself.
So,
just
as,
unlike
before,
where
I
started
up
the
demo
driver
separately,
this
script
just
starts
up
the
demo
driver,
together
with
the
instance.
That's
just
something
to
keep
in
mind.
It
obviously
can
change,
because
this
is
an
open
source
project.
So,
if
you're
checking
it
out,
though,
just
don't
be
confused,
it
just
starts
up
everything
together
and
then
runs
it
up
for
nine
thousand.
This
is
going
to
take
a
moment
to
get
started
up
so
yeah.
B
A
Yeah,
that's
that's
a
great
question,
so
one
part
of
our
learning
path,
especially
if
you're
a
beginner
and
you
want
to
understand
them
a
little
bit
because
it
does
take
just
a
little
bit
to
wrap
your
head
around.
We
have
our
demo.com
learn
page,
and
so
basically,
what
that
is
is
a
bunch
of
in
browser
examples
that
will
actually
execute
on
a
remote
linux
server
somewhere
and
allow
you
to
just
basically
walk
through
all
the
steps
of
learning
demo
and
getting
started
with
it.
A
So,
for
example,
over
here,
if
you
wanted
to
walk
run
through
this
deployment
again
without
watching
this
video,
you
can
go
to
deploying
download
production
ledgers
and
then
try
it
out
on
fabric
and
on
sawtooth,
and
what
you'll
get
here
is
basically
the
entire
thing
of
of
running
these,
so
you'll
basically
be
stepping
through
this
deployment
guide.
Here
the
pretty
much
the
exact
same
thing
except
interactively
online,
and
you
don't
even
need
to
download
anything
to
get
started.
A
This
website
actually
will
change,
probably
in
another
few
days,
so
yeah
look
look
forward
to
the
the
new
styling
on
it,
but
that's
what
I
would
suggest
for
when
you're
first
getting
started
and
then,
of
course,
when
you
want
to
learn
demo
in
depth
and
you
want
to
get
to
writing
devil.
We
have
just
excellent
introductions
to
demo
this
in
particular
underwriting
demo.
An
introduction
to
demo
is
basically
how
I
personally
learned
to
write
damo,
and
I
can
tell
you
from
my
own
experience.
A
I
am
somebody
who
has
tried
many
many
times
to
learn
a
functional
programming
language
and
not
ever
gotten
too
far,
and
this
actually
taught
me
basically
all
I
needed
to
know
in
order
to
to
write
demo.
But
of
course,
when
you
get
to
the
more
while
you're
going
through
this
journey,
you're
going
to
have
questions.
A
So
we
also
have
our
forum
and
it's
a
very
actively
trafficked
forum,
that
you
know
you
can
go
ahead.
Join.
Ask
your
questions.
If
you
spend
more
than
five
minutes
on
the
docs
or
demo.com,
learn
really
just
come
over
to
disqus.damo.com
and
go
ahead,
hop
over
to
the
questions
category
and
make
a
new
topic,
and
so
you
know
I
could
actually
say
how
does
demo
on
fabric
choose
a
channel
on.
My
fabric
instance
like
like
roland,
had
asked
before
so
just
give
it
a
little
demo
on
fabric.
A
A
A
A
And
yeah,
okay,
we've
definitely
started
up.
We
can
see
here
that
we
have
our
demo
driver
running
on
port
9000,
sometimes
also
called
download
rpc,
so
we
won't
be
able.
We
will
need
to
to
start
that
ourselves
and,
like
I
said
before,
I'm
going
to
avoid
recompiling
the
code
I
kind
of
misspoke,
because
demo
deploy
actually
recompiles
the
code,
whether
I
want
to
or
not,
but
it
is
the
same
exact
code
being
compiled
down
to
the
same
exact,
dar
file,
oh
and
just
fyi,
dar
files,
oh
I'm
deploying
to
the
wrong
port.
A
So
that's
why
we
timed
out,
because
this
one's
running
on
port
9000.,
dar
files
are
basically
the
same
as
jar
files
in
that
they
are
demo
compiled
down
to
an
intermediary
language
called
demo.
Lf
that
you
know
you
don't
need
to
know
yourself.
The
compiler
just
makes
it
for
you
and
then
basically
zipped
up.
In
the
same
way,
a
jar
file
is
with
all
its
dependencies
there
in
a
single
self-contained
executable
for
deployment
and
then
we're
going
to
serve
the
json
api.
A
Just
update
that
and
then
go
ahead
and
yarn
serve
again,
and
so
now,
without
you
know,
changing
a
single
line
of
code.
Just
with
changing
the
the
infrastructure,
we
can
have
the
same
code
running
on
a
completely
different
type
of
infrastructure
in
this
case
being
sawtooth,
so
we'll
go
ahead
and
log
in
like
maybe
this
time,
we'll
log
in
as
bob
and
bob
will
offer
a
beard
to
alice
the
first
time
you
do
this.
You
run
something
on
sawtooth.
I
think
it
does
some
just
in
time,
com
compilation.
So
it
does
take
a
moment.
A
A
Start
and
that'll
take
you
just
to
a
post
that
has
basically
everywhere
that
you
would
want
to
look
to
learn
demo
and
to
understand
it.
I
recommend
really
demo.com
learn
first
and
then,
if
you're
interested
further
go
ahead
to
docs.demo.com
and
always
come
by
the
forum
for
to
ask
questions,
we're
all
very
friendly
there
and
our
engineers
particularly
love
the
forum
so
they're
always
always
on
it,
and
also
you
know.
A
If
you
need
any
of
these
useful
links,
you
can
go
ahead
and
click
on
this
little
icon
up
here
and
check
out
all
the
useful
links
that
give
you
much
more
information
about
demo
and
kind
of
how
our
community
is.
And
yes,
so
that's
my
presentation.
Thank
and
thank
you
very
much
for
having
me.
If
there's
any
questions,
I'm
more
than
happy
to
to
answer
them.
C
A
Yes,
so
the
public
key
infrastructure-
and
we
do
have
some
blog
posts
on
that
as
well
I'll-
try
to
pull
one
up
here
as
I'm
talking,
but
basically
demo
intends
to
not
have
any
opinions
on
that
infrastructure.
Instead,
what
it
does
is
it.
It
basically
relies
on
the
public
key
infrastructure
that
you
that's
already
existing
within
your
enterprise
and
so
whatever
pkr
you're
using
it
can
just
it
can
handle
and
edward
actually
I'll
share.
This
link
in
the
chat
goes
into
how
that
works
in
much
more
detail
than
that.
B
So
I
have
to
ask
her
one
question
to
fabric
what
I
would
like
to
ask.
So
in
favor
we
can
use
a
different
world
state,
so
we
can
use
leveldb
or
couchdb,
but
you
mentioned
that
the
dummer
used
the
infrastructure
from
fabric,
and
that
would
mean
that
I
can
use
couch
to
be
database
as
a
world
state
or
also
level
dp.
If
I
would
like
to
do
this,
this
disco.
A
B
A
Oh,
so
all
parties
on
demo
ledgers
are
created
explicitly
so
with
that
that
happens
with
deployment,
so
over
actually
it'll
be
nicer
to
look
at
in
visual
studio
over
here
we
have
parties
that
are
declared
and
basically
when
it
goes
to
deploy,
these
parties
are
created,
but
there
the
other
ways
you
would
do.
It
are
there's
a
way
to
create
parties
over
the
json
api
endpoint
and
then
there's
a
way
to
create
parties
explicitly
on
the
command
line.
Using
like
a
demo
ledger.
B
B
A
B
B
B
A
B
C
So
there's
a
special
construct
in
hyperledger
fabric,
it's
called
private
data
collection.
It
looks
like
that
way
that
your
that
your
data
is
not
written
into
the
ledger,
but
basically
only
the
hash
of
your
data
is
written
to
the
ledger
and
you
can
control
that
your
data
are
is
basically
propagated
on
a
on
a
different
gossip
network.
But
again
so
the
main
idea
is
that
your
data
is
not
in
the
ledger.
Just
the
hash
of
your
data.
B
The
content
of
the
data
is
written
in
the
site
database
and
the
advantage
of
this
approach
is
that
you
can
delete
this
data
set,
for
example,
and
that
means
that
when
we
delete
this
private
data
set,
then
we
can
delete
this
only
in
the
site
in
the
site
database
and
in
the
on
the
ledger
in
the
channel
is
only
the
hash
of
this
data
set.
So
nobody
can
read
this
hash
so,
but
on
the
only
allowed
organizations
can
read
or
write
this
data
set
in
the
site
in
this
private
private
collection.
B
This
is
called
private
collections
and
this
is
a
way
to
be
a
little
bit
more
gdpr
compliant.
So
when
we
have
sensitive
informations
like
personal
informations,
then
we
can
use
this
kind
of
technique
to
store
personal
information
into
a
blockchain,
so-called
blockchain,
and
later
we
can
delete
this
from
the
blockchain
system
and
in
narcissist
in
in
in
other
systems,
with
other
architecture
that
wouldn't
possible.
So-
and
this
is
a
great
advantage
from
from
fabric
that
we
can
delete
data
and
yeah
and
that's
the
question
I
think
daniel.
A
Sometimes,
if
a
bunch
of
steps
can
essentially
occur
kind
of
off-chain
and
then
these
features
are
going
to
be
better
integrated
with
the
the
various
infrastructure
options
and
that's
kind
of
also
part
of
where
canton
comes
in
because
canton's,
something
that
allows
for
this.
This
similar
type
of
thing
where
you
know
you
can
have
not.
C
C
Okay
and
then
just
one
more
question
you
mentioned
like
transaction
privacy,
so
so
what
do
you
mean
by
that
I
mean
we
usually
have?
The
problem
is
that
I
mean
in
fabric
you
have
some
kind
of
a
transaction
privacy,
but
there's
no
privacy
in
terms
of
encryption.
So
if
you
have
practically
a
database
administrator,
your
database
administrator
can
log
into
the
to
the
couch
table,
for
instance,
or
leveldb,
or
to
the
ports
and
container
and
can
reload
the
data,
even
if
there's
some
kind
of
a
read
access
in
high
quality
fabric.
A
Yes,
so
what
I
was
referring
to
there
was
kind
of
referring
to
two
things
is
demo?
Has
this
notion
of
sub
transaction
privacy,
which
is
essentially
if,
for
example,
you
and
I
had
a
variety
of
contracts
that
we
had
to
fill
out
between
each
other
and
we
had
like
kind
of
a
starting
state
and
ending
state?
A
We
could
kind
of-
and
I
don't
know
the
the
technical
details
of
this,
but
for
some
of
those
things
if
they
just
required
both
of
our
signatures
at
the
end,
we
could
sign
them
and
produce
some
other
contract
without
storing
all
the
intermediary
steps.
In
between
on
the
ledger,
like
we
didn't
need
to
store
every
single,
every
single
part
of
of
a
transaction,
we
could
just
store
essentially
the
resulting
state
as
long
as
we've
all
signed
off
on
it.