Devops 조직에는 주번이라는 제도가 있는데, 영어로 oncall이다. 

이런 주번 시스템을 링크드인에서 사용하고 있는데, 이를 오픈소스로 선보였다.

https://engineering.linkedin.com/blog/2017/06/open-sourcing-iris-and-oncall

https://oncall.tools/

scala에서 Stream은 lazy하게 계산되는 리스트이다. 

Stream에서 concat을 하려면 :: 이 아니라 #::을 사용한다. 

실행 예제이다.

여기서 엄청 큰 수를 넣어도 Stream(1, ?로 나타난다. 

실제 m4s에 매개 변수가 길더라도 lazy라서 아직 계산되지 않았다.

실제 수행되는 시점에 toList를 호출한다.

코세라 강의 중 괜찮은 예제가 있어서 소개한다.

https://www.coursera.org/learn/progfun1/lecture/JIPKx/lecture-6-2-combinatorial-search-and-for-expressions

scala에서 소수를 구하는 isPrime() 

def isPrime(n: Int): scala.Boolean = (2 until n) forall (n % _ != 0)

println(isPrime(2)) // true
println(isPrime(3)) // true
println(isPrime(4)) // false
println(isPrime(5)) // true
println(isPrime(6)) // false
println(isPrime(7)) // true
println(isPrime(8)) // false
println(isPrime(9)) // false

합산이 소수일때만 더하는 집합 예제이다. 

def isPrime(n: Int): scala.Boolean = (2 until n) forall (n % _ != 0)

val result = (1 until 7) flatMap (i =>
  (1 until i) map (j => (i, j))) filter (pair =>
    isPrime(pair._1 + pair._2)
  )

println(result)

결과는 다음과 같다. 

scalaProduct 예제이다. 

def scalarProduct(left: List[Double], right: List[Double]): Double = 
         (for ((x, y) <- left zip right) yield x * y).sum

결과는 다음과 같다. 

스칼라의 forall 표현식 예제이다.

콜렉션에 대해서 forall을 사용하면 모든 Range에 대해서 forall 표현식이 참이라면 true를 리턴한다.

그러나, Range() 에다가 forall을 사용하면 결과 값은 무엇이 될까? 

true이다!!!

scala의 filter류 예제이다. 

filterNot은 filter의 expression의 !과 동일하다.

partition은 filter 와 filterNot을 합친 결과와 동일하다.

결과는 다음과 같다. 

takeWhile과 dropWhile은 처음봤을 때 기억해도 잘 나지 않는데. 다시 해봐야 겨우 기억나는 익숙치 않은(?) api이다.

take는 처음 엘리먼트를 얻는다. 

takeWhile은 take를 기반으로 생각하면 좋다.

takeWhile은 술어함수가 list의 엘리먼트가 참에서 시작해서 거짓이 되는 시점의 엘리먼트를 얻는다. 

span은 takeWhile과 dropWhile를 하나로 결합한 함수이다. 

코세라 Scala 강의 중 MergeSort 예제에서 조금 이해하기 쉽게 분리한 예제이다.

https://www.coursera.org/learn/progfun1/lecture/0uFfe/lecture-5-2-pairs-and-tuples

object MergeSort {
  def merge(left: List[Int], right: List[Int]): List[Int] = (left, right) match {
    case (l, Nil) => l
    case (Nil, r) => r
    case (leftHead :: leftTail, rightHead :: rightTail) =>
      if (leftHead < rightHead) leftHead::merge(leftTail, right)
      else rightHead :: merge(left, rightTail)
  }

  def mergeSort(list: List[Int]): List[Int] = {
    val n = list.length / 2
    if (n == 0) list
    else {
      val (left, right) = list splitAt n
      merge(mergeSort(left), mergeSort(right))
    }
  }
}

결과

Int 타입을 T 타입으로 (order:(T, T) => scala.Boolean)을 추가해서 compare를 할 수 있게 한다.

object MergeSort {
  def mergeSort[T](list: List[T])(order: (T, T) => scala.Boolean): List[T] = {
    val n = list.length / 2
    if (n == 0) list
    else {
      def merge(left: List[T], right: List[T]) : List[T] = (left, right) match {
        case (l, Nil) => l
        case (Nil, r) => r
        case (leftHead :: leftTail, rightHead :: rightTail) =>
          if (order(leftHead, rightHead)) leftHead::merge(leftTail, right)
          else rightHead :: merge(left, rightTail)
      }
      val (left, right) = list splitAt n
      merge(mergeSort(left)(order), mergeSort(right)(order))
    }
  }
}

object Main extends App {
  println(MergeSort.mergeSort(List(100,50,120,19))((x: Int, y: Int) => (x < y)))
  println(MergeSort.mergeSort(List(100,50,120,19))((x: Int, y: Int) => (x > y)))
  println(MergeSort.mergeSort(List("samuel","jack","juno","ben"))((x: String, y: String) => (x.compareTo(y) < 0)))
  println(MergeSort.mergeSort(List("samuel","jack","juno","ben"))((x: String, y: String) => (x.compareTo(y) > 0)))
}

결과는 다음과 같다.

언제나 스칼라는 타입을 숨길 수 있다.

List(100,50,120,19))((x, y) => (x > y))

여기에 math.Ordering을 임포트해본다.

import math.Ordering
object MergeSort {
  def mergeSort[T](list: List[T])(order: Ordering[T]): List[T] = {
    val n = list.length / 2
    if (n == 0) list
    else {
      def merge(left: List[T], right: List[T]) : List[T] = (left, right) match {
        case (l, Nil) => l
        case (Nil, r) => r
        case (leftHead :: leftTail, rightHead :: rightTail) =>
          if (order.lt(leftHead, rightHead)) leftHead::merge(leftTail, right)
          else rightHead :: merge(left, rightTail)
      }
      val (left, right) = list splitAt n
      merge(mergeSort(left)(order), mergeSort(right)(order))
    }
  }
}

object Main extends App {
  println(MergeSort.mergeSort(List(100,50,120,19))(Ordering.Int))
  println(MergeSort.mergeSort(List(100,50,120,19))(Ordering.Int))
  println(MergeSort.mergeSort(List("samuel","jack","juno","ben"))(Ordering.String))
  println(MergeSort.mergeSort(List("samuel","jack","juno","ben"))(Ordering.String))
}

결과는 이전과 동일하다. 

여기에 implicit을 추가해본다. 그리고 implicit을 쓰면 적당히 코드 삭제가 가능하다.

import math.Ordering
object MergeSort {
  def mergeSort[T](list: List[T])(implicit order: Ordering[T]): List[T] = {
    val n = list.length / 2
    if (n == 0) list
    else {
      def merge(left: List[T], right: List[T]) : List[T] = (left, right) match {
        case (l, Nil) => l
        case (Nil, r) => r
        case (leftHead :: leftTail, rightHead :: rightTail) =>
          if (order.lt(leftHead, rightHead)) leftHead::merge(leftTail, right)
          else rightHead :: merge(left, rightTail)
      }
      val (left, right) = list splitAt n
      merge(mergeSort(left), mergeSort(right))
    }
  }
}

object Main extends App {
  println(MergeSort.mergeSort(List(100,50,120,19)))
  println(MergeSort.mergeSort(List(100,50,120,19)))
  println(MergeSort.mergeSort(List("samuel","jack","juno","ben")))
  println(MergeSort.mergeSort(List("samuel","jack","juno","ben")))
}

역시 결과가 동일하다.

function value의 확장은 스칼라의 기초 지식이다. 

https://twitter.github.io/scala_school/ko/basics2.html

apply 개념은 다음 예제를 살펴본다. 

아래 익명 함수(function value)는 아래 익명 클래스로 확장(expand)된다.

또는 

익명 클래스 2) 

coursera의 강의 Functional Programming Principles in Scala 4장 강의 중에 Funtional 언어의 특징을 유난히 보였던 예제가 있어서 끄적거려 봤다..

abstract class Boolean {
  def ifThenElse[T](t: => T, e: => T): T

  def unary_! : Boolean = ifThenElse(False , True)

  def && (x: => Boolean): Boolean = ifThenElse(x, False)
  def || (x: => Boolean): Boolean = ifThenElse(True, x)

  def == (x: Boolean): Boolean = ifThenElse(x, x.unary_!)
  def != (x: Boolean): Boolean = ifThenElse(x.unary_! , x)

  def < (x: Boolean): Boolean = ifThenElse(False, x)
  def > (x: Boolean): Boolean = ifThenElse(x, False)

}

object False extends Boolean {
  def ifThenElse[T](t: => T, e: => T) = e
}

object True extends Boolean {
  def ifThenElse[T](t: => T, e: => T) = t
}

테스트 결과

True.ifThenElse(println("yes"), println("no"))       // yes
False.ifThenElse(println("yes"), println("no"))      // no
(! True).ifThenElse(println("yes"), println("no"))   // no
(! False).ifThenElse(println("yes"), println("no"))   // yes

println
(True && False).ifThenElse(println("yes"), println("no"))  // no
(True && True).ifThenElse(println("yes"), println("no"))  // yes
(False && True).ifThenElse(println("yes"), println("no"))  // no
(False && False).ifThenElse(println("yes"), println("no"))  // no

println
(True == True).ifThenElse(println("yes"), println("no")) // yes
(True && True == True).ifThenElse(println("yes"), println("no")) //yes
(False || True != True).ifThenElse(println("yes"), println("no")) //no

println
(False < True).ifThenElse(println("yes"), println("no")) // yes
(False > True).ifThenElse(println("yes"), println("no")) // no

구글에서 피드백을 보낼때 SBI를 쓴다고 한다.

https://www.mindtools.com/pages/article/situation-behavior-impact-feedback.htm

1. Situation

When you're giving feedback, first define the where and when of the situation you're referring to. This puts the feedback into context, and gives the other person a specific setting as a reference.

2. Behavior

Your next step is to describe the specific behaviors that you want to address. This is the most challenging part of the process, because you must communicate only the behaviors that you observed directly.

3. Impact

The last step is to use "I" statements to describe how the other person's action has affected you or others.

Google 매지저들이 한다는 oxygen project 내용

https://www.thestreet.com/story/12328981/1/googles-project-oxygen-pumps-fresh-air-into-management.html

1. Be a good coach.

2. Empower; don't micromanage.

3. Be interested in direct reports, success and well-being.

4. Don't be a sissy: Be productive and results-oriented.

5. Be a good communicator and listen to your team.

6. Help your employees with career development.

7. Have a clear vision and strategy for the team.

8. Have key technical skills so you can advise the team.