Here's a legitimate use for swap space -- even in 2016.

  There's  a  Java  program  that runs as a daemon. It requires a medium
  amount of memory. For example, let's say the system has 8GB of RAM and
  the  daemon requires 6GB of it. That's fine. The base system and maybe
  a small database will require some additional  memory,  so  the  total
  memory  usage is about 7GB or something like that. 1GB is left for I/O
  cache.

  Let's say the system runs smoothly now.

  Problem is, you need to be able to cleanly shut down the system.  Said
  Java daemon is an unfriendly one: In order to *shut down*, it needs to
  launch a new Java VM that tells the first VM, "please shut down",  and
  it  *insists*  on  using  the same memory configuration for this task.
  This means it will try to  allocate  *another*  6GB  of  memory,  even
  though it never uses it. Just for shutting down.

  Now,  Linux  does  memory  overcommit by default, which means that the
  kernel will happily tell  the  application,  "here's  your  memory,  I
  allocated  it",  even though it is not necessarily backed up by actual
  memory pages. This means that we *should* be able  to  shut  down  our
  daemon!  It  should  work.  But there are limits to memory overcommit:
  When above a certain threshold of memory usage, Linux will  refuse  to
  do more overcommit. In our scenario, we do have passed that threshold.
  As a result, our shutdown process will get an out of memory error  and
  we can't shut down the daemon. Dang.

  One way to solve this is to add the proper amount of swap space to the
  system. This keeps us *below* the threshold and the  shutdown  process
  can now run. We will never actually use the swap space, it just has to
  be there.

  This daemon exists in real life and so does  its  shutdown  procedure.
  It's a product sold by a big company.

  Next  on  the  TODO  list:  Which  kernel  parameters to tweak? How to
  actually set that threshold? Maybe we can get away without swap.