►
From YouTube: Code Faster with Concerto, Model-driven Blockchain Development - Matt Roberts & Dan Selman, Clause
Description
Is the business logic in your chaincode hard to find because it is buried in code that is doing boilerplate JSON serialization and data validation? Are you developing REST APIs by hand for your domain model? Concerto to the rescue!
This talk introduces Concerto, a lightweight 100% JavaScript schema language and runtime. It works in both a Node.js process and in your browser. Concerto models can be converted to JSON Schema, XML Schema, Java, Go, Typescript, Loopback APIs, HTML web-forms and PlantUML diagrams. Concerto is used today with Hyperledger Composer, Fabric and the Accord Project's platform-independent implementation for smart legal agreements.
----
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 #Blockchain
A
Okay,
let's
get
started
how
everyone
my
name
is:
Dan
Shulman
I'm,
the
CTO
of
Klaus.
We've
got
a
kind
of
an
avalanche
of
information
for
you,
so
we
got
I
think
two
slides
that
I'm
gonna
whiz
through
Matt's
gonna
do
a
demo
for
us
and
then
we'll
open
it
up
for
questions
and
we're
gonna
hit
you
hard.
So
please
save
your
questions
for
the
end
and
hopefully
we'll
have
some
time
for
discussion.
A
A
So
if
you're,
a
composer
user,
you'll
kind
of
have
a
bit
of
a
head
start
over
the
others,
because
what
we're
really
talking
about
is
the
composer
modeling
language
and
over
the
last
couple
of
months,
what
I've
done
with
some
help
from
that
is
we've
extracted
to
that
core
capability
and
we've
made
it
a
standalone
module.
So
you
can
use
it
on
a
web
page
inside
nodejs
chain
code
and
in
a
variety
of
other
places
that
that
Matt's
going
to
show
us
so
fundly.
A
What
fundamentally,
what
we're
trying
to
do
is
we're
trying
to
capture
this.
The
shape
of
data
and
concerto
is
an
object,
orientated
modeling
language
so
think
something
like
XML
schema,
so
it
can
model
Qasr
relationships,
so
a
vehicle
has
a
caller
is
our
relationships,
so
a
truck
is
a
vehicle
or
has
a
relationship
to
relationships.
A
So
things
like
an
employer
is
related
to
a
company
it.
It
C
realises
its
models,
well
the
instances
of
the
models
natively
as
Jason,
so
it
has
very
nice
easy
to
use
out-of-the-box
serialization
to
and
from
Jason
and
as
I
said,
what's
really
unique
about,
it
is
the
whole
stack
is
implemented
in
JavaScript,
it's
very
small,
quite
efficient,
and
it
means
that
you
can
embed
it
in
a
web
browser
and
lots
of
other
interesting
places,
and
this
is
this
is
fairly
unique.
A
A
So
many
of
these
models
already
exists,
but
at
the
moment
they're
quite
siloed
and
I
used
lots
of
different
technologies
to
to
represent
the
models
which
makes
them
challenging
to
use
in
blockchain
projects
and
then
that
we've
built
a
bunch
of
tools
around
this
core
concerto
capability.
So
there's
an
editor
that
you
can
use
in
Visual
Studio
code,
which
Caroline
is
there.
She.
She
can
probably
tell
us
much
more
about
that
editor,
but
we
can
also
convert
these
models
to
and
from
lots
of
interesting
sort
of
canonical
formats.
A
So
we'll
see
some
of
those
in
a
minute.
So
why
would
you
use
it
so
fundamentally,
blockchain
is
about
sharing
data,
it's
about
defining
the
participants
in
a
business
network
and
agreeing
what
data
we
want
to
share
across
that
network
and
if
anyone,
you
know
most
of
you
I'm
sure
have
tried
to
do
that
and
very
very
quickly.
A
You
hit
the
well
what
for
match
of
the
day
to
be
in
question
and
that's
usually
a
quite
a
complicated
question
and
I
would
like
to
use
my
format
and
you
would
you'd
like
to
use
your
format
and
then
it
turns
out.
There's
an
industry
defined
format
that
is
close
but
doesn't
quite
meet
our
needs
so
really
to
get
the
benefits
of
blockchain.
A
We
have
to
agree
on
data
formats
and
that's
you
know
a
key
purpose
for
concerto,
and
you
know
if
you've
been
around
a
bit
you'll
probably
know
there
are
lots
of
schema
languages
out
there.
You
may
have
invented
a
few
yourselves
kind
of
ad-hoc
schema
languages
using
yamo
or
json
schema
or
something
else
we
we
believe
that
concerto
is
is
better
than
those
for
this
specific
use
case
and
I
won't
get
into
the
details
of
exactly
why.
We
believe
that,
but
you
you
know,
feel
free
to
grab
me
afterwards.
A
Importantly,
it's
programming
language
neutral,
because
we
don't
really
know
you
know
what
languages
people
are
using
at
the
other
ends
of
these
pipes
and
and
in
many
cases
for
blockchain
projects
they're
using
multiple
languages.
You
know
they
might
be
using
typescript
on
the
front
end.
They
might
be
writing
go
code,
you
know
that's
running
in
fabric,
they
might
be
writing
Java
code,
that's
running
in
Corder,
but
you
all
want
to
share.
You
know
a
canonical
data
model.
A
It
gives
you
JSON
validation.
You
know
if
all
you
want
to
do
is
check
that
some
lump,
a
lump
of
JSON
that
I've
just
received,
conforms
to
a
schema,
that's
kind
of
a
one-liner
you
can.
You
can
define
your
schema
and
you
can
validate
your
data
and
we'll
see
that
in
a
minute
and
then
it's
foundational
technology
for
building
any
sort
of
platform
tools
that
are
configurable.
A
You
know
via
a
data
model,
so
common
use
cases
in
blockchain
are
things
like
I've
got
a
bunch
of
assets
on
my
blockchain
and
I
want
to
expose
them
over
a
REST
API.
So
there's
two
ways
you
could
do
that
you
can
either
sort
of
boot
up
your
you
know
boot
up,
Express
and
start
hand
coding
routes
in
Express.
A
You
know
for
all
of
the
crud
operations
for
your
various
assets
or
you
could
model
your
assets
and
then
generate
the
rest.
Api
automatically,
so
having
a
formal
data
model
can
can
accelerate
a
lot
of
the
kind
of
the
boilerplate
that
you
might
otherwise
write.
The
other
thing
that
you
can
do
is
you
can
automatically
generate
user
interface,
because
you
know
what
these
assets
are,
what
their
properties
are.
A
So
if
your
data
model
is
say
a
Yama
file
or
a
protobuf
that
obviously
doesn't
help
communication
with
Concetta,
you
can
generate
UML
diagrams
from
these
models
and
then
obviously
put
them
up
on
a
on
a
slide
and
have
a
discussion
about
well.
Is
this
really
the
definition
of
a
shipping
crate?
Are
these
the
attributes
that
we
want
to
be
that
we
want
to
be
storing
and
then
finally
publish
your
model
for
reuse
by
others?
A
Right
blockchain
is
about
you
know,
people
say
it's
a
team
sport
right,
it's
about
interacting
with
others,
so
once
I've
defined
a
data
model
on
my
end,
often
I
want
to
publish
it
for
reuse
by
others.
So
that's
the
set
up.
I
hope
that
made
sense
are
now
matt
is
going
to
hopefully
wow
us
with
with
some
demos
thanks.
B
So
that's
some
of
those
benefits
that
Dan
started.
That
Dan
mentioned
being
realized
already
there.
So
we'll
continue.
Let's
add
an
integer
here
for
the
age
and
maybe
a
date
time
for
the
date
of
birth.
We
got
some
nice
validation.
That's
only
a
allows.
Integer
values,
I
have
a
drop
down
field
here
for
date/time
and
again,
that's
all
serialize
serialize
nicely
on
the
bottom
and
I
could
further
extend
that
I
think
I'm
going
to
skip
through
that
in
the
interest
of
time.
But
what
I
could
do
is
bring
in
something
that
already
exists.
B
So
what
I'm
looking
at
now
is
models
that
are
called
project
org.
This
is
one
repository
that
contains
some
some
rebuild
models
that
you
can
reuse
there.
We
go
they're
all
listed
here
and
the
patient
model
is
quite
interesting
that
diagram
at
the
top
is
generated
automatically
using
plant
UML
from
the
definition
the
definition
source
is
listed
on
this
page.
But
what
we're
going
to
do
is
take
that
URL
and
I'm
going
to
pull
it
into
this
into
this
tool.
Choose
the
patent
asset
and
we
get
a
very
complex
form
and
generated.
B
You
know
automatically
for
me,
including
optional,
repeating
types
and
a
great
big
serialization
of
that
at
the
bottom.
So
that's
very
fast.
That's
pulled
down
across
the
internet
and
generated
in
real
time.
So
that's
that
step
number
one.
We
have
a
data
model.
We
can
do
some
things
like
generate
rest,
api's
and
forms
automatically
from
that.
B
Next
thing,
we're
going
to
do
is
look
at
some
of
these
other
other
serialization
formats.
These
are
the
conversions,
so
we've
got
chase
and
schema
typescript
java
xml
schema.
I
can
download
these
and
I
get
a
zip
that
contains
that
ones
are
Jotham
zip
that
contains
the
source
that
I
can
use
to
use
those
in
my
platform
of
choice.
Let's
start
with
java,
we
pulled
this
one
in
earlier
again
to
save
a
little
bit
of
time.
Two
things
we're
doing
here,
we're
going
to
start
from
a
Java
object,
that's
created
by
importing
the
definition.
B
I
have
a
this
is
the
definition
that
was
generated
by
that
file.
I
just
downloaded
of
that
same
paintin
patent
model
change,
one
of
the
values
and
then
serialize
it
to
Jason,
and
then
I'll
do
the
opposite,
go
back
the
other
way,
so
we
round-trip,
essentially
I,
read
in
the
JSON
file
from
from
disk.
That's
this
big
thing
here
and
then
I
convert
that
to
a
Java
object
and
I
print
that
out.
So
if
we
run
we're
going
to
run
this
one.
B
And
we
can
see
there
the
output
from
that
there,
here's
my
instantiated
object
from
Java,
with
just
one
value
change
and
here's
the
instance
that
was
created
in
created
from
the
file.
What
else
have
we
go
in
here?
Let's
take
a
quick
look
at
the
XS
d:
this
is
the
XS
deef
output
that
was
generated
for
that
same
country,
so
file
with
the
XS
d.
B
Editor
I
can
delve
into
one
of
these
perhaps
and
see
that
in
the
nice
editor
in
eclipse,
and
you
can
build
the
diagram,
perhaps
and
finally,
just
to
conclude
this
race
through
those
different
use
cases
I'm
now
switching
my
data
to
vs
codes.
We
have
a
nice
plugin
that
Dan
mentioned
earlier
4
vs
code
with
a
model
defined
and
what
we're
actually
doing
here
is
deploying
that
model
to
our
village
a
fabric
instance.
That's
what
this
snippet
does.
B
We
add
the
model
file
and
we
put
it
into
the
into
the
world
state
and
then
I
can
send
instances
to
that
and
I'll
get
notified,
whether
that's
valid
or
not.
So
we
have
a
valid
instance
there.
If
I
run
that
for
run
that
once
we
get
a
message
saying
that
that
was
successfully
put
and
then
eventually
committed
and
if
I,
let's
turn
off
one
of
these
required
fields,
so
we've
got
some
optional
fields
in
my
model.
B
This
is
an
instance
of
that
model
and
we'll
save
that
and
run
again
this
time
it
failed
and
if
I
check
my
logs
I'll
see
it
I
get
a
validation
error,
telling
me
that
it
was
missing
the
required
fields,
first
name
which
we
just
removed
so
very
quickly.
There
hope
you
can
see:
we've
targeted
what's
at
least
three
different
platforms
that
I've
shown
you
for
real
we've
got
a
standard
model
that
can
be
generated
for
each
of
those
platforms
and
seen
some
of
the
tooling
that's
available.
B
There's
a
whole
list
of
resources
here,
I
encourage
you
to
take
a
look
and
play
with
you
can
install
the
NPM
package
yourself,
and
these
will
be
available
in
the
slides
afterwards
and
the
final
thing
Dan
and
I'll
be
running
a
hands-on
workshop
for
a
set
of
tools
that
lives
above
concerto
for
building
smart
legal
agreements
from
the
Accord
project,
within
which
we
use
concerto
models
and
we're
running
two
workshops
one
tomorrow
and
one
on
Saturday,
so
be
great
to
see
you
all
there
in
one
of
those
sessions.
Thank
you
very
much
questions.
First,
then,.
A
A
A
Well,
you
know
composer
is
an
open
source
project,
so
it
will
be
carried
forward
based
on
people
contributing
to
it.
That's
how
open
source
works,
but
what
what?
What
we've
done
sort
of
physically
matt-
and
I
right
that's-
how
open
source
works?
Is
we've
we've
taken
that
core
concerto
capability
and
we've
extricated
it
from
composer
and
I'm
interested
in
doing
more
of
those
things.
A
So,
for
example,
another
logical
one
might
be
the
composer
query
language
cql,
which
has
allows
you
to
write
sequel
style,
queries
over
these
modeled
entities
and
then
compile
those
queries
to
MongoDB
query
language.
So
you
know,
based
on
people
scratching
their
own
itches,
we
might
see
more
of
composer
kind
of
motorized
which
would
allow
you,
then
to
use
it
inside
your
nodejs
chain
code.
D
E
You
for
your
presentation.
My
question
is
how,
if
we
use
concerto
for
deploying
it's
a
chain
code
fabric,
how
can
we
deal
with
the
relations
between
participant
model
and
an
asset
when,
when
we
use
composure,
when
you
implement
a
transaction,
you
could
just
call
the
gate.
Factory
function
to
define
to
get
the
model
of
a
participant
and
just
put
it
into
the
asset.
But
we
don't
have.
This
possibility
was
fabric
yeah.
A
So
you're
gonna
you'll
receive
a
transaction
which,
which
you've
modeled
and
within
that
transaction
you'll,
have
a
relationship
which
is
a
pointer
to
a
participant,
so
you'll
have
to
write
some
code.
You
know.
Maybe
this
is
a
good
idea.
No,
this
could
be
another
potential
library
which
basically
does
a
world
state
lookup
based
on
the
key
that
you've
just
received
and
then
instantiate
a
participant
instance.
You
know
based
using
that
key.