
Docker isn't serverless - jayfk
https://serverlesscode.com/post/docker-isnt-serverless/
======
kowdermeister
"Well, serverless isn’t really a technique for building distributed apps -
it’s about building useful apps"

"But serverless doesn’t mean there is no Docker – in fact, Docker is
serverless."

Yet another case where it's clear that "serverless" is a harmful term.
Everybody means something else by it and there's no wonder that posts like
this surface.

Yes, Docker is not serverless, because it runs on a server, like your lambda
functions.

~~~
kordless
The idea that words themselves can be harmful is ridiculous. People create and
use words. The people who say words can be harmful, if they are presenting
facts in the way they see them, as opposed to the way they are observed in
reality. Stop attacking words and start addressing those who use them in a
harmful and dissonance creating way.

The reason people become polarized over a given subject, especially when it's
boiled down to a single term, is because we all have different perceptions
based on our roles and responsibilities. The term "serverless" can be applied
to the _users_ of a given application. Gmail is "serverless" for me, but not
Google. For Google ops, Gmail is definately "server" based. Flipping terms, by
those who seek additional resources for themselves, their company and their
limited partners, is simply a means to hide the truth of the matter behind
running their software.

To achieve infrastructure which is trustworthy and not owned by self, we must
implement trusted architectures which can adapt to changing conditions and
provide fault tolerance to a given level for an immediate cost. Docker has
barely scratched the surface of what must be done to address these
architectural requirements. The unfortunate bit is that their business model
is likely to take them in the opposite direction of where we need to go with
all this. That's just the way innovation works when it's driven by VC capital.

~~~
kowdermeister
There are harmful words in use, but obviously it needs a user base to spread,
the two can't live without each other. I'm not talking about swear words, but
words that offend or misinform people or summarize a concept that can be
harmful or generate controversy. Take web 2.0 for example. It caused quite a
stir because nobody was sure what's 1.0 vs 2.0 was, then it faded away. I
consider homeopathy a harmful word too. It sounds innocent, memorable and
somewhat legit, but it's a dangerous thing.

I think that if many people point out that a word is pointless, inaccurate and
deceptive, then that user base can fade too, therefore it makes sense to
attack the word and not go ad hominem on the users.

> Gmail is "serverless" for me, but not Google.

Thanks for bringing this up, for me as a user, gmail is nothing but a webapp
for an email server. So is SaaS a better category for it or serverless?
Without net connection (to a server) it's pretty useless. Even from the user
point of view it's not clear what the term should cover.

After all, we should focus on the technology, because that's promising at
least.

------
jackweirdy
Kudos to the author for writing this. Serverless is a thing, but Docker
definitely isn't it. Nor is AWS lambda.

Serverless is client-only code, or even Peer-to-Peer between self-coordinating
clients.

There's a lot of stuff that overlaps in this domain, including microservices,
containers, serverless, and if we want to talk about them we should use the
right terminology.

~~~
jasode
_> Serverless is client-only code, or even Peer-to-Peer between self-
coordinating clients._

That's a valid definition but it's just one of many. The Function-as-a-Service
has also been called _" serverless"_.

Your definition of "serverless" demarcates on _where_ the code runs.

The FaaS "serverless"[1] differentiates on _what part of the stack_ you don't
have to manage the housekeeping for. With FaaS-serverless, you don't worry
about upgrading a particular Linux kernel version if you can decompose a
computation into a function that runs on AWS Lambda. So, deploy computation to
the cloud _without the Linux server_ embedded inside an image (AMI) -- and it
seems natural for a bunch of human beings to call that "serverless".

Likewise, the "server" in X Window X11 is the display services to
differentiate it from the "client" of a terminal app.[2]

All 3 meanings of "server/serverless" can coexist without confusion and it
doesn't seem like terminology we have to bikeshed. Personally, the context
surrounding serverless always makes it clear what we're talking about. Is
anyone truly confused between SQLite being "serverless" and AWS Lambda being
"serverless" because they happen to use the same word?

As for Ryan Scott Brown's definition of "serverless", is there near universal
consensus on his criteria?

[1][https://en.wikipedia.org/wiki/Function_as_a_Service](https://en.wikipedia.org/wiki/Function_as_a_Service)

[2][https://en.wikipedia.org/wiki/X_Window_System#Software_archi...](https://en.wikipedia.org/wiki/X_Window_System#Software_architecture)

~~~
jackweirdy
I think the deeper we go into this discussion the more philosophically
ambiguous it gets.

If I think of the most basic, abstract definition of a server I can, I'd say
it's a piece of software at a known location outside of the client process, to
which a client goes to transmit a message (and optionally have future messages
back and forth in the same "session").

I would say Lambda is not serverless because it depends on software outside of
the client process, and I know where it is.

X is not serverless because the client process is separate from the server.

SQLite is serverless because my process is calling the sqlite library.

Torrenting initially has a server (clients need a way to find peers) but very
quickly becomes serverless.

So I'd say my definition isn't about where it runs, but who is running it and
in what context.

That's my thoughts on it anyway.

~~~
jasode
_> If I think of the most basic, abstract definition of a server I can, I'd
say it's a piece of software at a known location outside of the client
process,_

But you're trying to reduce it down to a perfect singular definition. English
doesn't work like that and we'll just end up in contradictions as I will
demonstrate further down in my comment.

 _> I would say Lambda is not serverless because it depends on software
outside of the client process, and I know where it is._

Right... and I acknowledged and agreed that _your_ particular definition of
serverless doesn't include Lambda. However, I can also explain why _others_
call deployment without-the-Linux-kernel as "serverless". I guess a different
chain of memes might have resulted in alternative terminology such as
"Linuxless" computations or "os-free" functions but somehow the word
"serverless" gained currency.

 _> SQLite is serverless because my process is calling the sqlite library._

So what if my web browser submits a REST API call to a web server that uses
SQLite as it's backend? Is SQLite the "db server"? Yes and no. It depends on
_which_ definition of "server/serverless". (Machine location vs os in-
process/out-of-process)

If we insist on 1 definition, we will have contradictions.

~~~
spriggan3
> If we insist on 1 definition, we will have contradictions.

And if we keep on using catch-all buzzwords such as "serverless", it makes
words void of any real meaning.

~~~
neolefty
Serverless has a very definite meaning to me if I'm tired of administering
Linux servers.

------
cocktailpeanuts
I can understand why people try to come up with a definitive definition of
"serverless" but....

"Serverless" is an adjective.

Adjectives are used to provide auxiliary meaning to the noun it's attached to,
which means it depends on context.

It could be a "serverless website", it could be a "serverless hosting", it
could even be a "serverless diner"!

~~~
hacknat
It's funny to watch people debate the meaning of this word as though it's some
rigorously technical term that has been around forever. It's just the latest
buzz word for the latest evolution in simplifying/hiding operations from
developers.

~~~
cocktailpeanuts
From marketing point of view, I think it's the best naming ever, since it
makes people talk about it more.

------
stuaxo
Ugh, of all the jargon the dev world has come up with serverless is the worst
- if it runs on another computer it is not server less.

~~~
markus2012
I think it's an inside joke:

2 people bet each other a dollar they could take a fundamentally simple
concept and wax poetic insanity around it until the text was so insane no one
could actually read through it - so people just shrug, wash the virtual slime
off and move on. Their will power so drained by reading the BS they can't even
be bothered to complain.

Then comes the fake accounts to gush how 'serverless' and 'function-as-a-
service' are completely new and different and awesomer bra.

The next bet will probably be "mathematicsless": how we solve collision
detection without math - and you should too!

------
Johnny555
Just call it "cloud". That's already a meaningless catch-all term that covers
everything.

~~~
paulddraper
Whenever I hear serverless, I think of

[http://dilbert.com/strip/2015-12-20](http://dilbert.com/strip/2015-12-20)

------
pbiggar
"serverless" is a new term that people have been using in tons of different
ways. To the author, frankly I don't think you get to say what's serverless
and what isn't. I think only point 1 is agreed upon - the rest is up in the
air. Point 3: that it must be function-as-a-service: I dont agree there.
Counter-point: if your backend is google sheets, or plain S3, it's certainly
serverless.

Docker? Maybe. Depends how it's architected. I get that they're trying to
latch onto the up-and-coming big movement, but since that big term has no
definition, they have as much right as the author to claim to belong to it.

~~~
falcolas
> if your backend is [...] S3, it's certainly serverless

Is it really serverless if you have to configure the web server serving the
files? If you have to manage ACLs, regional distribution, compression, CDN
mirroring, versioning, DNS...

If you move to Lambda, you're also tossing in the API gateway configuration,
Kenesis streams, datastores, IAM permissions and roles, throttling behavior,
scheduled tasks, VPCs, subnets...

Just because you're not starting and stopping the processes doesn't mean
you're not managing the server.

/devilsadvocate

~~~
icebraining
The things that actually fits best with the new serverless term is - shared
hosting. Just FTP some PHP files into a directory, and it's running.

Excuse me, I'm off to sell my marketing consultation services to GoDaddy and
Hostgator.

------
StavrosK
I kind of feel that Erlang programmers are shaking their heads in frustration
at all this and saying "we've been doing things this way since the 80s and
saying they're great but nobody listens".

------
kidsil
How could someone claim docker is serverless? It's pretty much the definition
of server.

It's servermore if anything.

------
seangrogg
"Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo"

That's pretty much all I'm seeing in the comments, just with "Serverless"
instead.

~~~
dang
If I'm not mistaken, congratulations on getting the capitalization just right
there.

------
barnacs
Only if you forget to pay your hosting bills do your services become
serverless.

------
noobiemcfoob
Serverless is a word that only has meaning within the existing paradigms of
web development. A "Server" is nothing more than a metaphor for a machine with
stuff a "client" (another machine) can request. Everyone acts confused/amazed
at what is essentially semantics for describing infinitely more complex
systems.

It's the same process with any buzzword. They're terms that are so all-
encompassing that, yeah, every sensible, modern project operating in a related
space could probably be described by them. Like horoscopes for engineering.

------
throwaway2016a
As an avid Docker user and also a user of AWS Lambda my only reactive when
seeing this article is... "This wasn't obvious already?"

Reading the article I can see how it can be construed to be serverless but it
is a real stretch.

I don't agree with other posters that the only true serverless is client-only
technology. P2P has its place and is generally awesome but I feel that
distributing your app as small functions that can run on distributed systems
where you don't know or care what hardware or OS is underneath is a compelling
definition in lack of a better word.

------
djhworld
> In the demo, a new container is created for every function invocation which
> would introduce latency that wouldn’t really be acceptable for most user-
> facing systems.

That seems like an implementation issue that can be overcome, an alternative
approach could be to spin up a few containers, deploy the function
artefact/JAR/script/whatever and then continuously invoke it via a load
balancer.

Then if the function isn't called for a while, terminate or scale down the
container(s)

I believe AWS lambda works in a similar way to the above approach.

------
vectorpush
A PaaS is not serverless either. We embrace the fluidity of language because
that is the pragmatic choice, but using counter-intuitive terms with
misleading semantics is not pragmatic so we should reject such terms instead
of muddling the meaning of well established terms of art.

Everyone can pretty much agree on what constitutes a "server" so I don't see
why we should use confusing terms that belie our shared understanding of this
term.

------
forgottenacc56
Serverless isn't serverless either - it's pretending someone else's server
doesn't exist.

------
dubmax123
I think serverless has bad semantics for it's new connotation (which doesn't
even seem to be universally agreed upon). Maybe we should just focus on value,
not paying for more infrastructure than you need, and building useful things.
Maybe we could just call it practical?

~~~
GrinningFool
I was going to make a comment about how doing that would mean we couldn't get
to the next phase of the cycle, when we start talking about "serverless
microservices". Then I saw we're already there[1], and died a little on the
inside.

[1] [https://gun.io/blog/serverless-microservices-with-zappa-
and-...](https://gun.io/blog/serverless-microservices-with-zappa-and-flask/)

------
jpb0104
Related recently published podcast:
[http://softwareengineeringdaily.com/2016/08/23/serverless-
ar...](http://softwareengineeringdaily.com/2016/08/23/serverless-architecture-
with-mike-roberts/)

~~~
ryan_sb
I also was on SEDaily a while back on the same topic
[http://softwareengineeringdaily.com/2016/06/20/serverless-
co...](http://softwareengineeringdaily.com/2016/06/20/serverless-code-ryan-
scott-brown/)

------
digi_owl
Sounds like ol' Murky and ilk is at it again...

------
coding123
To me Servlerless is a PaaS model, but more specifically a payment model on
top of a PaaS model.

------
jondubois
I agree that Docker is not serverless, but I think that it does replace the
need for serverless services if coupled with an orchestrator such as
Kubernetes, Swarm or Mesos.

The first bullet point in the article is true when taken in its entirety but
it's also misleading because using Docker with an orchestrator like Kubernetes
does significantly reduce the need for maintenance - You do have to design
your apps in a particular way (so that they can auto-scale themselves - And
this is no small feat) but once you do, it's really easy on the maintenance
side. I think it's a matter of time before open source projects start to
become 'built for Kubernetes' \- I already did this with my own project
[https://github.com/SocketCluster/socketcluster](https://github.com/SocketCluster/socketcluster)
and I know lots of big open source developers who are also doing the same.
Kubernetes/Swarm/Mesos are becoming 'cloud' operating systems - Once their
popularity reaches a critical threshold, developers will build apps on top of
Kubernetes or Swarm in the same way that developers today build apps to run on
Linux or OSX.

Eventually, when people ask "What OS does your software run on?", the most
common answer will probably be "Kubernetes" or "Swarm" \- Instead of saying
"Linux", "OSX" or "Windows".

The second point is also correct when taken literally but also misleading.
While Docker doesn't use third-party services to reduce the amount of code...
It does allow you to use third-party Docker images to reduce the amount of
code... Same result, different approach. I think the second approach is better
(and cheaper sine you don't have to pay ongoing costs).

The third point makes sense but the concept of 'lambda functions' is
completely redundant in a self-orchestrated Docker environment. Lambda
functions were invented to fix a problem which BaaS introduced - By the very
fact that it doesn't offer you direct access to the backend. In my opinion,
Lambdas are not as good a solution as having your own backend code running in
auto-orchestrated containers (Lambdas often have lots of limits related to
resource usage, timeouts, including third-party modules, etc...).

I think that until now, BaaS providers have had the upper hand because they're
really easy to use, but I'm certain that Docker/Kubernetes/Mesos will win out
in the end for the simple fact that they are decentralized, that they are way
more flexible, that they leverage open source technology and that ultimately
they will cost much less (because of their high flexibility, customizability
and composability).

There are lots of great teams building new platforms on top of Docker which
will make it easier to use than BaaS.

~~~
sytse
I totally agree with your comment. I think that the potential of container
schedulers will start showing and will become popular.

Martin Fowler defined serverless as "bringing entire applications up and down
for every request".
[http://martinfowler.com/articles/serverless.html](http://martinfowler.com/articles/serverless.html)

I don't think that this is what we do with containers, they mostly stay active
when there are no requests since they take more than 20ms to boot up.

~~~
icebraining
Thing is, it's not what Amazon does with Lambda either; so if the prime
example of serverless, isn't, what is?

[https://aws.amazon.com/blogs/compute/container-reuse-in-
lamb...](https://aws.amazon.com/blogs/compute/container-reuse-in-lambda/)

------
paulddraper
Serverless just means PaaS, right?

------
yalooze
I would consider a project in Docker serverless _if_ it is used in something
like AWS EC2 Container Service (ECS).

~~~
joombaga
Why? Even with ECS the container's host is maintained by _you_. It's hardly
more "serverless" (less serverful?) than just running docker on EC2.

~~~
yalooze
Hmmmm perhaps my definition of serverless is non-standard :) My thinking is
that if you just have an endpoint that you can throw a container at, or
something like RDS for databases, then that's serverless enough for me (at
least it takes out a huge operations cost, especially for smaller companies).
But I get that it's not true 'servless' in compared to lambda etc.

