c# barcode generator library open source Keep Methods Short in Font

Print Data Matrix ECC200 in Font Keep Methods Short

Keep methods short. See whether you can code methods in a single line. If not a single line, see whether you can code them in a single statement. If you keep methods short, then the logic in each method is more obvious when you or someone else looks at the code. Let s see how the previous code can be made into single statements:

private def readLines(in: java.io.BufferedReader, acc: List[String]): List[String] = in.readLine match { case null => acc case s => readLines(in, s :: acc) } def read3(in: java.io.BufferedReader): List[String] = readLines(in, Nil).reverse

When I code Scala, I try not to have a curly brace around my method body. If I can t write my code this way, I have to justify to myself why my method should exceed a single statement. Keeping methods short allows you to encapsulate a single piece of logic in a method and have methods that build upon each other. It also allows you to easily understand the logic in the method.

In the beginning, you can write your Scala code as you would your Java code. It s a great place to start. Then, start applying the above rules. Let s go back to our validByAge example from 3 (see Listing 3-3). We ll start with the imperative code:

def validByAge(in: List[Person]): List[String] = { var valid: List[Person] = Nil for (p <- in) { if (p.valid) valid = p :: valid } def localSortFunction(a: Person, b: Person) = a.age < b.age val people = valid.sort(localSortFunction _) var ret: List[String] = Nil for (p <- people) { ret = ret ::: List(p.first) } return ret }

def validByAge(in: List[Person]): List[String] = { val valid: ListBuffer[Person] = new ListBuffer // displaced mutability for (p <- in) { if (p.valid) valid += p } def localSortFunction(a: Person, b: Person) = a.age < b.age val people = valid.toList.sort(localSortFunction _) val ret: ListBuffer[String] = new ListBuffer

for (p <- people) { ret += p.first } ret.toList }

def validByAge(in: List[Person]): List[String] = { val valid = for (p <- in if p.valid) yield p def localSortFunction(a: Person, b: Person) = a.age < b.age val people = valid.sort(localSortFunction _) for (p <- people) yield p.first }

Make your method into a single statement:

def validByAge(in: List[Person]): List[String] = in.filter(_.valid). sort(_.age < _.age). map(_.first)

While you can argue that this is too terse, we can refactor another way:

def filterValid(in: List[Person]) = in.filter(p => p.valid) def sortPeopleByAge(in: List[Person]) = in.sort(_.age < _.age) def validByAge(in: List[Person]): List[String] = (filterValid _ andThen sortPeopleByAge _)(in).map(_.name)

Either of the refactoring choices you make, the business logic of your code is a lot more visible. The refactoring also moves you toward thinking about the transformations in your code rather than the looping constructs in your code.

In the previous example, we composed filterValid and sortPeopleByAge into a single function. This function is the same as this:

(in: List[Person]) => sortPeopleByAge(filterValid(in))

However, the composition of the two functions results in code that reads like what it does. We started by turning our methods into single statements. This makes testing easier and makes the code more readable. Next we compose a new function by chaining the two functions together. Functional composition is a later stage Scala-ism, but it results naturally from making methods into single statements. In 7, we explored how Scala s traits can be composed into powerful, flexible classes that are more type-safe than Java classes. As you evolve your Scala coding skills and begin to refactor classes rather than methods, start looking for common methods across your interfaces and traits. Move methods from concrete classes into traits. Soon, you ll likely find that many of your classes have little in them other than the logic that is specific to that class and the vals that are needed to evaluate that logic. Once you reach this level in your coding, you will likely find that your traits are polymorphic, that your traits represent logic that can be applied to a contained type, and then you can feel secure that your mind has completely warped into thinking Scala. Once you re thinking Scala or thinking that you re thinking Scala, you might want to go hard-core on selling Scala into your organization. The next section provides some talking points for selling Scala. It gives you the benefits of my experience selling new technologies in organizations. Please keep in mind that because it s cool is not a justification for an organization to adopt a new technology. The new technology must solve a problem. However, it s pretty safe to say that most organizations want to make their developers happier and more productive, and Scala provides a great way to achieve those goals.