  Functional programming typically emphasizes programming with first-class
functions and immutable data. Immutable data types enable fault tolerance in
distributed systems, and ensure process isolation in message-passing
concurrency, among other applications. However, beyond the distinction between
reassignable and non-reassignable fields, Scala's type system does not have a
built-in notion of immutability for type definitions. As a result, immutability
is "by-convention" in Scala, and statistics about the use of immutability in
real-world Scala code are non-existent.
  This paper reports on the results of an empirical study on the use of
immutability in several medium-to-large Scala open-source code bases, including
Scala's standard library and the Akka actor framework. The study investigates
both shallow and deep immutability, two widely-used forms of immutability in
Scala. Perhaps most interestingly, for type definitions determined to be
mutable, explanations are provided for why neither the shallow nor the deep
immutability property holds; in turn, these explanations are aggregated into
statistics in order to determine the most common reasons for why type
definitions are mutable rather than immutable.
