►
Description
7 years - 7 design patterns. Will node continue to outshine? - Shubhra Kar, Joyent, a Samsung company
In the past 7 years, we have seen the rise of 7 key application architectures among others namely:
SPAs
Realtime Apps/APIs
Hybrid Mobile
Microservices
Serverless
IoT
AI
Node.js is very popular and performant and the hyper growth of modules and APIs proves the point…to an extent that there is a problem of too much choice and inconsistent quality.
Application architectures however cannot afford the same clip of change, else nothing meaningful will ever get delivered. Simultaneously GoLang, Weave, R, Async Java, Swift, Scala et all are competing for the same mindshare. Architects have purists (monoglot) and/or best of breed (polyglot) approaches. Many of them view languages as transient and designs as perpetual.
In this presentation, we will discuss standardization of design patterns across these 7 architectures and how node.js can be an integral part of them. We will also cover a detailed overview of Samsung’s Node.js and Docker based architecture and challenges supporting a Billion + devices (mobile, TVs, refrigerators, et all) and 100s of petabytes of data generated by 100s of millions of daily users.
About Shubhra Kar
Shubhra Kar is a passionate technology leader at Joyent, a Samsung company and the original stewards of Node.js. Shubhra spends his days working with large IoT, mobile and realtime analytics applications built on node.js and containers.
Previously he led products at IBM StrongLoop, building a node.js runtime and frameworks for micro-services API. He is also a subject matter expert on DevOps and APM/NPM technologies, having held tech leadership positions at InfluxData (creators of InfluxDB & TICK Stack), CA Wily (pioneers of APM) and Infosys.
Shubhra is an accomplished speaker who has delivered keynotes on API development, DevOps and Node.js best practices at Node Summit, MidwestJS, ConnectJS, HTML5DevConf, QCon, CloudExpo, IBM Interconnect and numerous community meet-ups.
A
Hey
thanks
for
stopping
by
and
sorry
for
keeping
you
away
from
lunch
I'll
try
to
make
it
quick.
So
a
lot
of
folks
already
know
me
for
those
who
don't
I'll,
give
you
an
introduction.
But
what
I'm
here
to
talk
about
today
is
looking
stepping
back
taking
a
pragmatic
look
at
what
has
happened
over
the
past
seven
years
and
we
have
been
talking
and
about
a
lot
of
design
patterns
that
have
evolved
and
when
we
are
into
the
weeds
into
coding.
A
We
kind
of
will
look
this
and
see
these
as
trends,
which
you
know
come
out
of
nowhere
right.
The
question
is:
will
node
continue
to
outshine
right?
So
that's
about
me
so
folks,
who
can
read
JSON,
that's
kind
of
my
signature.
I've
been
into
node
a
few
years
now.
I
was
a
Java
architect
for
a
number
of
years
dealt
in
enterprise
architecture
worked
in
gulang.
That
was
my
last
job
came
back
again
to
node
and
excited
to
see
the
momentum.
So
let's
talk
about
the
interface
like
people
talk
about
roadmaps,
I'm
gonna
talk
about.
A
Where
is
the
interface
headed
right?
So
obviously
you
know
it
started
with
you
know:
I'm
not
gonna,
go
back
a
decade
right
released,
looking
at
the
start
of
html5
and
then
eventually
we
were
hit
with
JSON
as
becoming
a
number
one
data
construct,
and
now
we
are
seeing
voice
right.
So
where
do
these
design
patterns
fit
in
in
terms
of
the
interface?
So
if
you
look
at
these
originally
we
were
serving
right
or
we
were
rendering
whether
we
were
entering
the
single
page,
apps
or
real-time
apps.
A
That
was
kind
of
where
the
technology
was
centered
and
where
the
architecture
was
evolving.
As
we
started
to
connect,
we
started
to
get
more
into
mobile
backends.
We
started
to
get
into
micro
services,
not
that
we
were
not
doing
services
earlier,
but
there
was
an
intermediate
connection
to
what
was
happening
on
Io
T
and
it's
not
hype.
A
I
can
prove
you
that
the
stock
and
finally,
what
we
are
looking
here
is
learning
right,
that's
kind
of
the
new
interface
and
when
you
talk
about
deep
learning,
can
your
machines
learn
for
you,
and
can
you
make
them
smart
enough
that
they
talk
back
to
you?
So
we
are
seeing
this
emergence
of
what
we
call
as
a
conversational
interface
apps.
As
you
know,
it
we
think,
will
eventually
disappear
in
the
next
four
to
five
years,
primarily
as
being
the
interface
for
you
right.
A
That
interface
would
probably
end
up
being
voice
and
voice
on
your
mobile
phone,
or
your
variable
will
be
the
guy
who
is
orchestrating
all
these
apps
using
micro
services
and
api's
on
the
backend
and
keeping
it
opaque
to
the
end-user
right,
so
that's
kind
of
where
the
roadmap
is
headed.
So
let's
look
at
some
of
these
design
patterns.
Right
I
had
seven
bubbles
up
there
and
let's
look
at
the
node
journey
and
how
we
can
still
stay
relevant
right.
So
we
started
with
no
reload
right.
A
That's
where
single
page
apps
came
in
and
was
great
right.
You
could
build.
You
know
there
are
tons
of
libraries.
You
didn't
have
dig
too
deep
into
the
JavaScript
trenches,
and
you
know
these
were
the
key
components
to
keep
in
mind
right.
You
were
dealing
with
chunking
right.
You
looked
at
frameworks
like
backbone,
GS,
you
know
jQuery
up
short
Jas,
you
name
it
right
controllers.
A
A
Can
anybody
tell
me:
are
these
close
to
near
real-time
Scheuer
fans
yeah
all
right,
so
there
have
been
innovations
here,
right,
I'm
not
going
to
go
back
all
the
way
into
socket
IO,
but
there
are
components
that
came
out
like
angular
life
sets
right
frameworks
like
loop
back
started,
supporting
them.
The
whole
idea
was
we
started
using
html's
event
source
web
api
instead
of
using
the
traditional
socket
IO
or
traditional
HTTP
web
sockets
right
kind
of
go
getting
away
from
long
pooling
strategies.
So
what
live
set
did
was.
A
It
did
not
require
HTTP,
sockets
or
request
to
be
upgraded
to
web
sockets
at
all,
and
it
was
compatible
with
all
kind
of
load
balancers
right,
so
this
is
kind
of
a
real-time
example
kind
of
on
the
bleeding
edge.
But
let's
see
what
happens
at
consumer
scale
today,
this
has
I
haven't
seen
a
production
application
using
angular
live
sets.
Yet
maybe
you
have.
This
is
kind
of
the
hell.
We
are
looking
at
right
and
I'll
Amy.
You
can
see
like
courtesy
of
the
I
was
using
this
right
you,
this
is
the
last
shop.
A
A
What
kind
of
context
you
provided
around
the
data
and
eventually
they
came
to
a
realization
that
we
need
a
consolidated
data
pipeline
where
you
know
you
can
have
multiple
ingestion
channels
and
put
that
on
to
some
kind
of
message:
bus
on
steroids
and
have
uniform
interfaces
where
you
know
different
apps
log
searches,
text,
analysis,
voice
analysis
can
pull
off
right.
So
again,
this
came
out
of
the
guys
working
at
LinkedIn
who
created
Gasca
right.
So
that's
kind
of
the
cafe
architecture
right
there
for
you.
So
I
have
a
quick
trivia.
A
Okay,
shoot
me
a
tweet
and
there's
a
raffle
for
you
I'll
announce
what
it
was
at
the
end
of
the
day.
So,
let's
start
taking
a
look
at
the
new
in
number
one
interface
right.
This
was
kind
of
what
driven
was
design
pattern
number
three
mobile
right,
so
mobile
wasn't
new.
What
happened
was
the
way
API.
Is
he
got
surface
to
the
new
mobile
interface
right?
All
of
a
sudden
we
had
swagger
to
dotto.
A
You
could
write
a
spec
and
generate
REST
API
out
of
that
right
and
multiple
frameworks
started
supporting
that
early
days
you
were
trying
to
go
down
the
ORM
path
or
sometimes
try
to
go.
Diy
writing
your
own
api's.
But
then
you
had
to
maintain
all
those
API
endpoints
yourself.
You
had
to
test
them
code.
Them
reiterate,
wasn't
really
agile
right,
so
I
think
so.
A
I
had
a
very
big
influence
on
this
and
if
you
start
looking
at
what
happened
started
happening
with
the
mobile
services
in
terms
of
geo
push
offline,
all
of
a
sudden
the
objects
that
you
were
creating
on
the
back
end
in
JavaScript,
they
could
have
a
remoting
interface
to
the
front-end.
So
classic
case
was,
if
you
are
using
angular
models
right
and
if
you
could
share
the
models
from
the
back
end
to
the
front
end.
A
So
this
kind
of
started
happening,
and
then
you
know,
but
however,
the
word
around
was
that
it's
not
going
to
be
full
stack
JavaScript,
it's
probably
going
to
be
hybrid
right
because
on
the
customer
side
from
the
interface
perspective,
what
matters
is
performance
as
well
as
native
experience
close
to
native
experience
right.
So
now
you
started
on
the
front
end,
seeing
a
mix
of
frameworks
like
bootstrap,
ionic
and
so
on.
Right,
which
are
trying
to
get
into
creating
a
full
stack
mobile
framework.
The
back
end
is
still
primarily
node.
A
The
frameworks
are
still
powered
with
JavaScript,
but
you
kind
of
have
a
close
to
native
experience
on
the
front
end
right.
So,
let's
look
at
moving
on
to
ten
number
four
shrink
and
ship
when
I
say,
shrink.
Obviously,
I'm
talking
micro
services
right,
but
I
don't
want
to
beat
a
dead
horse
over
and
over
again
many
of
you
might
have
just
memorized
this
right
and
what
my
microservice
says,
you
know
do
one
thing:
do
them
really
well
break
down
the
monolith,
blah
blah
blah
right
every
service
scales
on
its
own?
A
Has
it
done
then
see
as
security
and
whatnot?
Let's
take
a
look
at
the
reality
right.
So
that's
what
is
in
the
enterprise
today
a
bunch
of
polyglots
right,
so
that
that's
kind
of
the
implementation
of
Netflix
OSS
using
spring
cloud
and
they
were
trying
to
move
away
from
that,
but
you'll
always
have
coexistence
right
and
when
you
talk
about
coexistence,
you
also
need
to
think
in
terms
of
transactional
context.
Can
you
pass
a
transactional
context
from
JavaScript
to
Java
to
no
order
to
a
back-end
MongoDB
database
you're
not
going
to
have
a
pure
architecture?
A
You
know
I
would
love
to
be
a
purist.
So
if
you
are
a
purist,
you
can
do
something
like
this
hey.
We
build
a
pattern.
Adjoint
call
as
autopilot
pattern,
and
this
is
kind
of
a
pattern
we
are
inviting
more
and
more
developers
to
contribute
to
that.
There's
an
Orchestrator
and
you
can
bring
your
own
scale.
Doodle
scheduler
to
8-bit
kubernetes
beat
marathon.
A
Whatever
we
use
console,
there
are
different
options
at
CD,
as
your
registry
titan
is
essentially
our
data
center
orchestration,
open
source
software,
and
we
pick
docker
as
one
of
the
runtime
platforms
and
there
are
different
choice,
components
right
Seneca
was
probably
the
number
one
micro
services
node
framework
that
got
out.
We
talked
about
our
brought
in
happy,
we
put
in
flux,
DB
and
smart
things,
so
there's
a
live
demo
running
at
the
booth.
If
you
want
to
take
a
look
at
this
and
I'll
pass,
this
stick
along,
but
net
net.
A
Now
we
are
seeing
a
new
affinity
in
the
stack
right,
node
and
docker.
Why
nobody
asks
the
question?
Why?
Just
because
it's
easy
to
deploy?
No
the
fundamental
concept
there
is.
It
has
micro
service
is
supposed
to
be
immutable.
If
you
are
pushing
a
change,
you
are
updating
a
micro
service,
update
it
on
the
laptop
push
and
you
build
out
right
and
that
concept
is
very
minimalistic
but
and
it's
immutable.
That
concept
goes
hand-in-hand
with
how
you
build
and
shape
docker
based
applications
right.
So
that's
where
the
affinity
comes
in.
A
Let's
talk
about
reconnect
like
let's
try
this
all
together
right,
we've
talked
a
bunch
of
technologies,
so
here
are
some
of
the
IOT
pipe
wash
it.
It's
actually
hard
to
put
all
of
yo
T
landscapes
into
a
single
canvas.
I
tried
to
take
a
stab
at
this,
but
primarily
there
are
nine
domains
right,
starting
with
variables
to
smart
offices,
homes,
logistics,
industrial
automation,
you
name
it
so
there's
the
device
side
of
the
house,
a
bunch
of
those
devices
are
analog
and
they
were
not
digital.
A
They
did
not
actually
talk,
REST,
API
or
HTTP,
so
you
needed
a
bunch
of
gateways
right.
These
web
gateways,
which
worked
on
the
edge,
did
protocol
transformation,
made
them
work,
REST,
API
and
on
the
cloud
you
actually
needed
an
API
gateway
for
these
devices
to
register
for
these
devices
to
authenticate
for
these
devices.
To
send
the
state
and
updates,
and
then
you
needed
an
analytic
system
which
could
track
data
from
millions
and
millions
of
these
tiny
devices
and
sensors
and
then
go
and
analyze
and
report
on
them
right.
A
So
there
are
some
real-time
API
gateways,
there's
one
being
developed
by
strongloop
I
used
to
work
there
kind
of
cool
you're.
Looking
at
dealing
with
multiple
protocol,
bridges
right,
there's,
MQTT,
there's
obviously
browserify,
and
then
there
is,
you
know:
node
style,
Redis,
and
then
you
know,
obviously,
with
the
bridge
you
get
kind
of
can
go
streaming
text
protocol,
stomp
or
you
could
go
essentially
Brooker
style
and
get
the
data.
In
a
couple
of
things
to
note
from
a
Samson
side
now
joint
is
part
of
Samsung.
A
We
started
working
on
some
projects,
good
ones,
Jerry
script
is
coming
in
it's
a
super
lightweight
JavaScript
engine
runs
on
a
microcontroller
with
as
less
as
64
kilobytes
of
memory,
footprint
right
and
works
on
a
variety
of
devices,
Lizzie
and
then
there's
IOT
GS,
which
is
actually
built
on
top
of
JavaScript.
This
uncanny
similarity
with
node
there.
It
actually
uses
Libby
we
as
well
for
async
transactions,
but
that's.
A
What's
getting
ported
right,
so
we
were
doing
a
lot
of
scientist
projects
on
raspberry
PI's,
but
when
you
start
building
something
industrial-grade,
you
know
you
need
to
look
at
these
kind
of
frameworks
right.
So
the
last
one
I
want
to
know
cover
is
about
learning
and
conversational
interfaces
right,
so
we
have
to
be
building
chat,
servers
for
a
long
long
time.
We
didn't
really
build
a
bot
right
and
now
we
are
seeing
an
explosion
of
chat
BOTS.
These
are
learning
so
on
the
Left.
A
You
essentially
have
a
pikachu
game
talking
back
to
you,
so
what
is
important
right?
There
are
a
bunch
of
static
responses
that
you
can
code
in,
but
they
are
not
good
enough
right.
There's,
no
single
answer!
What
you
really
need
to
get
into
is
response
generation
and
dynamic
models.
Right
and
dynamic
models
are
also
called
as
generative
models
and
generative
models
are
really
hard
to
do.
A
So
you
have
to
the
main
challenge:
is
how
do
you
train
the
system
to
learn
and
respond
right,
so
you
can
have
multiple
events
that
are
coming
in
and
based
on
those
events.
Every
event
has
an
intent
and
every
event
has
an
entity
attached
to
it
right
and,
as
your
boards
handle
these
kind
of
events,
can
you
train
the
system?
A
Maybe
you
start
statically
responding
to
them
right,
but
then
can
you
put
in
some
machine
learning
to
build
in
automatic
responses
and
responses
which
are
important
so
next
thing
that
we'll
gonna
happen
is
you're
going
to
talk
to
CD
on
your
iPhone,
and
it
automatically
knows
that
there's
a
bunch
of
events,
that's
coming
in
from
your
car
from
your
SmartWatch.
Here's
from
a
wearables
gets
you
your
location,
so
it
kind
of
puts
your
question
that
you
are
asking
to
Siri
in
context
and
gives
you
an
answer
which
is
kind
of
related
to
that
context.
A
Right
so,
hey
I
am
out,
and
I
am
searching
for
food
because
tell
Siri,
hey
I
am
hungry,
but
it
tells
you
like:
hey
I,
know
that,
based
on
your
geolocation
tracking
I
know
you
visit
these
restaurants
right.
These
are
your
food
choices.
This
is
the
time
you
usually
eat
right.
So
it
gives
me
a
very
intelligent
answer
based
on
that
context,
so
catbots
are
taking
over
right
and
training.
Your
BOTS
is
really
the
key
here.
A
I
can
confidently
say
that
node
is
still
the
number
one
choice
of
how
messaging
and
API
frameworks
are
built
on
the
backend.
Json
is
still
the
number
one
data
construct,
although
I
see
a
lot
of
overlap
with
voice
coming
in
golang
and
Java,
however,
are
fighting
it
out
for
the
deep
learning
piece
of
it.
Note
is
not
really
very
good
at
deep
learning
or
heavy
computational
processes.
I
think
Java
is
Java,
is
gonna
stay
for
a
bit,
but
goo
is
eventually
gonna
win.
A
Actually,
if
you
could,
please
use
the
microphone
in
the
middle
of
the
room,
yeah
I'll,
repeat
the
question
in
your
case,
I
think
his
question
was
what
about
Python
right?
Is
that
and
they're
a
bunch
of
Python
libraries
for
deep
learning?
Do
we
see
them
catching
up
right,
I?
Think
it
comes
down
to
probably
one
key
thing
right.
A
How
do
you
manage
compute
write
and
how
do
you
self
learn
and
how
much
parallelism
there
is
in
terms
of
running
those
compute
jobs
right?
You
could
not
still
have
done
it
with
Java,
I,
wouldn't
say,
there's
a
clear
winner.
Yet
on
deep
learning,
there
are
a
bunch
of
Python
libraries
which
do
that.
But
traditionally,
when
you
are
talking
about
deep
learning,
you
know
you
see,
the
roadmap
is
started
all
the
way
like
with
big
data
right.
A
You
went
from
Hadoop,
he
went
to
MapReduce,
you
went
to
streaming
right
spark
storm
and
eventually
you
are
dealing
with
real-time
streaming
technologies.
Even
Java
has
started
doing
this
right,
but
more
and
more,
the
question
is:
can
they
all
work
on
the
same
data
pipeline
for
IOT
that
data
at
scale
the
primary
data
set?
Is
time
series
data
right,
so
you're
not
working
on
big
payloads
of
data
and
if
you
can
have
Python
scripts
that
you
can
bring
to
process
these
data
pipelines
on
time
series
data,
then
yes,
there
will
be
a
win
right.