Clojure in Action Ch. 1

by Amit Rathore

Preface

복잡성의 두가지
Essential complexity : 원래 복잡한 것.
Accidental complexity : 문제 외의 영역에서 초래된 복잡성.

Chapter 1. Introduction to Clojure

1.1 What is Clojure

1.1.1 Clojure – the reincarnation of Lisp

리스프의 환생.

1.1.2 How we got here

LISt Processing : LISP. 1958년에 설계된 언어.
“code as data” 의 개념.  70~80년대에 인공지능에 많은 투자가 이뤄졌지만, 대부분 실패. 그 오명을 리스프가 지게 됨.
JVM 위의 리슾 개념 : JScheme, Kawa, ABCL  등등.  하지만, 실용적으로 유용한 건 없었슴.
Rich Hickey : 창조자. 는 굉장한 일을 하였다.
클로져는 마침내 살아남은 리슾이 되었다.  –> 리슾의 미래이자 동적 프로그램 언어의 미래.

1.1.3 How this book teaches Clojure

이 책의 철학은 두 기둥에 놓여있다.
> 클로져의 첫번째 원칙을 강조하는 것.
> 그리고, 이러한 원리를 이해하기 위한 실용적인 접근.
많은 코드를 통해 이를 제공할 것이다.
클로져는 새로운 사고를 요구한다.

1.2 Understanding Clojure syntax

신택스는 호불호가 갈린다.
A Clojure expression is either < a symbol > or < a sequence >.
클로져는 배우기 지극히 간단한 언어다. (지랄. 아님) 신택스의 관점에서.. (맞아) 거의 아무것도 없다. (오케이)

1.2.1 XML and parentheses

1.2.2 Lists, vectors, and hashes

클로져는 리슾보다 더 많은 문법이 있지만, 이것이 가독성을 높여준다.
[ 벡터 ]  :  함수의 인수 리스트에 사용.  정수 인덱스 체계.
{ 해시 맵 / 사전 } : { :키 ,  값 }

1.3 The sources of Clojure’s power

1.3.1 Clojure and Lisp

1.3.2 Clojure and functional programming

> immutability, higher-order functions, laziness, concurrency semantics.

1.3.3 Clojure and the JVM

1.3.4 Clojure as a Lisp

AST (abstract syntax tree)
클로져의 런타임은 다른 언어와 다르게 작동한다. JIT 컴파일러 채용.. thanks to the JVM. 코드를 겁나 빠르게 컴파일 / 실행한다.
As alluded to, 암시…  contrive 억지스런, 고안해내다.
The Reader
리더는 소스코드를 AST 구현으로 크로져의 고유 데이터 구조를 이용하여 컨버트한다.
The Macro System
매크로는 클로져 함수. s-expression 을 인수로 받는다. s-expre.. 이 데이터 구조이므로 변형되고 반환가능하고 리턴된 값은 원래 형태로 사용된다.
이러한 코드-변형 매크로는 클로져 ‘위에’  미니 언어를 만들 수 있음.  DSLs (domain specific languages)
Metaprogramming with Macros
코드를 생산하는 코드
모든 클로져 코드는 같은 구조.  크로져 코드를 만들려면 심볼과 다른 데이터 구조를 갖는 클로져 데이터 구조를 만들면 됨.
이러한 신택스 없음과 매크로 시스템은 DSL 에 적합하게 한다.  ==> programmable programming language.
frivolous  천박한
매크로는 메타 프로그래밍의 ‘궁극’의 모습이다.

1.3.5 More advantages of Clojure

Dynamic Language
The REPL

1.3.6 Clojure as a functional language

클로져는 맵 리듀스 같은 higher-order functions 을 장려한다.
Higher-Order Functions

Advertisements

C# 5.0 In a Nutshell. Ch. 4.

C# 5.0 In a Nutshell. [ by Albahari Bro.]

1. Delegates [ 12 / 5 ]

메서드를 부를 줄 아는 객체. 인수 / 리턴형 지정.콜러가 딜리깃을 호출하면, 딜리깃이 대상 메서드를 부름.
콜백 과 유사.

public int Transformer (int x);
Transformer t = SquareThis; // 이것은
Transformer t = new Transformer (SquareThis); // 이것의 축약형
t(3);  // 은
t.Invoke(3) // 의 축약형.

Writing Pulg-in Methods with Delegates

딜리깃 변수는 런타임에 할당. 이것은 플러그-인 메서드를 쓰기 유용.  예제 ..  정수 어레이와 변형 함수를 주어 모든 멤버에 대해 실행하게 함.

Multicast Delegates

+=, -= 등을 이용. 여러 함수 호출.

Instance Vs. Static Method Targets

Target property 는 인스턴스 함수의 인스턴스를 가리킴.
someDelegate.Target ,  someDele.Method

Generic Delegate Types

public delegate T Trans < T > ( T args );

The Func and Action Delegates

delegate TRlst Func < in T, out TRslt > ( T argu );
delegate TRlst Func < in T1, in T2, out TRslt > ( T1 arg1, T2 arg2 );
delegate void Action <in T> (T arg);

Delegates Vs. Interfaces

2. Events

3. Lambda Expressions

4. Anonymous Methods

C# 5.0 In a Nutshell. Ch. 3.

C# 5.0 In a Nutshell. [ by Albahari Bro.]

1. Classes

// Fields : 멤버 변수.
/*
* – The – readonly – modifier : 생성 이후 변경 불가.
* – Field initialization – 기본값으로 세팅. 생성 이전에 초기화됨.
* – Declaring multiple fields together  int a, b, c ; 이러 식.
* */

// Methods
/* Overloading methods  */
void Foo(int x) {}    //float Foo(int x) {} // 에러.
void Foo(ref int x) {} // OK.. out과 ref를 동시사용 은 안됨 (혼동)

// Instance Constructors
/*  생성자는 초기화 코드 : initialization code 를 실행. 메서드 같지만 이름과 리턴타입이 함축. */
/* – Overloading constructors
*   다른 생성자 호출 가능
*   public Apple (int x, int y) : this ( x )  이런 식.  불린 놈이 먼저 실행됨.
*
* – Implicit parameterless constructors : C# 이 자동 생성.
*   struct 는 이런 무인수 생성자는 intrinsic (원래 있는)  사용자가 지정 불가. 기본값 세팅함.
*
* – Constructor and field initialization order
* – Nonpublic constructors : pool 에서 꺼내 쓰거나 하는 등의 용도..  */

// Object Initializers  아래 예처럼 { } 이용하여 멤버 초기값 세팅 가능.

// The This Reference [9/21]

// Properties : get set 코드로 로직이 있는 멤버. [9/21]
/* – Read-only and calculated properties : write-only 가능하지만 드물다.
* – Automatic properties { get; set; }  C# 3.0
* – get and set accessibility : 아래 AccessiBility 예.
* – CLR property implementation : 내부적으로 get_XXX 이름으로 컴파일 됨. 인라인으로.
*/

// Indexers : string의 인덱스. [9/22]
/* – Implementing and indexer public string this [int wordNum] { get …. set … }
* – CLR indexer implementation     */

// Constants : 변하지 않는 static field. 컴파일에 산정되어 값이 사용될 때마다 값 치환 C++ macro 비슷.
//    public const string myMsg = “Hello “;  // 선언과 동시 초기화
//    static readonly 보다 더 제한적. 차이점 : 컴파일 시 값 산정한다는 점. readonly 는 어플마다 다를 수 있다.
//      다른 버전에서 값이 바뀔 수 있을 경우.

// Static Constructors : type 당 한번만 실행. (인스턴스 당이 아님)
/*   static ClassName() { SomeFunction(); }  이 클래스가 사용되기 전에 자동으로 한번 실행.
*   역할 : 타잎 초기화, 타잎의 static member 에 접근.
*   unsafe, extern 에만 접근 가능.
*   예외를 발생하면 그 타잎은 사용 불능.
*
* – Static constructors and field initialization order
*   Static 생성자 이전에 불림. */

// Static Classes [9/30
/*  static member 만 갖고, 상속할 수 없는 클래스.  예) System.Console, System.Math */

// Finalizers : Class only Methods . GC 실행 전에 수행.  ~ClassSample()

// Partial Types and Methods  여러 파일에 코드 분산
/*   구현할 인터페이스를 각각 구성 가능.
* – Partial methods  …  void, implicitly private ..   C# 3.0에서 도입.
*      partial void GetSomeValue();        // definition  코드 제네레이터에 보통 있음.
*
*      partial void GetSomeValue() { 구현 }  // implementation  매뉴얼 작성. */

2. Inheritance [p80]

// Polymorphism [10/1]

// Casting and Reference Conversions : 암시적 upcast to base class / 명시적 downcast to subclass.
/* – Upcasting : 캐스팅 후에도 동일한 객체임. objA == objB
* – Downcasting
* – The as operator : 다운캐스트 실패 시 null 세팅.
* – The is operator : if (a is Stock)  */

// Virtual Function Members : 상속을 위한 클래스. Methods, properties, indexers, events 모두 가능.
//  생성자에서 부르는 것은 잠재적 위험.

// Abstract Classes and Abstract Members  [10/7]
//  추상 클래스는 초기화되지 않음.

// Hiding Inherited Members
//  동일한 이름으로 베이스클래스 속성을 숨긴다.  Warning 발생.
//  new 를 통해 워닝 억제..
/* – new VS override
*   new 로 재정의한 함수는 부모클래스로 캐스팅 하면 상위 함수가 불린다..  */

// Sealing Functions and Classes [10/8 86p]
//  더 이상의 override 를 막기 위해 봉인.

// The base Keyword : this 비슷.
//  파생 클래스에서 상위 멤버 접근, 상위 생성자 콜.

// Constructors and Inheritance
/* – Implicit calling of the parameterless base-class constructor
*   인수 없는 상위 생성자는 암시적으로 자동 실행.
* – Constructor and field initialization order  순서 .. */

// Overloading and Resolution : 상속.. 캐스트하면 어느 함수를 부를 것인가.. dynamic ..

3. The object Type [p89]

// System.object 는 궁극의 베이스. 뭐든 object 로 캐스트 가능. 밸류 타잎도 박싱을 통해 가능.

// Boxing and Unboxing [10/9]
//  Value type 을 reference type 으로
// – Copying semantics of boxing and unboxing

// Static and Runtime Type Checking
//  int x = “5” ;  // static
//  int z = (int) y; // Runtime; unboxing.. GetType 을 통해 형 확인.

// The GetType(runtime) Method and typeof(compile time) Operator
//  theObj.GetType() == typeof(theObj)   Name, FullName

// The ToString Method  (overide 가능.)

// Object Member Listing

4. Structs [p93]

// Struct Construction Semantics [10/10]
//  인수 없는 생성자 안됨.

5. Access Modifiers [p94]

// public (assembly:file 밖에서 인식 가능), internal (assembly 내에서 오픈, non-nested type 기본값) private (class, struct 기본값) protected, protected internal

// Examples

// Friend Assemblies
//    System.Runtime.CompilerServices.InternalsVisibleTo  strong name ?

// Accessibility Capping  타잎의 접근성을 멤버도 따라간다.
//    class C { public void Foo() {} }  C 가 internal 이므로 Foo도 마찬가지.

// Restrictions on Access Modifiers  동일하게 오버라이드 해야.. 예외. protected internal => overide 는 protected 여야 함..

6. Interfaces [p96] 클래스와 비슷하지만 구현보다는 스펙을 제공.  [10/14]

//    멤버는 모두 ‘암시적 추상’ 반면 클래스는 양쪽 모두.  implicitly public …  구현하면 모두 퍼블릭.
//    클래스는 여러 인터페이스 구현 가능. 반면 상속은 한 클래스에서만. 구조체는 상속 불가.   down cast 가능.
//    member, property, event, indexer 만 포함.

// Extending an Interface :: 다른 인터페이스에서 파생 가능.

// Explicit Interface Implementation
//  두 인터페이스 멤버이름이 충돌할 때 I2.Foo(), I3.Foo() 이런식으로 구현 가능.. 리턴형은 다름. 부를려면 캐스트 해야..
//    명시적으로 멤버 이름을 구현하는 이유는 특별한 함수를 숨기거나 혼동하지 않기 위해서.  예)  ISerializable …

// Implementing Interface Members Virtually [10/15]
//    기본적으로 sealed 임.. virtual 로 해야 오버라이드 가능. 상위 클래스 / 인터페이스의 멤버를 불러도 파생된 함수가 불림.

// Reimplementing an Interface in a Subclass
/* – Alternatives to interface reimplementation
*   문제점 : 베이스 메스드를 부를 방법이 없다..  기대하지 않았던 일.  sealed .. 고려해 봐야.  */

// Interfaces and Boxing

7. Enums [p102 10/20] 이름 지어진 숫자 상수

//      기본은 정수이며 바이트도 사용 가능.  enum SomeValue : byte { n1, n2 = 3, n3 }; … 이렇게.

// Enum Conversions : (int) 로 캐스트 가능. enum 끼리 캐스팅도 가능.

// Flags Enums : 2개의 값을 갖을 수 있음.  테스트 함 해볼 것…
//[Flags]   &(and) |(or) ^ (배타적 or)  의 의미들..  1 or 2  면 3인가? ..

// Enum Operators

// Type-Safety Issues : 정수형 연산을 할 수 있다.  플래그 있는 enum validation 확인.

8. Nested Types [p105 11/3] ClassA.ClsB. …

9. Generics [p106 11/5]

상속과 제네릭을 통한 코드 재사용.
C++ template 과 유사.

Generic Types

Stack<T> : open type  정의..
Stack<int> : closed type..   구현

Why Generic Exist

object 로 할 수도 있지만.. 번거롭고, 에러 발생

Generic Methods

static void Swap(ref T a, ref T b) // 요런식..
Swap( ref x, ref y) ; // 이렇게 불리거나
Swap( ref x, ref y) ; // 이렇게 써도 됨.

제네릭 메서드에는 형을 명시하지 않아도 됨. 컴파일러가 암시적으로 형 정의.
메서드와 타잎은 타잎 인수를 도입할 수 있는 유일한 생성자.
프라퍼티, 인덱서, 이벤트, 필드 .. 은 불가. 이미 정의된 타잎을 partake 은 가능. A
비슷하게, 생성자는 기존 타잎인수에서 partake 가능, 하지만 introduce 는 불가. B

public T this [int index] { get { return data [index]; } } // generic item 리턴.  ex) A
public Stack() {  }  // 불가 ... ex) B

Declaring Type Parameters [11/6]

타잎 인수는 클래스, 스트럭, 인터페이스, 딜리깃, 메서드 에서 가능.
일반적으로 T 를 씀.

[typeof] and Unbound Generic Types

오픈 제네릭 타잎은 런타임에는 존재하지 않음 : 컴파일의 일부로 닫힌다.
[언바운드] 제네릭 타잎이 런타임에 존재하는 것은 가능… 순수히 Type 객체로… [typeof]

class A {}
Type a1 = typeof(A<>); // Unbound type
// Closed type
Type a3 = typeof(A<int, int>);

The default Generic Value

default(T) : 디폴트 값.  null / 0 …

Generic Constraints

특정 클래스, 인터페이스 등으로 제한할 때.

class GenClass<T, U> where T : SomeClass, InterfaceSome
where U : new()  // 인수 없는 생성자가 필요함. => 함수 내에서 new U(); 를 부를 수 있음.

Subclassing Generic Types

베이스 클래스를 오픈함. 또는 확정 타잎으로 할 수도 있음.

class Stack
class SomeStack : Stack
// concrete type..
class OtherStack : Stack
// fresh type
class KeyList<T,TKey> : List

Self-Referencing Generic Declarations

Static Data

정적 데이터는 각 닫힌 타잎에서 유니크하다.

class Bob { public static int Count; }
....
++Bob.Count ; 1
++Bob.Count; 1 각 타잎마다 다른 정수 참조.

Type Parameters and Conversions

C# 캐스팅
# Numeric conversion
# Reference conversion
# Boxing/unboxing conversion
# Custom conversion (via operator overloading)
무슨 변환을 할지는 연산자의 알려진 타잎에 기초하여 [컴파일] 때 일어남.
제네릭 변환시 재밌는 현상.. 정확한 형은 모르기 때문. => 모호성.. 커파일러가 에러 발생.

if (arg is StringBuilder) // 1. 레퍼런스 컨버전.
StringBul ssbb = arg as StringBul  // 2. as 연산자.. 사용
if (ssbb == null) return;
(StringBul)(object)arg ; // 3. object 로 변환 후 캐스팅.
int Foo (T x) { return (int) (object) x; }

Covariance [11/19]

정의 :: A is convertible to B 일때 ,  X 는 Covariant 하다 만약 .. X<A> is convertible to X<B>..

Classes

Bear : Animal 상속 관계에서..

public static void Wash (Stach animals) { ... } // 여기엔 Bear 를 못 넣음.
public static void Wash (Stach animals) where T : Animal { ... } // 이렇게는 가능.

Arrays

역사적으로 어레이 타잎은 ‘코베리언트’ 함. 즉,

Bear[] bears;
Animal[] animals = bears ;  // OK

Interfaces

..

public static void Wash (Stach animals) where T : Animal { ... } // 이렇게는 가능.
public static void Wash (IPoppable animals) where T : Animal { ... } // 이게 가능..

Contravariance [11/19]

X 를 X 로 컨버팅 가능하면 컨트라배리언트 .. 함.

public interface IPushable<in T> {}  // <in T> 에 유의.
// Legally do this
IPushable<Animal> animals =  new Stack<Animal>();
IPushable<Bear> bears = animals; // Legal
bears.Push(new Bear() );  // 하지만, output 할 방법이 없음.

C# Generics Versus C++ Templates

C++ 템플릿은 dlls 로 디플로이 되지 않음. 소스코드로만 존재. 컴파일 시 해당 클래스로 치환..

End ..  13 11 19

Machine Learning in Action Ch. 1, 2, 3

Part 1 CLASSIFICATION

1. Machine learning basics

Numpy, matrix, array etc

2. Classifying with k-Nearest Neighbors

숫자 인식.. 스킵.

3. Splitting datasets one feature at a time : decision trees

스무고개 ?  예/아니오 만 가능.
가장 보편적인 등급화 기법.  조사 결과 가장 많이 사용되는 ‘기법’.
이메일 분류.. 직원, 하키(친구) 기타는 스팸으로 분류.
콘택 렌즈 분류..

3.1 Tree construction

D. trees
Pro : 싸다, 결과를 사람이 인지하기 쉽다. 값이 빠져도 OK, 상관없는 특성들을 다룰 수 있다.
Cons : Prone to overfitting
숫자 값, niminal values 에 사용.

Information theory ..

데이터를 나눌 첫번째 결정을 설정해야..

createBranch .. 재귀적..
어떻게 데이터셋을 나눌 것인가.  [10/27]

General approach to decision trees
1. Collect : Any method.
2. Prepare :  ~~~

 

 

 

Functional Programming in C# [ Ch. 4, 5, 6 ] __ Oliver Sturm

Chap. 4. Flexible Typing with Generics [9/22]

제네릭 가능 : class, method, interface, delegate
대표적인 것 : 컨테이너 클래스.  다목적 베이스 클래스.

Generic Functions [9/22]

static void SomeThing<T> (T param) { // 함수 이름 뒤에 <타잎> 표시.
}
// Usage ..
SomeThing<int>(33);
SomeThing<string>(" The Parameter ");

<타잎> 변수 생략 가능 : 컴파일러 추론.

Generic Classes

..

Constraining Types 제한.

static void OutputVal<T> ( T value ) where T : ListItem<string> {}   // ListItem<string> 에서 파생되어야..

Other Generic Types

// Delegate
public delegate Rt SomeDelegate<T, Rt> (T param);  // Func<T, Rt> 와 같은 기능..
// Func
public delegate TResult Func<T1, T2, T3, T4, TResule> (T1 p1, T2 p2, T3 p3, T4 pr);
// 대부분의 추상 함수에 사용 가능.  4개 인수와 1개 리턴 값.
// Action 은 리턴 값이 없는 함수에 사용 가능.

Covariance and Contra variance

object[] objList = new object[3];
objList[2] = 10;
string[] strArr = new string[] { "one", "two", "thr" };
objList = strArr; // 이런 할당을 허용할 것인가..
// 좀 더 복잡한..
objList[2] = 10; // Runtime exception .. 어레이가 스트링 형이므로..
int[] intArr = new .... ;
objList = intArr; // intArr 는 밸류타입임.. 이 경우 covariance 는 레퍼런스 타잎만 지원

Variance 는 언어를 더 직관적으로 기능하게 하는 요소다.

List<object> objLst = new ...;
List<string> strLst = new ...;
objLst = strLst; // 허용 안됨.
// IEnumerable<T> 의 예.
public interface IEnumerable<out T> : IEnumerable { }  // retrieved from methods 에서 사용 가능. not passed into them.
IEnumeralbe<object> objSeq = new .. ;
IEnumeralbe<string> strSeq = new .. ;
objSeq = strSeq; // 가능.

4.0 에서 in, out 제레릭에서 사용 가능. 데이터 흐름의 방향을 제어 가능.

Chap. 5. Lazy Listing with Iterators

데이터를 효율적으로 다루기.

The Meaning of Laziness [9/23]

Linq 도 이같은 원리에 근거.

Enumerating Things with .NET

IEnumerable 인터페이스.
MoveNext(), Current(), Reset() …

Implementing Iterator Functions [9/24]

C# 2.0에서 도입된 IEnumerable / IEnumerator 조합을 이용. 제네릭, 넌제네릭 모두 가능.
특별한 형태의 리턴.  yield return 문.  Laziness ..  p49 코드를 볼 것.
리스트를 다 채우는 것이 아니라… 필요할 때 가져온다.. (미리 할 필요가 없다. 중간에 멈추면 후속 값 계산을 안 한다.).

Returning IEnumerator [9/29]

IEnumerable, IEnumerator ..

Chanining Iterators

.. laziness ..

.

Chap. 6. Encapsulating Data in Closures

Scope문제 Closure를 이용 해결.

Constructing Functions Dynamically [9/30]

C# 1.0 : ~ = C ..
delegate, event  : multicast
C# 2.0 : 무명함수.  함수를 만들어서 외부 스코프에 리턴하는 것은 이득이 많음.

The Problem with Scope

엄격한 스코프.
함수 플글에선 변하는 값을 별로 안 좋아함. 가이드 라인은 : { 변하는 값을 전혀 갖지 않음 }
가장 좁은 스코프 안에 집어 넣는 것.
순수 함수는 로컬 변수만 이용. 외부 참조 없음.   => 첫 반응은 incredulity.. 회의..
전역 변수가 않 좋은 이유 : 특정 시점에 어떤 값을 갖을 지 알 수 없음. ..
클래스 멤버는 좁은 스코프.
초기화 과정에서 나중에 쓰일 변수가 있다면 ?  클로져를 이용하는 대안..

How Closures Work

함수를 리턴하는 경우.. 그 안에 로컬 변수..  리턴 된 후 그 함수를 실행시키면 크래쉬. => 컴파일러가 그 값을 보관.
컴파일러는 무명 클래스를 생성하고 인스턴스 생성해서 그 함수를 부른 함수 내부에 둔다.
무명함수는 그 무명 클래스 내부의 함수로 생성. 그 콜러가 지속할 때까지 살아 있는다.  로컬 변수는 무명클래스의 필드로 된 것.
동적 함수는 객체 지향의 메서드 오버로딩과 유사. 하지만, 동적으로 생성됨.