►
From YouTube: DXR 2.0 (Part 1: Dog & Pony Show)
Description
Part 1 of the DXR 2.0 presentation from the Mozilla work week at Whistler, June 2015. This part is a demonstration of new features. Part 2 is a group discussion on the upcoming roadmap.
* Improved C/C++ analysis
* Multi-language support—Python and Rust, for starters
* Generic identifier search
* Image browsing
* Zero slow queries
* Independent, parallel tree indexing. (This will help us get all the trees currently under MXR indexed.)
* Permalinks to old revisions
* A new plugin architecture so we can add new languages, query types, and cross references easily
* Lots more
Part 2: https://air.mozilla.org/dxr-2-0-part-2-discussion/
Help us caption & translate this video!
http://amara.org/v/2Fhk/
A
So
I
already
asked
how
many
bxr
looks,
like
maybe
two-thirds
have
to
a
third
something
like
that
for
those
that
don't
you're
going
to
see
lots
of
demos
in
about
a
minute.
It's
our
search
and
exploration
tool
for
large
code
bases
and
we
are
about
to
land
a
long-running
branchless.
It's
been
so
long
running
is
so
far
reaching
out
decided
to
call
it
vxr
2.0
and
it
improves
every
part
of
DX
star
touches
every
subsystem.
I
didn't
mean
for
it
to
be
a
almost
rewrite,
but
that's
what
happened.
So
today's
talk
has
two
halves.
A
I'm
going
to
show
you
the
wizzy
new
things
landing
in
2
point
0
and
second
half
is
you're
going
to
help
me
choose
the
ways
you
do
things
for
the
release
after
that
and
we're
gonna
stop
having
these
long
running
branches.
I.
Don't
usually
do
that.
But
this
happened
by
accident
whole
big
pile
of
people
have
been
helping
out.
The
project.
I
was
shocked
last
night
I'll.
Let
me
get
that
seven
people
who
have
helped
in
the
last
year.
A
These
are
the
ones
just
in
the
last
year
who
contributed
just
code
plus
Kendall,
because
so
much
stuff,
our
ops,
superheroes.
Let's,
let's
see
what
they've
added
I've
been
thinking
as
DX
of
2
point
0
is
like
a
multiple
brain
transplant:
we've
rewritten
several,
the
innermost
subsystems
or
darn
close
to
it
and
most
important.
We
replaced
the
backend
storage
sequel
lights,
gone
away.
Custom
C++,
trigram
index
that
nobody
was
maintaining
and
elastic
search
is
here
to
stay
an
elastic
searches,
orders
of
magnitude
faster
for
the
comments
of
common
operations.
A
We
do
more
scalable,
we
cluster
it
does
all
these
little
tricks.
Fuzzy
matching
I
can
give
the
efficient
resolve
counting,
so
J
ruderman
can
do
google
fights,
we
can
do
fastening
and
scoring
boys
scoring
hurts
a
relational
system.
We
can
harness
the
fuzzy
stuff.
Do.
Did
you
mean
kind
of
stuff,
sparse,
attribute
storage?
So
we
don't
chill
continually
think
of
a
highly
represent
the
sum
and
union
of
all
programming
languages
and
a
rectangle
extreme
flexibility
of
tokenization.
The
ability
to
hey
this
is
cool.
You
can
pull
out
individual
lines
of
source
files
that
we've
indexed.
A
So
we
context
research
results
or
load
big,
huge,
crazy
files
incrementally
over
the
web
really
a
useful
thing,
but
of
course
this
meant
we
had
to
replace
everything
in
the
system
that
assumed
a
relational
model,
fun,
fun
fun.
So,
before
we
embarked
on
this
road,
we
did
a
very
careful
study
of
various
storage
engines
thinking
as
far
ahead
to
the
future
as
we
could
possibly
fathom
and
we're
pretty
satisfied
that
elastic
search
is
going
to
take
us
a
long
way.
A
Aside
from
elasticsearch
other
things
that
have
been
rewritten
include
the
HTML
rendering
pipeline.
Now
we
emit
well-formed
markup,
no
more,
like
three
clothes
anchor
tags
in
a
row.
We
do
all
this
stuff
at
request
time,
so
we
don't
build
and
store
30
gig
of
HTML
/
tree
on
best
store
that
we
it's
like
ten
dollars,
a
kilobyte
or
some
ridiculous
thing.
A
new
multi
processing
engine,
which
is
no
longer
strange,
new
query,
parser,
actually
parser.
Now
yay
config
system
is
not
stupid
anymore
either.
A
So
what
kind
of
cool
new
features
that
was
back
in
stuff
gotten
us
well?
Speed
is
probably
the
most
visible
thing
before
some
kinds
of
queries
would
be
slow
because
we
forget
to
make
an
index
or
sequel
lights.
Planner
would
do
something
silly
and
naive.
Well,
the
leucine
behind
elasticsearch
doesn't
know
how
to
be
slow.
It
won't
do
table
scans.
Everything
is
indexed
for
it.
At
worst,
you
get
an
index
can
out
of
it.
Also
it
has
mad
crazy
caching
and
results
come
on
joy.
A
A
Your
caching
I
want
you
to
cash,
yes,
this
and
this,
but
also
cash,
each
branch
individually
and
when
Kashi
sings
it's
bitmaps,
and
so
what
we
end
up
with
LRU
Styles
wind
up
with
the
set
of
all
star
dot,
cpp
files
shoved
in
the
memory
as
a
bitmap,
and
we
can
just
set
math
on
these
things,
so
crazy,
fast
and
leucine,
compresses
them
and
hashes
them.
So
many
cool
data
structures
we
get
tons
of
mad
speed
out
of
it.
When
I
was
recording
this
you
can
actually
see
intermediate
results.
A
A
Better
C++
analysis
wasn't
really
an
intention
of
this
release.
It's
just
something
that
sort
of
happened
as
we
cleaning
things
up.
We
corrected
a
whole
bunch
of
weirdnesses
and
these
are
there's
the
ones
that
I
could
convey,
tersely
enough
to
actually
fit
on
a
slide.
A
big
one
was,
I
audited,
the
compiler
plugins
location
handling,
so
we
have
just
plugging
it
leaves
in
clang
and
bails
data
off
to
the
side.
We
suck
it
in.
That's
what
you
get
so
as
a
result
of
fixed
location
stuff.
We
can
probably
find
lots
of
things
we
couldn't
before.
A
Probably
we're
just
throwing
lots
of
things
on
the
floor,
especially
around
macro
sites.
Wrap
macro
calls
another.
My
favorites
is
the
caller's
query
find
the
calls
to
this
function.
Well,
now
we
point
to
the
actual
call
site
its
total
up
to
the
top
of
the
function
that
might
contain
the
call
site.
So
that's
cool.
Let
C++
is
great
and
everything,
but
there
are
other
languages,
which
is
why
the
xr2
point
0
supports
rust
and
Python
and
I
got
to
thank
Jeff,
Bradbury
and
Osmos
with
a
Python
thing.
You
come
on
in
my
own
port.
A
The
sport
is
pretty
basic
right
now,
but
it
still
does
a
whole
bunch
of
useful
things
already.
We
can
find
subclasses
of
things
over
writers
of
methods.
We
can
find
modules
by
name
and
it
even
understands
them
folder
with
a
peanut
pie.
File
in
it
is
a
module
of
sorts
and
one
of
the
thing
I'm
particularly
proud
of
that
M
Kelly
wrote
was
we
traced
the
import
lineage
of
symbols
functions
for
example.
A
So
if
you
have
a
function
somewhere,
deep
in
a
package
may
be
at
a
private
module
when
you
you've
lifted
it
up
imported
it
into
an
API
package.
That's
the
public
interface
and
import
it
from
here
to
somewhere
else,
and
then,
if
you
look
at
the
definition
of
it,
it
skips
that
interstitial
step
and
takes
you
right
to
the
source
so
happy
smart,
useful
stuff.
A
As
for
rust,
we're
going
to
index
the
rust
compiler
and
servo
for
starters,
and
there
are
rumors
that
we
might
go
a
little
more
crazy
and
do
community
packages
like
everything
on
crepe
de
o,
dxr
understands
rough.
Specific
constructs
like
impuls
could
hunt
them
bound
for
you
and
a
big
shout-out
to
Mick
Cameron,
who
did
our
rust
support,
actually
have
our
analysis
in
the
rust
core,
not
some
crazy,
janky
on
the
side.
A
Plugin,
that's
going
to
go
out
of
date,
all
the
time
and
done
by
tests,
both
in
rust
and
dxr,
which
runs
against
each
nightly.
So
we
we
know
right
away.
Sex
I
happen
once
already
by
doing
it
for
24
hours
and
something
had
broken,
but
these
two
languages
are
just
the
beginning.
The
future
is
bright.
We
can
do
javascript.
Now
we
can
do
various
homegrown
I
dl's.
These
are
possible
next
steps
and
since
we've
removed
all
the
C++
assumptions
from
the
codebase,
we
made
things
a
lot
more
general.
A
How
we
work
internally
is
something
I
call
like
line
tagging.
We
lay
down
these
these
breadcrumbs
for
defined
later
these
needles.
We
call
them
as
any
needles
in
a
haystack,
for
example,
we
would
tag
this.
This
line
up
here
as
defining
a
python
class
called
member
function,
tests
catch
that
data
to
that
line.
Now,
of
course,
we
can
have
more
than
one
tag
on
a
line.
A
Why
not
right
so
we
can
also
say
this
line
defines
a
python
class
that
subclasses
single-file
test
case
in
this
entire
power
hour,
subclass
searches
or
find
subclasses
menus
and
so
on.
Likewise,
we
can
tag
this
line
down
here
as
defining
a
down
here
there
we
are
as
defining
a
function.
Function
with
the
given
name
and
also
a
member
of
a
given
class
is
a
method
on
this
class.
A
So
this
simple
approach
is
completely
language
agnostic
to
the
point
where
it's
not
even
limited
to
programming
languages
right,
we
could
just
as
easily
teach
it
to
find
occurrences
of
names
in
a
legal
document
or
the
occurrences
of
CSS
classes
in
some
markup.
So
we
can
get
this.
We
can
put
this
a
long
way
without
having
to
change
anything
about
the
schema.
A
This
led
to
some
weird
behavior,
where
a
multi-word
search
query
would
have
alt
words
and
it
together
to
choose
the
files
to
show
you,
but
then
have
those
words
ordered
together
to
choose
the
lines
to
show
you.
So
not
every
line
had
your
terms
on
it.
It's
kind
of
unexpected
kind
of
bizarre
into
point.
Oh
it's
just
like
grep.
We
find
the
lines
that
match
all
the
words
you
type
as
you
can
see.
If
I
type,
all
the
things
every
result
contains
all
three
words
yeah,
just
like
it
should
now.
A
If
you
want
to
match
the
whole
phrase
you
just
put
quotes
around
it
and
then
their
continuous
now
I
wanted
to
kind
of
float
this
everybody
in
the
room
who
thinks
that
we
should
kind
of
concatenate
together
consecutive
texts,
terms
that
find
the
phrase
by
default
unless
you
may
be
put
in
like
capital
or
between
the
words
or
something
anybody
want
the
phrase
matching
by
default.
Nobody,
okay,
cool
I,
will
not
build
that
I.
Think
we
always
inquisitive
of
you
and.
A
Yeah
I've
been
lifting
a
lot
from
Google's
colon
syntax
and
everything.
Okay,
excellent,
brilliant,
brilliant
I'm,
actually
gonna
take
notes
while
we're
doing
this,
and
this
will
help
power.
The
future.
The
possibility
of
us
not
operator
is
interesting.
We
have
one
its
minus
go
on
yeah,
it
exists
right
now
we
can
use
it
on
Amazon
and
try
it
out.
Let
me
know
if
it
surprises
you
in
any
way
the
local
people
ask
our
features.
We
have
no
right
possible.
A
Thank
you
very
much.
Sooo
parallel
indexing
happens
now
same
before
we
got
started.
This
will
help
us
get
all
the
trees
and
MX
our
index,
30
or
50
trees,
or
something
that
we
have
it
align
the
whole
ticket
collecting
people
who
want
their
stuff
in
there,
and
it
also
will
mean
that
indexing
different
trees
is
independent.
So
if
calm
Central's
bill
breaks
or
something
and
maz
central
will
be
held
up,
it
never
breaks.
No.
A
We've
got
a
nice
HTTP
API.
Now,
with
no
strange
format,
equals
adjacent
query,
string,
parameters
and
I'll.
Let
you
do
things
like
write,
a
DX
star,
search
plugin
for
your
editor,
which
Osmos
has
done
these
plug.
This
thing
into
adam
and
you
can
search
for
files,
it
will
find
the
corresponding
local
file
and
pull
it
up
for
you
and
click,
or
you
can
search
for
lines
of
code.
Your
structural
queries,
anything
you
like
it
all
works
very
nicely.
A
Performance
is
fine
and
my
P
few
guitar
solos
hit
and
there's
Easter
eggs,
okay,
permalinks
or
something
that
it
was
a
who
who
aren't
permalinks
in
here.
Okay,
let's
roll
breaking
that
exists
right
now
in
staging,
and
it
keeps
your
highlight
regions
and
everything.
So
you
can
paste
your
links
into
bugzilla
and
it'll
work
forever.
A
A
So
this
is
I'm
really
happy
and
proud
and
cheerful
about
this.
So
mxr
has
its
identifiers
searching
right.
Let's
not
that
accurate,
because
mxr
just
kind
of
like
guessing
its
tub
with
red
x's
and
well.
Now
we
have
that
in
vxr
and
it's
correct
all
the
time
just
type
ID
colon,
whatever
you
can
find
ID
food
finds
all
the
Foos
ID
bar,
finds
all
the
bars
and,
as
you
can
see,
is
all
kinds
of
things
in
here
struck.
There's
some
variables,
there's
a
class
definition.
A
A
A
A
You
can
try
all
the
stuff
on
staging
right
now.
It
exists,
find
bugs
give
feedback,
expect
intermittent
breakage
right
now,
I
think
I
know
that
context.
Menus
are
working
for
some
reason.
I
think
it's
a
built
problem,
but
there
is
more.
The
entirety
of
DX
are
2.
Point
0
is
built
on
a
flexible
plug-in
architecture
here,
while
we're
at
it
everyone's
we're
writing.
When
we
write
it
hook,
able
a
plugin
can
add
entirely
new
languages
entirely.
New
query
types
like
rust:
the
rust
is
rust
is
a
plug-in.
Python
is
a
plug-in.
A
A
Most
common
hooks
are
fairly
intuitive.
They
correspond
what
you
see
on
the
screen:
coloring
stuff,
hooking,
menus
to
things
you
just
make
a
subclass
implement
whatever
hooks
interest
you
and
then
register
it
with
a
one-liner,
setuptools
entry
point
and
so
far
we've
kept
the
plugins
inside
the
DX
our
code
base,
just
because
the
API
is
kind
of
flopping
around
still,
but
the
flapping
is
really
slowing
down
so
well.
You're.
Welcome!
If
you
want
to
write
a
plug-in,
please,
like
upstream
of
DX,
are
and
will
include
it
will
have
batteries
included
and
everything.
A
A
A
So
that
concludes
the
first
half
of
a
talk,
a
dog
and
pony
show,
but
what
is
next,
putting
2
point
0
into
production,
obviously,
but
after
that,
I
want
to
get
your
opinions
on
these
things.
We
have
a
couple
of
ideas.
Here
are
some
of
the
possibilities
that
are
floating
around
in
my
brain
and
I
want
to
take
some
self-selected
unscientific
poles
of
the
interested
users
in
the
room.