[D2 campus seminar]스칼라를 통한 다양한 언어의 패러다임 맛보기

1. 스칼라를 통한
다양한 언어의 패러다임 맛보기

2. 변하는 것과 변하지 않는 것
• 변하는 것
• 변하지 않는 것

3. 오늘의 목표
• 프로그래밍 언어의 패러다임?
• 스칼라
• 실습

4. 프로그래밍 언어의 패러다임
• 패러다임이란?
• 패러다임의 종류
• 객체지향
• 함수형
• 타입시스템
• 기타

5. 세벌식 자판

6. 객체지향
• 프로그래머들이 프로그램을 상호작용하는 객체들의 집합
으로 보는 시각

7. 함수형
• 상태값을 지니지 않는 함수값들의 연속으로 보는 시각

8. 타입 시스템
• 프로그램 각 부분이 만들어낼 수 있는 값의 종류를 나눔
으로써 그 프로그램이 특정 오류 상황을 발생시키지 않는
다는 것을 자동으로 검증해주기 위한 문법적 검증 방법

9. 프로그래밍 언어
• 좋은 프로그래밍 언어란?
• 프로그래밍 언어의 종류와 역사

10. 좋은 프로그래밍 언어?

11. 실무에서 어떤 언어를 사용하나요?
• Java
• Python
• Ruby
• JavaScript
• DSL
• SQL
• Template Language

12. 코딩하는 시간이 전체 개발에서 차지하는 비율
• CI
• 빌드
• 테스트
• 배포
• 분석
• 테스트
• VCS
• 협업
• 개발 도구
• 문서화
• 적절하게 휴가 쓰는 법

13. 스칼라
• 스칼라 소개
• 선택의 이유
• 스칼라 패러다임과 스타일

14. 스칼라의 탄생
• Martin Odersky

15. 현재…

16. 스칼라

17. Scalability
Functional Object

18. 선택의 이유
• FP and OOP with Java libraries
• 자바 프로젝트의 효율성을 끌어올리기 위해서
• 실용적인 함수형 프로그래밍 언어
• 거쳐가는 언어
• 배울게 많아서
• 스타일을 강제하지 않음
• 우수한 개발자 커뮤니티

19. 학습에 투자할 만한 가치가 있을까?
• 스칼라는 어렵다?
• 스칼라를 배움으로써 얻을 수 있는 것은?

20. 어렵다는 것은?
• 학습에 필요한 기반 지식이 필요하다.
• 외워야 할 것이 많다.
• 생소한 개념을 익혀야 한다.
• 문서나 샘플이 부족하다.

21. 스칼라를 배움으로써 얻을 수 있는 것은?
• More OOP
• Pure Functional
• Be better developer

22. Scala vs Java
• Simple Simple Simple
• More OOP
• Pure Functional

23. // Java
ClassA classA = new ClassA(“myFirstClass”);
ClassB classB = new ClassB(“mySecondClass”);
!
// Scala
val classA = ClassA(“myFirstClass”)
val classB = ClassB(“mySecondClass”)
Simple

24. // Java
List<String> list = new ArrayList<String>();
list.add("1");
list.add("2");
list.add(“3”);
// Arrays.asList("1", "2", "3");
!
!
// Scala
val list = List("1", "2", "3")
Simple

25. // Java
List<String> list = new ArrayList<String>();
list.add("1");
list.add("2");
list.add(“3");
!
!
// Scala
val list = List("1", "2", "3")
Simple

26. // Java
List<Integer> iList = Arrays.asList(2, 7, 9, 8, 10);
List<Integer> iDoubled = new ArrayList<Integer>();
for(Integer number: iList){
if(number % 2 == 0){
iDoubled.add(number 2);
}
}
!
!
// Scala
val iList = List(2, 7, 9, 8, 10);
val iDoubled = iList.filter(_ % 2 == 0).map(_ 2)
Java vs Scala

27. 5 + 3
More OOP

28. Imperative vs Functional (Declarative)
• 퀵소트 알고리즘

29. public void quickSort(int left, int right){
int i,j;
TableEntry p, tmp
if(left<right){
i=left;
j=right;
p=table[left];
while(i<j){
while (table[j].key>p.key) j--;
while (i<j && table[i].key<=p.key) i++;
!
tmp = table[i];
table[i]=table[j];
table[j]=tmp;
}
table[left] = table[i];
table[i]=p;
quickSort(left,i-1);
quickSort(i+1,right);
}
}
Quick sort (Java, Imperative)

30. def sort(xs: Array[Int]) {
def swap(i: Int, j: Int) {
val t = xs(i); xs(i) = xs(j); xs(j) = t
}
!
def sort1(l: Int, r: Int) {
val pivot = xs((l + r) / 2)
var i = l; var j = r
while (i <= j) {
while (xs(i) < pivot) i += 1
while (xs(j) > pivot) j -= 1
if (i <= j) {
swap(i, j)
i += 1
j -= 1
}
}
if (l < j) sort1(l, j)
if (j < r) sort1(i, r)
}
sort1(0, xs.length - 1)
}
Quick sort (Imperative)

31. def sort(xs: Array[Int]): Array[Int] = {
if (xs.length <= 1) xs
else {
val pivot = xs(xs.length / 2)
Array.concat(
sort(xs filter (pivot >)),
xs filter (pivot ==),
sort(xs filter (pivot <)))
}
}
Quick sort (Functional)

32. Python vs Scala

33. Python
• 코드의 의미가 명료하고 간결하다.
• 적절한 함수형 스타일, 절차형 스타일, 객체지향
• 훌륭한 라이브러리와 프레임워크
• 유용한 Wrapper 언어
• 동적언어
• 통일된 스타일

34. Scala
• 확장성 (타입 시스템, 순수 함수형)
• 잘 설계된 기본 라이브러리
• 풍부한 자바 라이브러리
• 확장 가능성
• 깊이 이해하기까지 익혀야 할 개념들이 많음
• JVM
• 다양한 스타일

35. Swift와의 비교

36. // Swift
var myString: String?
!
// Scala
val myString: Option[String]
Option Type

37. // Swift
switch value {
case (x) where x > 0 : "positive"
case (x) where x < 0 : "negative"
}
!
// Scala
value match {
case x if x > 0 => "positive"
case x if x < 0 => "negative"
}
Switch & Pattern matching

38. // Swift
var x: (String,String) = ("dog","cat")
!
// Scala
val x: (String,String) = (“dog","cat")
Tuple

39. // Swift
typealias MyString = String
!
// Scala
type MyString = String
TypeAlias

40. // Swift
func f() -> (Int -> Int)
!
// Scala
def f: Int => Int
!
함수 선언

41. // Scala
@lazy var x = complexFunction()
!
// Swift
lazy val x = complexFunction()
Lazy

42. // Scala
extension SomeType {
var convert(x: Int): Int = { return x * 2 }
}
!
// Swift
trait myTrait {
def convert(x: Int) = x * 2
}
Extension & Trait

43. 스칼라의 패러다임
• 객체지향
• 함수형
• 타입 시스템

44. 함수형

45. 타입 시스템

46. 실습
• Functional
• Lazy
• Pattern matching