'프로그래밍'에 해당되는 글 23건

아래 코드를 보자. 

let total = 0;
let item = [
    {name : '새우깡', price: 100},
    {name : '고래밥', price: 200},
    {name : '꼬북칩', price: 300},
    {name : '하이트맥주', price: 400},
];

const addItem = (name, price) => {
    item.push({
        name : name,
        price : price
    });
}


addItem('땅콩', 400);

이전 글과 같은 이유로, addItem 은 액션이다. 

 - 암묵적 입/출력이 존재

 - 실행 시점 및 횟수에 영향을 받음

위를 "계산" 으로 바꾸려면 

 - 암묵적 입/출력을 명시적 입/출력으로 변경 

 - 실행 시점 및 횟수에 영향이 없도록 변경 

이전 글 처럼, 먼저 암묵적 입/출력을 명시적 입/출력으로 바꿔보면

let total = 0;
let item = [
    {name : '새우깡', price: 100},
    {name : '고래밥', price: 200},
    {name : '꼬북칩', price: 300},
    {name : '하이트맥주', price: 400},
];

const addItemCalc = (items, name, price) => {
    items.push({
        name : name,
        price : price
    });
    
    return items;
}

item = addItemCalc(item, '땅콩', 400);

console.log(item);

 명시적 입/출력으로 변경하였다. 암묵적 입/출력 문제가 사라진 듯 하지만, 암묵적 출력 문제는 존재한다.  

문제는 items 파라미터는 '참조' 로 전달이 되기 때문에, 함수 내 변경사항이 원본에 적용이 된다.

// items 파라미터는 참조로 전달된다, 즉 items 에 뭔가를 추가한다면,
// 파라미터로 전달된 원본도 같이 변경된다. 
// return 값이 존재하지만, 암묵적 출력은 여전히 남아있다.
const addItemCalc = (items, name, price) => {
    items.push({
        name : name,
        price : price
    });
    
    return items;
}

함수의 실행이, 함수 외부의 변수와 '완벽하게' 차단된다면 부수효과(side effect) 억제효과도 있고, 그만큼 테스트와 유지보수 용이성도 증가할 것이다. 

해결방법 중 하나는 '복사본 리턴' 이다. 

const addItemCalc = (items, name, price) => {
    let result = items.slice(); //여기서 복사본을 만든다.
    result.push({
        name : name,
        price : price
    });
    
    return result;
}

복사본을 만든 후, 배열을 변경 하고, 그 후에 변경된 배열을 리턴한다. 

위와같이 구현하면, 큰 자료구조라 하더라도, 조작 시, 로직과 데이터를 완벽하게 분리 해낼 수 있다. 

결론

동작을 계산으로 바꾸는 첫번째 방법 - 변경시에는 복사본을 사용하고 변경된 데이터를 리턴하라.

추가

- 객체 복사 시 성능 이슈가 있을 것이라 생각되는 분이 많을 듯 하다. 자바스크립트에서는 복사 시 기본적으로 얕은복사를 사용하고, 깊은 복사는 loadsh 등의 라이브러리를 사용하여 처리한다. 성능상의 이슈는 그리 크지 않은것으로 보이며, 필요할 경우에만 깊은 복사를 사용하면, 발생할 수 있는 성능상의 이슈를 줄일 수 있을 것이다. 

  참고 : https://jess2.xyz/JavaScript/copy/

아래 코드를 보자, 동작(Action) 이 있는 코드다.

let total = 0;
let item = [
    {name : '새우깡', price: 100},
    {name : '고래밥', price: 200},
    {name : '꼬북칩', price: 300},
    {name : '하이트맥주', price: 400},
];

const getTotalAmount = () => {
    for(let i = 0; i < 4; i++) {
        total += item[i].price;
    }
    console.log(`total: ${total}`)
};


getTotalAmount();

getTotalAmount 는 total에 item 배열의 price 값을 모두 더하는 간단한 함수.

위 코드에서 getTotalAmount 의 특징은 

1. 암묵적인 입/출력이 있다. 

  - 암묵적 입력 : item

  - 암묵적 출력 : total

2. 실행 횟수와 시점에 영향을 받는다. 

  - getTotalAmount 를 두번 호출한다면 item 배열의 요소를 두번 순회, total 값은 2000 이 된다. 

때문에, getTotalAmount 는 '동작' 이고, getTotalAmount 의 유지보수 및 테스트를 위해서는 코드 전체를 확인한 후, 

item 과 total 의 값 변경에 신경쓰며 작업해야한다.

작은 프로젝트에서야 저렇게 하는게 빠르고, 신경쓸 부분도 적기 때문에 상관이 없지만, 

프로젝트가 증가하고, 같이 일할 사람들이 생길수록 저런 부분은 복잡성을 증가시키고, 여러 개발자들이 같은 작업을 계속하게된다.

(암묵적 입/출력 분석 및 상태 변경 처리 등...)

위 코드에서 암묵적 입/출력을 명시적 입/출력으로만 변경하여도, 유지보수 시 작업의 복잡도를 줄일 수 있다.

//getTotalAmountCalc 의 계산버전
const getTotalAmountCalc = (itemList) => {
    let result = 0;
    for(let i = 0; i < 4; i++) {
        result += itemList[i].price;
    }
    return result;    
}

getTotalAmountCalc 함수가 갖는 특징 

1. 명시적인 입/출력이 생김 

  - 입력: itemList

  - 출력: result 

2. 실행 횟수와 시점의 영향을 받지 않음 

  - 100 번을 실행해도 itemList 가 같으면 항상 같은 값이 출력됨 

위 1,2 번의 특징으로 인해 갖는 장점 

1. 코드 테스트 부하가 상대적으로 감소 

  - 입력값에만 영향을 받으므로, 개발자가 원하는 특정 상황에서 테스트 가능

2. 유지보수 시 공수 감소 

  - 문서에는 '입력' 과 '출력' 타입 및 동작만 기술하면, 이후 개발자는 입출력만 신경써서 개발하면 된다.

    (정 못믿겠으면, 개발 전에 테스트용 입력값 갖고 테스트만 하면됨.)

위 1,2 번의 특징으로 인해 갖는 단점 

1. 코드량 증가 

  - 함수 첫부분 선언코드, 마지막의 return 코드 

2. 메모리 추가사용 

  - 함수 안의 지역변수 선언, 지금은 작은 사이즈라 상관없지만, 크기가 자꾸 커지면???

단점이 없지는 않지만, 향후 정리할 '얕은 복사' 와 '방어적 복사' 등을 사용하고, 

요즘 GC 들은 많은 부분에서 최적화가 이루어지고 있기 때문에, 기가바이트 급의 대용량이 아니라면, 

저 단점들은 '투자' 의 개념으로 생각하는게 좋지 않을까 한다. 

결론

동작을 계산으로 바꾸는 첫번째 방법 - 입/출력을 명시적으로 선언하라

  => 비지역 변수 read 는 함수의 파라미터로, 비지역변수 write 는 함수의 리턴값으로 바꿀 것.

코드는 세가지 종류로 구분할 수 있다.

1. 동작(Action) 

  - 실행 시간과 횟수에 영향을 받음

  - 같은 코드라 해도, 나오는 결과가 다를 수 있다. 

  - ex) 메일을 보내는 코드, DB 에 기록하는 코드

  - 명시적 입/출력(함수 파라미터, 리턴값)과 암묵적 입/출력이(전역변수, 객체변수 등의 비지역변수) 섞여있음

2. 계산(Calculation)

  - 입/출력이 모두 명시적입 

  - 출력값은 입력값에 대해서만 영향을 받음

  - 입력값이 같으면 항상 같은 값을 출력함

3. 데이터 

  - 이벤트 실행의 결과, 

  - 우리가 흔히 아는 변수(리스트, 값 등...)

소프트웨어 개발에서 '액션' 이 갖는 특징 

1. 구현 / 설계가 상대적으로 용이함 

  - C/C++, JAVA 구현하듯이 절차적으로 구현하면 됨 

2. 유지보수 및 테스트의 어려움 

  - 소프트웨어 규모가 증가할수록 많은 암묵적 입력이 존재(복잡성이 증가함) 

  - 테스트 자동화 진행 시, 모든 암묵적 입력값을 설정해줘야 함.

소프트웨어 개발에서 '계산' 이 갖는 특징 

1. 구현의 상대적인 까다로움

  - 초반 적응의 어려움 (방어적 복사 등... )

2. 유지보수 및 테스트의 상대적인 용이함 

  - 입력값이 같으면 출력값 또한 같다. (-> 유닛 테스트 용이)

때문에, 소프트웨어 개발 시, '액션' 의 갯수는 최소화하고, 가능하면 '계산' 을 사용하는게

유지보수에 편할 수 있음.

Akka 코딩 공작소 예제중에

ScalaTest 3.2.0 과는 다른 부분이 있어 기록해둠.

원래 코드는 아래와 같다.

import org.scalatest.{WordSpecLike, MustMatchers}
import akka.testkit.TestKit
import akka.actor._

//This test is ignored in the BookBuild, it's added to the defaultExcludedNames

class SilentActor01Test extends TestKit(ActorSystem("testsystem"))
  with WordSpecLike
  with MustMatchers
  with StopSystemAfterAll {
  // Commented to make the travis build pass, this is the original test in the book
  "A Silent Actor" must {
    "change state when it receives a message, single threaded" in {
      //Write the test, first fail
      fail("not implemented yet")
    }
    
    "change state when it receives a message, multi-threaded" in {
      //Write the test, first fail
      fail("not implemented yet")
    }
  }
}

ScalaTest 3.2.0 에서는 객체들 이름이 변경되었다, 자세한 내용은 아래 링크를 참고바란다.

www.scalatest.org/release_notes/3.2.0

예제 코드의 변경사항만 적어보자면,

WordSpecLike -> AnyWordSpecLike 로 변경 (org.scalatest.wordspec.AnyWordSpecLike 패키지 사용)

MustMatchers -> Matchers 로 변경 (org.scalatest.matchers.must.Matchers 패키지 사용)

두가지다, 이부분을 적용해보면,

class SilentActor01Test extends TestKit(ActorSystem("testsystem"))
  with AnyWordSpecLike /*scalatest 3.2.0 에서 변경*/
  with Matchers /*scalatest 3.2.0 에서 변경*/
  with StopSystemAfterAll {

  "A Silent Actor" must {

    "change state when it receives a message, single threaded " in {
      //Write the test, first fail
      fail("not implemented yet")
    }

    "change state when it receives a message, multi-threaded" in {
      //Write the test, first fail
      fail("not implemented yet")
    }
  }
}

이렇게 된다. 빌드도 정상적으로 된다.

참고들 하시길.

Blender 상에서 아래와 같은 구조로 되어있을 때,  

getObjectByName 함수를 사용하면 각 객체들 (Mesh, Object3D, Camera, Light 등등) 을 불러올 수 있다. 

하지만 Animation 의 경우는 읽어오질 못하는듯.... 혹시 읽는 방법 아시는분 댓글로 공유 부탁드립니다.

Slick 으로 DB CRUD 를 해보고 있는데

DateTime 을 읽을 때 아래와 같은 오류가 난다.

java.time.format.DateTimeParseException: Text '2019-07-24 00:00:00' could not be parsed at index 10

"scala slick date" 키워드로 구글링 검색 결과, Slick 3.3.2 Upgrade Guide 가 나온다.  일단 들어가본다

https://scala-slick.org/doc/3.3.2/upgrade.html

사용중인 DBMS 는 mySQL.

Upgrade Guide 의 slick.jdbc.MySQLProfile 부분에 보면 DateTime -> LocalDateTime 으로 Parsing 될 때 

어떤 타입의 Texts를 읽는지 나온다. 

java.time.LocalDateTime TEXT '2019-02-03T18:20:28.661'

즉 yyyy-mm-dd'T'hh:MM:ss 형태로 있어야 하는데, T 가 없어 10번째 인덱스를 로딩하는중에 에러가 났던 것.

DB 를 바꾸긴 힘들고, Slick 로딩부분을 수정할 방법을 찾는다. 

Upgrade Guide 에서 제공하는 링크를 참고하여 코드 수정 시작 

(참고 : https://github.com/d6y/instant-etc/blob/master/src/main/scala/main.scala#L9-L45)

import java.sql.ResultSet
import java.time.LocalDateTime
import java.time.format.DateTimeFormatter

trait NewMySQLProfile extends slick.jdbc.JdbcProfile with slick.jdbc.MySQLProfile {
  override val columnTypes = new JdbcTypes
  class JdbcTypes extends super.JdbcTypes {
    override val localDateTimeType : LocalDateTimeJdbcType = new LocalDateTimeJdbcType {
      override def getValue(r: ResultSet, idx: Int) : LocalDateTime = {
        val pattern = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")
        r.getString(idx) match {
          case null => null
          case iso8601String => LocalDateTime.parse(iso8601String, pattern)        }
      }
    }
  }
}

object NewMySQLProfile extends NewMySQLProfile

코드는 전부 올려두었으니, 분석은 이거 읽는분이 알아서... 

그리고 Slick 의 코드에 

import slick.jdbc.MySQLProfile.api._ 

이 부분을 

import NewMySQLProfile.api._ 

로 바꾸면 된다. 패키지 & 클래스명은 자기의 패키지에 맞게 수정하시길.

1. 빌드 툴 

 - SBT, 스칼라는 라이브러리 의존성 및 빌드를 위해 SBT 를 사용, 자세히 까지는 아니어도, 대략적으로라도 알고 있어야 함 

   https://github.com/sbt/sbt

2. Typesafe Config 

 - 스칼라에서는 환경 설정등을 읽어들이기 위해 Typesafe 를 사용함, resources 안에 application.conf 를 넣어서 관리하거나, 다른 방법으로 관리할 수 있음.

    https://github.com/lightbend/config

3. 그 밖의 라이브러리 & 프레임워크 

 - cats : 이런저런 일을 해주는 라이브러리 

 - slick : DB 접근 라이브러리 

 - play framework : 웹 서버 프레임워크

 - akka : actor 기반 작업용 프레임워크 

기본기를 잘 쌓자. typesafe 부터 반복연습

1. 액터 

  - 각자의 특정 작업을 수행, 각자의 Queue 를 갖고있고 dequeue 한 후 작업을 수행 

2. Supervisor 

  - 액터들의 상태를 감시하는 액터. 계층상 상위에 있는 액터는 슈퍼바이저가 된다. 

3. 테스트 

  - SilentActor -> 메세지를 받기만 하고 외부로 아예 안내보내는 액터, underlyingActor 으로 접근해 확인하거나 , expectMsg 함수호출해서 확인한다. 

  - SendingActor -> 받은 메시지를 다른 액터에 보낼 때 사용하는 방법, expectMsgPF 사용한다. 

  - SideEffectActor -> Side Effect 가 있는경우 사용 (가령 함수 내에서 로그 메시지를 출력한다거나..), 리스너를 사용할 수 있다. 

4. 내고장성 

  - 액터에 여러가지 문제가 생겼을 때, 어떻게 작동할 지 설정할 수 있다. 

  - 재시작, 종료, 진행, 위로전달 전략을 설정할 수 있으며, OneForOneStrategy 는 한개의 액터에만, AllForOneStrategy 에는 자기 휘하의 모든 액터를 종료한다.

코세라 스칼라 강좌 4.4 Variance 중.

Typing Rules for Functions 

If A2 <: A1 and B1 <: B2 then

    (A1 => B1) <: (A2 => B2)

뭔 소린지 전혀 몰라서 수시간을 고민해보다가 stackoverflow 보고 이해 

원문 주소는 https://stackoverflow.com/questions/41098105/subtyping-between-function-types 여기

내가 이해한 방식으로 정리한다. 

1. subtype 이다? 

  - subtype 이란건 'a 는 b 이다' 의 is - a 관계가 성립하는거.

2. (A1 => B1) <: (A2 => B2) 임을 증명하려면 

  - '(A1 => B1) 함수(이하 F1)는  (A2 => B2) 함수(이하 F2)다' 가 증명되면 됨.

'F1 는 F2 이다 ' 가 true 가 되려면 필요한 규칙은 

F2(a) 를 F1(a) 로 바꿔도 에러 없이 정확한 값이 나와야 한다는 소린데(리스코프의 치환 원칙), 이소리는 즉

1. F2 의 모든 input 이 F1 에서 에러가 없어야 함

2. F1 의 모든 output 이 F2 의 output 이 되어야 함

저 규칙에 맞나 보면 

1. F2 의 모든 input 이 F1 에서 에러가 없어야 함

  -> 만족한다. A2(F2 의 input) <: A1 (F1 의 input) 이기 때문에, A2 는 A1 의 부분집합이고, A2의 모든 원소는 A1 이다.

2. F1 의 모든 output 이 F2 의 output 이 되어야 함 

  -> 만족한다. B1(F1 의 output) <: B2(F2 의 output) 이기 때문에 B1 은 B2 의 부분집합이고, B1 의 모든 원소는 B2 이다.

이 때문에 'F1 은 F2 이다' 는 참이고, F1 은 F2 의 subtype 이다.

맞나 이거? 

다시 한번 복습 

A <: B 이고 C[A] <: C[B] 인걸 Covariant

A <: B 이고 C[A] >: C[B] 인걸 Contravariant

Contravariant 는 주로 함수를 파라미터로 넘길 때 일어난다고 이야기 함.

이걸 그림으로 다시 생각 해보자, 일단 아래와 같은 클래스가 있다. 

class Animal {}

class Bird extends Animal {}
class Chicken extends Bird {}
class Duck extends Bird {}

이걸 밴 다이어 그램으로 그려보면 아래와 같이 된다.

이제 함수를 선언해보자. 

object HelloWorld {
  type FunctorType[A] = (A => String) //함수타입 한개 선언

  val animalFunc : FunctorType[Animal] = { a => "Animal" }
  val birdFunc : FunctorType[Bird] = { a => "Bird" }
  val chickenFunc : FunctorType[Chicken] = { a => "Chicken"}
  val duckFunc : FunctorType[Duck] = { a => "Duck"}
}

위의 밴 다이어 그램을 보면서 다시 정리해보자 

Animal >: Bird 이면, FunctorType[Animal] 과 FunctorType[Bird] 의 관계는?

FunctorType[Animal] 을 풀어보면 Animal => String 이고, 

FunctorType[Bird] 을 풀어보면 Bird => String 인데, 

위의 벤 다이어그램에서 보면, Bird 는 Animal 의 부분집합 이니까, 모든 Bird 는 Animal 이다. 따라서, 

FunctorType[Bird]  는 Bird => String 도 될 수 있고, Animal => String 도 될 수 있다. 

때문에, FunctorType[Animal] <: FunctorType[Bird] 이 되고, 

FunctorType 은 contravariant 가 된다... 

코세라 강의 보는 중에 

A <: B 이고 C[A] <: C[B] 인걸 Covariant 

A <: B 이고 C[A] >: C[B] 인걸 Contravariant 라고 한다.

Covariant 는 이미 알고있는 거고,

Contravariant 가 무슨소린지 도저히 모르겠어서, 구글링... 하다가 하나 발견... 4시간에 걸쳐 겨우 이해하고, 정리글을 남긴다. 

아래와 같이 클래스들이 있고, 함수 타입 한개를 선언한다.

그리고 몇가지 함수들을 선언한다.

class Animal {}

class Bird extends Animal {}
class Chicken extends Bird {}
class Duck extends Bird {}

object HelloWorld {
  type FunctorType[A] = (A => String) //함수타입 한개 선언

  val birdFunc : FunctorType[Bird] = { a => "Bird" }
  val animalFunc : FunctorType[Animal] = { a => "Animal" }
  val chickenFunc : FunctorType[Chicken] = { a => "Chicken"}
  val duckFunc : FunctorType[Duck] = { a => "Duck"}
}

이경우 클래스 관계는 

Animal <- Bird <- Chicken

Animal <- Bird <- Duck

이런 형식으로 된다. 다들 알다시피 

하지만 함수 아래와 같이 함수가 파라미터로 전달 될 때도, 다형성이 그대로 유지될까?

def test_contravariant(a: FunctorType[Bird]): Unit = {
    val ret1 = a(new Chicken);
    println(ret1)
    val ret2 = a(new Bird);
    println(ret2)
}

test_contravariant(animalFunc) 
test_contravariant(birdFunc) 
test_contravariant(chickenFunc)  //컴파일에러
test_contravariant(duckFunc)     //컴파일에러

맨 처음 봤을때는 의외의 결과였다. 그 전에 C++ JAVA 에서 써왔던 것과 반대로 나타났기 때문이다. 

내친김에 covariant 도 테스트 해본다. 

def test_covariant(a: Bird) : Unit = {
    println(a.toString)
}

예상한대로 결과가 나온다.

test_covariant(new Animal)  //컴파일에러
test_covariant(new Bird)      
test_covariant(new Chicken)
test_covariant(new Duck) 

클래스 상속과 관련해서 생각을 다시 정리해본다. 

"

슈퍼클래스의 참조로 하위클래스의 객체를 생성하거나 파라미터로 전달해도 문제가 없는 이유는, 

하위클래스라고 해서 있던 public 함수/변수가 없어지거나 하지 않기 때문이다.

"

그리고 contravariant 예제를 다시한번 본다.

val animalFunc : FunctorType[Animal] = { a => "Animal" }
val birdFunc : FunctorType[Bird] = { a => "Bird" }
val chickenFunc : FunctorType[Chicken] = { a => "Chicken"}
val duckFunc : FunctorType[Duck] = { a => "Duck"}

def test_contravariant(a: FunctorType[Bird]): Unit = {
    val ret1 = a(new Chicken);
    println(ret1)
    val ret2 = a(new Bird);
    println(ret2)
}

test_contravariant 의 파라미터로 chickenFunc 나 duckFunc 를 넘기게 되면, 

Chicken 클래스에는 있는 public 함수지만, Bird 클래스에는 없는 public 함수가 있을 수 있다.

Duck 클래스에는 있는 public 함수지만, Bird 클래스에는 없는 public 함수가 있을 수 있다.

하지만 animalFunc 을 test_contravariant 로 넘기게 되면,

Animal 클래스에 있는 모든 public 함수는 Bird 클래스에 있다.

이때문에 FunctorType[슈퍼클래스] 에 대해서는 다형성이 일어나지만,

FunctorType[하위클래스] 에 대해서는 다형성이 일어나지 않는다. 

즉, 상속 관계가 역전이 된다. 

이런 경우가 A <: B 이고 C[A] >: C[B] 이며, 

이를 contravariant 라고 부른다. 

play framework로 이런저런 작업과 스칼라 관련 모임에서 코드를  보는 와중에 

implicit 키워드가 눈에 자주 보인다. 

나중에 혼란스러워 하지말고 미리 정리.

- implicit parameter 

(참고 : https://docs.scala-lang.org/ko/tutorials/tour/implicit-parameters.html.html

먼저 메인 클래스를 선언한다.

object HelloWorld {
  def main(args: Array[String]): Unit = {
    println("hello, world!")
  }

  def testFunction(name : String)(implicit liveObject : LiveObject) : Unit = {
    println("I am " + name)
    liveObject.introduce();
  }
}

간단하다, Hello, world 문자열하나만 보여준다. testFunction 은 implicit 파라미터로 LiveObject 를 사용중이다.

testFunction 은 지금 당장은 사용하지 않으니 "이런게 있구나" 수준으로 넘어가자.

trait의 내용은 아래와 같다. 

trait LiveObject {
  def introduce() = {
    println("I am LiveObject")
  }
}

이제 LiveObject 를 믹스인한 클래스 두 개를 생성한다.

class Animal extends LiveObject {
  override def introduce(): Unit = {
    println("I am Animal")
  }
}

class Human extends LiveObject {
  override def introduce(): Unit = {
    println("I am Human")
  }
}

간단하다 introduce 를 재정의 해서 문자열 하나만 다르게 재정의 했다.

준비작업은 모두 끝났다. 이제 main 함수 내에서 testFunction 을 호출을... 했는데? 어라? 에러가 있네?

에러 내용을 자세히 보면 

직접 넣어줄 수는 있다.. 근데 이건 '암시적' 아닌 것 같아 다른 방법을 찾아본다.

바로 위에 Animal 변수를 하나 추가해준다.. 이러면 돌아가겠지.

object HelloWorld {

  def main(args: Array[String]): Unit = {
    println("hello, world!")
    val animal = new Animal
    testFunction("thomas")
  }

  def testFunction(name : String)(implicit liveObject : LiveObject) : Unit = {
    println("I am " + name)
    liveObject.introduce()
  }
}

여전히 에러가 난다. 

암시적 파라미터 관련 스칼라 문서를 다시 읽어보면... 

스칼라 컴파일러는 implicit 파라미터를 만났을 때, 실제 파라미터에 할당할 변수를 검색하는데 규칙은 다음과 같다. 

1. 메서드가 호출되었을 때, prefix 없이 접근할 수 있는 변수 (당연히 변수들은 implicit 키워드가 붙어야 함.)

2. implicit 키워드가 붙은 암시적 파라미터와 관련된 모든 멤버 

2번은 조금 어려우니 일단 1번부터, 암시적 파라미터를 설정하려면 implicit 을 붙여야 한다. 변수를 implicit 으로 변경해서 다시.

object HelloWorld {
  def main(args: Array[String]): Unit = {
    println("hello, world!")
    implicit val animal = new Animal
    testFunction("thomas")
  }

  def testFunction(name : String)(implicit liveObject : LiveObject) : Unit = {
    println("I am " + name)
    liveObject.introduce()
  }
}

이번엔 실행이 제대로 된다.

  hello, world!
  I am thomas
  I am Animal
  Process finished with exit code 0

암시적 변수 / 함수를 선언하려면 implicit 키워드를 사용하여 선언해야 정상적으로 인식하는듯

그러면 이번에 같은 type 을 두 개 넣으면 어떻게 될까? 

def main(args: Array[String]): Unit = {
    println("hello, world!")
    implicit val animal = new Animal
    implicit val human = new Human
    testFunction("thomas")
}

실행 해보니 아래와 같은 Exception 이 발생한다. 

머릿속에 어느정도 그림이 그려진다. 

implicit 파라미터는 "함수가 호출 된 타이밍" 에 prefix 없이 접근 가능한 변수 중 "가장 가까운 변수 " 가 할당되다 라고 이해하면 빠를듯.

다음번엔 implicit function 을 좀 더 봐야겠다.

2019년 11월 18일 추가 

변수의 scope 가 다를경우 같은 타입의 implicit 의 선언이 가능하다. 이 경우에 가장 최근에 선언된 implicit 변수가 사용된다.

object HelloWorld {
  def main(args: Array[String]): Unit = {
    println("hello, world!")
    implicit val human = new Human
    overlapfunction()
  }

  def overlapfunction()(implicit liveObject : LiveObject) : Unit = {
    implicit val animal = new Animal
    testFunction("thomas")
  }

  def testFunction(name : String)(implicit liveObject : LiveObject) : Unit = {
    println("I am " + name)
    liveObject.introduce()
  }
}

위 코드를 실행하면 아래와 같은 결과가 나온다.

hello, world!
I am thomas
I am Animal

다음에 다시 정리할 예정입니다.

Amazon AWS EC2 에서(OS : Ubuntu Linux) Tomcat을 사용 하여 S3 에 접근하려 할 때, 오류 발생 

오류 정보는 

Unable to load AWS credentials from any provider in the chain 

credential 정보는 이미 ~/.aws/credential 에 있는 상태 

여러번의 시도 끝에 아래 경로에 넣으니 일단 정상 작동 

/usr/share/tomcat7/.aws/config

다 끝난줄 알았으나, 톰캣 로그에 경고 표시 

WARN : com.amazonaws.profile.path.cred.CredentialsLegacyConfigLocationProvider - Found the legacy config profiles file at [/usr/share/tomcat7/.aws/config]. Please move it to the latest default location [~/.aws/credentials].

왜이러나... 

일단 tomcat 의 HOME 이 /usr/share/tomcat7/ 로 지정되어있어서 그런 듯 보이나... 

경고 한줄 뜨는게 살짝 성가시다. 

왜 이렇게 되는지는 천천히 생각해보자.

1. bootstrap 

  -  http://getbootstrap.com/

  - html 요소를 좀 더 예쁘게 만들어 줌 

2. 날짜선택 시 달력기능

  - http://www.daterangepicker.com/#options

  -  bootstrap 기반, 달력 선택 기능 제공

3. 파일 업로드 기능 

 - http://markusslima.github.io/bootstrap-filestyle/

 - 파일 업로드 태그의 커스터마이징을 도와줌

Play framework 버전 2.5.x 에서 구현한 내용입니다. 

Play Framework 로 DB 연동할 때 주로 사용하는 도구 Slick

에러 처리 관련하여 API 문서를 뒤져 알아낸 사실들 정리

로그인 처리를 위해 Account 테이블에 쿼리를 날리는 함수 등록 

def verifyPassword[A, B](account : String, password : String) = {

  db.run {

    accounts

      .filter(record => record.account === account && record.password === password)

      .map(_.userName)

      .result

  }

}

그리고 Controller 에서 verifyPassword 호출

val loginData = request.body

ac.verifyPassword(loginData.account, loginData.password).map {

  a => if (a.nonEmpty) Ok(a.toString) else Ok("NoUser")

}

에러사항 없이 잘 돌아간다.... 근데 항상 좋은일만 생길일은 없는 법

PK 가 겹칠수도 있고

DB 서버가 맛이 가, 커넥션이 끊길수도 있고

트래픽이 많이 몰려 타임아웃이 날 수도 있고 

테이블 이름을 잘못 써 오류가 날 수도 있다.

그때마다 Play framework 는 에러를 적나라하게 보여준다. 

에러 발생 시, 적나라하게 보여준다.

 쪽팔림을 막고, 행여나 터질 보안이슈를 대비해 저런 에러들을 수정해보자.

 일단 구글에서 Slick error handling 으로 검색, 

http://slick.lightbend.com/doc/3.1.0/dbio.html  여기를 보면 아래와 같이 써있다. 

Note

For even more flexible error handling use asTry and failed. Unlike with andFinally and cleanUp the resulting actions cannot be used for streaming.

좀 더 유언하게 에러 처리를 하려면 asTry 랑 failed 를 사용해라...

일단 asTry 부터, asTry는 맨 마지막에 .asTry만 추가해주면 된다. 자세한 내용으 API 문서 참고 바람.

def verifyPassword[A, B](account : String, password : String) = {

  db.run {

    accounts

      .filter(record => record.account === account && record.password === password)

      .map(_.userName)

      .result

      .asTry

  }

}

그리고 호출부에서 결과 처리부분을 추가한다. 

val loginData = request.body

ac.verifyPassword(loginData.account, loginData.password).map {

  _ match {

    case Success(a) => if (a.nonEmpty) Ok(a.toString) else Ok("NoUser")

    case Failure(t) => Ok("Failure!!")

  }

}

테스트... 해보면 의도했던 화면들이 나온다.... 

마지막으로, 

에러처리를 위해 failed 를 쓰라고 했는데... 이건 어떻게 쓰는지 다음에 찾아봐야겠다.

람다 대수 관련 자료를 찾아보면 다음과 같은 규칙이 있다. 

(x, y -> ax + by) 는 (x -> y -> ax + by) 형태로 바꿀 수 있으며 이를 커링 이라고 한다. 

Scala 를 공부하면서 가장 많이 접하는 형식인데, 지금까지 내가 쓰고있던 명령형 언어들(C/C++) 과는 형식이 많이 달라 혼란스러웠지만, 이제 머릿속으로 정리되는 듯 하여 글로 남긴다. 

대체 커링은 왜 쓰는 것인가?

Scala 공부하는 내내 '커링 이걸 대체 왜 쓰고, 어디다가 쓰는 것인가?' 란 생각이 가장 많이 들었고 오늘에서야 그 답을 찾았다. 행여나 이 글을 읽는 분께는 아래 설명이 '절대적인 정답' 이 아닌 '쓰임새 중 하나' 로 이해하시길 바란다. 

쓰임새 중 하나 : 디폴트 파라미터에 적용할 수 있다. 

우선 C++ 코드를 보자, 공간이 없어 full code 는 올리지 않겠다.

(나중에 시간이 나면 gut hub 같은데 올릴수도..)

int Adder(int num1=1, int num2=2)
{
  return num1+num2;
}

쉽게 알 수 있듯 파라미터로 넘어온 num1 과 num2 의 합을 리턴해주는 코드다.

위 C++코드엔 몇가지 제약사항이 있다. 

1. default 파라미터 뒤에, default 가 아닌 파라미터가 오면 안된다. 

  =>int Adder(int num=1, int num2 = 2, int num3) 은 안된다는 소리다(컴파일에러)

2. 매개변수가 주어지지 않을 때, default 파라미터는 왼쪽 변수부터 적용이 된다.

  => Adder(3) 으로 호출이 되었을 때 num1 의 값은 3이고, num2 의 값은 2이다.

  => num1 에는 default, num2에는 4 값을 사용토록 하려면 Adder(1,2) 같은 형태로 호출해야 한다.

Scala 에선 커링을 이용하면 이를 좀 다른 방법으로 사용할 수 있다.

(주, Scala 에서는 언어 차원으로 default parameter를 지원한다. 

링크 :  http://docs.scala-lang.org/ko/tutorials/tour/default-parameter-values )

위의 C++ 코드와 같은 기능을 하는 Scala 함수를 생각해보자 

def Adder(x : Int, y : Int) : Int = x + y

이 함수를 커링하면

def AdderDefaultX(x : Int)(y : Int) : Int = x + y

혹은

def AdderDefaultY(y : Int)(x : Int) : Int = x + y

이렇게 된다.

이후, x 값을 100 이 default  로 정해놓고 싶다면 

val AdderX100 = AdderDefaultX(100)

y 값을 100 으로 정해놓고 싶다면 

val AdderY100 = AdderDefaultY(100)

이렇게 하면 된다. 

위의 예시는 '그냥 이렇게 쓴다' 란 정도로 설명을 해 둔것이고. 

라이브러리 등의 구현(여러명이 같이 작업할 코드들)에서

'이 함수는 불려질 때 반드시 어떤 파라미터가 어떤 값이 되어야 함.' 이 호출 규칙일 때 

위 아래로 주석을 달거나, 문서화를 하기 보다는 

특정 파라미터를 특정 값으로 세팅한 함수(위의 Adder 함수들 같이)로 커링하여 외부에 노출 시킨다면 

안정성이 훨씬 증가할 듯 보인다. 

추신 : 이 글은 절대적인 글이 아니니, 수정사항이나 틀린부분 있으면 언제든지 지적을 부탁드립니다.

일단 http://kr.zeromq.org/page:get-the-software 여기서 파일들을 다운로드 받는다.

(현재 stable 한 버전은 2.1, 개인의 취향에 따라 git Download 도 가능.) 

나의경우, Mac OS X  를 사용중이기 때문에, 압축파일을 통짜로 다운로드 받음.

파일들의 압축을 풀고, 라이브러리 빌드 시작... 

빌드 방법은 홈페이지에 친절하게 되어있음. 

1. libtool, autoconf, automake가 설치되어 있는지 확인하세요
2. uuid-dev 패키지, uuid/e2fsprogs RPM이나 이것과 동등한 것이 시스템에 설치되어 있는지 확인 합니다.
3. .tar.gz 소스아키이브를 풀고
4. make 명령에 의해 ./configure를 실행합니다.
5. ØMQ시스템 전체를 설치하기 위해서 sudo make install을 실행합니다.
6. 리눅스에서 ØMQ를 설치한 후 sudo ldconfig를 실행합니다.

이렇게 하면 usr/local/lib 에 zeromq 의 라이브러리 파일이, 

usr/local/include 에 zeromq 의 헤더파일이 생성된다. 

OS X 의 파일 시스템에 익숙치 못해 똑같은 짓을 몇번 반복... 

여튼 설치는 완료, 다음은 node.js 에서 zeromq 설치

npm install zmq.... 언제나 그렇듯 처음은 에러로 시작 

npm 홈페이지에 가보니 이것저것 설치가 필요하다고 한다. 

zeromq 라이브러리 설치에 필요한건 세개 

1. Zeromq 라이브러리 ( http://zeromq.org/intro:get-the-software )

2. Homebrew 패키지  ( http://brew.sh/index_ko.html )

3. Homebrew 패키지로 pkg-config 다운 (brew install pkg-config 명령어를 터미널에서 입력)

이후 Webstorm 을 켜고, npm install zmq 타이핑

성공이다, 이제 API 문서보고 하나씩 해나가면 된다.