►
Description
Visit the https://archive.devcon.org/ to gain access to the entire library of Devcon talks with the ease of filtering, playlists, personalized suggestions, decentralized access on Swarm, IPFS and more.
https://archive.devcon.org/archive/watch/6/better-solidity-support-in-vscode-by-hardhat/
A brisk jaunt through the state of the art in Solidity editor tooling, a tour of Nomic's Solidity Language Server and how we can take Solidity editor support to the next level.
Speaker(s): John Kane
Skill level: Beginner
Track: Developer Infrastructure
Keywords: developer,infrastructure
Follow us: https://twitter.com/efdevcon, https://twitter.com/ethereum
Learn more about devcon: https://www.devcon.org/
Learn more about ethereum: https://ethereum.org/
Devcon is the Ethereum conference for developers, researchers, thinkers, and makers.
Devcon 6 was held in Bogotá, Colombia on Oct 11 - 14, 2022.
Devcon is organized and presented by the Ethereum Foundation, with the support of our sponsors. To find out more, please visit https://ethereum.foundation/
A
A
T
and
we're
going
to
be
covering
this
is
going
to
be
like
a
jaunt,
quite
an
easy
joint
through
the
different
virtual
Studio
code,
extensions
for
solidity.
There
will
be
showing
of
the
extension
I
work
on
and
then
more
interestingly,
we'll
move
on
to
a
couple
of
the
technical
blockers
that
are
holding
us
back
from
giving
you
this
solidity
experience
you
all
deserve,
and
then
you
know
a
plan
for
getting
around
those
blockers.
So
my
name
is
John
Kane
I'm
from
the
nomik
foundation.
A
You
probably
knows,
as
the
heart
attack
people
and
normik
is
a
not-for-profit
foundation.
Pay
for
by
donations
with
a
remit
to
improve
the
ethereum
developer.
Experience
hard,
Hat's,
a
big
part
of
that,
but
the
rematch
General
and
we've
identified
a
gap
in
editor
tooling,
and
that's
why
we
have
built
and
released
a
vs
code
extension
called
solidity
by
Dynamic
Foundation
of
which
I'm
the
the
team
lead.
So
you
can
find
me
on
GitHub
or
hang
around
our
Discord
server,
particularly
the
heart
VSCO
channel.
A
So
if
you
want
to
come
and
chat
or
suggest
some
features
or
you've
got
a
really
detailed
book
report
and
a
matching
PR
come
chat,
come
chat,
editor,
Tilly,
let's
kick
off
by
addressing
the
Microsoft
branded
elephant
in
the
room
right.
Why
are
we
focused
on
vs
codes
and
the
reason
is
we
have
good
reasons
to
believe
that
vs
code
is
the
main
way
that
circle
is
getting
developed
today.
So
if
we
take
a
look
at
the
most
recent
solidity
developer
survey,
you
can
see
the
vs
code
is
dominant
right.
A
In
fact,
the
60
Visual
Studio
people,
we
suspect,
actually
meant
Visual
Studio
code
rather
than
the
venerable.net
IDE.
Similarly,
the
remix
and
that's
an
online
solidity
editor
a
bit
booze
in
key
components
from
vs
codes
right,
so
you're
actually
down
at
then
before
you're,
not
talking
about
vs
code
or
vs
code
adjacent
right,
and
we
suspect
that
the
solidity
developer
survey
skews
towards
those
who
are
deep
in
the
ecosystem
right,
those
who
are
on
crypto,
Twitter
and
and
click
on
the
survey
link
when
it
goes
out.
But
another
way
it's
over
representing
this
long
tail.
A
It's
over
representing
the
shadowy
supercoders
who
are
doing
their
development
and
then
and
a
teamwork
session
over
a
VPN
to
a
military
satellite
that
they
repurpose
for
the
day.
Actually,
let's
just
test
right
hands
up
anyone
who,
when
they
do
do
solid
development,
they
do
it
and
vs
code
and
hands
up
if
you're,
a
shadowy,
supercoder
who's
doing
it
within
alright
see
that's
a
track.
No
shadowy,
supercoder
with
admit,
right
and
actually
hands
up.
If
anyone
any
of
the
two
emacs
users
are
in
the
room
because
I'll
buy
them
a
drink.
I'm.
A
Having
my
doubts,
I've
created
the
wrong
incentives
here,
right
and
I'm,
not
immediately
going
to
renege
on
that
promise.
Right
well,
be
a
lesson
on
soft
promises
and
the
value
of
escrow
right
so
by
Pareto
analysis.
Vs
go
to
Japan
vs
code.
I
might
just
write
the
development
I'm
looking
at
the
marketplace.
A
A
A
A
A
We
find
them
under
the
bulb
icon,
so
let's
bring
back
public
possibility
and
simply
making
sure
that
we
set
the
overrated
specifier.
These
are
small
annoyances
with
function
signatures,
but
we
have
more
complicated,
quick
fixes.
For
instance,
we
have
a
contract
that
needs
to
implement
an
interface
or
multiple
interfaces.
A
So
once
I
had
four
knew
if
I
push
play,
this
is
going
to
play
again
good
if
I
could
buy
it.
I
want
to
add
three
caveats
to
that.
Video
gave
it
number
one
like
any.
Suitably
advanced
technology
is
indistinguishable
from
a
direct
Tech
demo
right
and
what
you
just
saw
was
a
reg
take
demo.
You
didn't
see
all
of
the
places
where
jump
to
definition
doesn't
work
or
you
you're,
aiming
for
completions.
A
We
don't
resolve
bolts
out
of
completions
caveat
number
two
I
just
re-emphasize
that
the
documentation
against
function
wasn't
appearing
on
hovers
and
there's
a
technical
box
to
that.
I
want
to
come
back
to
right
and
fee
is
the
biggest
caveat,
which
is.
There
are
some
key
features
in
there
actually
like
Diagnostics
and
quick
fixes
that
only
work
inside
of
a
hardtop
project
right
and
that's
a
problem
that
I
want
to
come
back
to
again.
But
let's
take
a
look
at
the
other
extensions
quickly
solidity
why
Juan
Blanco
this
is
the
OG.
A
It's
been
the
Workhorse
of
statistic,
development
for
years
with
over
800
000
downloads
relative
to
ours.
Let's
just
see,
we
know
how
event
feels
it
provides
syntax,
highlighting
integrated
formatting,
and
it
has
navigation
and
Diagnostics,
and
the
default
structure
assumes
you're,
organizing
your
contracts
under
source
and
lib,
so
setting
it
up
for
heart
attack
is
is
difficult,
but
it's
going
to
work
better
if
you're
doing
boundary
or
adapt
tools
or
or
brownie,
and
next
we
have
truffle
for
the
escort.
A
This
leverages
solidity
by
one
Blanco
for
the
syntax,
highlighting
Diagnostics
Etc
that
adds
a
layer
of
UI
Integrations
into
the
Truffle
two
Suite
right,
so
that
you
can
run
compile
through
the
the
UI
through
the
task
subsystem
in
vs
code,
for
example
right
and
that's
great
for
onboarding,
if
you're
new
to
truffle
or
you
prefer
the
UI
to
the
CLI
right.
One
other
really
cool
feature
is
integration
with
the
Truffle
debugger
just
wanted
to
mention
as
well.
A
So
how
do
we
move
from
where
we
are
now
to
that
Best
in
Class
experience,
and
one
of
the
answers
is
just
time
and
resources
right,
but
there
are
a
few
technical
blockers
I'm
going
to
spend
the
rest
of
that
stock
taking
into
those
first
off
feature
fragmentation,
so
we
have
features
which
are
siloed
by
editor
and
also
cycled
by
development
framework.
The
others
feature
productiveness
right.
Can
you
rely
on
a
feature
to
always
be
there
and
to
do
the
right
thing
and
for
fragmentation
clearly
extensions.
A
We
have
built-in
vs
codes,
a
maybe
the
lack
of
support
and
then
is
why
there
are
as
many
people
using
them
right.
If
they
had
those
Advanced
features
in
film,
they
would
be
using
them.
So
that's
one
form
of
fragmentation.
The
other
form
of
fragmentation,
though,
is
in
developer
framework,
not
all
of
the
features
that
were
listed.
A
There
work
for
all
development,
Frameworks
right
if
you're
working
on
a
truffle
code
base,
you're,
probably
using
truffle
for
vs
code
and
if
you're
in
a
heart
attack
code
base,
hopefully
you'll
use
the
normic
extension
and
if
you're
in
Foundry
you're
likely
using
one
blank
was
extension
right
and
that
makes
sense
for
some
development
specific
features.
But
there
are
core
editor
features.
A
We
should
just
work
across
all
of
them
right,
you're,
going
to
want
rename
and
Foundry
just
as
much
as
you're
going
to
want
to
in
heart
app,
but
currently
it's
siled
in
hard
times
right.
How
are
we
going
to
get
around
this?
This
sorry?
There
are
multiple
reasons
for
that,
and
one
of
the
reasons
is
is
just
Conway's
law.
A
So
if
you've
got
four
teams
working
on
compiler
and
then
you're
going
to
end
up
with
a
four-phase
compiler,
the
code
structure
matches
the
communication
structure
of
the
teams
right
and
the
development
teams
that
are
rating
editor
support.
It's
easier
for
them
to
add
it
for
their
own
development
framework.
A
It's
easier
for
me
to
harangue
the
other,
hard
hat,
devs
or
cajole
them,
or
convince
them,
or
go
crying
to
the
CTO
to
try
and
get
it
changed
than
it
is
for
me
to
convince
the
entire
ecosystem
to
just
do
what
I
see
right
but
there's
on
another
aspect.
That's
part
of
solidity
right,
which
is
that
solidity
doesn't
specify
how
import
loading
works
or
sorry
or
doesn't
specify
that
part.
It
leaves
it
up
to
the
development
framework
right.
A
So,
if
you
so,
if
we've
got
an
import
statement
here,
pulling
in
other
solidity
codes,
so
C
requires
a
custom
loader
to
actually
resolve
that
and
it
has
to
be
provided
by
the
development
framework.
And
if
it's
a
relative
path,
the
development
frame
was
probably
going
to
do
that
as
relative
to
the
on
the
file
system
right
from
the
current
file.
A
But
if
it's
a
direct,
then
for
then
there's
multiple
different
interpretations
which
make
sense
right
and
heart
hats,
we
would
interpret
this
as
a
look
inside
of
node
modules
and
then
find
open
sample
and
resolve
the
rest
of
the
path
read.
The
irc20
soul
fail,
and
that
makes
sense
right,
heart
out
leverages
GS,
including
node
modules,
but
that
doesn't
make
sense
for
Foundry
right.
A
It's
going
to
resolve
this
based
on
remappings
in
either
the
foundry.tomo
or
remapping
txt
right,
and
that
has
profound
implications
for
editor,
telling
right
so
say,
you're
on
irc20,
that's
token
here
and
you
wanted
to
jump
to
definition.
The
editor
can
only
resolve
that
if
it
understands
this,
our
open,
ziplin
import
line
right
that
implies.
The
editor
has
to
understand
the
import
loading
logic
of
the
development
framework
that
this
file
has
been
dealt
with
under
okay.
A
So
how
are
we
going
to
work
around
these
fragmentations
and
editors
and
different
editors
and
fragmentation
across
development
framework
I'm,
going
to
in
two
steps?
First,
we're
going
to
use
the
language
server
which,
as
language
efforts
of
technology,
that
came
out
of
yes
code
but
tries
to
deal
with
the
fragmentation
you
get
across
editors
right.
A
So,
instead
of
each
editor
implementing
language
features
for
each
language,
we
gather
up
the
language
features
under
a
Daemon
and
we
have
the
editor
put
that
demon
up
ask
which
features
it
provides
turn
those
features
on
in
its
UI
and
whenever
the,
whenever
it
was
a
request
by
the
user.
It
delegates
them
off
to
the
Daemon
and
the
communication
between
the
editor
and
the
demon
is
covered
by
a
clearly
specified
protocol
language
server
protocol
and
that's
what
we're
doing
in
the
nomic
extension
today
right.
A
There
is
a
a
language
server
which
is
encoding
all
of
the
completions
diagnostic
servers
that
we
that
we
provide
today
and
there's
that
is
embedded
in
vs
code,
but
there's
nothing
stopping
us
from
exposing
that
out
so
that
other
editors
save
in
could
take
advantage
of
it
right.
But
what
about
the
important
or
more
difficult
form
of
fragmentation
right
between
developer
Frameworks?
If
you
have
a
language
server,
an
economic
extension
already?
A
Why
is
it
that
I
don't
have
advanced
completions
in
Foundry
right
and
the
reason,
because
that
is
because
currently
the
language
server
is
really
a
hard
language
server,
rather
than
a
solidity
language
server?
We
are
all,
through
the
code
base,
encoding
heart
assumptions
to
deal
with
things
like
the
import
loading
that
we
saw
earlier
right
and
the
reason
that
we've
done,
that
is,
we
use
bits
of
the
heart
attack
code
base
right,
which
allowed
us
to
get
up
and
running
quickly.
A
We
can
make
hard
hat
dance
right
and
subtraction
is
hard
right,
but
we
are
looking
now
to
refactor
the
language
server
to
isolate
out
these
heart
particular
points.
The
development
framework
particular
Parts
behind
an
adapter
interface
will
have
a
heart
attack
adapter,
but
we
also
can
then
have
the
implementations
for
Foundry
truffle
brownie
right
and
in
that
way
we
can
add
feature
once
and
have
it
available
across
the
ecosystem.
One
of
our
point-
I
just
wanted
to
mention
recent
versions
of
Southsea
have
a
language
server
built-in
right.
A
So
so
that's
why
right,
but
just
to
summarize
the
normic
extension
has
an
in
language
server
and
we
are
making
development
framework
agnostic
and
then
we're
going
to
make
Standalone,
so
it
can
be
used
in
other
editors
and
that's
how
we
can
build
a
feature
once
and
leverage
it
across
the
ecosystem
feature
platforms
right.
This
is
about
quality.
The
edits
are
just
doing
the
right
thing,
and
so,
when
you
to
jump
to
definition,
you
can
do
jump
to
an
air
finish
in
all
the
places
you
expect
and
actually
goes
to
the
right
place.
A
Anatomic
extension
has
blind
spots
right.
There
are
lots
of
places
where
features
don't
quite
work.
As
we
would
like-
and
there
are
several
areas
that
we
need
to
work
on
this
and
but
I
just
wanted
to
focus
down
on
one
in
particular
today
right
and
that
is
that
we
are
not
giving
the
best
experience
when
people
are
annoyingly
trying
to
use
the
editor
to
make
edits.
A
Walkthroughs
you're
popping
about
inside
of
the
Department
inside
of
the
editor
you're
doing
navigations
you're,
exploring
the
code
base,
yeah
jump
back
again
right
and
then
you
start
making
an
edit
and
you
remove
a
semicolon
right.
Shame
on
you,
shame
on
you,
but
suddenly
drop.
The
definition
doesn't
work
right,
and
why
is
that?
So?
A
The
video
just
showed
you
a
change
in
the
document
and
that
change
dot
gets
passed
to
the
language
server
right
and
the
language
server
does
a
parse
and
it
builds
and
Abstract
syntax
stream
right
and
that's
a
data
structure
which
represents
the
syntactic
elements
in
the
in
the
code.
The
code
might
represent
our
function
and
then
sub
nodes
would
represent
substructures
like
the
function
name,
the
parameter
list,
the
the
function
body
I,
know
as
well
that
the
parse
produces
an
abstract
syntax
tree
right.
A
So
some
trevia
is
thrown
away
stuff
that
isn't
strictly
necessary,
like
white
space
like
comments
right
because
they
are
not
typically
used
in
later
phases
by,
for
instance,
the
parser
right
and
that's
why?
When
we
do
hovers,
we
don't
show
the
documentation.
The
abstract
syntax
tree
is
abstract,
because
it's
thrown
those
elements
away
and
because
the
ASD
doesn't
have
it,
we
don't
have
it
so
we
can't
provide
it.
And,
however,
we
take
the
the
language.
A
Server
takes
the
AST
and
it
combines
that
EST
with
the
asts
of
all
the
other
code
files
right
and
then
we
do
a
further
analysis
stage.
We
overlay
it
with
type
information.
We
also
scan
through
the
nodes
and
we
find
definition
nodes
on
your
signals
right.
So
our
definition,
node
might
be
a
function.
Declaration
and
a
usage.
A
It
looks
up
the
nodes
underneath
that
particular
underneath
the
cursor
and
finds
a
function,
notification
right
and
then
looks
up
that
pre-calculated
link
to
find
the
definition
nodes
and
we
return
that
location
right
in
terms
of
its
file
line
column
actually
both
to
start
and
the
end
and
vs
code
then
jumps
to
that
location.
Next,
the
user
makes
an
edit
and
introduces
a
syntax
together,
the
change
dot
comes
through.
We
do
a
part
and
it
fields
right,
and
why
did
the
powers
feel?
A
Well,
we
like
other
projects
in
the
ecosystem,
leverage
solidity
parser
right
for
parsing,
but
solidity
parser
is
it's
a
GIS
library
and
it's
designed
to
give
binary
answers
to
the
question
of.
Is
this
syntactically
valid?
If
it's
syntactically
valid,
we
produce
an
AST,
otherwise,
here's
list
of
errors,
and
that
makes
sense
right
most
use
cases
of
a
parts
are
stop.
If
there's
a
syntax
error,
you
don't
proceed
onto
compilation
or
generation
steps
after
as
a
syntax
error
right,
editors
have
have
other
needs
right
and
the
editors
case.
A
A
It's
just
that
sometimes
the
syntax
tree
will
be
valid
and
other
times
it
will
not.
But
hopefully
slang's
error.
Recovery
will
mean
that
a
missing
semicolon
and
one
function
doesn't
mean
we
don't
get
the
syntactic
structures
in
all
of
the
other
functions
so
that
we
can
take
advantage
of
those
and
extra
features
right.
One
of
the
other
advantages
of
building
parser,
specifically
for
the
editor,
is
that
you
can
include
that
trivia.
A
That's
normally
missed
out
the
white
space
right,
the
comments
so
that
we
can
show
the
comments
and
hovers,
for
instance
right
or
we
can
do
Advanced,
formatting
or
sorry
refactorings
right
right
now,
we're
blocked
in
refactorings,
because
developers
probably
won't
be
too
happy
on
doing
a
refactoring.
We
stripped
out
all
the
comments
in
the
file
right,
that's
probably
unacceptable,
but
with
our
partial
design
for
the
purpose,
we
have
that
information
and
we
can
make
sure
it's
there.
Okay.
A
To
summarize,
if
you're
using
hardware
and
you're
using
vs
code,
we
think
you
should
give
a
strategy
by
nomic
go
and
we
think
it
represents
an
excellent
set
of
features
and
you've
just
heard
how
we're
driving
up
the
quality
of
those
features
by
building
editor-specific
components
and
swapping
out
the
general
components
that
we
have
and
we
are
looking
to
make
those
features
available
across
other
development
Frameworks
right.
We
want
a
credibly,
neutral
language
server
and
we're
doing
the
refactoring
and
putting
in
the
work
to
or
putting
in
the
workforce
attraction
to
support
that.
A
We
also
want
it
to
be
a
standalone
language
server.
So
we
want
to
pull
it
out
for
being
embedded
in
vs
codes.
It's
going
to
need
to
do
a
a
small
amount
of
cleanup.
This
is
actually
one
of
the
easier
things
we
need
to
do
and,
but
hopefully
sometime
soon
Shadow
is
super.
Coder
will
be
able
to
hack
away
in
solidity
to
their
hearts
content.
Okay,
so
that's
how
we're
going
to
improve
the
solidity
developer.
Experience
for
everyone!
C
A
Sorry
so
the
questions
are
there
any
other
tools
that
can
take
advantage
of
this
and
we
would
hope.
Definitely
yes.
The
slant
parts
are
we're
building
a
component
that
could
be
used
in
devtooling
across
the
ecosystem
right
and
it's
going
to
give
more
detailed
information
and
work
across
different
solidity
versions
right,
so
it
should
be
giving
you
rich
information,
cross
versions.
Other
parts
of
the
solidity
project
also
intend
to
add
other
components
to
write.
Even
more
information,
so
usage
in
definition,
would
be
the
next
one
that
we're
we're
looking
to
tackle.
B
B
A
Looking
to
dog
fit
the
slang
part
or
within
the
vs
code,
extension
I
I'm,
not
giving
her
estimates,
maybe
like
it's
not
up
to
me.
But
yes,
we're
hoping
to
put
on
the
slang
bars
are
in
the
near
future
in
terms
of
random
COC
and
that's
part
of
making
the
the
language
server,
Standalone
and
webcoc
would
be
the
first
Target
for
making
it
work
with
that,
and
that's
something
that
is
within
just
what
team's
remit.
So,
hopefully
that
should
be
in
the
near
future.