►
Description
Join Daniel, Chris, and Ben as they talk about the Atom editor's history & future as it reaches 1.0.
About CodeConf
CodeConf improves the software community by providing a forum for thought-provoking talks and forging social connections. The third installment of the CodeConf series took place in Nashville in 2015. Attendees came together to discuss open source, best practices, documentation, and community.
For more information on this year's CodeConf, go to:
https://codeconf.com/
A
Hopefully,
most
of
you
in
the
audience
are
already
using
atom.
It's
a
text
editor
based
on
web
technologies
that
we've
been
working
on
for
a
while.
Our
goal
is
to
make
something:
that's
modern,
customizable
and
hackable
to
the
core,
but
still
approachable
by
people
that
want
to
be
productive
without
customizing
theme.
It's
based
on
our
electron
app
framework,
which
is
basically
the
guts
of
Google's
Chrome
browser
integrated
with
the
node.js
runtime.
There's
a
lot
of
power
and
flexibility
in
that
combination.
I.
A
So
the
web
platform
is
the
most
widely
used
and
well
documented
means
to
create
software
that
exists
today
and
probably
has
ever
existed.
So
it
made
a
lot
of
sense
to
us
that
our
ideal
editor
of
tomorrow
will
be
built
with
these
tools.
The
web
has
progressed
a
long
way
from
its
origins
as
a
collection
of
documents,
and
only
documents
right
like
the
early
web
was
just
text
and
now
it's
an
app
platform
and
by
using
chromium
we
get
to
take
advantage
of
Google's
great
adoption
and
support
of
the
latest
additions
to
the
web
platform.
A
You'll
hear
Elliott
spray
and
talk
about
web
components
later
this
morning,
web
components,
if
you're
not
familiar
with
them.
It
should
be
really
interesting,
they're.
A
great
example
of
how
Adam
can
take
advantage
of
the
web
of
tomorrow
to
build
our
editor
of
tomorrow.
So
the
first
early
beta
version
of
Adam
came
out
last
year,
we've
learned
a
lot
about
what
people
want
from
the
editor
as
well.
As
you
know
how
people
want
to
customize
their
tools
with
special
use
cases.
They
have.
A
It
out-
and
we
really
look
forward
to
learning
more
about
that,
and
fortunately,
Adam
is
now
I
work
I'm
up
here,
I'm
representing
the
core
team
and
I
work
for
github,
and
we
work
for
github,
but
Adam
has
grown
so
far
beyond
the
walls
of
github
into
an
open
source
project
with
an
active
Barun
community
and
the
core
team
doesn't
have
figured
out
all
on
their
own.
The
growth
of
this
community
is
really
inspiring.
I
want
to
share
with
you
guys,
some
numbers
that
we
have
about
the
growth
Adam.
A
You
know,
don't
have
any
secrets
in
this
room,
so
this
is
active
monthly
users
for
Adam
ending
last
month.
As
you
can
see,
it's
open
to
the
right
really
excited
about
that.
That's
a
lot
of
people
that
are
depending
on
the
editor
for
their
day-to-day
tasks,
whether
it's
writing
markdown
or
writing
software,
and
so-
and
these
are,
of
course,
just
people
that
that
have
metrics
turned
on.
A
But
anyway,
as
you
can
see
in
a
short
time,
the
added
communities
racked
up
an
impressive
number
of
customizations
visual
changes,
themes.
A
lot
of
the
people
that
written
some
of
these
packages
are
in
the
room.
Today,
too
radical
extensions
to
change
a
lot
about
how
the
editor
works.
An
example
of
the
latter
is
Facebook's
new
cloud
project,
which
is
a
collection
of
adam'
packages
that
transform
adam
into
a
new
IDE
entirely
and
you'll.
A
So,
as
you
can
see,
I've
got
nearly
a
thousand
people
contributing
in
the
in
the
organization
on
github,
and
you
know
a
hundred
thousand
commits
in
the
make
up
the
package
index
and
that's
a
lot
of
people
coming
together
to
their
tools,
the
combined
brainpower
of
all
these
people
and,
hopefully
a
lot
more
people.
Hopefully
some
of
you
in
this
room
that
haven't
contributed
yet
will
help
us
really
make
Adam
shine
anyway.
Since
Adam
has
announced,
public
Adam
has
changed
a
lot,
it's
grown
and
improved
in
a
lot
of
ways,
but
what
about
before?
A
It
was
announced
to
the
public?
A
lot
of
you
may
not
know
that
you
know
Adam
existed
within
the
walls
of
github
before
February
of
2014,
when
Adam
was
announced,
the
core
in
the
packages
had
thousands
and
thousands
of
lines
of
CoffeeScript
and
C++.
So
where
did
those
lines
of
code
come
from
to
tell
you
a
little
bit
more
about
that
I'd
like
to
welcome
chris
wanstrath,
the
CEO
of
github
and
the
originator
of
the
Adam
project
stage?.
B
Thank
you,
the
Daniel,
hey
everybody!
What's
going
on
hello,
Nashville
so
who
likes
to
mess
with
our
editor?
Has
anyone
ever
yeah
a
couple
people
all
right,
all
right,
I
do
as
well,
so
I
am
chris
wanstrath
I,
better
known
as
defunct
with
a
K
and
if
you've
ever
interacted
with
me
online
I
apologize
for
ruining
your
ability
to
spell
that
word
properly
ever
again
in
your
life,
but
in
about
let's
say,
2007,
I
sort
of
had
this
idea
that
any
piece
of
software
that
I
didn't
like
I
was
going
to
reinvent.
B
Does
anyone
ever
gone
through
that
before
right,
yeah,
just
like
any
tool
that
didn't
feel
right?
I
am
I'm.
The
most
genius
person
in
the
planet,
I
can
write
lines
of
code
for
a
computer
I'm
just
gonna
like
a
redo.
It
make
it
better,
because
it's
not
like
that
there
are
people
way
smarter
than
me.
They've
been
working
for
decades
on
this
stuff
right.
B
The
problem
is
is
I,
know,
I,
said
like
I
wanted
to
reinvent
everything,
but
I
really
wanted
to
add
on
to
an
existing
editor.
I
wanted
to
find
like
a
solid
foundation
and
go
nuts
writing
plugins
and
extensions
anyone
a
tee
Pope
I
wanted
to
be
the
tee
Pope
of
some
editor
he's
that
he
does
tons
of
Vinh
extensions
and
integrations
and,
and
things
like
that,
he's
made
them
amazing
right.
So
I
started
learning
vim
script
and
I
was
like
man
I'm,
just
I'm,
not
T
Pope.
This
is
not
for
me,
a
film
script.
B
It's
just
impenetrable
and
it's
a
sandbox.
You
know
vim
is
written
in
C.
It's
like
five
files.
It's
it's
amazing
program.
If
you
ever
have
the
chance
look
at
it,
it's
very
well
done,
but
it's
it's
a
few
files,
it's
this
very
strong,
very
well-done
core
and
then
there's
an
extension
library.
Our
attention
language
called
vim
script,
that
the
core
allows
you
to
drive
the
editor,
and
that
means
that
you
only
get
as
much
power
as
the
people.
Writing
them.
B
Let
you
have
so
you
can't
do
something
like
say,
create
collaboration
because,
like
real-time
collaboration,
because
the
core
editor
only
supports
a
single
cursor
and
that's
not
a
knock
against
vim,
it
just
means
your
your
hands
are
tied
as
far
as
what
you
can
do,
an
extension.
If
you
wanted
to
create
collaboration,
you
could
probably
make
a
pull
request
of
them
itself,
but
I,
don't
know,
see
or
I
dunno
see,
but
I'm
not
allowed
to
write
it
because
I
would
create
security
vulnerabilities.
B
B
This
I
I
would
love
to
be
a
novelist
one
day,
but
my
immediate
concern
is
balancing
parentheses
and
Lisp
and
making
sure
that
when
I
open
a
curly
bracket
in
JavaScript
that
the
closing
curly
bracket
gets
placed
in
automatically
so
I
got
passed
a
couple
of
the
fantasy
chapters
and
got
into
the
guts
of
Emacs
and
I
just
sort
of
fell
in
love.
So
if
you've
ever
really
used,
Emacs
and
I-
don't
blame
you
for
that,
it's
old,
it's
a
it
started
out
in
the
80s.
B
In
fact,
it
was
ported
to
the
new
in
1985,
but
that's
not
to
say
it's
bad,
because
it's
old,
that's
to
say
it's
great,
because
it's
old
it
has
staying
power
like
how
many
pieces
of
software
that
were
written
in
the
80s
are
still
used
today,
probably
just
Emacs,
no
there's
very
few
right.
How
many
pieces
of
software
did
you
write
last
year
that
you
don't
even
use
anymore
right?
So
the
fact
that
Emacs
was
so
old
was
really
compelling.
There
was
something
there.
There
was
an
idea.
There
was
a
concept.
B
There
was
a
technical
innovation
that
was
really
amazing
and
the
deeper
I
dug
into
it.
What
I
started
discovering
was
that
Emacs
was
written
in
itself
or
tries
to
be
that's
the
goal
and
it's
not
100
percent
written
in
itself,
but
it's
very
close,
and
so
what
you
have
is
the
core
of
Emacs
is
a
C
program,
that's
essentially
a
lisp
interpreter
and
they
have
their
own
version
of
Lisp
emacs
lisp,
which
we
can
talk
about.
B
If
you
want
it's
not
a
real
list,
but
they
basically
have
this
core
Emacs
Lisp
interpreter,
and
then
they
write
as
much
of
the
editor
as
they
can
in
Emacs
Lisp.
And,
aside
from
that,
being
just
like
a
fun
thing
to
think
about
what
that
means
is,
if
you're
curious
about
how
two
cursors
work
in
Emacs
or
how
does
the
indentation
system
work
in
Emacs
or
I
want
to
write
a
gist
library?
How
does
the
networking
work
in
Emacs?
Well,
you
can
go
to
the
documentation.
B
You
can
read
the
book
that
tells
you
how
to
write
sci-fi
novels
in
Emacs
or
you
can
just
go
to
the
source
and
me
I,
really
like
going
to
the
source
I
like
looking
at
how
the
code
is
written,
I
likes
getting
into
the
mind
of
another
developer
and
I
like
skipping
the
middleman
in
many
ways
like
there's,
there's
one
there's
a
lot
to
be
said
for
reading
someone's
perspective
on
the
source.
There's
another
thing
to
be
said
for
just
reading
it
directly.
B
So
Emacs
is
great
because
not
only
do
you
read
the
source,
the
source,
browsing
and
debugging
and
discovery
and
exploration
are
built
into
the
editor
itself.
So
you're,
not
just
in
Emacs
and
you're,
going
to
I
was
going
to
say
github,
but
I
think
it's
something
else:
CVS
you're,
not
just
in
Emacs
and
you're,
jumping
to
CVS
or
github
or
whatever,
to
look
at
the
source.
It's
right
there
you're
hovering
over
a
function
or
a
macro,
and
you
hit
a
key
command
and
you
go
right
to
the
source.
B
There's
documentation,
that's
generated
by
the
comments
that
are
left
in
each
list
function.
So
you
really
feel
like
I
am
in
this
system
I'm
deep
in
this
system,
if
you
know
give
it
a
5
more
years
than
I,
can
imagine
plugging
in
like
oculus
VR
and
just
being
like
all
the
way
in
there
like
it's
the
matrix.
You
really
felt
like
you
are
part
of
this
thing
and
while
you're,
adding
plugins
or
while
you're
writing
extensions,
you
don't
feel
like
you're
in
a
sandbox.
B
You
don't
feel
like
you're
you're
in
this
like
separate
world,
you
feel
like
you're
part
of
the
core
editor,
and
so
that
was
really
really
amazing
and
I
deeply
fell
in
love
with
Emacs.
It
has
a
lot
of
faults
but
I
it
to
build
github
essentially
and
write
a
lot
of
code
for
the
next
five
or
so
years.
I
love
the
editor,
and
it
gave
me
a
lot
of
really
great
inspiration.
B
So
what
I'm
about
to
say
is
what's
controversial
and
insane
one
day,
I
said
to
someone
I,
think
JavaScript:
isn't
that
bad
okay,
and
so
in
2007?
That
was
an
insane
statement
and
everyone
would
to
you,
like
you
were
crazy,
but
it
but
there's
this
idea
that
even
then
JavaScript
was
everywhere
there
were.
It
was
the
most
widely
installed
programming
platform
in
the
world
right,
because
every
browser
has
a
JavaScript
interpreter,
even
though
they're
wildly
different,
and
then
thinking
on
that
on
that
that
line
of
thinking
the
JavaScript
Wars
started.
B
So
this
is
when
squirrelfish
came
out.
This
is
one
monkey
whatever
came
out.
This
is
when
Chrome
and
Safari
and
Firefox
started
competing
for
JavaScript
performance,
and
it
really
starts
I.
Think
with
the
era
of
Gmail
right,
like
Gmail
was
the
first
really
heavy
javascript
application
that
many
of
us
use
or
the
mainstream
use,
and
so
then
that
proved
the
JavaScript
was
slow
and
the
VMS
were
not
that
great
and
so
Google
put
their
double
down
and
said.
B
So
you
can
make
something
blink
or
move
or
like
make
an
ad
pop-up
you're,
trying
to
read
a
news
article.
This
is
something
that
you
can
build
real
applications
in
and
even
though
that
wasn't
really
true
in
2007
2008,
it
was
still
really
hard
to
build
JavaScript
applications.
They
were
still
really
slow.
B
B
One
of
the
first
things
you
learn
is
how
to
open
a
file
and
JavaScript
is
literally
impossible,
because
it's
in
a
browser
right,
so
it's
not
a
real
programming
language
and
so
again
it's
like
list
without
recursion,
something
is
missing.
However,
there
were
some
experiments.
There
were
some
people
trying
to
take
Mozilla's
javascript
engine
and
put
it
on
the
command
line,
John
John
Barnett,
and
then
there
were
other
experiments
as
well,
which
leads
us
to
the
idea
that
maybe
you
could
actually
build
real
applications
in
JavaScript
people
are
learning,
it.
Kids
are
learning
it.
B
B
Coco
handles
that,
for
you,
a
dotnet
handles
that
for
you,
those
concerns
are
have
long
gone
now,
you're
focusing
on
the
application,
but
Emacs
still
had
a
lot
of
these
concerns
baked
into
it
so
say:
2007
2008,
let's
say
2020.
How
would
you
build
an
editor
and
one
of
the
nice
things
about
Lisp
in
the
80s
was
a
it
was
dynamic.
You'd
have
to
worry
about
typing
and
compiling
all
these
things,
but
be
a
lot
of
people
knew
it.
A
lot
of
people
in
the
80s
were
learning
lists,
as
they
were.
B
Learning
how
to
program
they
would
learn
C,
they
learned
lisp
alongside
of
it,
so
it
was
extremely
popular
and
it
was
sort
of
like
a
like
a
like
a
baseline
for
a
lot
of
developers
that
has
changed.
Unfortunately,
if
you
don't
know,
lisp
I
highly
recommend
learning
reading
the
little
schemer.
It's
an
amazing
book
and
it'll
change
your
mind,
hopefully
for
the
better,
but
in
2007
2008
I.
Think
the
answer
is:
what
is
a
programming?
B
Language
is
sort
of
like
the
foundation,
the
baseline
and
the
answer
was
quickly
becoming
JavaScript,
so
Emacs
list
in
2008
or,
let's
say
2020.
What
would
that
look
like?
It
would
look
like
a
something
written
in
JavaScript
be
as
much
of
it
possible
written
in
JavaScript
C?
Why
would
you
want
to
learn
cocoa,
or.net
windowing
system
when
you
already
know
HTML
in
CSS
and
D?
Let's
assume
that
there's
a
network,
because
one
of
the
things
that
you
didn't
have
in
the
80s
was
let's
say
the
Internet
as
we
have
it
today.
B
Right
I
mean
it
exists,
but
not
the
same
way
that
looks
today
when
in
2007
2008,
when
Adam
was
just
being
started.
There
was
1.5
billion
people
on
the
Internet
today,
there's
three.
So
in
seven
years
the
Internet
has
doubled
from
1.5
billion
people
to
3.
So
like,
let's
just
assume
that
there's
a
network
right,
we
all
have
a
network
connections
in
our
pocket.
What
does
that
actually
do
to
your
editor?
B
When
every
time
you
open
it,
you
can
reasonably
assume
that
you're
connected
to
everyone
and
Emacs
it's
sort
of
tacked
on
vim,
it's
tacked
on
what,
if
we
built
that
right
in
from
the
start,
so
we
started
playing
with
building
a
Mac,
OS
10
application,
and
you
can
see
it
here.
This
screenshot
was
actually
taken
a
couple
weeks
ago.
If
we
still
have
it
we're
going
to
make
it
available
for
you
to
download,
but
we
started
playing
with
this
thing.
B
We
called
atomicity
and
we
called
it
that
because
I
don't
know
it
was
a
new
word.
It
was
interesting
and
then
internally
we
had
like
a
neutron
library
and
a
proton
library
which
you've
all
probably
gone
through
and
it's
a
horrible
idea.
I
was
confusing,
but
the
idea
was,
let's
write,
a
Mac
application
and
let's
expose
as
much
of
the
native
technologies
as
we
can
to
JavaScript
through
api's
and
let's
build
the
application
in
JavaScript
and
so
in
2007
2008.
B
This
was
possible
because
the
Mac
stuff
KOCO
had
a
bridge
through
WebKit
through
their
JavaScript
core
infinitive
technologies,
where
you
could
surface
Objective,
C
functions
as
JavaScript
functions
and
call
them,
and
so
we
actually
got
a
lot
done.
We
got
we.
This
is
basically
a
web
page
that
can
open
files
could
save
files
can
close
files.
The
syntax
highlighter
was
an
open
source
project.
We
got
off-the-shelf.
The
indenting
was
an
open
source
project
that
we
got
off
the
shelf.
You
can
open
it.
You
can
see
the
different
options
there.
B
It
recognized
files,
but
the
problem
was
there
were
a
lot
of
bugs
the
the
JavaScript
bridge
between
cocoa
and
JavaScript
itself
was
very
buggy.
We
had
this
idea
of
well.
How
are
we
gonna
do
like
a
sidebar?
Let's
use
frames,
we
can
use
HTML
for
everything,
but
you
didn't
have
the
same
context
available
in
each
frame.
B
You
couldn't
really
drive
that
from
JavaScript,
so
it
was
really
frustrating
because
the
whole
point
of
this
was
I,
don't
know
made
of
stuff
I
stuck
at
it
like
I've,
read,
books
and
I
can
make
this
work
right,
but
I'm,
not
a
native
developer,
I'm,
a
web
developer
and
I'm
running
into
all
of
these
barriers
that
are
preventing
me
from
writing.
The
application
in
JavaScript
so
now
I'm
becoming
this
objective-c,
not
expert
I
want
to
say,
but
student
and
like
this
is.
This
is
not
the
point.
The
point
is
to
ignore
objective-c.
B
The
point
is
to
ignore
c-sharp.
The
point
is:
focus
on
JavaScript.
Also
I
had
this
thing
going
at
the
time
which
is
called
github
comm,
which
we
were
bootstrapping
and
it
was
still
in
the
first
year,
and
so
this
became
more
and
more
of
a.
It
seemed
like
a
big
undertaking,
so
we
thought
this
is
going
to
be
inevitable.
There's
going
to
be
an
editor,
that's
going
to
be
written
in
JavaScript,
it's
going
to
be
network
aware
it's
gonna!
B
Let
you
log
in
to
the
editor
and
not
in
a
creepy
Cora
way
where
you
have
to
log.
In
to
use
it,
but
an
awesome
like
social
way
of
you
can
log
in
you
can
have
connections
to
people.
You
can
share
code
like
there's
a
lot
of
awesome
stuff.
You
get
from
a
web
browser.
What,
if
you
got
that
from
a
native
piece
of
technology
as
well,
specifically
one
that
you're
using
eight
to
twelve
to
twenty
nine
hours
a
day
to
write
code
right?
B
So
we
said:
okay,
we're
going
to
table,
add
Amissah
t,
even
though
the
name
is
great
and
the
electron
proton
thing
really
really
makes
sense
to
people
and
we're
going
to
focus
on
get
up
and
someone
else
is
going
to
do
this.
For
us,
someone
else
is
going
to
eventually
write
a
JavaScript,
editor
and
so
the
somewhere
here
today's,
but
that
didn't
happen.
So
we
worked
on
github,
we
focused
on
github,
and
you
know
they
were
there.
There
are
some
that
have
come
out
brackets
is
awesome
from
Adobe.
B
There
are
some
in
this
direction,
but
really
the
way
the
world
went
was
trying
to
build
text
editors
in
a
web
browser
I,
don't
know
how
many
of
you
do
your
full-time
coding
in
a
web
browser
but
I'm.
Guessing
it's
not
a
lot
right.
Okay,
yeah!
It
doesn't
make
any
sense
like
what
you
want
are
the
web
technologies.
What
you
want
is
JavaScript.
What
you
don't
want
is
to
hit
command-d
and
accidentally
bookmark.
The
tab
you're
in
you
want
all
of
your
keyboard
shortcuts
dedicated
to
the
craft
of
programming,
not
to
managing
a
browser.
B
You
also
don't
want
to
like
leave
your
MySpace
tab
open
and
have
it
eat
up
your
RAM
and
then
crash
your
editing
session.
It
doesn't
make
any
sense
right,
there's
a
reason
that
we
have
different
applications
of
different
contexts.
So
what
we
wanted
was
web
technologies
running
in
a
native,
isolated
environment,
and
it
just
wasn't
happening,
however,
because
people
were
working
on
building
text
editors
into
the
web
browser
for
some
reason,
I
mean
I'm
being
pretty
harsh
here,
but
I've
tried
it
I
wanted
to
believe
it
just
doesn't
work.
B
There
were
a
lot
of
really
great
editing
technologies
built
in
javascript
in
in
HTML
in
CSS,
and
one
of
them
is
called
ace.
The
people
at
cloud
9
did
a
phenomenal
job
with
this
editing
technology
called
ace.
Another
one
was
called
code,
mirror
and
they're
really
good
they're
faster
performant.
They
they
feel
like
a
real
web.
They
feel
like
a
real
editing
technology.
B
You
know
it'll
indent,
for
you
appropriately
and
things
like
that
as
well,
and
so
one
night
in
2011
I
was
well.
That's
not
true.
Actually,
I
gave
a
presentation
to
the
company
about
internally
to
github
about
the
new
ACE
technology
that
we
were
using
and
what
I
showed
off
was
collaboration
which
we
had
built
into
github,
but
never
ship
and
I
was
showing
like
what,
if
you
could
collaboratively
edit
files
on
github
with
someone
else
which
I
doesn't
really
make
a
lot
of
sense.
B
Yet,
but
we'll
see
where
this
is
going
and
I
got
a
text
at
night
from
someone
who
worked
at
github
named
Corey
Johnson
and
he
had
worked
on
the
original
atomicity.
There
was
a
small
music
group
of
mailing
lists
and
he
said:
oh
you've
got
to
the
end
of
your
presentation
and
it
was
collaboration
built-in
to
github.com.
I
thought
you
were
going
to
show
off
a
new
version
of
atomicity
and
I
was
like
wow.
That's
really
fascinating.
I
haven't
thought
about
that
in
a
while
I've
been
waiting
for
someone
else
to
do
it.
B
Maybe
we
should
we
should
give
that
a
shot.
I
was
like
why.
But,
but
let
me
would
that
be
any
good.
Is
that
something
that
people
would
want?
He
was
like
yeah,
no
everything,
sucks,
I'm
tempted
to
reinvent
everything
every
day
and
I.
Just
I
really
want
to
use
an
awesome
editor
that
feels
right.
So
we
started
working
at
night
and
we
in
very
little
time
created
an
OS
ten
application.
That
was
basically
a
web
view
with
ace
inside
of
it
and
like
that's
it
like.
B
That's
all
you
need,
like
all
the
heavy
lifting
was
done
for
us
by
this
point.
Javascript
we
got
in
super
fast.
The
bridge
has
gotten
super
sophisticated.
Some
a
group
of
open-source
developers
had
created
this
amazing
editor
in
web
technologies.
All
I
had
to
do
was
my
dream,
which
is
glue
a
bunch
of
stuff
together
and
take
all
the
credit
right.
So
what
happened?
Was
we
realized?
This
could
be
a
real
thing.
B
You
could
actually
build
an
editor
in
web
technologies
that
ran
natively,
that
you
could
open
and
save
and
just
work
like
Emax
work
like
vim,
except
it
wouldn't
just
be.
Oh
well,
Lisp
is
gone
now,
there's
JavaScript,
you
would
have
the
network,
you
would
have
Ajax
available
to
you
and
you
wouldn't
have
the
single
domain
restriction.
You
could
make.
B
B
So
we
worked
on
atomicity
for
a
while
and
the
way
that
it
became
Adam
was
really
like
man
when
you
launch
textmate
from
the
command
line.
You
just
write
mate
and
that's
like
cool.
So
what
are
we
gonna
write
on
the
command
line?
Well,
let's
just
write
Adam
we're
like
well.
Why
do
we
have
all
these
other
letters?
Let's
just
get
rid
of
them?
Adams
cool
we're
gonna
call
it
that
there
is
an
XML
thing
called
atom,
but
no
one
remembers
that
either.
B
So
we
thought
okay,
we're
going
to
rename
this
atom
we're
going
to
start
working
on
it
Cory
and
I
nights
and
weekends,
and
we
think
this
is
not
just
like
a
crazy
idea
anymore.
We
think
this
could
be
a
github
thing.
We
think
this
is
something
that
is
core
to
get
admission
of,
helping
people
build
great
software
and
its
core
to
the
ideas
of
community
great
tools
and
an
ecosystem
like
this
fits
in
directly
with
what
we're
trying
to
do
with
our
day
job.
B
Essentially,
so
we
created
a
demo
video
of
Adam
and
really
the
demo
was
mostly
style
over
substance.
But
what
we
wanted
to
do
was
show
what
was
possible.
We
showed
opening
gist
and
saving
it,
and
when
you
save
it,
it
saves
directly
to
just
API.
Instead
of
locally,
we
showed
being
able
to
change
fonts
and
colors
with
CSS,
and
then
we
showed
there's
this
asteroids
thing,
bookmarklet,
that
when
you
load
it
it
creates
a
little
spaceship
and
you
can,
you
can
fly
it
around.
B
You
can
shoot
and
destroy
elements
of
a
webpage
like
you
can
blow
up
the
CNN
logo
or
things
like
that,
so
the
finale
of
the
atom
demo
video
is
we
load
this
asteroid
game
into
your
editor
and
you're
shooting
lines
of
code
and
files,
and
it's
like.
Why
would
you
ever
do
this?
It's
so
confusing
and
what
is
happening
right
now,
but
that
was
the
point
is
that
you
can
do
anything.
B
You
want
right,
and
that
gives
you
a
lot
of
rope
and
you
are
perfectly
capable
of
making
bad
decisions,
but
that
also
means
you're
capable
of
making
good
decisions
too,
and
so,
while
the
querque
plugin
has
been
recreated
an
atom,
that's
not
the
core
of
it.
The
core
of
it
is
stuff
that
we're
talking
about
today.
It's
turn
its
linters.
It's
a
mini
map.
It's
this
amazing
community
that
has
been
building
packages
on
top
of
atom.
That's
way
broader
and
way
deeper
than
a
core
team
of
engineers
could
ever
do
at
their
day.
Jobs
right.
B
The
atom
community
is
really
what
makes
atom
amazing
and
it's
driven
by
some
really
really
great
people
that
work
for
github
and
that
don't
work
for
github
as
well.
So,
coincidentally,
I
was
at
the
1
million
user
party
for
github
in
October
of
2011.
We
were
celebrating
our
one
millionth
user.
The
other
day
we
last
week
we
actually
had
our
10
millionth
user,
so
things
have
changed
slightly
and
the
rumor
was
out
that,
like
there's
like
a
thing
coming
from
github,
that's
written
in
web
technologies
and
I'm
ran
into
someone
there.
B
I
was
introduced,
someone
there
named
Nathan,
Silva
and
Nathan
I
knew
from
way
back
in
the
day
he
had
expressed
to
me
at
one
point
wanting
to
write
an
editor
in
Ruby
for
a
lot
of
the
same
reasons.
I
wanted
to
write
an
editor
in
JavaScript
and
he
was
like
yo,
someone
told
me:
I
should
talk
to
you,
I,
don't
know
why.
B
So
we
went
and
got
coffee
and
we
started
hanging
out
and
I
was
like
what
ever
happened
to
your
editor
and
Nathan's,
trying
to
pitch
me
on
writing
editor
and
Ruby,
and
the
back
of
my
head.
This
is
all
happening,
but
I'm
like
trying
to
be
coy
about
it.
I
was
like
yeah
but
like
what
about
JavaScript
right
and
he's
like
nah
I'd,
never
work,
it'll,
never
work
great.
B
B
We
started
this
rnd
project
called
Adam,
Cory
and
Nathan
went
full-time
on
it,
and
that
was
basically
at
the
beginning
of
2012
and
really
that's
when
I
step
out
of
it
because,
like
I've
been
saying
I'm
like
I'm,
pretty
busy
with
this
github
thing
and
Adam
has
always
been
a
huge
huge
dream
of
mine
and
something
I
want
to
use
and
I
want
to
build.
But
I
don't
know
how
to
write
an
editor.
I,
don't
know
native
technologies,
I.
B
Don't
how
to
make
things
fast
like
what
I
specialize
in
is
not
building
Adam,
it's
using
Adam,
and
so
the
team
took
it
over.
They
eventually
made
an
open-source
and
I'm
so
so
excited
to
be
here
today
to
be
celebrating
the
1.0
release
of
Adam
cuz.
For
me,
this
has
been
like
a
seven
or
eight
year
dream
and
it
just
goes
to
show
you
like.
B
Sometimes
you
just
got
to
do
it
yourself,
like
other
people,
if
they're,
not
if
they're
not
there,
if
they're
not
doing
it
for
you,
it's
not
that
you
should
rely
on
other
people
to
do
things
for
you
it's.
If
that
they
don't
what
you
should
do.
Is
you
start
it,
and
then
you
bring
them
in
like
communities
build
great
software
communities
build
great
products,
and
the
adam
community
is
really
its
strongest
feature,
and
so
I
guess
I
just
want
to
end
with
saying.
B
Emacs
is
amazing
because
it's
been
around
since
the
80s
vim
is
amazing
because
it's
been
around
since
the
80s
as
well.
Adam
is
going
to
outlive.
All
of
us.
Adam
is
open.
Source
Adam
is
a
product
of
the
community.
Github
is
a
corporation
I
hope
it'll
be
around
for
hundreds
of
thousands
of
years,
but
I
have
no
doubt
in
my
mind
that
Adam
will
be
around
forever
like
open
source.
B
But
we
can't
even
dream
big
enough,
because
what
people
are
going
to
build
with
Adam
is
going
to
blow
all
of
us
away
and
not
not
I'm
talking
about
five
years
from
now
imagine
20
years
from
now.
This
thing
is
going
to
be
absolutely
amazing
and
absolutely
huge,
because
it's
open
source
and
because
it's
community
driven
and
that's
the
key
to
building
great
software.
So
thank
you
all
for
listening
me.
Ramble
I'm,
just
like
so
excited
to
be
here
today.
B
A
Adam,
we
were
a
small
team
and
we
could
polish
and
what
Chris
was
saying.
Emax
is
a
30
year.
Project
Adam
could
be
a
30
year
project.
We
were
sitting
in
a
room
trying
to
polish
it
and
make
it
perfect.
We
realized
that
we
could
do
it
forever
and
we
needed
a
release
date,
so
we
brought
it
under
the
umbrella
of
R&D
at
github,
and
we
said:
okay,
it's
coming
out
on
this
day,
February
26,
which
was
my
32nd
birthday,
coincidentally
I,
think
we
weren't
sure
how
the
world
was
going
to
respond.
A
We
were
thinking,
maybe
we're
going
to
be
overwhelmed
with
feedback
there's
only
four
or
five
of
us
remember
this
invite
base
release.
It
got
a
lot
of
attention
and
it
was
super
overwhelming,
but,
like
Chris
was
saying
that
open-source
community
really
adopted
it,
it
was
really
inspiring.
We
opened
the
beta
test
and
open
source
to
all
of
Adam.
A
But
our
technical
philosophy,
now
Chris
kind
of
talked
about
sort
of
the
overarching
philosophy
and
concepts
behind
of
what
Adam
is
at
a
very
high
level,
but
sort
of
the
technical
philosophy
of
how
we
decided
to
build
Adam
sort
of
in
the
modern,
mature,
post,
atomicity
era,
combined
with
the
community's
organic
approach
to
collaboration,
has
helped
us
move
in
the
right
direction.
Right.
So
I
don't
want
to
ramble
on
too
much
about
that.
C
All
right:
hey
everybody,
okay,
so
what
is
the
perfect
editor?
So
our
goal
with
Adam
is
not
to
hand
you
the
perfect
editor,
because,
because
that's
impossible,
so
the
perfect
editor
is
a
really
personal
thing.
It
depends
heavily
on
context
like
like,
let's,
let's
say,
I
write
code,
I,
write,
front-end
code
for
websites
and
you
write
systems
code
and
go
our
needs
are
totally
different.
So
like
we
on
the
core
team
and
or
really
anyone
at
writing
an
editor.
We
can't
know
all
of
the
intricacies
and
all
the
nuance
of
of
what
what
everyone
needs.
C
For
example,
like
I,
don't
write
any
go
code,
so
so
I,
don't
know
what
tools
go.
Authors
need
so
like.
How
do
we
make?
How
do
we
make
an
editor
that
works
for
everyone
so
like,
like
Chris
touched
on
its
with
community?
So
we
want
it.
We
want
to
build
a
community
that
enables
the
people
who
want
better
tools
and
who
are
who
have
the
domain-specific
knowledge
to
write
those
tools,
just
like
like
I,
don't
know
go,
but
somebody
in
this
room
does
Joe
Fitzgerald's.
C
You
wrote
the
go
p--
the
go
across
package,
so
the
bigger
goal
of
adam
isn't
just
to
build
a
product.
It's
to
build
a
community
with
adam
just
at
the
center.
So
there's
a
ton
of
smart
motivated
people
who
write
code
and
who
want
tools
for
writing
code
who
want
better
tools
for
writing
code.
So
we
want
to
do.
Is
you
just
want
to
all
those
people
pointed
in
the
same
direction
and
helped
them
work
together
to
solve
these
problems
for
themselves?
C
C
So
it's
a
foundation
that
ever
you
want
to
grease
on
just
like
we're
all
going
to
speak
English
to
each
other
today
or
we're
all
going
to
spend
dollars
like
the
local
cafes.
But
the
problem
is
like
getting.
People
to
agree
is
super
hard.
It's
really
expensive,
it's
really
hard.
So
here's
an
example
from
from
nodejs.
This
is
a
poor
request.
This
changes,
URL
dot,
parse,
stop
protocol
to
return
HTT
to
HTTP
instead
of
HTTP
colon.
C
So
it's
removing
the
colon,
it's
a
two
character
changes
and
it
has
124
comments
that
span
four
months
so,
like
all
these
people
spent
tons
of
time
and
energy
fighting
for
their
opinion,
there
was
like
anger,
there's
frustration.
There
was
a
picture
of
a
bike
shed
in
there,
but
it
ultimately
it
didn't
get
merged.
So
this
is
the
node
maintainer
x'
fault.
It's
just
that
making
something
that
intersects,
like
everyone's
opinions,
is
really
really
difficult.
C
So
this
node
example
might
seem
extreme,
but
I'm
sure
everyone
in
this
room
has
felt
has
felt
this
at
some
point
where
you
want
to
get
something
in,
but
it
takes
a
week
of
emails
and
back
and
forth
even
just
to
get
started
so
like
with
Adam.
We
want
to
avoid
this
expense
as
much
as
we
can
so
like
as
a
developer
community.
What
are
the
things
that
we
can
agree
on?
Like
Chris
touched
on
like
what's
what's
the
most
popular
developer
platform
in
the
world?
It's
the
web.
C
It
has
all
of
these
companies
like
getting
behind
javascript
in
and
web
web
technologies.
So
it's
the
web,
and
so
I
bet
everyone
in
this
room
knows
HTML
and
CSS
and
JavaScript
or
and
if
they
end
you
don't
like,
there's
lots
of
materials
out
there
to
learn
it
so
by
anchoring
to
the
web
platform,
we
also
get
longevity,
so
web
browsers,
they're,
probably
not
going
away.
They
have
just
tons
of
companies
that
are
getting
behind
them
and
browser
vendors
are
really
careful
to
to
add
things
that
are
only
like
useful
in
the
long
term.
C
It's
a
sense
we're
using
web
platform
you're
using
javascript
like
let's
use
node,
it's
use
no
js'.
Once
we
use
node
all
of
a
sudden,
we
get
all
of
these
packages
to
get
thousands
of
packages
that
are
already
written.
We
can
just
use
them.
So
that's
consensus.
We're
using
all
these
technologies
that
the
developer
community
has
already
chosen
and
that's
really
powerful.
We
can
just
build
on
top
of
that.
So
here's
some
examples.
This
is
Adam
turn
J
s.
What
this
does
is
it
it.
C
It
gives
you
autocomplete
suggestions
in
JavaScript,
and
this
isn't
just
like
pulling
words
out
of
the
buffer.
It's
actually
figuring
out
like
what
are
the
functions,
what
are
the
variables
and
like
what
are
those
functions
return
one
of
the
parameter
types
of
stuff,
and
so
the
core
of
this
is:
is
this
node
module
called
turn
Jas
and
TAS?
Does
all
the
heavy
lifting
and
so
because
we
use
node?
All
we
have
to
do
is
wrap
this
in
an
atom
package
and
we
kind
of
we
kind
of
get
it
for
free.
Is
that
that's
awesome?
C
So
the
next
one
is
reg,
X,
railroad
diagram,
this
thing,
parses
your
regular
expressions
and
and
and
it
displays
them
in
graphical
form,
so
again
we're
using
a
node
module,
called
railroad,
diagrams
and
all
available
diagrams
does.
Is
it
pulls
in
your
your
regular
expression
and
outputs,
an
SVG
diagram
because
we're
using
the
web
platform
and
node
we
can?
C
We
can
display
the
output
of
that
node
module
and
so
the
most
important
example
is
Katie,
detect
kitty
detects
detects
cat
faces
in
cat
and
cat
pictures,
so
you
could
even
hook
up
the
Web
Audio
API
and
and
write
a
write,
a
theremin
for
your
cat.
You
can
play
music,
so
I
mean
important
stuff,
but
it's
super
easy
to
do
an
atom,
because
there's
a
node
module
called
kitty
door
and
Kitty
door
does
the
heavy
lifting
of
actually
detecting
the
cat
faces.
C
C
So
that's
one
part
of
the
foundation
is
the
tech
stack.
We
get
a
lot
of
power
and
familiarity
by
by
like
by
using
the
technologies
everyone
has
agreed
on.
So
the
next
part
of
the
community
foundation
is,
is
the
thing
that
we
build
on
top
of
of
this
tech
stack
it's
adam
core.
So
it's
not
the
core
like
the
default
distribution
like
the
the
tabs
in
the
tree
view,
but
it's
it's
like
the
api
and
the
package
system,
so
remember
that
consensus
is
difficult
and
it's
expensive
so
with
Adam
4
we
want
to
like.
C
We
want
to
limit
that.
We
want
to
limit
the
surface
area
as
much
as
we
can
so
that
so
there's
just
less
that
we
have
to
agree
on.
So
we
just
focus
on
the
primitives
and
we
focus
on
the
general
case
in
Adam
core.
Now
we
build
consensus
and
Adam
for
by
by
keeping
it
open
source
and
letting
it
be
shaped
by
thousands
of
contributors
or
hundreds
of
computers.
C
I'm,
sorry,
and
so
these
contributors
have
ranged
from
people
making
their
first
pull
request
ever
to
like
professional
developers
like
the
Facebook
team,
the
nucleoid
team
and
Facebook.
So
like
that's,
the
Community
Foundation,
it's
Adam
core
or
its
web
platform
on
the
bottom
and
Adam
core
on
top.
This
is
the
thing
that
the
community
can
sort
of
can
rally
around.
C
But
beyond
that
everything
else
is
packages
so,
like
nearly
everything
that
you
interact
with
is
a
package
like
everything.
In
there
it's
all
green,
the
only
thing
that
you're
not
interact
or
that
that's
not
a
package
in
this
is
the
the
editor
component
itself
and
the
pane
in
the
panel
system,
but
everything
else
finer
place
and
tabs
in
the
mini-map
and
everything
is
a
package.
C
So
when
everything
is
packaged,
this
is
where
it
gets
interesting,
because
packages
allow
for
divergence
and
divergence
is
important,
because
then
we
don't
need
to
agree
on
every
little
detail.
You
don't
need
to
go
into
core
and
ask
for
something
you
can
just
you
can
just
hack
it
together
and
you
can
throw
it
up
on
the
package
store
for
anyone
to
use
who
wants
to
use
it.
So
this
is
super
valuable.
Like
daniel
pointed
out,
there's
over
2000
packages.
C
There's
like
can't
live
without
packages
like
linter
is
the
minimap
there's
even
abandoned
packages
like
adam
term,
which
is
a
terminal.
Then
there's
like
packages
that
replace
the
abandoned
packages
like
adam
term,
there's
three
Python
autocomplete
providers,
there's
five
get
clients,
then
there's
like
Facebook
and
particle
io,
who
are
building
your
IDs
on
top
of
atom.
C
So
this
divergence
and
competition
is
really
is
really
great
packages.
They
can,
they
can
like
share
ideas
and
they
can
break
apart
and
they
can
recombine
and
they
can
compete.
And
so
it's
like
it's
like
a
true
ecosystem
where,
like
specialized
niches,
can
form
and
the
strongest
and
most
interesting
things
they
sort
of
sort
of
rise
to
the
top.
So
one
example
is,
is
autocomplete
or
autocomplete
plus.
C
So
this
was
the
original
autocomplete
we
that
we
bundled
in
the
first
version
of
atom,
but
no
one
knew
it
was
there,
because
you
had
to
hit
control
space
to
make
it
show
up,
and
so
we
got
tons
of
issues
that
were
like
you
guys
should
make
autocomplete
we're
like
we
have,
it
turns
out.
You
just
had
to
hit
control
space,
and
so
right
after
we
launched
somebody,
forked
autocomplete
and
they
created
autocomplete
+
autocomplete
+
had
like
better.
C
It
had
better
suggestions,
it
showed,
while
typing,
which
is
huge
for
users,
and
it
was
extensible,
so
users
immediately
downloaded
because
they
didn't
know
that
we
had
autocomplete
and
then
developers
got
behind
it.
Cuz,
it's
extensible,
so
they
started
writing
these
providers
for
their
specific
language.
So
at
this
point,
autocomplete
was
totally
winning
it
was.
It
was,
was
beating
our
default
autocomplete,
but
then,
in
the
twist
of
plot
developers
they
needed
an
asynchronous
API
so
that
the
autocomplete
+
API
was
synchronous.
C
C
C
So
then
this
package,
it
led
to
let
to
talk
about
like
unifications
like
we're
all
doing
the
same
things
like
let's
sort
of
get
pointed
in
the
same
direction,
and
so
the
async
api
was
added
into
autocomplete
plus
and
at
that
point,
like
autocomplete,
plus
a
totally
one.
So
we
so
we
bundled
it,
and
this
is
the
beauty
of
the
organic
model
like
if
we
had
baked
autocomplete
plus
into
core
or
autocomplete
in
a
core
like
none
of
this
could
happen.
Ography
plus
would've
never
have
existed.
C
Probably
there
would
have
been
this
issue
that
looked
like
this.
It
was
just
like
improve
autocomplete,
please
fix
you
know,
and
then
there
would
be
+1
comments
and
then
more
+1
comments
and
then,
like
a
whole
bunch.
+1
comments,
then,
would
be
like
angry
lots
of
comments,
holy
crap
and
then
I
mean
it's
just
war
right,
it's
terrible.
So
so
then
this
is
just
the
beginning.
C
C
C
So
again,
like
Chris
was
saying
the
way
that
we
think
about.
Adam
is
not
just
the
product.
It's
it's
a
community
with
Adam
at
the
centre,
so
we
want
Adam
to
be
around
for
a
really
long
time,
and
for
that
to
happen,
the
community
needs
to
transcend
us.
It
needs
to
be.
It
needs
to
be
a
self-guided
community.
This
is
already
happening,
so
we
have
several
community
maintainer
who
I
can
see
in
the
audience
here.
If
Lee
down
manages
the
forum,
so
these
people
they
they
fix
issues
they
merge
PRS
they
help
us
get.
C
Pr
is
ready
to
be
merge.
They
convinced
us
to
add
or
fix
things
they
help
with
issue
triage
they
and
they
manage
the
forum
which,
by
the
way,
has
tripled
in
traffic
since
the
launch
yesterday.
So
thank
you
Lee.
Thank
you
mark
on,
particularly
with
that
and
then
package
wise
they've,
taken
on
bikinis,
taking
on
huge
features
like
the
enter
in
the
mini-map
they've
created
IDE
level
features
like
around
specific
languages
like
go+
and
Adam
type
scripts
in
Omni,
sharp
Adam
and
IDE
Haskell
and,
like
every
one
of
these
packages,
has
their
own
community.
C
C
So
what
is
adam
1.0?
So
it's
all
the
things
I
talked
about.
We
have
the
text
stack
at
the
bottom.
We
have
adam
core.
On
top
of
that,
we
got
a
bunch
of
packages
all
the
packages
you
interact
with
all
the
packages
you
can
download,
but
but
the
most
important
part
is
the
community
and
it's
the
promise
that
Adams
gonna
be
around,
like
Chris
said
for
a
really
long
time,
because
it's
guided
by
the
community
because
we're
not
you
know
we're
just
the
shepherds
so
another
way
to
visualize
Edda
1.0
is
like
this.
C
This
is
the
foundation,
but
but
it's
the
foundation
of
what
you
know.
Of
course,
we're
going
to
like
continue
to
polish.
The
core
editor
experience,
we're
going
to
continue
to
improve
import
or
performance.
These
things
are
really
important
to
us.
We're
gonna,
improve
stability,
we're
gonna,
add
real
international
support,
but
what
about
big-picture
stuff
like?
What
can
we
do
with
this
thing?
C
So
so
some
of
the
things
we're
thinking
about
are
like
what
is
really
deep.
Get
integration.
Look
like
like
what
is
social
coding
mean
in
your
editor?
What
if
we
had
the
entirety
of
the
github
community
in
your
editor?
What
does
that
mean?
What
does
that
give
you,
and
also
we
want
to
see
more
things
like
IDE
Haskell
and
like
go
plus
and
nuclide,
come
up
so
like?
How
do
we
enable
those
people
to
write
IDE
level
features?
C
How
do
we
enable
them
to
write
little
features
with
like
by
building
frameworks
for
them
like
the
linter
and
like
autocomplete
plus?
So
at
one
point,
I
was
just
the
foundation
of
all
of
these
things,
so
I'm
gonna
I'm
gonna
bring
Daniel
back
up
to
talk
about
what
is
one
point:
I
mean
for
developers
and
users.
A
Thanks
man,
that
was
awesome,
I
totally
inspired
tears,
welled
up
in
my
eyes
at
certain
points,
I
know
that
we're
running
over
time
a
little
bit
so
I'm,
going
to
kind
of
close
it
up
here.
So
Adam
won't
point
out
been
talked
a
lot
about
what
Adam
1.0
means
what
it
can
mean
for
you
in
the
future,
where
it's
going
like
kind
of
asked
you
to
help
us
build
this
giant
beautiful
building.
A
But
let's
talk
about
nuts
and
bolts
about
what
Adam
won't
by
no
means,
because
1.0
means
different
things
for
software
project
for
an
open-source
community.
You
know
for
a
piece
of
hardware
or
whatever.
So
what
for
us
for
this
project?
Does
Adam
won't
put
it
on
me.
Let's
start
about
talking
about
what
it
means
for
the
developer
that
wants
to
work
on
or
stand
Adam.
The
various
entry
points
for
customizing
Adam
that
are
available
today
are
very
different
from
what
we
shipped
with
early
last
year.
A
A
Let's
do
it,
but
as
Ben
and
Chris
both
said
we
we
don't,
we
didn't
know,
then
we
still
don't
know
now
what
people
wanted
exactly
what
they
weren't
to
build,
what
their
goals
were
so
over
the
last
year
the
community
helped
us
discover
a
lot
of
novel
use
cases
and
help
serve,
and
people
came
from
a
lot
of
various
diverse
technical
communities.
We
learned
a
lot
about
what
kind
of
patterns
preserve
editor
performance
because,
as
these
needs
change
and
people,
people
use
the
API
as
heavily
or
less
heavily
their
performance
ramifications.
A
So
we
learned
about
what
kind
of
patterns
hurt
editor
performance
and
like
how
we
could
guide
people
in
the
right
directions.
With
the
api's
we
found
places
where
the
api's
could
be
more
consistent,
where
one
set
of
methods
implied
another
where
100
people
filed
+1
comments,
trying
to
customize
something
specific.
A
So
whoops
pardon
me
anyway,
throughout
this
process,
has
been
talked
about.
The
packaged
ecosystem
exploded
along
with
that
thousands
of
unique
configurations.
Blossom
people
depended
on
a
wide
range
of
packages
to
do
their
work,
and
these
packages
depended
on
the
api's
that
were
available
the
day
that
the
person
released
the
package
so
Adam
had
a
major
version,
starting
with
zero,
so
per
semantic
versioning.
We're
allowed
to
break
the
api's,
but
we
knew
that
wasn't
an
option
because
even
pre
1.0
people
were
depending
on
Adam
to
do
work.
A
We
introduced
the
deprecation
system
and
tools,
help
users
and
developers
know
if
the
package
they
built
or
depended
on
would
have.
Issues
in
the
future
was
really
difficult
to
coordinate,
but
it
was
the
right
thing,
and
so
the
community
came
together
to
update
their
packages,
21.0
standards
that
represent
all
the
things
that
we
learned
about
performance
and
what
people
wanted
and
what
like
the
right
way
to
customize
an
editor
without
stepping
on
some
other
packages.
A
Toes
was
so
it's
that's
great
for
code,
quality
and
performance
for
us
and
for
this
world
code
that
we
don't
control
so
with
1.0.
We
declare
the
current
package
API
stable
and,
like
that's
the
core
of
what
it
means
to
developers,
that
is
to
say
any
package
you
write
today
or
into
the
public
API
is
guaranteed
to
work
without
modification
for
the
entire
1.0
line.
Long
may
it
run.
A
It
doesn't
mean
that
we
won't
add
new
and
improved
or
experimental
tools
for
developers
that
want
to
extend
adam,
but
it
does
mean
that
we're
making
a
public
commitment
to
the
package
developer
community
and
anyone
here
that
wants
to
develop
a
package
that
if
you
follow
the
docs,
your
package
will
work
and
your
package
will
benefit
from
the
ongoing
performance
work
that
we
do.
So
that
is
what
it
means
to
developers.
What
does
it
mean
to
users?
A
1.0
represents
the
end
of
the
pre-release
or
beta
period,
and
that
means
that
we
believe
that
Adam
is
ready
to
be
the
only
editor
on
your
system
for
most
developers.
There,
of
course,
edge
cases
here
and
there
tools
that
we
want
to
build.
Yet
that
might
not
get
that
1%
case,
but
we
think
for
99%
Adams.
All
you
need
I
mean
it's
all
I've
needed
for
18
plus
months
2
years
performance
is
good.
It's
only
getting
better
we're
listening
to
your
feedback
and
adding
features
that
people
consider
must-haves
and
honestly.
A
Everybody's
got
a
different
must-have
feature
right,
so
we've
added
a
lot
of
them
and
they're
more
they're,
more
coming
in
1.1,
1.2
and
so
on.
So
whether
you
want
to
modify
Adam
or
whether
you
want
to
use
adam
adam
1.0
is
ready
for
you.
I'm
I
think
we
should
wrap
it
up.
I'd
like
to
close
this
session,
with
something
special
from
the
folks
in
get-ups
video
department
and
thank
you
and
enjoy.
D
After
a
long
day
of
work,
dad
unwinds
in
his
study
he's
using
atom
1.0
a
fully
modern
text.
Editor,
that's
hackable
to
the
core,
a
tool
that
you
can
customize
to
do
just
about
anything,
looks
like
dad's
using
atom
to
rewrite
the
houses
temperature
regulation
protocols.
Since
he
writes
a
lot
of
JavaScript
he's
installed
atom
turn
and
the
JavaScript
linter.
He
no
longer
makes
mistakes
and
has
increased
his
productivity
by
50%
nice
job.
Dad.
D
Mom
is
a
programmer
for
the
Alpha
Centauri
project,
where
she
uses
atom
every
day.
She's
writing
the
software
that
will
help
direct
the
first
rocket
ship
to
carry
humans
to
other
solar
systems.
She
can
even
work
on
atom
at
home,
continuing
to
work
without
missing
a
beat
with
built-in
get
support
and
the
minimap
package.
She
keeps
track
of
all
the
work
she's
done
and
the
changes
she's
yet
to
commit.
That's
keeping
her
eye
on
the
big
picture.
D
Junior
wants
to
be
a
rocketship
engineer
as
well,
so
when
mom's
done
working,
she
encourages
him
to
work
on
his
own
projects
like
mother,
like
son,
Adam
is
based
on
JavaScript,
and
so
it's
easy
to
use
for
everyone.
It's
fully
customizable,
conforming
to
whatever
your
needs
might
be
seems
like
jr.
is
having
some
trouble.
Maybe
grandma
can
help,
though
she
might
need
to
adjust
a
few
things.
First,.