►
Description
KEYNOTE: Express, State of the Union - Doug Wilson, Express
A
So
I
want
to
start
off
real
quick
just
in
case
anybody
doesn't
know
what
Express
is.
You
know
just
give
a
little
overview.
So
Express
is
a
node.js
web
server
project,
so
it's
one
of
a
bunch
of
them
there's
plenty
of
them
around.
It
has
been
around
for
quite
a
long
time.
The
first
commit
was
actually
made
back
in
about
the
summer
of
2009,
and
then
it
was
first
published
MPM
about
winter
2010
and
back
then
I
was
a
user
of
Express
before
it
was
even
on
NPM.
A
In
fact,
back
way
way
long
ago
was
never
involved
in
the
project
took
quite
some
time
later,
but
I've
certainly
been
using
it
for
feels.
Like
forever
and
Express
is
actually
pretty
simple,
it's
really
just
a
routing
plus
sugar
layer
on
top
of
the
actual
base,
node
J,
sh
t,
P
server,
so
express
itself
isn't
actually
a
server.
It's
just
basically
a
way
that
this
gives
you
a
little
bit
of
extra
on
top
of
what
you
get
by
just
doing
like
HTTP,
create
server
and
node.
A
So
it's
a
you
know,
certainly
a
very
basic
middleware
pattern,
but
it
pretty
much
works
for
what
was
needed
to
be
done
and
it
has
actually
it's
what
helped
make
Express
a
large
community.
You
no
excluding
the
long
tivity
that
it's
been
alive
for
so
incubating
project,
so
nodejs
foundation
had
taken
an
Express
jeaious
in
back
in
the
early
2006.
They
call
it
an
incubating
project.
What
that
means
is
it's
basically
it's.
A
It
was
actually
a
fairly
new
saying,
I
think
we
were
one
of
the
first
ones
into
it,
if
not
I
think
maybe
still
the
only
one
I'm
not
sure,
but
it
basically,
it
doesn't
really
change
express
itself,
but
what
it
tries
to
do
is
it
tries
to
take
like
a
project
like
Express
and
basically
help
them
with
governance.
So,
for
example,
we
get
mentors
to
help
guide
the
project.
We
have
two
mentors
that
have
been
assigned
from
the
node
Foundation,
which
is
Michael
Rogers
and
James
Snell.
A
It
helped
outline
the
project
governance
so,
for
example,
before
it
really
has
had
no
governance
at
all.
It
was
just
whatever
you
know.
The
person
in
charge
just
happened
to
say,
which
has
moved
through
few
people
from
the
original
author
to
at
the
time.
It
was
I
think
it
was
basically
myself
at
that
time.
But
now
we
have
like
a
project
governance
and
we
just
took
that
from
the
node.js
foundation
they
had
for
their
incubating
project.
They
actually
had
a
big
outline
of
a
very
basic
one,
and
we
just
incorporated
that
into
our
project.
A
We
helped
use
that
to
determine
what
our
founding
core
contributors
were
so
over
time
as
well.
People
have
contributed
the
project,
people
have
been
active,
people
have
become
inactive
for
various
reasons.
Maybe
they
move
to
a
different
language.
Maybe
that
they're
doing
note
primarily
because
that
was
what
they
did
at
work
and
now
their
job
changed.
Either
they
went
to
a
new
company
or
not
and
there's
you
know
they
don't
have
an
interest
in
it
anymore.
A
Basically,
for
the
last,
like
bunch
of
months
since
we
moved
in
there
just
to
get
like
here's,
this
group
of
people,
you
know,
let's
start
the
conversation
about
all
this
governance
stuff
with
this
group
here,
so
we
can
get
something
kick-started
and
really
the
goal
of
this
whole
thing
is
really
to
what
they
call
Graduate,
which
is
basically
saying
like
this
project.
Has
a
good
governance
in
place?
A
Is
that
it's
a
participatory
project,
it's
transparent
and
it's
effective,
and
so
when
we
meet
that
kind
of
stuff
we
can
apply
to
graduate
and
then
you
know
we'll
figure
it
out,
but
otherwise,
while
we're
here,
we
have
our
mentors
which
of
course
we
can
always
talk
to
anyways.
But
it's
a
very
nice
thing
and
they
gave
us
a
lot
of
starting
points.
A
So
I
mentioned
that
we
started
with
that
core
contributors.
So
we
made
like
a
thing
as
part
of
the
governance
just
by
default,
like
called
technical
committee,
which
some
of
you
may
be
familiar
with
that
term
from
node
core
as
well.
So
it's
basically
just
a
group
of
people
who
guide
the
project.
So
it's
not
necessarily
decision-makers
or
yes
or
no.
It's
really
just
like
essentially
like
a
guiding
I,
think
that
there's
like
a
technical
steering
committee
as
well
and
node
core
they're
a
lot
bigger.
So
they
have
a
more
structure.
A
Ours
is
pretty
simple,
just
committee
or
just
contributor
or
commit
or
sorry,
so
we
just
meet
every
other
week
to
discuss.
Just
topics
will
always
meet,
but
you
know
we
may
or
may
not
have
pre-arranged
agenda
depending
on
what
happened
between
the
LAT
between
the
last
meeting
in
that
meeting
and
then
we'll
talk
about
whatever
needs
to
be
talked
about
either
new
ideas,
things
that
we
saw
because
most
of
us
are
all
subscribed
to
everything
that
happens
in
all
the
repos.
A
So
we
always
see
everything
so
we'll
talk
about
like
just
different
things
that
were
brought
up
or
you
know,
does
it
align
to
like
folk.
You
know
our
philosophies.
Do
we
want
to
change
philosophies,
talk
about
this
governance
stuff,
which
is
a
lot
of
the
stuff
as
well.
Just
you
know,
over
the
last
bunch
of
months
we
also
go
and
we'll
make
decisions
if
there's
objection.
A
So
if,
for
example,
because
you
know
Express,
there's
a
lot
with
code,
if
there's
you
know
maybe
some
kind
of
pull
request
or
other
kind
of
issue-
that's
just
been
there
for
a
while.
It's
not
getting
resolved
by
itself
in
the
comments,
then
we
can
always
specifically
bring
up
that
and
talk
about
it,
so
there's
really
sometimes
specifically
bring
it
up,
just
to
say
oh
cool,
let's
iterate
on
this
idea.
This
is
awesome,
and
you
know,
let's
do
this
next
or
hey.
A
This
doesn't
seem
to
be
going
anywhere,
let's
at
least
what
do
we
think
about
this
and
then
we'll
like
put
our
thoughts
in
there.
So
we
can.
We
can
figure
out
what
we're
going
to
do,
which
is
also
I,
think
the
note
court
EC
does
as
well
and
then,
like
I
said,
will
discuss
new
topics
and
align
and
direction
for
where
we
want
to
take
the
project.
A
A
There's
a
couple
stages
for
how
people
get
into
the
TC,
which
is
become
a
the
basic
right
now
has
become
a
committer
and
then
the
TC
nominates
that
person
and
into
the
TC,
and
it's
I-
think
it's
very
similar.
To
course,
since
that's
where
we
took
our
stuff
from-
and
we
just
haven't
had
the
opportunity
just
yet,
but
soon
we
might
so
that's
a
lot
about
that.
A
I
just
wanted
to
also
talk
about
some
of
the
stuff
where
the
what
this
organization
is
for
Express,
so
a
lot
of
people
when
they
hear
Express
Jas,
they
think
of
just
like
the
NPM
module
called
Express
or
the
github
repo.
That
is,
that
NPM
module,
but
express
itself
is
actually
like.
The
project
which
is
what's
in
the
know.
Generation
is
really
all
of
its
pieces,
which
was
split
into
three
github
organizations
due
to
management
over
a
year
ago.
So
those
organizations
on
github
are
Express
j/s,
which
is
basically
the
main
project.
A
A
A
The
tagline
is
the
built,
your
own
HTTP
framework
framework.
So
it's
like
the
framework
to
build
your
own
HTTP
framework
kind
of
was
the
idea.
So,
for
example,
we
have
the
the
core
router
is
in
there
so
like
you
could
get
that
app
dot
use
app
that
getting
all
that
stuff.
Without
anything
else.
You
could
just
use
that
if
you
really
wanted
to
then
the
last
one
is
JSA
CP,
which
is
our
low
level
JavaScript
HCP
related
modules,
so
that
has
a
whole
bunch
of
stuff
that
was
just
like
little
wheels.
A
A
So
just
hang
high,
like
show
you
kind
of
like
what
we
logically
were
trying
to
like
put
these
three
organs
in
the
layers
so
like
at
the
top
would
be
the
Express
j/s
org
set
has
expressed
itself
and
its
middleware,
which
are
not
actually
dependencies
of
expressed,
so
I
didn't
bother
putting
them
up
there
and
then
pillar
JSS
basically,
would
be
the
next
level
down.
So
we
have
the
module
called
router,
which
is,
which
is
the
Express
router.
A
We
have
the
send
module,
which
is
another
popular
one,
for
people
to
direct
require
that
has
all
of
our
logic
for
reading
files
off
the
file
system
and
then
sending
them
out
and
bundling
that
up.
That
has
things
like
cache
checking
for
304,
not
modified
responses
and
cleaning
up
making
sure
the
file
descriptors
are
cleaned
up,
doing
some
things
like
sending
partial
responses
for
arranged
requests
and
a
couple
other
neat
things
and
another
examples,
final
Handler.
So
that's
basically
the
final
handler.
A
So
all
the
different
things
and
express
the
different
functions
you
put
are
the
handlers,
and
so
this
is
the
final
one.
This
one
will
if
it
gets
to
it,
it'll.
Just
send
a
404
basically
and
if
an
error
is
handed
to
it'll
serialize,
that
error
out
and
write
it
out
and
Express
uses
that
as
well.
That's
how
it
does
those
defaults
for
a
four
page
or
the
default
error
page,
if
you
don't
put
anything
yourself
and
then
underneath
that
would
be
the
J's
HTTP.
A
So,
for
example,
like
the
send
module
we'll
use
a
couple,
other
modules
like
the
e-tag
module.
So
that's
how
it
will
just
hand
some
information
over
and
it
will
just
calculate
a
simplistic
etag
it'll
send
data
from
the
request
and
what
it's
about
to
send
out
to
the
response
together
to
this
module
called
fresh
and
then
that
module
will
say.
Yes,
you
need
to
send
the
whole
thing
back
as
a
200
or
no,
you
can
send
back
a
304,
not
modified.
It.
Just
has
that
little
logic
bundled
up
and
then
it
had
you
know.
A
Another
example
is
the
range
parser
module,
so
you
no
need
to
parse
the
ranges
for
those
conditional
requests
or
those
yeah
and
then
final
handler,
for
example,
will
use
on
finished,
which
send
uses
as
well
to
do
things
like
clean
up
things
on
the
request.
So
that's
one
of
those
ones
where
you
get
to
add
a
bunch
of
event,
handlers
to
go,
get
the
same
functionality,
and
so
we
just
wrap
it
all
up
for
you.
A
So
that
way
you
can
basically,
for
example,
send
will
use
that
to
make
sure
that
no
matter
what
happens,
no
matter
when
the
event
listener
was
added.
So
if
you
somehow
for
some
how
you
invoke
send
after
the
request
is
already
done,
we
still
realize
all
that
request
was
done.
We
need
to
actually
go
and
like
close,
that
file
descriptor
for
you,
so
it
doesn't
just
hang
open,
which
used
to
be
a
problem,
for
example,
and
so
we
that's
why
we
bundle
up
all
these
things.
A
So
we
get
a
lot
of
questions
about
what
Xpress
5
is
so
Express.
5
is
very
much
really.
You
can
think
of
it
as
a
marketing
version.
That's
what
people
a
lot
of
people
like
to
know
major
versions,
so
we
try
to
kind
of
like
bundle.
A
bunch
of
things
together
into
the
major
I
mean
they're,
typically,
all
breaking
anyways,
but
rather
than
each
breaking
one
incrementally
coming
out,
especially
because
there's
so
many
books
and
all
kinds
of
things
on
there.
You
know
a
lot
of
people
use
it
for
a
lot.
A
A
lot
of
applications
like
myself
like
you,
know,
I'll
use
it
for
all
kinds
of
applications,
and
you
know
a
new
major
comes
out
and
every
time
you
turn
around
it
and
get
difficult
to
keep
track
of
everything.
So
Xpress
5
is
of
course
coming
I
mean
people
always
ask
for
it,
but
you
know
we're
making
sure
that
it
is
not
only
ready
but
actually
has
a
good
enough
significant
feature
set.
That
makes
it
somehow
distinctly
different
to
actually
really
say:
there's
a
difference
between
them.
A
Instead
of
like
there's
these
random
things
here
and
there
that
are
not
compatible
versus
you
know
not
so,
for
example,
native
promised
support
and
routing
is
the
biggest
one,
so
that
will
actually
bring
if
we
get
that
done.
That
will
actually
bring
Xpress
into
the
new
es,
I
think
2017
stuff
that
has
the
async
functions,
so
async
functions
just
return
a
promise.
So
essentially
that
would
actually
add
native
async
functions
directly
into
Express.
A
The
solids
middleware
and
handler
could
be
those
native
async
functions
and
it
would
just
automatically
work,
and
so
we
actually
have
a
few
different
PRS
and
discussions
going
on
about
exactly
how
we're
going
to
implement
that
in
a
way
that
won't
be
completely
destructive
to
the
entire
ecosystem
to
get
that
out
there.
But
have
it
really
awesome,
but
you
know
we
want
everything
to
just
kind
of
work
as
well
working
on
improved
template,
rendering
system.
So
we
have
right
now,
foodways
use
it.
A
This
template
rendering
system,
it's
actually
fairly
basic,
there's
a
lot
of
issues
with
it.
For
example,
we
actually
synchronously
will
read
the
file
of
the
disk
for
the
first
time
in
production
mode
will
cache
the
content,
so
we
don't
actually
read
it
over
and
over
again,
but
still
that
needs
to
be
reworked.
A
Improved
query
string
handling
we're
working
on
so
right.
Now
it's
it's!
We
parse
query
string
is
kind
of
lacking.
You
can't
really
say
you
can't
it
always
parses,
even
if
you
don't
need
to
use
it
a
lot
of
that.
Actually,
that's
pretty
much
mostly
done
right
now.
Improve
cookie
handling,
so
Express
will
actually
allow
you
to
set
cookies.
But
you
can't
read
it.
You
can't
even
read
cookies
by
default
from
Express,
which
is
kind
of
nonsense,
which
is
hard,
especially
when
you
need
to
read
the
same
format
that
expressed.
A
A
We've
been
trying
to
do
to
get
more
contributors
like
we've,
been
working
a
lot
with
project
documentation
like
we
have
a
lot
of
goals
that
the
Express
project
is
but
they're,
just
like
in
the
people
who
run
their
projects
as
minds
right
we're
trying
to
get
them
like
written
down
on
our
website,
for
example,
contributing
guides.
So
we
have
some
basic
ones
from
the
foundation,
but
we're
trying
to
get
them
a
lot
more
beefed
up
to
be
much
more
specific
to
express
itself.
A
The
organizational
structure
I
was
just
sharing
with
you
earlier,
so
we're
working
on
like
a
way
to
actually
have
that
on
our
website.
We
just
started
putting
in
a
lot
of
those
supplementary
modules.
The
readme
is
directly
on
our
website
that
was
fairly
recent,
so
wispy
coming
we're
trying
to
make
it
look,
much
more
unified,
better
location
of
resources,
which
we've
mostly
done
now.
We
even
have
our
YouTube
channel,
which
is
art
by
or
every
off
every
other
week.
A
Meetings
is
up
a
link
on
there
and
we're
going
on
some
level
up
guides
for
specifically
how
you
become
a
committer
and
become
a
TC
member.
Those
are
in
our
governance,
but
it's
very
wishy-washy,
so
we're
trying
to
see
if
we
can
come
up
with
way
more
specific
ways
that
yet
you
can
do
that
so
yeah
thanks.
Everyone
I
hope
you
really
enjoyed
hearing
a
lot
about
Express
in
its
new
governance.