►
From YouTube: W6 TEC Lab!: Tokenomics Dashboarding with Python Panel
Description
In this episode, the gang makes further iterations on the TECH parameter template and results visualization.
🙏 Thank you for watching! Hit 👍 and subscribe 🚩 to support this work
🌱Join the Community🌱
on Discord https://discord.gg/DDr5kYU
or say hello on Telegram http://t.me/CommonsStack
Join the conversation https://forum.tecommons.org/
Follow us on Twitter: http://twitter.com/CommonsStack
Learn more http://tecommons.org/
B
A
B
B
So
today
I
have
a
little
it's
not
quite
so
structured,
it's
more
going
to
be
a
full
collaborative,
build
session,
but
that
should
be
fun.
A
B
Last
time
we
had
just
put
the
conviction
we
basically
had
the
parameters
outlined,
I
mean
in
the
widgets,
so
I've
taken
that
a
bit
further.
This
time
I
want
to
actually
have
those
parameters
connected
to
visualizations,
so
I've
made
a
simple
example
for
the
dandelion
voting.
B
Okay
yeah:
I
guess
this
is
we're
a
few
minutes
in
so
I
think
I'll
just
get
started.
Okay,
so
I've
got
here
like
always
the
so
from
tech
labs
pinned
channel.
Then
you
can
find
the
notion
workspace.
B
So
everyone
should
go
ahead
and
open
that
up
and
go
ahead
and
open
up
the
attendance
sheet.
We'll
get
some
emojis
going
insert
row.
Sorry,
where
is
it
so?
The
best
way
to
go
is
probably
in
the
tech
labs
channel
here
in
discord
and
then
the
pinned
messages
at
the
top
and
from
there
you'll
see
notion
thanks.
B
B
A
C
C
C
A
C
And
in
fact,
you
might
have
a
few,
you
might
have
a
few
in
fact,
yeah
you're,
gonna,
you're
gonna
have
a
few
extra.
I
totally
up
the
dispersal
yeah
you
could
just
go
to
vlogscout.com
and
and
go
to
xdi
and
it'll.
There's
a
yeah
you're
on
next
time.
Then
you
can
just
put
in
your
address
your
common
stack
address
in
the
top
corner.
C
C
And
in
the
end,
you
don't
need
to
know
that
you
have
the
tokens.
The
token
log
will
show
you
that
you
have
the
tokens.
C
B
This
is
awesome,
though
I'll
have
to
check
in
to
this
yeah
good
job,
guys,
I'm
not
gonna
go
through
all
my
wallets
on,
while
we're
recording,
but
that's
pretty
epic.
I'm
excited
to
check
that
out.
Okay,
so
yeah.
If
everyone
wants
to
pop
open
the
attendance
sheet
and
get
some
emojis
going
so
how
I
was
just
saying
how
I
usually
navigate
to
that
just
through
the
tech
labs
channel
pin
at
the
top
is
the
notion
workspace,
I'm
getting
a
little
bit
of
feedback
from
maybe
sam.
B
Griff,
okay,
awesome,
so
I
think
everyone's
tracking
six
minutes
in
so
from
the
notion
page
also
just
a
reminder.
So
we
have
the
youtube
channel
here
and
in
the
calendar
we
have
a
dedicated
page
for
each
lab,
and
so
today
we
have
lab6,
and
these
are
open
for
comments.
So
as
we
go,
you
guys
can.
Actually,
if
you
have
questions-
and
you
can
just
post
them
in
here-
you
can
post
them
in
discord
too.
B
So
this
is
the
tech
lab.
Let's
see
tech
template
customization
and
I
think
the
tweet
headline,
the
twitter
headline
was
actually
dashboarding,
tokenomics
dashboarding
tokenomics
dashboarding
with
panel
python
panel,
so
we
we've
been
doing
this
for
a
few
weeks,
so
this
is
kind
of
the
it's
in
a
more
mature
state.
Now,
so
what
we're
going
to
do?
I've
got
20
minutes,
scheduled
I'm
going
to
give
you
an
overview
of
what
I've
got.
B
I've
been
tinkering
with
this
stuff
quite
a
bit,
and
I've
got
quite
a
dif,
a
few
different
ways
that
we
can
visualize
things
like
the
parameters,
the
outcomes
of
the
parameters
and
then
what
I
think
is
really
important
that
we
can
tie
into
this
is
like
probability
distributions
we
can
say:
okay,
what's
the
distribution
of
voters
who
are
going
to
vote
or
you'll
see
we're
going
to
go
over
the
distribution
of
impact
hours?
It's
a
pretty
interesting
distribution.
Definitely
not
a
normal
distribution.
You'll
see
that
most
people
have
in
the
range
of
the
one.
B
You
know
one
two
or
three
impact
hours
and
then
there's
some
people
who
have
like
250.
So
it's
this
sort
of
skewed
like
beta
distribution,
but
that's
super
interesting.
I
think
that's
a
natural
fit
actually
for
any
community.
So
it's
nice
to
see
those
things
emerge,
and
then
we
can
play
with
those
distributions
to
see
how
the
hatch
can
play
out
given
the
parameters,
but
it's
still
early
stages.
So
that's
why
I've
scheduled
a
nice
40
minutes
that
we
can
all
do
a
collaborative
build
session
together.
B
After
you
see
the
the
first
steps
that
I've
been
working
on
here
and
really
important
to
open
up,
this
is
awesome
me,
griff
and
jake,
and
I
think,
tonga,
a
couple
helpers.
We
hashed
this
out.
So
this
is
the
guide
that
we're
working
on,
and
you
can
see
this
in
the
lab
6
page
on
notion
it's
linked
in
there,
so
you
can
see
what
we
got
last
week,
where
these
widgets
that
we
can
interact
with,
and
so
what
we
were
doing
is
saying:
how
can
we
refine
the
language
here?
B
How
can
we
make
this
more
simple?
So
people
know
what
they're
actually
configuring
and
then
what
kind
of
visualizations
can
we
come
up
with?
What
kind
of
questions
can
we
answer
is
really
the
important
mindset
to
have
with
this
stuff
and
just
some
examples
and
some
notes
on
how
we
might
be
able
to
visualize
some
of
these
things.
So
this
is
really
the
map
of
what
we're
going
for
here.
It's
not
fully
built
out
we'll
see
how
far
we
can
get
in
the
collaborative
session
today,
and
this
is
griff's
take
on
it.
B
Then,
ideally,
they'll
just
hit
a
button
and
it
outputs
a
white
paper
that
specifies
their
their
whole
crypto
network
and
all
the
parameters
and-
and
everything
like
that,
I
think
that'd
be
so
cool
and
seems
like
something
we
could
strive
towards.
So
this
is
a
really
good
reference
document
here,
I'll
probably
keep
that
open
in
another
tab.
B
B
A
B
Oh
yeah,
that's
even
better
yeah
better
than
a
white
paper
is
the
actual
like
the
gardens
template
really
just
the
parameters
go
right
into
the
garden's
template
and
launches
the
dow.
That's
even
next
step.
C
Yeah,
the
basic
idea,
I
mean
that's
yeah,
that's
that
would
be
the
next
step.
That's
what
you
got
to
work
on,
but
the
the
general
concept
is
that
when
you,
you
click
a
button
and
then
you
get
an
editable
like
maybe
like
a
config
file
that
you
can
change
some
numbers
and
then
you
get
all
these
graphs
all
these
scenarios.
All
these
questions
answered
in
you
know.
A
Parameters?
Okay,
I
will
say
from
my
from
my
perspective:
it's
it
it
will
be
just
the
same,
but
do
whatever
you
have
to
do.
B
B
It's
it's
the
same
thing,
sam,
it's
the
same
thing:
we
output
a
json
and
we
send
that
to
the
little
microservice
that
can
populate
a
white
paper
and
that
same
json
can
go
to
the
service
that
can
actually
deploy
the
dow.
So
it
can
be
this
kind
of
standard.
Oh
wow,
it's
like
a
dow
hatch
object
and
you
pass
that
to
the
white
paper
factory
or
to
the
dow
factory
yeah.
In
the
end.
A
B
That's
the
sort
of
mvp
and
that's
what
we're
going
to
go
towards,
but
it
would
just
be
a
sort
of
a
fun
data
science
spin-off,
not
even
necessarily
data
science,
but
just
a
little
bit
of
like
template
programming
to
make
a
white
paper
template
and
and
take
this
one
step
further
past
the
notebooks,
but
we're
definitely
not
getting
to
that
point
in
this
lab.
So,
let's
not,
let's
not
get
too.
Okay,
that's
a
that's
a
moonshot
idea,
but
I
like
your
idea
too,
sam
of
just
populating
a
dow
directly.
B
So
I
just
want
to
guide
people's
attention
a
little
bit
I
was
playing.
You
might
have
seen
me
posted
in
the
tech,
labs
channel
and
I've
there's
a
branch
here.
It's
called
poetry,
which
is
nice
and
that's
because
it's
using
a
library
called
python
poetry
that
has
beautiful
documentation,
very
inspirational
and
really
cool
open
source
project.
It's
a
newer
kind
of
python
package
manager,
and
so
it's
like
poetry,
add
your
dependencies.
B
You
can
build
and
you
can
publish
which
actually,
this
launches
your
project
onto
pi
pi,
so
people
can
install
it.
You
can
get
a
dependency
tree
visualization
and
it
uses
this
new
kind
of
file,
call
uses
a
tomo
file
and
it
and
it
locks
your
project
as
well,
which
something
like
pip
doesn't
necessarily
do.
B
So
it
has
every
all
the
information
that
it
needs
to
actually
deploy
your
project
as
a
as
a
package
like
on
pi
pi.
So
this
is
a
a
pretty
nice
system,
I'm
playing
around
with
it
it's
new,
so
I'm
I'm
not
trying
to
shill
it
too
much
yet,
but
it's
nice
if
people
go
ahead
and
use
it
and
see
if
they
run
into
problems.
B
So
this
is
sort
of
the
working
branch
that
I'm
on
now
is
this
poetry
branch,
and
so
it
has
the
install
instructions
using
poetry
and
it's
quite
simple:
the
poetry,
install
itself
was
easy
and
then
using
poetry
is
quite
easy.
You
just
have
to
remember
to
activate
your
shell
and
that's
going
to
put
you
in
the
jupiter
environment
so
that
you
have
access
to
all
the
libraries
you
need,
and
you
saw
that
I
ran
that
here.
So
I
just
called
poetry,
shell
and
then
that
gave
me
like.
B
Let
me
split
my
thing
here:
okay,
and
so
if
I
go
poetry,
shell,
it
actually
brings
up
an
interactive
option
here
at
the
bottom
to
select
which
virtual
environment
I
want,
and
so
I
just
hit
enter,
enter
and
then
there's
a
little
bit
of
a
glitch
here,
because
I'm
using
the
fish
shell.
So
it's
duplicating
this
but
anyways.
You
can
see
now
that
it's
activated,
but
just
a
little
note
on
poetry.
B
So
before
we
get
into
the
hatch
template.
I
think
I
have
this
here,
which
is
just
this
was
this
is
actually
where
we
left
off
last
time.
B
So
let's
just
go
through
this
as
a
reminder,
so
we're
looking
at
the
dandelion
parameters
here,
so
we
had
support
required
min
acceptance
quorum
and
time
it
takes
to
propose
a
pass.
So
he
had.
We
had
aggregated
a
few
of
the
parameters,
the
time
parameters
into
a
single
one.
We
were
still
that
wasn't
finally
decided
because
we
were
thinking
well.
Maybe
people
should
really
get
to
see
the
actual
parameters.
B
We
can
come
back
to
that
in
a
bit.
So
here's
a
hatch,
so
we
have
these
constants,
which
we
said
are
the
total
c
stack
tokens:
the
hatch
oracle
ratio,
the
min
goal,
the
max
goal,
the
hatch
period,
the
hax
hatch
exchange
rate,
which
I
believe
we
said
actually
that
we're
going
to
take
that
out
and
the
hatch
tribute.
B
So
then
we
have
some
impact
hours
here,
and
I
think
this
is
what
I
want
to
show
you
guys.
So
this
is
using
the
same
visualization
library
that
we're
using
to
get
a
lot
of
these
things
just
to
render
tables.
So
we
can
kind
of
render
tables
side
by
side.
This
might
look
a
bit
cluttered,
but
we
have
essentially
the
two
different
versions
of
impact
hours
here
and
I
apologize
if
my
screen
resolution
isn't
that
high
on
the
stream.
B
If
you
can't
read
this,
but
here
we
have
an
ordered
list
of
all
the
community
members
and
their
associated
impact
hours.
So
of
course
that's
very
useful
for
modeling.
We
can
later
calculate
how
many
dollar
amounts
this
calculus.
This
could
be
given
the
price
of
the
token
and
the
impact
hour.
Distribution
model,
and
then
over
here
we
have
more
summaries
of
rounds
so
for
each
round.
Two,
three
four.
Where
I
believe
around
is
two
weeks,
then
we
have
the
total
impact
hours
accumulated
the
cumulative
impact
hours.
B
B
Oh
yeah,
mingle
at
15
die
per
hour.
Oh
yeah
yeah!
This
is
awesome.
I
want
to
get
back
to
this
because
this
is
saying
given
this
many
total
impact
hours.
This
is
how
much
we
have
to
raise.
Actually
it's
the
cumulative.
B
So
it's
given
that
we've
have
624
total
impact
hours
so
far,
then
we
need
to
raise
62
485
die
in
order
to
have
a
15
diaper
hour,
minimum
wage
and
a
15
tribute.
B
So
this
is
a
really
good
data
set,
and
this
is
actually
really
readable
through
the
just
going
directly
to
the
google
sheet,
which
you
can
find
through
the
notion
page.
I
think
on
lab
four
or
five.
This
is
linked,
and
so
these
are
the
kind
of
options
that
we
want
to
be
visualizing
with
these
templates
is,
did
the
scenarios.
B
So
let's
say
we
had.
You
know
2
000
impact
hours
total.
How
much
would
we
have
to
raise
to
have
this
minimum
wage?
So
these
can
be
some
selection
options
that
we
implement
in
a
bit
is
like
what
what
sort
of
minimum
wage
is?
The
is
the
community.
C
B
Nice,
that's
great,
so
I
just
made
a
this
is
a
little
sort
of
this
is
not
directly
related
to
the
hatch.
This
is
just
what's
called
a
beta
distribution
parameter
a
beta,
a
beta
distribution,
so
we
can
play
with
these
parameters
here
to
see
how
the
distribution
changes
and
the
reason
I'm
using
this
is
because
you'll
find
I'm
not
sure
if
I
have
it
down.
Oh
yeah,
this
yeah,
so
this
is
the
actual
impact
hour
distribution.
B
So
we'll
see
it
starts
at
zero,
and
so
the
majority
of
people
have
this
between
like
zero
and
20
25
impact
hours
and
then
there's
a
distribution
of
people
that
have
in
this
sort
of
25
to
50
is
a
is
a
pretty
significant
amount
of
members
and
then
there's
a
small
amount
of
members
who
are
essentially
the
core.
B
These
would
be
you
know,
maybe
the
stewards
or
like
sam,
of
course,
santi
zeptimus
people
who
are
busy
doing
either
technical
development
or
santi's
involved
in
a
lot
of
different
places,
zeptimus
of
course,
doing
all
the
recording
and
everything.
So
we
can
see
that
given
certain-
and
we
could
do
some
further
analysis
on
this
later-
that
would
be
really
interesting
to
see
what
kind
of
roles
are.
The
roles
that
end
up
accumulating
the
most
impact
hours,
and
so
that's
why
I
was
playing
with
this
beta
distribution.
B
B
So
we
can
make
theoretical
scenarios
where
we
have
different
types
of
sort
of
work
distributions,
and
I
think
that's
not
a
this-
is
a
nice
to
have.
This
was
just
me
going
off
on
and
playing
around.
This
is
more
of
a
nice
to
have,
but
I'm
hoping
the
code
is
here.
So
this
is
in
lab
six
hatch
parameters,
which
is
the
notebook
that
was
just
very
experimental
for
me,
playing
with
different
ideas,
so
you
can
take
this
and
run
with
it
and
we
can
use
it
later.
B
Here
I
was
playing
around
with
this
concept
of
a
simple
like
stock,
rendering
so
you'll
if
you've
taken
the
value
flows,
ecosystem
design
course,
it's
all
about
stocks
and
flows
right,
so
this
is
kind
of
a
fun
way
to
visualize
what
a
stock
might
be,
or
just-
and
oh,
actually,
I
use
this
later
in
the
dandelion
voting.
So
we'll
we'll
see
that
how
we
can
use
that
looks
like
this
was
just
some
oh
yeah.
B
This
is
a
different
use
of
a
beta
distribution,
so
we
we
can
use
this
to
model
essentially
impact
hours,
but
perhaps
other
things
as
well.
So
the
codes
there
for
inspiration
and
then
this
is
the
impact
hours
that
we
saw
earlier,
and
what
do
we
got
here?
This
was
me
hacking
around
see.
Some
of
this
is
kind
of.
B
I
didn't
have
that
much
time
this
week,
so
I
didn't
get
all
of
these
completely
cleaned
up,
but
this
is
something
I
was
going
for
and
I
don't
remember
it
to
what
extent
I
got
this
completely
working.
This
might
be
something
we
we
build
on
in
this
section,
but
I
think
it
would
be
fun
to
see
this
curve
actually
move
sort
of
bend.
If
we
can
bend
this
curve
between
an
optimistic
impact,
hour
scenario
and
an
actual
impact
hour
scenario,
and
then
we
can
take
this
and
we
can
multiply
it
against.
B
So
I
think
that's
what
we
have
and
so
we're
going
to
use
this
session
to
just
see
how
far
we
can
get.
You
know
it's
getting
a
little
bit
complex
at
this
point,
because
we
do
have
I
mean
the
higher
you
build,
the
more
abstractions
you
create
the
more
sort
of
prone
it
is
to
the
details,
but
I
think
so.
So
this
is
a
rough
notebook
with
a
lot
of
just
inspiration
of
what
we
can
do
now.
B
I've
got
this
one
here,
which
is
the
hatch
template,
and
this
is
the
first
iteration
of
a
nice
clean
hatch
template
that
we
can
start
to
play
around
with,
and
so
this
is
where
we
want
to
start
moving
towards
is
what
we
have
here
is
more
of
a
quite
comprehensive
sort
of
dashboard,
and
that's
the
title
of
this
lab
is
tokenomics
dashboarding.
B
So
this
is
for
the
dandelion
voting
and
I
was
able
to
put
this
visualization
together.
It
doesn't
look
like
much
yet
because
minimum
quorum
defaults
to
only
two
percent
of
token
holders,
but
we
can
start
to
play
with
these
values.
So
this
is
a
minimum
quorum
required
and
I've
just
in
this
case
I've
fixed
the
number
of
tokens
to
be
1
million
and
we
can
play
around
with
this
minimum
quorum
quantity.
B
So
we
could
even
say
let's
say
we
could
set
that
at
50
percent,
and
then
we
have
the
support
required,
which
is
the
number
of
votes
that
have
to
vote.
Yes
in
order
for
that
vote
to
pass.
So,
given
that
minimum
quorum
is
50
and
if
we
set
support
required
to
50,
then
we
see
that
50
of
that
quorum
has
to
vote.
Yes,
oh,
and
this
is
cool.
I
actually
was
able
to
go
a
little
side
note.
So
if
we
go
github
te
commons,
then
we
have
the
branding
assets.
I
love
this
repository.
B
This
is
so
useful.
We
have
logos
all
sorts
of
different
stuff
typography,
even
we
could
use,
but
I
just
went
into
these
colors
and
grabbed
these
hex
values
some
of
these
hex
values
so
that
we
can
actually
use
them
in
our
charts,
which
is
fun
yeah.
B
Cool
yeah,
so
it's
this
when
we
we're
using
hv
plot
to
make
the
charts
and
after
we
create
our
plot.
So
this
is
essentially
a
fully
created
plot
and
then
that
object
has
this
dot
ops
method,
to
set
options,
and
we
just
say:
color
equals
hp.
Hv
is
our
hv
plot
library,
so
hv
dot
cycle,
and
then
we
just
give
it
a
list
of
colors
and
it's
just
gonna
cycle
through
those
colors.
B
A
B
I
think
that
is
a
good
exercise.
We
can
try
to
tackle
that
and
I'll
I'll
keep.
Actually.
This
is
mostly
all
of
what
I
have
here.
I
started
putting
this
idea
together
of
a
community
participation
model,
and
that's
where
I
was
going
to
have
the
distributions,
like
percentage
of
token
holders
who
show
up
to
votes
and
things
like
that.
That
might
be
something
we
tackle,
but
I
think
this
is
good
sem.
B
I
I
think
I'll
just
finish
going
over
what
we
have
here,
so
support
required,
and
then
these
I
added
I
haven't
visualized
anything
but
essentially
days
to
vote
on
a
proposal
is
the
way
that
I
interpreted
these
notes
here.
If
you
go
into
the
notes.
B
Let's
see
tech
model
spec,
so
we
had
a
few
different
discussions
on
how
to
sort
of
compress
the
these
vote.
Duration
blocks
vote
buffer
blocks,
vote
execution
delay
blocks
all
into
perhaps
a
single,
oh
yeah,
and
and
as
I
was
working
on
this
yesterday,
I
was
coming
back
to
this
idea
that
I
think
in
this.
What
we're
doing
here
should
be
prioritized
towards
simplicity
and
understanding
instead
of
exact
technical
precision
so
because
it'll
give
it'll
allow
people
to
sort
of
exercise
their
intuition.
B
So
it's
like
important
that
people
do
understand.
You
know
what
these
three
different
parameters
are,
but
when
what
we
want
to
do
here
is
gauge
the
community
and
sort
of
their
perspectives
and
opinions
on
the
hatch
and
what
they
think
is
important
and
what
they
want
to
see.
So
for
that
reason
I
started
going
with
this
sort
of
abstract
these
away
and
just
give
the
give
a
few
simple,
very
intuitive
parameters.
B
So
I
had
things
like
days
to
vote
on
a
proposal
days
to
exit
a
hatch,
given
that
someone's
not
happy
with
a
proposal
and
then
cost
to
make
a
proposal.
B
B
A
Name
in
which
you
that
you,
you
have
to
wait
until
a
new
proposal
is,
is
ready.
B
A
Yes,
because
you
have
to,
but
in
that
case
it's
it's
adding
the
both
time
and
the
and
the
other
one
and
the
blocks.
C
B
Oh
yeah,
so
the
final
piece
of
this
over
here
is
as
we
change
this
quorum
and
support
level.
B
We
get
over
here,
minimum
tokens
to
meet
quorum
and
we'll
we'll
fix
this
up
a
bit
as
you
mentioned
sim,
but
so
we
can
get
an
idea
of
how
many
tokens
need
to
show
up,
and
you
know
this
might
be.
You
might
say
well
well
what
percentage
of
tokens
is
that?
Well,
it's
just
our
quorum
percent,
so
you
can
look
at
this
actual
number
to
say.
B
Oh
yeah,
86
percent
of
tokens
need
to
show
up,
but
to
get
an
exact
amount
of
tokens
you
can
see
over
here
and
then
the
minimum
tokens
to
pass
a
vote
and
the
minimum
tokens
to
block
a
vote
and
those
will
change
depending
on
our
support
level
required
so
sam.
I
think
we
should
go
through
this
and
and
yeah.
Let's
get
this
minimum
quorum
precise
if
we
can.
B
So
the
go
ahead.
A
B
Yeah,
so
here
we
have
all
the
params,
so
yeah
total
tokens
is
just
fixed.
We
have
the
minimum
quorum
support
required
days
to
vote
on
a
proposal
days
to
exit
the
hatch
cost
to
make
a
proposal
maximum
number
of
proposals
per
month,
and
then
we
have
this
view
which
is
giving
us
everything
here
and
so
what
we
do
here.
B
B
Yeah
support
required,
so
if
support
required
is
say
50
and
minimum
quorum
is,
let's
just
imagine
a
100
percent,
then
so
far
we
have.
The
support
required
would
be
500,
000
tokens.
B
A
A
I
think
that
it
just
multiply
the
that
that
quotum
per
super
required
and
that
support
required
is
going
to
be
maybe
0.5
which
will
make
it,
but
I'm
not
sure
what
what
I
say
is
that,
because
you
are
counting
the
yes
votes,
then
the
yes
votes
are
there?
Are
that
super
required?
A
B
B
Yes,
so
this
is
the
final
output,
so
what
you're
seeing
here
is
it's
a
row,
so
this
is
how
we
use
python
panel.
It
has
these
essentially
three
functions,
panel,
dot
pain
and
we
can
pass
something
like
our
dandelion
voting
instance.
B
So
when
we
have
a
parameterized
class
and
we
pass
it
to
the
panel,
this
is
python
panel
here
then,
ultimately,
when
panel
renders
it
gives
you
a
pain
like
the
fine
like
what
we
have
here
is
a
pain.
So
the
final
view
is
a
pain,
but
it
can
be
composed
of
rows
and
columns.
It's
almost
like
bootstrap,
if
you,
if
you
use
bootstrap,
so
we
can
make
a
row.
B
I
wonder
if
this
will
work
yeah,
so
we
could
have
as
many
things
here
as
we
want.
B
Oh
yeah,
you
can
even
put
html
right
directly
in
here,
so
it
opens
up
a
lot
of
possibilities
for
doing
cool
things
and
then
we
can
make
a
column
as
well,
and
these
are
composable,
so
we
can
go
panel
dot
column
and
then
we
could
go
so
d
dot,
okay
and
then
what
we
have
here
is
any.
So
when
we
have
these
parameterized
classes,
we
can
make
a
function.
That
returns
some
sort
of
view,
and
so
I've
called
this.
B
The
view
function
because
we're
re
we
make
this
plot
and
then
we
return
a
row
of
the
plot
and
some
statistics
over
here.
So
let's
just
and
we
pass
it
as
a
function,
so
we
get
this.
So
we
have
our
row
here
and
our
columns
like
this,
so
we
can
start
to
compose
dashboards
in
this
way
really
nicely.
So
we
could
actually
take
our
hatch.
We
could
have
our
dandelion
params,
our
hatch
params
and
our
maybe
impact
our
distribution.
Oh
yeah
impact
hour
function
here,
so
this
is
cool.
B
B
Yeah,
I
never
I
didn't
this
didn't
even
click
for
me
until
now,
I'm
like
whoa,
this
looks
amazing.
Okay,
so
I
have
some
stuff
I'll
have
to
bring
in
let's
bring
this
in.
This
is
awesome.
A
B
B
B
So
if
you
end
up
running
things
out
of
order,
then
it'll
seem
like
everything's
broken
when
you
might
have
just
missed
a
cell
that
you're
supposed
to
run
okay.
So
let's
bring
this
up
so
we've
got.
B
B
A
And
that
view
in
in
the
other
pane
you
did
in
another
way
that
showed
itself
or
not
you
you,
you
say
be
that
view.
B
B
So
this
can
return
a
row
and
it
can
be
put
into
a
column
when
we
actually
go
ahead
and
use
it,
but
it's
just
a
one
thing
to
because
it's
using
it's
actually
passing
a
function
if
you
notice,
because
what
we're
doing
here
is
like
d
dot
view
is
actually
a
function
like
if
we
pass
this.
If
we
put
parentheses
here,
then
it
would
call
the
function
and
return
this,
but
we're
actually
not
doing
that.
We're
passing
this
a
view
function
into
the
panel
column.
A
B
A
A
B
B
How
did
I
think
I
deleted
what
we
had
before?
It
was
actually
kind
of
nice.
I
should
have
kept
it.
Oh
maybe
I
can
no
it's
gone.
So
let's
get
all
of
our
parameters
actually
in
one
place.
So
let's
just
go
d
h
and
I
okay
cool.
B
B
B
B
A
B
B
That's
pretty
amazing.
Well,
this
is
really
is
possible.
If
we
take
this,
you
know
and
run
with
it.
I
would
love
to
see
these.
The
lab
contents
be
spun
off
into
because
probably
one
hour
a
week
isn't
enough
to
fully
develop.
If
we
want
to
do
various
ambitious
projects
like
like
that's
totally
possible,
we
could
have
a
a
button
here
that
hit
you
know
we
could,
because,
because
we
could
just
have,
we
can
pass
around
json.
B
We
could
use
the
python
requests
library
to
hit,
or
we
could
use
actually
like
web3
python
or
something
to
hit
ethereum
directly
but
that'd
be
that'd,
be
really
interesting.
That's
to
start
to
connect
connect
to
these
ecosystems
and
and
get
them.
A
A
Okay,
we
were
loading
it
as
a
mapping.
I
I
I
think
that
it's
not
the
the
moment,
but
we
can
whatever
it
can
be
a
token
or
a
mapping
level
in
the
solidity.
A
C
C
One
quick
thing
that,
from
our
front
end
designs
that
we're
working
on
with
fiore
there's
a
and
I
think
it
also
makes
sense
for
quickly
communicating
to
the
people
who
are
voting
on
these
parameters.
Like
the
idea
but
it'd,
be,
I
think,
it'd
be
nice
to
force
the
person
creating
the
proposal
to
also
have
a
target
goal
like
there's
the
main
goal
on
the
max
goal,
but
how
much
they're
when
they're
designing
this?
C
B
B
Yeah,
let's
think
about
that
tonga,
if
we
can
so
maybe
we
can
have
sort
of
an
offline
lab
times
lab
sessions,
we
could
have
it's
almost
like
the
working
groups
right.
They
have
their
sort
of
offline
check-ins
and
everything,
and
then
they
have
a
central
meeting.
So
this
this
space
could
be
sort
of
the
community
lab
session.
Where
everyone
comes
together,
we
can
do
really
coordinated,
builds
and
lectures
and
special
guests
and
things
like
that.
B
But
then
we
could
also
have
sort
of
more
of
a
core
group
that
meets
does
like
these
working
groups,
because
that's
kind
of
how
it's
been
for
me,
I'm
putting
in
you
know
a
few
hours,
probably
about
three
hours
throughout
the
week
to
like
really
get
my
mindset
already
on
this
and
then
have
it
ready
to
go
through
the
lab
session.
B
So
it
would
be
much
better
more
much
more
productive
to
have
it
not
just
me
doing
those
preparation
sessions,
although
jake
and
griff
have
been
really
helpful
in
guiding
this
like
we
do
like
we
made
this
whole
dock,
which
was
awesome.
Oh
yeah,
tonga.
You
were
there
too,
I
think
and
but
yeah
we
can
do
these
sort
of
preparation
lab
sessions
throughout
the
week
tonga.
So
let's
set
that
up.
A
A
B
B
A
No,
it's,
it's
called
minimum
core,
sorry
a
minimum
quorum,
and
I
think
that
last
time
I
in
the
in
the
last
lap,
I
I
said
it's
important-
that
the
quorum
is
less
than
support
or
something
like
that.
B
Yeah,
it's
here,
oh
wait!
No,
oh!
This
is
the
hatch
yeah.
I
have
that
I
have
it
here,
but
I
was
considering
this
so
deeply
this
throughout
this
week.
When
I
was
building
and
then
I
realized
wait,
this
can't
be
true.
I
know
I
took
it
out.
I
thought
that
that
doesn't
make
any
sense
to
me,
but
that
probably
just
represents
I'm
a
bit
confused
because
I
understand.
C
B
A
A
B
B
Then
is
is
minimum
quorum
is?
Is
it
a
percentage
of
all
tokens.
A
It
was
not
like
the
people
who
voted.
Yes,
it's
like.
I
think
that
what
I
say
I
just
said
that
doesn't
have
sense.
You
need
at
least
two
percent
of
people
who
vote,
but
the
thing
is
that
the
people
who
vote
no-
I
mean
you
they
yeah.
That's
that's!
That's
of
all
the
votes.
B
Yeah
yeah:
here
we
got
it,
we
got
it.
Okay,
it's
actually
so
simple,
okay!
So
this
okay,
we
have
two
minutes,
I'm
kind
of
curious.
If
we
can
get
this,
that
was
a
little
breakthrough.
This
is
making
sense
to
me
of
all
the
tokens.
Two
percent
of
them
have
to
vote
yes
and
of
all
the
tokens
that
vote
at
least
50
of
them
have
to
be
yes
cool.
B
At
least
this
is
clear.
I
don't
know
if
we'll
visualize
this
in
two
minutes,
but
at
least
this
is
clear
now,
but
I'm
just
gonna
think
about
this
a
little
bit.
So
two
percent
of
all
tokens
must
say
yes,
so
basically,
let's
imagine
this
visualization,
we
would
say
based
on
a
million
tokens
support
required.
B
A
Of
that
that
visualization
makes
sense,
I'm
setting,
if,
if
you
have,
for
example,
a
50
of
and
the
the
quotum
is
the
people
who
vote
cs,
I
mean
you
need
that
right
now
the
quotum
is
the
sum
of
yes
and
knows
so.
For
example,
right
now
you
have
a
quotient
right
of
45
percent
46,
and,
and
that
means
that
the
yes
tokens
should
be
at
46
percent
35.
A
In
in
the
in
the
in
the
graph,
the
that
that
should
represent
that
we
have
46
percent
of
tokens
that
board
cs,
and
this
is
why
forum
must
be
less
or
equal
than
support
required.
C
B
A
What
what
that?
What
I
try
to
say
is
that
the
the
blue
box
should
be
equal
to
minimum.
A
B
B
So
to
me,
this
is
so
clear,
so
I'm
going
to
take
this
and
make
it
work
in
a
visualization
and
I'll
I'll
post,
a
screenshot
and
I'll
push
that
to
github,
because
I
know
if
I
can
get
this
visualization
going,
then
it's
it's
gonna
be
really
clear
and
I
might
make
two:
it
might
have
to
be
two
different
bar
charts.
Instead
of
stacked,
it
might
make
more
sense
to
have
them
independent.
A
B
And
then
we'll
see
that
property
and
then,
if
they're,
independent,
we'll
see
that
property
where
support
wait,
what
is
it
quorum
cannot
pass
support.
B
Okay,
thank
you
guys
we're
a
little
over
two
minutes
over
and
this
is
so
cool,
so
I'm
gonna
push
this
we're
getting
towards
this
is
I
want
to
check
in
with
you
guys,
griff
and
with
the
sprint
planning
and
everything
and
and
line
up
this
development,
so
it
really
lines
up
nicely
with
what's
being
planned
for
the
hatch,
so
we'll
just
have
a
we'll
have
a
chat
about
that.
C
We
can
also
when
we
meet
up
on
the
weekend.
We
can
definitely
go
through
a
lot
more
of
this
yeah
and
then
we
can
really
have
a
timeline
planned
perfect
because
I'm
also
getting
some
good
feedback
from
wes.
So
I
think
yeah
or
I
think
we're
gonna
we're
gonna
line
up
just
fine,
but
we
can
hack
out
more
on
sunday
and
go
from
there.
B
Yeah
yeah,
I
think
it's
great
and
I'm
excited
to
get
more
people
signed
up
to
have
some
guest
lectures.
I'm
going
to
start
working
on
that
more.