Why should I avoid using local modifiable variables in Scala?

It's not so related with Scala as with the functional programming methodology in general. The idea is the following: if you have constant variables (final in Java), you can use them without any fear that they are going to change. In the same way, you can parallelize your code without worrying about race conditions or thread-unsafe code.

In your example is not so important, however imagine the following example:

val variable = ...
new Future { function1(variable) }
new Future { function2(variable) }

Using final variables you can be sure that there will not be any problem. Otherwise, you would have to check the main thread and both function1 and function2.

Of course, it's possible to obtain the same result with mutable variables if you do not ever change them. But using inmutable ones you can be sure that this will be the case.

Edit to answer your edit:

Local mutables are not bad, that's the reason you can use them. However, if you try to think approaches without them, you can arrive to solutions as the one you posted, which is cleaner and can be parallelized very easily.

How to iterate over collection then in functional languages like Scala?

You can always iterate over a inmutable collection, while you do not change anything. For example:

val list = Seq(1,2,3)
for (n <- list)
  println n

With respect to the second thing that you said: you have to stop thinking in a traditional way. In functional programming the usage of Map, Filter, Reduce, etc. is normal; as well as pattern matching and other concepts that are not typical in OOP. For the example you give:

Like an example: Suppose we have a list of ints, how to write a function that returns sublist of ints which are divisible by 6?

val list = Seq(1,6,10,12,18,20)
val result = list.filter(_ % 6 == 0)

Firstly you could rewrite your example like this:

def max(first: Int, others: Int*): Int = {
    val curMax = Math.max(first, others(0))
    if (others.size == 1) curMax else max(curMax, others.tail : _*)
}

This uses varargs and tail recursion to find the largest number. Of course there are many other ways of doing the same thing.

To answer your queston - It's a good question and one that I thought about myself when I first started to use scala. Personally I think the whole immutable/functional programming approach is somewhat over hyped. But for what it's worth here are the main arguments in favour of it:

Immutable code is easier to read (subjective)

Immutable code is more robust - it's certainly true that changing mutable state can lead to bugs. Take this for example:

for (int i=0; i<100; i++) {
  for (int j=0; j<100; i++) {
     System.out.println("i is " + i = " and j is " + j);
  }
}

This is an over simplified example but it's still easy to miss the bug and the compiler won't help you

Mutable code is generally not thread safe. Even trivial and seemingly atomic operations are not safe. Take for example i++ this looks like an atomic operation but it's actually equivalent to:

int i = 0;
int tempI = i + 0;
i = tempI;

Immutable data structures won't allow you to do something like this so you would need to explicitly think about how to handle it. Of course as you point out local variables are generally threadsafe, but there is no guarantee. It's possible to pass a ListBuffer instance variable as a parameter to a method for example

However there are downsides to immutable and functional programming styles:

Performance. It is generally slower in both compilation and runtime. The compiler must enforce the immutability and the JVM must allocate more objects than would be required with mutable data structures. This is especially true of collections.

Most scala examples show something like val numbers = List(1,2,3) but in the real world hard coded values are rare. We generally build collections dynamically (from a database query etc). Whilst scala can reassign the values in a colection it must still create a new collection object every time you modify it. If you want to add 1000 elements to a scala List (immutable) the JVM will need to allocate (and then GC) 1000 objects

Hard to maintain. Functional code can be very hard to read, it's not uncommon to see code like this:

val data = numbers.foreach(_.map(a => doStuff(a).flatMap(somethingElse)).foldleft("", (a : Int,b: Int) => a + b))

I don't know about you but I find this sort of code really hard to follow!

Hard to debug. Functional code can also be hard to debug. Try putting a breakpoint halfway into my (terrible) example above

My advice would be to use a functional/immutable style where it genuinely makes sense and you and your colleagues feel comfortable doing it. Don't use immutable structures because they're cool or it's "clever". Complex and challenging solutions will get you bonus points at Uni but in the commercial world we want simple solutions to complex problems! :)

Your two main questions:

1. Why warn against local state changes?
2. How can you iterate over collections without mutable state?

I'll answer both.

Warnings

The compiler warns against the use of mutable local variables because they are often a cause of error. That doesn't mean this is always the case. However, your sample code is pretty much a classic example of where mutable local state is used entirely unnecessarily, in a way that not only makes it more error prone and less clear but also less efficient.

Your first code example is more inefficient than your second, functional solution. Why potentially make two assignments to submax1 when you only ever need to assign one? You ask which of the two inputs is larger anyway, so why not ask that first and then make one assignment? Why was your first approach to temporarily store partial state only halfway through the process of asking such a simple question?

Your first code example is also inefficient because of unnecessary code duplication. You're repeatedly asking "which is the biggest of two values?" Why write out the code for that 3 times independently? Needlessly repeating code is a known bad habit in OOP every bit as much as FP and for precisely the same reasons. Each time you needlessly repeat code, you open a potential source of error. Adding mutable local state (especially when so unnecessary) only adds to the fragility and to the potential for hard to spot errors, even in short code. You just have to type submax1 instead of submax2 in one place and you may not notice the error for a while.

Your second, FP solution removes the code duplication, dramatically reducing the chance of error, and shows that there was simply no need for mutable local state. It's also, as you yourself say, cleaner and clearer - and better than the alternative solution in om-nom-nom's answer.

(By the way, the idiomatic Scala way to write such a simple function is

def max(a: Int, b: Int) = if (a > b) a else b

which terser style emphasises its simplicity and makes the code less verbose)

Your first solution was inefficient and fragile, but it was your first instinct. The warning caused you to find a better solution. The warning proved its value. Scala was designed to be accessible to Java developers and is taken up by many with a long experience of imperative style and little or no knowledge of FP. Their first instinct is almost always the same as yours. You have demonstrated how that warning can help improve code.

There are cases where using mutable local state can be faster but the advice of Scala experts in general (not just the pure FP true believers) is to prefer immutability and to reach for mutability only where there is a clear case for its use. This is so against the instincts of many developers that the warning is useful even if annoying to experienced Scala devs.

It's funny how often some kind of max function comes up in "new to FP/Scala" questions. The questioner is very often tripping up on errors caused by their use of local state... which link both demonstrates the often obtuse addiction to mutable state among some devs while also leading me on to your other question.

Functional Iteration over Collections

There are three functional ways to iterate over collections in Scala

1. For Comprehensions
2. Explicit Recursion
3. Folds and other Higher Order Functions

For Comprehensions

Your question:

Suppose we have a list of ints, how to write a function that returns sublist of ints which are divisible by 6? Can't think of solution without local mutable variable

Answer: assuming xs is a list (or some other sequence) of integers, then

for (x <- xs; if x % 6 == 0) yield x

will give you a sequence (of the same type as xs) containing only those items which are divisible by 6, if any. No mutable state required. Scala just iterates over the sequence for you and returns anything matching your criteria.

If you haven't yet learned the power of for comprehensions (also known as sequence comprehensions) you really should. Its a very expressive and powerful part of Scala syntax. You can even use them with side effects and mutable state if you want (look at the final example on the tutorial I just linked to). That said, there can be unexpected performance penalties and they are overused by some developers.

Explicit Recursion

In the question I linked to at the end of the first section, I give in my answer a very simple, explicitly recursive solution to returning the largest Int from a list.

def max(xs: List[Int]): Option[Int] = xs match {
  case Nil => None
  case List(x: Int) => Some(x)
  case x :: y :: rest => max( (if (x > y) x else y) :: rest )
} 

I'm not going to explain how the pattern matching and explicit recursion work (read my other answer or this one). I'm just showing you the technique. Most Scala collections can be iterated over recursively, without any need for mutable state. If you need to keep track of what you've been up to along the way, you pass along an accumulator. (In my example code, I stick the accumulator at the front of the list to keep the code smaller but look at the other answers to those questions for more conventional use of accumulators).

But here is a (naive) explicitly recursive way of finding those integers divisible by 6

def divisibleByN(n: Int, xs: List[Int]): List[Int] = xs match {
  case Nil => Nil
  case x :: rest if x % n == 0 => x :: divisibleByN(n, rest)
  case _ :: rest => divisibleByN(n, rest)
}

I call it naive because it isn't tail recursive and so could blow your stack. A safer version can be written using an accumulator list and an inner helper function but I leave that exercise to you. The result will be less pretty code than the naive version, no matter how you try, but the effort is educational.

Recursion is a very important technique to learn. That said, once you have learned to do it, the next important thing to learn is that you can usually avoid using it explicitly yourself...

Folds and other Higher Order Functions

Did you notice how similar my two explicit recursion examples are? That's because most recursions over a list have the same basic structure. If you write a lot of such functions, you'll repeat that structure many times. Which makes it boilerplate; a waste of your time and a potential source of error.

Now, there are any number of sophisticated ways to explain folds but one simple concept is that they take the boilerplate out of recursion. They take care of the recursion and the management of accumulator values for you. All they ask is that you provide a seed value for the accumulator and the function to apply at each iteration.

For example, here is one way to use fold to extract the highest Int from the list xs

xs.tail.foldRight(xs.head) {(a, b) => if (a > b) a else b}

I know you aren't familiar with folds, so this may seem gibberish to you but surely you recognise the lambda (anonymous function) I'm passing in on the right. What I'm doing there is taking the first item in the list (xs.head) and using it as the seed value for the accumulator. Then I'm telling the rest of the list (xs.tail) to iterate over itself, comparing each item in turn to the accumulator value.

This kind of thing is a common case, so the Collections api designers have provided a shorthand version:

xs.reduce {(a, b) => if (a > b) a else b}

(If you look at the source code, you'll see they have implemented it using a fold).

Anything you might want to do iteratively to a Scala collection can be done using a fold. Often, the api designers will have provided a simpler higher-order function which is implemented, under the hood, using a fold. Want to find those divisible-by-six Ints again?

xs.foldRight(Nil: List[Int]) {(x, acc) => if (x % 6 == 0) x :: acc else acc}

That starts with an empty list as the accumulator, iterates over every item, only adding those divisible by 6 to the accumulator. Again, a simpler fold-based HoF has been provided for you:

xs filter { _ % 6 == 0 }

Folds and related higher-order functions are harder to understand than for comprehensions or explicit recursion, but very powerful and expressive (to anybody else who understands them). They eliminate boilerplate, removing a potential source of error. Because they are implemented by the core language developers, they can be more efficient (and that implementation can change, as the language progresses, without breaking your code). Experienced Scala developers use them in preference to for comprehensions or explicit recursion.

tl;dr

1. Learn For comprehensions
2. Learn explicit recursion
3. Don't use them if a higher-order function will do the job.

It is always nicer to use immutable variables since they make your code easier to read. Writing a recursive code can help solve your problem.

def max(x: List[Int]): Int = {
  if (x.isEmpty == true) {
    0
  }
  else {
    Math.max(x.head, max(x.tail))
  }
}
val a_list = List(a,b,c,d)
max_value = max(a_list)