Introduction:

ช่วงนี้รู้สึกสนใจภาษา clojure มันดูมีความน่าสนใจอยู่หลายๆอย่าง (แล้วก็เงินเดือนนี่สูงปรี้ดเลย [1][21] แค่นี้ก็จูงใจผมได้มากแล้ว) เป็นต้นว่า clojure เป็นภาษา functional ที่พัฒนาแนวคิดต่อมาจาก LISP [2] ฉะนั้นเราอาจเจอวงเล็บยั้วเยี้ย ซึ่งบางคนพอเจอวงเล็บแล้วก็รู้สึกไม่ดีเท่าไหร่ แต่จริงๆแล้วมันไม่ได้เป็นปัญหาขนาดนั้น พวกบรรดา text editor ก็ยังมีตัวช่วยให้เราเขียน clojure สะดวกขึ้นอย่างมากมาย เป็นต้นว่า อย่างผมที่เป็นสาวกของ atom มันก็มีตัวช่วยจัดการวงเล็บคือ package ชื่อ parinfer ความสามารถมันแบบประมาณว่ามันจะจัดการวงเล็บให้เราตาม indent แต่ถึงอย่างไรมันก็เกิดปัญหาได้ เพราะบางทีมันก็ฉลาดเกินไปจนไปจัดการวงเล็บที่เราไม่อยากให้ไปจัดการ หรือบางทีเราก็อยากเข้าไปสังคายนาตัวโค้ดในกลุ่มวงเล็บบางกลุ่ม ซึ่งก็มีตัวช่วยจัดการอีกเหมือนกันคือ lisp-paredit แค่นี้ก็ถือว่าจัดการปัญหาเรื่องวงเล็บไปมากแล้ว ซึ่งทำให้เราไม่ต้องพะวงกับการนับวงเล็บอะไรแบบนี้อีกต่อไป

นอกจากนั้นใน atom ยังมี proto-repl ที่เอาไว้ลอง experiment กับฟังก์ชันที่เพิ่งเขียนไป ทั้งนี้คำแนะนำคือให้ setup ตาม gist ลิ้งด้านล่างนี้ไปเลย ซึ่งครบถ้วนทั้งหมดทุกตัวที่กล่าวมา

Atom Clojure Setup

แต่โอเคถ้าคุณไม่อยากใช้ atom จริงๆแล้ว clojure มันดูไปกันได้กับ editor ตัวอื่นอีกมากมายอย่าง emac ผมแนะนำให้ลองดูการ setup เบื้องต้นจาก https://www.braveclojure.com/basic-emacs/ และ vsCode ก็มี plugin ตัวช่วยอยู่เหมือนกัน

สำหรับตัวจัดการ project หรือ package ในโลก clojure มีอยู่สามสี่ตัวที่น่าสนใจ แต่ที่ดูจะฮอทบวกฮิตมากที่สุดน่าจะเป็น Leiningen ซึ่งผมเองก็คงแนะนำให้ใช้ตัวนี้เพราะ community ค่อนข้างจะใหญ่และดู stable มาระดับนึงแล้ว หลังจากติดตั้งไปแล้ว (ชาว os x สามารถใช้ brew install leiningen ได้) เราก็จะสามารถสร้าง project ได้ง่ายๆด้วยคำสั่ง

lein new your-app-name-here

Clojure is compiled to JVM bytecode:

Clojure จริงๆแล้วมันถูก compile เป็น jvm (java virtual machine) bytecode [3][4] แต่นั่นไม่ได้หมายความว่า clojure มันจะแปลงไปเป็น java ก่อนแต่อย่างใด แต่มันกลายเป็น java bytecode เลย อันที่จริง jvm ไม่รู้จัก java ด้วยซ้ำ มันรู้จักแค่ java bytecode เท่านั้น [6] โดยตัวที่ jvm นั้นจะอ่าน (interpreted) ขอแค่อยู่ในรูป jvm bytecode [18] ซึ่งจริงๆแล้วอยู่ในฟอร์แมต Java Class File Format (ตัวอย่าง อื่นๆก็ scala, Kotlin) ตัวอย่างสามารถดูได้จากรูปด้านล่าง [3][5][6] นั่นทำให้ function ใน clojure เวลา compile สุดท้ายจะกลายเป็น .class[3]

ถึงตรงนี้ จริงๆแล้วอธิบายเวิ่นเว้อไปมาก สามารถสรุปได้ดังนี้

(เพิ่มเติม: เราอาจบอกว่า java bytecode ก็คือชุด class ไฟล์หลายๆไฟล์รวมกันซึ่งแต่ละไฟล์ข้างในก็จะมีชุด instructions [6])

เราสามารถลอง compile ได้ด้วย

lein new app
cd app
lein compile app.core
ls target/classes/app

เราจะได้ไฟล์ 4 ไฟล์ หน้าตาประมาณนี้ ตัวเลขอาจไม่เป๊ะ พวกนี้คือ java byte code ที่ได้จากคำสั่ง lein compile app.core

core$fn__38.class                    
core$foo.class                       core$loading__5569__auto____36.class 
core__init.class

ตรง core$foo.class จริงๆแล้วมันคือ ฟังก์ชัน foo ที่ถูกสร้างขึ้นอยู่ใน src/app/core มาตอนที่เราใช้คำสั่ง lein new appพอมันถูก compile มันจึงกลายเป็น .class ถ้าเราลองสร้างฟังก์ชันอื่นๆใน core.clj จากนั้นเรา compile อีกที มันก็จะโผล่มาใน target/classes/app เป็น core$anyFunction.class นั่นเอง เราสามารถทำการส่องในแต่ละไฟล์ได้ด้วย javapเช่นสมมุติเราจะส่อง core$foo.class หรือส่อง core__init.class

javap -c target/classes/app/core\$foo.class
javap -c target/classes/app/core__init.class

เราจะเห็นข้างในเป็น JVM assembly instruction [3]

ส่วนสามไฟล์ที่เหลือ

core__init.class // core.clj loader class
core$fn__38.class // dosync anonymous function
core$loading__5569__auto____36.class // with-loading-context anonymous function

สามารถอ่านเพิ่มเติมได้ใน [3][6]

แต่ทีนี้ clojure มัน run แบบไม่ต้องผ่านการ compile แล้วได้เป็นไฟล์ออกมาแบบที่เราทำไปก็ได้ คือมันสามารถ dynamic compilation ได้ แบบเหมือนทำกลางอากาศ คือมันก็ได้ bytecode มาให้ JVM อยู่เหมือนกันเพียงแต่มันไม่ save เป็นไฟล์แบบตอนเราใช้ lein compile ซึ่งเป็น ahead-of-time compilation เราสามารถลอง dynamic compilation ผ่าน lein repl [6]

Clojure is dynamic language

Clojure เป็นภาษา dynamic language ฉะนั้น โดยปกติเราประกาศตัวแปรแบบไม่มี type [2][7] ตัวอย่างด้านล่างจะเป็นการประกาศตัวแปรต่างๆ

(def n 100000) // ประกาศตัวแปร n ให้เป็น Number มีค่าเป็น100000
(def a "blabla") // ประกาศตัวแปร a ให้เป็น String มีค่าเป็น "blabla"
(def f (fn [x] x)) // ประกาศ f เป็น function ที่รับ x แล้วคืนค่า x
(defn o [x] x) // ประกาศ function ชื่อ o รับ x แล้วคืนค่า x

แต่มันก็ยัง strict เรื่อง type นะ คือเราไม่สามารถทำแบบนี้

(+ 10 "hello") // error
ทำได้เพียง
(+ 10 10) // 20

อันแรกมันจะฟ้องว่าเรา add String เข้ากับ Number ไม่ได้ เราอาจกล่าวว่า clojure เป็นภาษาที่เป็น dynamic strong type (แต่โดยส่วนมองว่า definition ของ strong/weak นั้นยังเป็นที่ถกเถียงอยู่ [19]) นอกจากนั้นเราใส่อะไรที่คล้ายๆ type ได้ เรียกว่า Type-hint ซึ่งจะเพิ่ม performance ได้ในกรณีที่มีการไปยุ่งกับ java (clojure นั้นจริงๆก็เป็นญาติกับ java) เราสามารถสังเกตได้ว่าอันไหนมันมาจากโลกของ java ด้วยการดู ‘.’ ว่ามันอยู่หน้าฟังก์ชันไหม ถ้าอยู่แสดงว่ามันคือ instance จาก java [8] [12] เราใส่ type-hint เพื่อไม่ให้ ตอนที่มัน compile พวกตัวที่มาจาก java มันส่องหา type อยู่ตลอด เป็นการบอกใบ้นั่นเองว่า ไอ่ที่ส่งเข้าไปเนี่ยมันเป็น type อะไรกันแน่ [8]

ซึ่งเอาเข้าจริงเราไม่ควรใช้ type-hint ตลอดเวลาหรือทั้งหมดทั้งโปรเจ็คเพราะมันก็คือการเพิ่มข้อมูลที่ส่งไปให้กับ compiler ด้วยเช่นกัน และ document แนะนำให้ใช้แค่ตอนที่เจอปัญหาแบบคอขวดแล้วรู้ว่าต้นตออยู่ตรงไหน [8][11]

สำหรับด้านล่างนี้ถ้าเอาไป run แข่งกับแบบไม่ใส่ type-hint เช่นเอาไป run สักล้านรอบเราจะเห็นว่ามันไวขึ้นมาก ข้างล่างนี้จะเห็นว่ามันมี .length อันนี้มาจาก java แน่ๆ และเราใส่ type-hint เพื่อใบ้ compiler ว่ามันคือ string [7][8]

(defn len [^String x] (.length x))

Anatomy of Clojure’s syntax:

หากลอง lein repl จากนั้นลองแต่ละอันข้างล่าง พิมพ์แล้วกด enter ดูผลจะได้ว่า

user=> ()            // empty list, stay empty list
()

user=> (def x 10)    // not empty list, x is 10
#'user/x
user=> x
10

user=> (1 2 3)        // not empty list, get error (T_T)
ClassCastException java.lang.Long cannot be cast to clojure.lang.IFn  user/eval1244 (form-init321820076331617300.clj:1)

user=> (list 1 2 3)   // not empty list, get list
(1 2 3)

เรารู้มาว่า clojure จะอยู่ในวงเล็บ แต่อะไรล่ะที่อยู่ในวงเล็บแล้วมันจะอ่านไม่พังไปซะก่อน (หรือพูดตรงกว่านั้นก็คือ eval ใน JVM แล้วไม่ error) ก่อนอื่นเราต้องทำความรู้จักกับวงเล็บก่อน จริงๆแล้ววงเล็บมันคือ data structure รูปแบบหนึ่ง อันที่จริงมันคือ Lists (ตัววงเล็บรุ่นพ่ออย่าง LISP ชื่อก็ย่อมาจาก lists processing [7]) ซึ่งสิ่งที่จะทำให้ lists ใดๆ มัน eval แล้ว resolve (หรือก็คือเราพิมพ์ๆไปแล้วกด enter ใน repl แล้วมันทำงานไม่ขึ้น error) ก็ต่อเมื่อสมาชิกตัวแรกมันเป็นหนึ่งในด้านล่างนี้

- function
- macro 
- special form

ex. (SOMETHING x 10)

SOMETHING should be one of those guy

ถ้ามันเข้าเงื่อนไข สมาชิกตัวที่เหลือใน lists ก็จะกลายเป็น parameters ของไอ่ตัวแรกแบบเรียงลำดับทันที เช่น

(+ 1 2 3 4)
function = +
parameter = 1 2 3 4

[7] จริงๆแล้วพอมีวิธีอย่างหยาบในการเช็คว่าอะไรเป็นอะไรอยู่บ้าง เช่นฟังก์ชัน list ที่จับ arguments มายัดเข้าไปให้กลายเป็น list พอพิมพ์ตรงๆไปที่ repl จะขึ้นเป็นแบบว่า

user=> list
#object[clojure.lang.PersistentList$Primordial 0x74866d26 "clojure.lang.PersistentList$Primordial@74866d26"]

เราสามารถลองพิมพ์ตัวอื่นเล่นๆได้เช่น +, — , *, / ก็จะขึ้นหน้าตาคล้ายๆกันกับ list

ส่วน macro (เช่น defn, when) พอพิมพ์ไปตรงๆที่ repl จะได้แบบนี้

user=> when
CompilerException java.lang.RuntimeException: Can't take value of a macro: #'clojure.core/when, compiling:(/private/var/folders/db/vnkkt7mx5wj84jxcwh4jplsw0000gn/T/form-init1239338506849356429.clj:1:1062)

ส่วน special form(เช่น if) พอพิมพ์ไปตรงๆที่ repl จะได้แบบนี้

user=> if
CompilerException java.lang.RuntimeException: Unable to resolve symbol: if in this context, compiling:(/private/var/folders/db/vnkkt7mx5wj84jxcwh4jplsw0000gn/T/form-init1239338506849356429.clj:1:1062)

ซึ่งจริงๆแล้ว ก็ไม่ได้เกี่ยวกันเสียทีเดียว และไม่เวิร์คอีกต่างหาก คือถ้าลองพิมพ์อะไรมั่วๆ มันก็ออกมาเหมือนพิมพ์ if

ทำไมมันถึงขึ้นว่า unable to resolve symbol แล้วอะไรคือ symbol สำหรับ clojure ? โอเคเดี๋ยวเราไว้มาตอบทีหลัง แต่ก่อนอื่นเราลองมาใช้ doc ดูจะเข้าท่ากว่า เราสามารถลองเช็คแต่ละตัวได้ด้วยแบบนี้

user=> (doc list)
-------------------------
clojure.core/list
([& items])
  Creates a new list containing the items.
nil

user=> (doc when)
-------------------------
clojure.core/when
([test & body])
Macro
  Evaluates test. If logical true, evaluates body in an implicit do.
nil

user=> (doc if)
-------------------------
if
  (if test then else?)
Special Form
  Evaluates test. If not the singular values nil or false,
  evaluates and yields then, otherwise, evaluates and yields else. If
  else is not supplied it defaults to nil.

  Please see http://clojure.org/special_forms#if
nil

user=> (doc doc)
-------------------------
clojure.repl/doc
([name])
Macro
  Prints documentation for a var or special form given its name
nil

! นอกจากจะพอบอกว่าแต่ละอย่างมันเป็นอะไรแล้ว มันยังบอก parameters และอธิบายคร่าวๆด้วยว่ามันเอาไว้ใช้ทำอะไร (นอกจากนั้นเราสามารถใช้ find-doc ซึ่งเอาไว้เสิร์ชหาสิ่งที่เกี่ยวข้องเช่นอยากหาฟังก์ชันหรือมาโครที่ทำงานเกี่ยวข้องกับ xor ก็สามารถใช้(find-doc xor) )

ทีนี้เรามาดูกันว่าจริงๆแล้ว function, macro กับ special form มันคืออะไรกันแน่?

Special form

ก่อนเราจะพูดถึง special form ซึ่งแน่นอนว่าเราต้องพูดถึง form ก่อน สำหรับ clojure แล้ว form คืออะไรก็ตามที่สามารถถูก eval ได้ฉะนั้น function, macro, special form ก็จัดว่าเป็น form [7][16] แต่จริงๆแล้วก่อนที่จะ eval มันจะต้องผ่าน read ก่อน ซึ่งฟังก์ชัน read จะทำการอ่าน text (ที่จริงๆแล้วรับเข้ามาเป็น stream ศึกษาเพิ่มเติมได้ใน (doc read)) แล้วแปลงไปเป็น data structure (หรือโดยส่วนมากสำหรับโลก clojure ก็คือ list นั่นเอง)แล้วถูก eval อีกที โดยจริงๆแล้วตัว repl ก็ทำงานผ่าน read ซึ่งเราสามารถสรุป flow มันจะได้เป็น read-eval-print loop[7](ย่อว่า REPL) [14]

สำหรับขั้นตอน read จริงๆตรงนี้ก็ทำงานเหมือน parser คือรับ text แล้วแปลงเป็น data structure [14] โดย data structure มีดังนี้

• symbols: คืออะไรก็ตามที่ไม่ได้ขึ้นต้นด้วยตัวเลข แต่สามารถมีตัวเลขตามมาได้รวมทั้งพวกสัญลักษณ์ เช่น me-and-you, I!007, hello❤, etc. จะว่าไปจะเรียกมันว่าตัวแปรก็ได้
• list (), vector [], map {}, set #{}
• literals: เช่น string(พวกที่อยู่ใน double quote เปิดปิด), character (พวกที่อยู่หลัง \ เช่น \n), number, nil, boolean, key( :key , :word ), etc.

สำหรับ literals และพวก vector, map, set พอ eval พวกนี้จะคืนค่าเดิมออกมา ในกรณีของ list พอ eval แล้วจะเรียกฟังก์ชันหรือทำงานตามแต่ที่สมาชิกตัวแรกของมันจะสั่งให้ทำ เช่น (+ 1 2) , (defn x [] 3) ส่วน symbol จะถูกเก็บไว้เป็นตัวแปรไว้รอเรียก [14][16][17]

เช่น

user=> (+ 3 4)
7

การทำงานจะเริ่มจาก (read)(+ 3 4) จากนั้น form ที่ส่งเข้ามานี้ (หมายถึง (+ 3 4) ) จะถูกแปลงความหมายจากก้อน text เป็น data structure ที่พร้อมถูก eval นั่นก็คือมันกลายเป็น list ที่เริ่มต้นด้วยฟังก์ชัน + ที่รับ parameter เป็น 3 4 ตามลำดับ ซึ่ง eval แล้วได้ค่า 7 นั่นเอง [7][15]

แต่เดี๋ยวก่อน นั่นไม่ได้หมายความว่าไอ่ตัว +เนี่ย พอ readแล้วมันก็ถูกแปลงเป็น symbol ด้วยหรือเปล่า? ใช่แล้ว มันคือ symbol ซึ่งเราเรียกว่า verb เพราะมันเป็น symbol ที่ออก action กับอะไรสักอย่าง ซึ่งตามที่กล่าวไว้ข้างบนว่า symbol มันจะ store เก็บไว้ให้รอเรียกถ้ามันมีให้เรียก [17]

user=> +
#object[clojure.core$_PLUS_ 0x33d6a662 "clojure.core$_PLUS_@33d6a662"]

นั่นหมายความว่า ตอนที่มันกำลัง eval มันเข้าไปดูว่า symbol + มัน store อะไรไว้ ซึ่งนั่นก็คือ function [17] ฉะนั้นแล้ว

user=> (+ 1 (+ 1 2))
4

ก็เหมือนกับว่า เมื่อ clojure eval มันจะเข้าไปดูความหมายที่เก็บไว้ของ + ก่อน

(#object[clojure.core$_PLUS_ 0x33d6a662 "clojure.core$_PLUS_@33d6a662"] 1 (#object[clojure.core$_PLUS_ 0x33d6a662 "clojure.core$_PLUS_@33d6a662"] 1 2))

จากนั้นมันถึงทำการ eval แล้วได้ค่าออกมา [17]

กลับเข้ามาที่ชื่อ special form ซึ่งจริงๆแล้วที่มันพิเศษกว่าชาวบ้านหรือถูกเรียกว่า special ก็เพราะว่ามันเป็น forms ที่ถูก eval พิเศษ

โดยปกติทั่วไป form จะทำงานในรูปแบบ eval (operator […operands]) หรือก็คือเราจะเอา operator ไปทำงาน กับ operands เช่นเมื่อเราบอกว่า (+ 1 2 3 4) นั่นหมายถึงว่าเราเอา + ไปทำงานกับ 1 2 3 4 [20]

note: เราเอาฟังก์ชัน + ไป apply กับ 1 2 3 4 ฉะนั้นฟังก์ชันที่ชื่อ apply ทำงานแบบนี้ (apply + [1 2 3 4]) จะเท่ากับ (+ 1 2 3 4) ก็คือเรานำ + ไปใช้ใน vector [1 2 3 4], ถ้าเล่น clojure ไปสักพักจะเจอว่ามันมีฟังก์ชันชื่อ reduce ที่ทำงานคล้ายๆกัน แต่ว่าจริงๆแล้วทำงานต่างกัน (reduce + [1 2 3 4]) จะได้เป็น (+ (+ (+ 1 2) 3) 4)

แต่ทีนี้ถ้ามีกฎแค่นี้เราก็จะเกิดปัญหา นั่นก็คือ แล้วเราจะสร้างตัวแปรขึ้นมาใช้ยังไง? สมมุติเราบอกว่า (def x 3) นั่นมันหมายความเราเอา def ไป apply กับ x และ 3 ? แบบนี้ก็ดูจะไม่มีความหมาย เพราะ def ไม่ได้ยุ่ง x แบบเดียวกับที่ยุ่งกับ 3 (อย่าลืมว่าตอนที่เรา (+ 1 2 3 4) นั่นเราเอา + ไปยุ่งกับทุกตัวในลักษณะเดียวกัน)

ในทางตรงกันข้าม มันเป็นการที่เราเอา x ไปยุ่งกับ 3 เองมากกว่า แบบนี้ก็จะหลุดกฎซึ่งเป็นที่มาของ special form นั่นเอง เมื่อเราต้องการสร้างกฎใหม่ที่ไม่ได้เอา operator ไปทำงานกับ operands (แบบที่เราเอา + ไปทำงานกับ 1 2 3 4) ก็จะถูกเรียกเป็น special forms หมด ทีนี้แสดงว่าอย่าง (if <เงื่อนไข> <ผลที่ตามมา> ​<ผลอื่นๆ>), ex. (if (> 2 1) "always true, right?" "no ways!")ก็แสดงว่าเป็น special forms ด้วย? ใช่แล้ว แสดงว่าคุณเข้าใจ special forms มาถูกทาง เพราะเราก็ไม่ได้เอา if ไป apply หมู่กับ arguments แต่เห็นได้ชัดว่ามันมีกฎพิเศษคอยคุมอยู่ [20]

เรากลับมาดูตัวที่น่าสนใจซึ่งคงผ่านตามาแล้วอย่าง def สำหรับการเอาไว้ประกาศนุ่นนี่ ซึ่งdef จริงๆแล้ว def ประหนึ่ง atom สำหรับ forms เพราะเดี๋ยวเราจะได้เห็นกันว่า forms ทุกอย่างล้วนงอกมาจาก def ทั้งนั้น (ยกเว้น special forms ) แต่ก่อนอื่นเรามาดูกันว่าจริงๆแล้ว def นั้นทำอะไรกันแน่

user=> (doc def)
-------------------------
def
  (def symbol doc-string? init?)
Special Form
  Creates and interns a global var with the name
  of symbol in the current namespace (*ns*) or locates such a var if
  it already exists.  If init is supplied, it is evaluated, and the
  root binding of the var is set to the resulting value.  If init is
  not supplied, the root binding of the var is unaffected.

  Please see http://clojure.org/special_forms#def
nil

ใน doc บอกไว้ว่า def นั้น

Creates and interns a global var with the name of symbol in the current namespace (*ns*) or locates such a var if it already exists.

อย่างที่บอกคือถ้าไม่มี def เราก็จะประกาศตัวแปรไม่ได้ และถ้าไม่มี fn เราก็จะประกาศฟังก์ชันไม่ได้ นั่นหมายความว่าเราไม่สามารถประกาศ macro ได้อีกด้วย อาจมีคนไม่เชื่อ ให้ลองใช้ sourceที่ปกติเอาไว้ดู source code ดู ลอง(source defmacro) ดู แล้วจะเห็นว่ามันสร้างมาจาก def ส่วน special form บางตัวจะใช้ defmacroสร้างขึ้น เช่น let และเอ่อ fn

(ข้างล่างขออนุญาตตัดบางส่วนทิ้ง เพราะเดี๋ยวมันจะรกเกินไป)

user=> (source defmacro)
(def

 ^{:doc "Like defn, but the resulting function name is declared as a
....

user=> (source fn)
(defmacro fn
  "params => positional-params* , or positional-params* & next-param
...

user=> (source def)
Source not found
nil

โอเค เราจะเห็นว่า def — สร้าง — > defmacro — สร้าง — > fn

ยังไม่สาแก่ใจตามไปดูใน source code ที่ core.clj ซะหน่อย

ถึงตรงนี้อาจมีบางคนงอกคำถามใหม่มาแทน แล้ว def มันคืออะไร ทำไมเราส่อง source code มันไม่ได้ ในขณะที่มันสร้างชาวบ้านทุกๆตัว ?

งั้นลองเข้าไปส่องใน clojuredocs ก่อนละกัน

อ่า….นั่นไงลิงค์เข้าไปดู source / คลิกพลัน

(… )

ที่เราหาไม่เจอจากใน source เพราะว่ามันไม่ได้ถูก implement จาก clojure แต่มันจะถูก binding ใน compiler แปลงเป็น bytecode อีกที จะว่าไปมันก็เมคเซนส์ เพราะเราจะเอาอะไรไปสร้าง def ตั้งแต่แรกล่ะ ในเมื่อมันอยู่นอกกฎ!?

เราสามารถเข้าไปส่องได้ที่ compiler.java

เราจะเห็นไอเดียคร่าวๆว่ามันเอา def ไปโยงกับ parser ของ DefExpr นอกจากนั้นตัว symbol อื่นที่เห็นในไฟล์นี้ ก็ถือว่าเป็นพวก special form ทั้งนั้น ตอนนี้เราอาจกล่าวได้ว่า special form ก็คือ symbol พิเศษที่ตั้ง rule ขึ้นมาโดยเฉพาะ

ฉะนั้นเราอาจกล่าวได้ว่า special forms นั้นคือสิ่งที่ primitive ที่สุดใน clojure และเป็น ground ในการสร้างสิ่งอื่นๆทั้งหมดในโลก clojure เลยก็ว่าได้

Function

อย่างที่เราเห็นมาก่อนหน้านี้ function คือ symbol หนึ่งๆที่ทำให้เกิดเป็น forms ขึ้นมา function มีทั้งที่ build-in เข้ามาอย่างพวกตัวดำเนินการทางคณิตศาสตร์อย่าง +,-,*,/ แต่จริงๆแล้วมันคืออะไรกันแน่? เวลาเรียกใน repl มันคืนอะไรออกมา ? เกิดอะไรขึ้นเมื่อเราสร้างฟังก์ชันใหม่ขึ้นมา? แล้วอะไรคือ verb?

user=> +
#object[clojure.core$_PLUS_ 0x378b64f7 "clojure.core$_PLUS_@378b64f7"]

user=> juxt
#object[clojure.core$juxt 0x2691d52a "clojure.core$juxt@2691d52a"]

user=> (defn lol [lol-what] (str "hahaha " lol-what))
#'user/lol
user=> lol
#object[user$lol 0x2948ef0a "user$lol@2948ef0a"]

function โดยพื้นฐานแล้วจะรับค่าอะไรสักอย่างแล้วก็จะคืนค่าอะไรสักอย่าง

user=> (fn [] 10)
#object[user$eval1275$fn__1276 0x7b781f24 "user$eval1275$fn__1276@7b781f24"]

user=> ((fn [] 10))
10

user=> ((fn [x] (+ 10 x)) 5)
15

การที่จะทำให้ function ทำงานได้มันจะต้องอยู่ในรูป forms ฉะนั้น เราจึงเห็นว่าถ้าเราใส่วงเล็บมันสองชั้น มันจะอยู่ในรูปฟอร์มที่ไม่ต้องการรับ argument ซึ่งทำให้มัน eval ได้ค่าออกมาเลยได้ ส่วนอันแรกมันก็คืนค่าออกมาเป็น verb อันที่สามคือเราเพิ่ม argument มันเข้าไปด้วย แล้วใส่ 5 เข้าไปในฟังก์ชันนั้น[7][13] ทีนี้เราก็จะพอบอกได้ว่า function โดยการทำงานมันเหมือนเราสร้างอะไรสักอย่างทิ้งไว้ ซึ่งถ้าไม่มีใครเรียกมันก็จะหายไป แต่ถ้ามีการเรียกการทำงานมันก็จะคืนค่าออกมา ลองดูที่ตัวอย่างสุดท้าย เราจะเห็นว่า จริงๆแล้วมันก็คือฟังก์ชันที่เอาค่าที่รับเข้ามาไป + 10 แล้วคืนค่ากลับ แต่ x ที่เป็น argument ตรงนี้เราเรียกว่ามัน unbound เพราะมันยังไม่มีค่าในตัวมัน …มันกำลังรอค่าอะไรสักอย่างมาแทนที่มันอยู่

user=> (let [x 1] (+ x 1))
2
user=> (let [x 2, y 3] (+ x y))
5

จากตัวอย่างการใช้ let เราจะเห็นว่าอย่าง (+ x 1) จริงๆก็คือฟังก์ชันที่เอาไปบวก 1 แล้วคืนค่านั้นออกมา แต่ทีนี้ x ในนี้ก็ยังเป็น unbound อยู่จนกระทั่งมี let ที่เอาค่า 1 ไปใส่ให้ x แล้วทำให้เราได้ (+ 1 1) ซึ่งคืนค่าออกมาเป็น 2 ทีนี้กลับมาดูฟังก์ชัน

user=> ((fn [x] (+ 10 x)) 5)
15

เราอาจบอกได้ว่า (fn [x] (+ 10 x)) นั้นถ้าเราตั้งชื่อสมมุติเป็น add-ten มันจะได้ออกมาเป็น (add-ten 5) ซึ่งก็จะทำในลักษณะเดียวกับ let คือนำ argument ที่ได้รับไป bound เข้ากับ unbound ตามตำแหน่งของ argument [13] ถ้ายังจำกันได้ def ก็ทำอะไรที่คล้ายๆกันกับ letเหมือนกัน แต่ต่างกันที่ scope โดย def จะไป bind ในระดับ global ในขณะที่ let จะ bind แค่ในระดับวงเล็บ

ทีนี้เรากลับมาดูที่ไอ่ก้อนแรก

#object[user$eval1275$fn__1276 0x7b781f24 “user$eval1275$fn__1276@7b781f24”]

ส่วนนี้มันคือ instance เพราะถ้ายังจำกันได้ตั้งแต่ตอนต้นว่า function ใน clojure สุดท้ายจะโดน compile ไปเป็น class

เรามาดู anatomy ของ instance อันนี้ดีกว่า เริ่มจาก function + เราเห็นว่า #object[clojure.core$_PLUS_ 0x378b64f7 “clojure.core$_PLUS_@378b64f7”] เริ่มจาก clojure.core ตรงนี้มันคือ namespace และ _PLUS_ (ซึ่งอันที่จริงมันแทนสัญลักษณ์ + )คื่อชื่อของ function ส่วน 0x378b64f7 นี่คือ memory address [13]

อะไรคือ namespace ของ clojure ถ้าเอาอย่างง่ายเลยมันคือที่อยู่ที่ฟังก์ชันนั้นเขียนขึ้นมา เช่นในที่นี้ก็คือใน core

ซึ่งจริงๆแล้วตัวมาโคร ns นี่เองที่เป็นตัวสร้าง namespace ของไฟล์นั้นๆ [7]

ตัวอย่างเพิ่มเติม เช่น

lein new app-to-show
cd app-to-show

แล้วเราจะได้ folder structure ดังนี้

เข้าไปดูไฟล์ core.clj

(ns app-to-show.core)

(defn foo
  "I don't do a whole lot."
  [x]
  (println x "Hello, World!"))

โอเค ดูข้างบนสุด เราจะได้ namespace สำหรับไฟล์ core.clj ซึ่งมันอยู่ใน namespace app-to-show.core แล้วถ้าเราจะพูดถึงฟังก์ชัน foo มันก็คือ app-to-show.core$foo โดยปกติ clojure มักจะนิยมตั้ง namespace ตาม folder structure

function โดยง่ายสุดประกาศผ่าน defn

user=> (defn plus-ten [x] (+ 10 x))
#'user/plus-ten
user=> (plus-ten 10)
20

โครงสร้างของการประกาศผ่าน defn มีดังนี้

(defn <function-name> <vector-of-parameters> <body>)

นั่นก็คือเริ่มจาก defn ตามด้วยชื่อ function function-name แล้วตามด้วย vector ที่ข้างในรับ parameter เช่น[x y z] แล้วตามด้วย body เช่น (+ x y z) ประกอบกันจะได้ (defn function-name [x y z] (+ x y z))

(ถ้าไม่ใส่วงเล็บตรง body อย่าง (defn function-name [x y z] + x y z) มันจะคืนเป็นค่าของ z มา นั่นก็เพราะว่าตามปกติธรรมชาติของ clojure มันมักจะคืนตัวหลังสุดก่อน)[13]

แต่ทีนี้ฟังก์ชันมันไม่จำเป็นต้องรับ argument ก็ได้ จะได้เป็น

user=> (defn return-5 [] 5)
#'user/return-5
user=> (return-5)
5

Macro นั้นหน้าตาคล้ายฟังก์ชันมาก เราลองมาดูตัวอย่างการประกาศ macro กันก่อน

(defmacro t1 [x] x)

อ้าวหน้าตามันก็เหมือนฟังก์ชันเลยนี่หว่า คือมีชื่อ คือ t1 รับค่าคือ x แล้วมี body ในที่นี้คือคืนค่า x เอ๊ะแบบนี้มันก็ไม่ต่างนี่หว่า จริงๆแล้วมันอาจจะต่างนิดหน่อยในตัวอย่างนี้ ไม่เชื่อลอง (defn t2 [x] x) จากนั้นพิมพ์ t2 ลงไปบน repl

#object[user$t2 0x712b623d "user$t2@712b623d"]

ทีนี้ลองจัด t1 กันบ้าง จะเจอกับ error หน้าตาคล้ายๆแบบนี้

CompilerException java.lang.RuntimeException: Can't take value of a macro: #'user/t2, compiling (/private/var/folders/db/vnkkt7mx5wj84jxcwh4jplsw0000gn/T/form-init1239338506849356429.clj:1:1062)

กลับมาที่ macro มีคนบอกว่ามันต่างจากฟังก์ชันตรงที่

• macro แปลงโค้ดๆนึงไปเป็นโค้ดอีกแบบนึง
• function แปลงค่านึงไปเป็นอีกค่านึง

โอ้ว นี่มัน abstract ระดับนึงเลยนะเนี่ย [9] อันที่จริงเรามาทำ”อะไรๆกับโค้ด” อย่างที่เขาบอกดูบ้าง อย่าง clojure จะใช้ funtion ขึ้นก่อนตามด้วย argument เช่น ‘+’ จริงๆมันก็คือฟังก์ชัน add เช่น (+ 1 1)จะได้ 2 ทีนี้เราอยากลองให้มันสลับที่ของ argument บ้าง เช่น แทนที่ (/ 20 2) จะได้ 10 มันจะต้องสลับเป็น (/ 2 20) แล้วได้ 1/10 แทน โดยเราจะลองทั้ง macro แล้วก็ function เขียนเหมือนๆกัน โดยเราจะใช้ฟังก์ชัน list เข้ามาช่วยสร้าง list อีกที

user=> (defmacro m [x y z] (list x z y))
user=> (defn f [x y z] (list x z y))

user=> (m / 20 2) 
1/10
user=> (f / 20 2) 
(#object[clojure.core$_SLASH_ 0x36e8bb94 "clojure.core$_SLASH_@36e8bb94"] 2 20)

(defn f [x y z] (x y z)) ;; แก้เกมสำหรับฟังก์ชัน เอาใหม่ๆ
user=> (f / 20 2)
1/10

อืม มาดูที่ฟังก์ชัน f ก่อน ถ้าเราดูดีๆเราจะพบว่าคำตอบมันสลับที่กันอยู่จริง คือ 2 สลับกับ 20 ส่วนไอ่ก้อนๆข้างหน้าจริงๆแล้วมันคือ / นั่นแหละ (ดูที่คำว่า _SLASH_) แสดงว่า / มันไม่ได้ทำงานรับ 2 กับ 20 แล้ว resolve แต่อย่างใด ซึ่งจริงๆก็ถูกต้องแล้วเพราะเราใช้ฟังก์ชัน list มันก็ควรจะคืนค่ามาเป็น list ถูกไหม ได้เป็น (/ y z) ซึ่ง / มันก็คืนค่ามาเป็น verb ที่ /ชี้ไปหานั่นเอง

ในขณะที่มาโคร m มันคืนค่าออกมาเป็น 1/10 ซึ่งมันหมายความว่าจริงๆแล้ว มันมองเห็นว่า (/ y z) เป็น code ไม่ใช่ list! จากนั้นมันจึงทำการ eval ทั้งก้อนนี้อีกที [7][10]

ส่วนของ macro ค่อนข้างซับซ้อนและน่าจะมีอะไรให้พูดอีกเยอะมากๆ คร่าวๆไว้แค่นี้ก่อนฮะไว้มาเขียนต่อในบทความอื่นๆ

บทสรุป การสร้างจักรวาล Clojure

1. Compiler และ Reader สำหรับ eval และ read เพื่อแปลง Clojure ไปเป็น JAVA bytecode และนำไปทำงานใน JVM
2. Reader forms เปรียบเสมือน atom ของโลก Clojure พวกนั้นได้แก่ symbol, literals, list, vector, map, set
3. Symbol บางตัว สมควรที่จะมีความพิเศษเหนือชาวบ้าน หรือมีกฎที่แตกต่างออกไป เช่นเอาไปสร้างเงื่อนไข สร้าง function พวก symbol พิเศษนี้เราเรียกว่า special forms
4. ในโลก Clojure ตัว verb ที่สามารถทำงานได้จะอยู่ในรูป list เราเรียกพวกนี้ว่า forms ซึ่งประกอบไปด้วย function, macro, และ special forms

Acknowledgement:

ขอบคุณพี่ๆเพื่อนๆที่ตรวจทานบทความ ให้คำแนะนำ และเสนอแนะ I'Boss Potiwarakorn, Weerasak Chongnguluam, Veha Suwatphisankij, Thanat Jatuphattharachat, Tap

References:

[1] https://insights.stackoverflow.com/survey/2017

[2] https://clojure.org/

[3] http://blog.guillermowinkler.com/blog/2014/04/13/decompiling-clojure-i/

[4] https://www.braveclojure.com/getting-started/

[5] https://en.wikipedia.org/wiki/List_of_JVM_languages

[6] http://blog.ndk.io/clojure-compilation.html

[7] Michael Fogus and Chris Houser. 2014. The Joy of Clojure(2nd ed.). Manning Publications Co., Greenwich, CT, USA.

[8] https://clojure.org/reference/java_interop#typehints

[9] http://blog.klipse.tech/clojure/2016/05/01/macro-tutorial-1.html

[10] https://www.braveclojure.com/writing-macros/

[11] https://www.safaribooksonline.com/library/view/clojure-programming/9781449310387/ch09s05.html

[12] http://clojure-doc.org/articles/language/functions.html

[13] https://aphyr.com/posts/303-clojure-from-the-ground-up-functions

[14] https://clojure.org/reference/reader

[15] https://en.wikibooks.org/wiki/Learning_Clojure/Special_Forms

[16] http://clojure-doc.org/articles/language/macros

[17] https://aphyr.com/posts/301-clojure-from-the-ground-up-first-principles

[18] https://en.wikipedia.org/wiki/Interpreted_language

[19] https://www.destroyallsoftware.com/compendium/types?share_key=baf6b67369843fa2

[20]Harold Abelson and Gerald Jay Sussman with Julie Sussman. Structure and Interpretation of Computer Programs (2nd edition). The MIT Press.

[21]https://insights.stackoverflow.com/survey/2018/

1. นั่งคิดว่ามันคืออะไร เขาจะหมายถึงการเหยียดที่กระทำเป็น uniform distribution แบบนั้นเหรอ หมายถึงเหยียดทุกกลุ่มทุกคนอย่างเท่าๆกันด้วยการกระจายเท่าๆกัน (หมายความว่าไม่ได้มีกลุ่มใดกลุ่มนึงโดนเหยียดเป็นพิเศษ) แต่ถ้าแบบนี้มันจะตอบยากเป็นพิเศษ เพราะเราไม่รู้ว่ามันต้องกระจายไปถึงเท่าไหร่หรือเปล่า? โอเคลองนึกภาพตาม สมมุติว่าเรามีเซตของกลุ่มที่จะต้องเหยียดเป็น {a, b, c, …, n} เมื่อ n คือกลุ่มที่จะเหยียดอันสุดท้าย ถ้างั้นหมายความว่าเราจำเป็นที่จะต้องเหยียด n กลุ่ม (และแน่นอนด้วยการกระจายแบบเท่าๆกัน — uniform distribution) คำถามคือ เราแน่ใจได้อย่างไรว่าเรา reach ไปถึง n กลุ่มแล้ว ? (แต่แน่นอนเพื่อความ ideal เราจะมาพูดถึงเรื่องนี้อีกรอบในภายหลัง) หรือเอาเข้าจริงคือ เราจะมั่นใจได้อย่างไรว่าเราจะเหยียดได้แบบ universal จริงๆ

2. ต่อมาเรามั่นใจได้อย่างไรว่าจะไม่มีใครถูกเหยียดเป็นพิเศษ? หมายถึงว่าจากข้อ 1. สมมุติว่า ในเมื่อเราไม่สามารถ reach ไปถึง n ได้เนื่องด้วยความไม่รู้ (ขีดจำกัดว่าด้วยความไม่รู้ว่ามีกลุ่มที่ตกหล่น) แสดงว่าถ้ามีการตกหล่น มันจะต้องมีกลุ่มใดกลุ่มนึงที่โดนเหยียดเป็นพิเศษใช่หรือไม่ (ต้องใช่สิ) หรือถ้าพูดกันแบบ real world problem เราจะแน่ใจได้อย่างไรว่าถ้าเกิดคนถือ universal racism หรือเหยียดชาวบ้านอย่างเท่าๆกันแบบเต็มไปหมดแล้ว (หมายถึงแนวคิดนี้แพร่เป็นวงกว้างจนแทบจะ dominating สังคมแล้ว) จะไม่มีกลุ่มใดกลุ่มนึงที่โดนเหยียดเป็นพิเศษ และไม่มีสภาวะโครงสร้างใดๆที่เอื้อให้มีคนถูกเหยียดเป็นพิเศษ? และเราจะแน่ใจได้อย่างไรว่าแนวคิดนี้ไม่ได้สร้างปัญหาการกดทับที่รุนแรงยิ่งกว่าเดิมมหาศาล เนื่องด้วยมันทำให้ฝั่งที่มีพลวัตอำนาจแต่เดิมแล้วคุมเกมได้ยิ่งกว่าเดิม? (หมายความว่าหากประชากรส่วนใหญ่ไม่มีทางจะเหยียดแบบ reach ไปได้ n/2 ด้วยซ้ำ การเหยียดกลุ่ม a ไปถึงกลุ่ม n/2 จะยิ่งกว่าเป็นการเหยียดซ้ำไปซ้ำมาอย่างซ้ำซาก)

3. นั่นนำมาสู่ข้อเสนอจากข้าพเจ้าถึงการ จะไปสู่ universal racism ได้อย่างไร? ข้าพเจ้าขอเสนอว่า

3.1 ตกลงให้แบ่งกลุ่มจัด stereotype ให้ชัดเจนว่าจะมีจำนวน n กลุ่มขั้นต่ำที่จะต้องเหยียดให้ครบ

3.2 ให้กลุ่ม A เหยียดทุกกลุ่มในวัน α จากนั้นวันต่อมาให้กลุ่ม Β เหยียดทุกกลุ่มในวัน β ไปเรื่อยๆ…จนถึงกลุ่ม n ในวันที่ N จากนั้นก็วนเริ่มใหม่

หรือเขาจะหมายถึงแบบอื่นกัน ?

2.structure และ architecture ของตัว project สำคัญตั้งแต่แรกเริ่ม การวางแย่มาตั้งแต่ตอนแรกจะทำให้ตอนหลังมีปัญหาที่จะต้องรื้อตัว proj นั้นใหม่ แต่กระนั้นก็ไม่มีอะไรที่ดีตั้งแต่แรกหรือเราก็ไม่รู้ว่าตอนแรกที่คิดว่าดีจะกลายเป็นแย่ตอนท้ายหรือเปล่า แต่พิจารณาง่ายๆว่าตัวโครงสร้างมันเป็น modular พอหรือเปล่า มัน independent ขนาดไหน ก็คือควรพยายามทำให้มันเป็นตัวต่อ lego ถอดๆเสียบๆได้ ยิ่งในยุคที่เทคโนโลยีไปกันไวมาก การวางโครงสร้างไว้ให้ดีจึงเป็นอะไรที่สำคัญมาก นอกจากนั้นยังทำให้ง่ายต่อ developer ต่อการทำความเข้าใจภาพรวมของตัว software นั้นๆด้วย

3.naming ขอพูดเรื่องนี้แยกจาก convention เรื่องนี้ดูเหมือนเล็ก แต่จริงๆแล้วใหญ่มาก การคิดระบบตั้งชื่อที่ดีตั้งแต่ตอนแรกช่วยให้เราสามารถทำงานได้เร็วขึ้นอย่างมีนัยยะสำคัญ เพราะ 1. ไม่เกิดการสับสนระหว่างชื่อนั้นนี้ และป้องกันไม่ให้เกิดการตั้งชื่อซ้ำได้ 2. ชื่อที่ดีจะทำให้เราสามารถ focus และทำให้ code มัน readability สูงขึ้น คิดง่ายๆว่าถ้าตั้งชื่อ function ที่อ่านปุ๊บรู้เลยว่ามันเอาไว้ทำอะไร มันก็เพิ่ม flow มากๆแล้ว ปัญหาคือ แล้วถ้าเกิด function มันทำงานใกล้กันมากล่ะๆ อันนี้เป็นปัญหาจริงๆ มีหลายข้อเสนอ แต่สำหรับเรา ถ้ามัน refactor ไม่ได้ หรือยุบรวม function ไม่ได้ เราคิดว่าเรายอมตั้งชื่อ function ให้ยาวดีกว่า แล้วก็ comment เพิ่มไปอีกนิดหน่อย ซึ่งแน่นอนว่าวิธีนี้ก็มี cost ของมัน

เนื่องจากบทความนี้ใช้เครื่องมืออยู่สามเครื่องมือ จึงขออนุญาตแบ่งบทความออกเป็นสามท่อนตามแต่ละเครื่องมือ คือ

1. Hapi.js
2. Firebase
3. Angular.js

Motivation

ที่มาของบทความนี้เกิดจากว่าต้องการหาตัวจัดการกับ server ที่ดูง่ายๆ และทำงานกับ database ที่ไม่ยากเกินไปนัก ในระดับที่นั่งเขียนโค้ดกันไม่เกินชั่วโมงสองชั่วโมงก็ได้คร่าวๆแล้ว ตัว framework ที่เราเลือกผลจึงตกมาที่ Hapi เพราะดูจาก document แล้วอ่านไม่ยากเกินไป รวมทั้ง API ที่ดูเข้าใจง่าย (นอกจากนั้นอีกเหตุผลคือไม่เคยลอง แล้วอยากลอง) ในขณะเดียวกัน Firebase ก็ถือว่าเป็นทางเลือกที่ดีเนื่องจากเป็น realtime database ที่อยู่บน cloud เรียกใช้งานได้ง่าย มี gui รองรับ พูดง่ายๆว่าการมี firebase ทำให้ประหยัดเวลาในการจัดการกับพวก backend ไปได้มาก (เหมาะกับพวกชอบลองเทคโนโลยีนุ่นนี่เป็น hobbyist อย่างเรา) นอกจากนั้นยังสามารถทำพวก single-page application ได้อย่างง่ายอีกด้วย(เพราะเสมือนว่ามีคนทำ backend ให้คร่าวๆแล้ว — ถ้ายังจำได้เคยมีแข่งสร้าง web app โดยกำหนดให้ทำแค่ frontend only แนวแฮคคาธอนด้วยแหละ สนับสนุนโดย firebase, ฉลาดจริงๆ) ทั้งนี้ตัว front-end ที่เราเลือกมาจับโยงข้อมูลคือ AngularJS

สิ่งที่ต้องมีก่อนเล่นกับ Hapi + firebase + angularJS นั่นก็คือ Node.js และ npm ซึ่งพวกนี้เอาไว้เล่นกับ Hapi ส่วน firebase กับ angularJS ไม่จำเป็นต้องติดตั้งอะไร เพราะเดี๋ยวเราจะเรียกใช้ไปเลย แต่ทั้งนี้เราต้องการ node.js เวอร์ชันใหม่ๆขึ้นไป (เพื่อรองรับ ECMAScript 5)

1. HapiJS

Hapi เป็น framework ตัวหนึ่งที่ทำงานบน Node.js โดยในที่นี้เราจะเอามาไว้สร้าง เซิฟเวอร์แล้วให้มันทำหน้าที่เป็นตัว render ไฟล์ html แบบเบื้องต้น

เปิด terminal (หรือ command prompt) cd ไปยัง path ที่ต้องการทำงาน จากนั้นพิมพ์คำสั่งลงไป

npm init

จากนั้นจะมีให้กรอกรายละเอียดเกี่ยวกับ project ของเรา ก็ใส่รายละเอียดลงไปแล้วกด enter ถ้าไม่ใส่มันจะเป็นค่า default ซึ่งก็คือค่าที่อยู่ในวงเล็บ

จากนั้นจะมีสรุปข้อมูลและถามว่าเราชัวร์ไหม ก็ให้ตอบ yes

เพื่อทำการติดตั้ง module ของ hapi ลงใน project ใช้คำสั่งนี้

npm install hapi — save

จากนั้นสร้างไฟล์ใหม่ชื่อ server.js แล้วนำโค้ดด้านล่างไปใส่ คำอธิบายการทำงานอยู่ตรงคอมเม้น ส่วน ‘use strict’ ขออธิบายคร่าวๆว่าเป็น features ใหม่ของ ECMAScript 5 ซึ่งจะทำให้มันเช็ค error มากขึ้นและป้องกันมากขึ้น
อ่านเพิ่มเติมได้ที่นี่ ECMAScript 5 Strict Mode ซึ่งไอ่ตัวนี้มัน require พวก node เวอร์ชันใหม่ๆ ก็ทำการอัพเดทกันก่อน (อาจจะอัพเดทผ่าน nvm — node version manager, หรืออัพเดททับกันดิบๆเลยก็ได้)

จากนั้นกลับไปที่ terminal แล้วใช้คำสั่งนี้

npm start

ถ้าสำเร็จจะขึ้นเป็น

SERVER STARTED: http://Wasawats-MacBook-Pro.local:2000

(ซึ่งค่าตรง server.info.uri ที่เราให้แสดง log ก็ได้มาจากต้นตอของ server นั่นแหละ ซึ่งในที่นี้คือ http://Wasawats-MacBook-Pro )

นั่นมันหมายความว่าเราได้สร้าง server เบื้องต้นขึ้นมาแล้ว แต่ผมอยากกำหนดให้มันพิมพ์เป็น localhost แล้วตามด้วย port เพราะรู้สึกว่าตอนนี้มันยาวไปสิ่งที่ผมต้องทำคือเพิ่ม host ไปใน server.connection

server.connection({
 port: 3000,
 host: ‘localhost’
});

จากนั้นถ้าเราลอง npm start จะเห็นว่าตอนนี้แทนที่จะเป็น http://Wasa... ยาวๆ มันเปลี่ยนเป็น http://localhost:3000 แทน

จากนั้นได้เวลาจัดการส่วนอื่นเพิ่มเติม อย่างการทำหน้า html

ก่อนอื่นเราต้องติดตั้ง plugin เข้าไปก่อน โดยเราจะติดตั้งตัวที่ชื่อว่า inert มาช่วยในการจัดการกับ static files

npm install — save inert

จากนั้นเพิ่มโค้ดนี้เข้าไปในไฟล์ server.js

จะเห็นว่ามีการเรียกใช้ inert โดยผ่านเป็น parameter เข้าไปใน function ต่อจากนั้นถ้ามาดูตรง reply จะเห็นว่าจำเป็นต้องมี subfolder ชื่อ public และมี file คือ index.html อยู่ในนั้น จากนั้นดูตรง path จะเห็น ‘/test’ นั่นหมายความว่าเราได้สร้าง route ในที่นี้ก็คือ http://localhost:3000/test

แน่นอนว่าเรายังไม่มี public และ index เราเลยต้องมาสร้างก่อนโดยสร้าง subfolder คือ public แล้วสร้าง index.html ลงไปในนั้น ซึ่งเบื้องต้นใน index.html ใส่โค้ดนี้ลงไป

<body>
<h1> Hello world </h1>
</body>

จากนั้น npm start แล้วตามเข้าไปดู ในที่นี้คือ http://localhost:3000/test ถ้าสำเร็จก็จะขึ้น Hello world โชว์หรา

ก่อนที่เราจะไปส่วนต่อไปเรามาหาวิธีโยนข้อมูลเข้า database แบบง่ายๆก่อนด้วยการให้มันโยนผ่าน jsonp ครับ

jsonp ย่อมาจาก JSON with padding จากการไล่ๆดูเพื่อหาคำอธิบายที่ฟังดูง่ายๆคิดว่าอันนี้น่าจะพอใช้ได้

“JSONP is script tag injection, passing the response from the server in to a user specified function” — https://remysharp.com/2007/10/08/what-is-jsonp

หรือก็คือมันมีการอนุญาติให้เราใส่ข้อมูลผ่าน URL แล้วยิงเข้าไปที่ DOM (ผ่านการ inject ด้วย tag <script>) ซึ่งอยู่ในรูปฟังก์ชันให้เรียกใช้ ถ้ายังงงๆลองดูตัวอย่าง

ถ้าสมมุติเราอยากได้ json เราก็ทำการส่ง request เข้าไป เราก็จะได้ JSON ในรูปแบบประมาณนี้

[{
“id”: 1,
“name”: “Cameron”
}]

ส่วน JSONP จะใกล้เคียงเพียงแต่โดนยัดไปอยู่ในรูปฟังก์ชันให้เรียกใช้ (โดยผ่านทาง callback)

someCallback([{
“id”: 1,
“name”: “Cameron”
}]);

ตัวอย่างการเรียกใช้ callback

someCallback = function(data){
console.log(data.id); // which data.id = 1
};

ทีนี้ใน Hapi มันจะมีตัวช่วยในการที่เราจะใช้งาน JSONP กับการส่งข้อมูลไปที่ firebase ผ่าน URL แต่ก่อนอื่น ลองดูตัวอย่าง code ข้างล่างนี้ก่อน

เรามาดูที่ server.route ก่อน จะเห็นว่ารอบนี้ตรง path ของเราเป็น

path: ‘/{temperature}/{humidity}/’

ทีนี้ตรง {temperature} กับ {humidity} จะเป็น key ที่เราจับคู่กับข้อมูลที่เราใส่เข้าไปใน URL เช่น สมมุติว่าผมอยากส่งค่า temperature เป็น 10 กับ humidity เป็น 20 ผมต้องใส่ URL เป็น http://localhost:3000/10/20/ (อย่าลืมใส่ / ปิดท้ายเลข 20 ด้วย ผมเคยงงๆมาแล้ว)

ทีนี้เราก็จะได้ json ที่มีข้อมูลประมาณนี้ { temperature: ‘10’, humidity: ‘20’ }

มาดูต่อที่ config ตรง handler (ที่เราเคยใช้ก่อนหน้านี้) จริงๆแล้วมีไว้จัดการกับ request, response (ใน Hapi ใช้ replyในการจัดการกับ response ซึ่งมีรายละเอียดนิดหน่อยถ้าสนใจเข้าไปอ่านได้ — hapi_reply) หรือตัวใส่ logic ให้ route นั่นเอง ในที่นี้เราจะใช้ function test (ซึ่งเขียนไว้ตรงด้านบน) เพื่อทดสอบว่า ค่าที่เราส่งผ่าน URL เนี่ย มันส่งติดเป็น jsonp หรือเปล่า ส่วนตรง jsonp: ‘callback’ นั่นก็คือเราเรียกใช้ jsonp สำหรับ route นี้นั่นเอง

ย้อนกลับไปดู function test ที่เขียนไว้ด้านบน

var parts = {
temperature: request.params.temperature,
humidity: request.params.humidity
};

จะเห็นว่าเราเปลี่ยนตรง request มันมาเก็บไว้ใน parts และสามาถเรียกเก็บได้ด้วยการเติมชื่อตัวแปรต่อท้าย อย่าง temperature เราก็แค่ใช้ request.params.temperature ทีนี้มันทำให้ส่วนนี้เราสามารถใช้เป็น logic ในการโยนเข้าไปใน database ของเราได้

ส่วนตรง return reply ตรงนี้เป็นการแสดงข้อมูลไปที่หน้าเพจ ในที่นี้แสดงข้อมูลของ parts ซึ่งหลังจากเราทำการพิมพ์ URL http://localhost:3000/10/20/
เราจะเห็นว่าได้มีข้อมูลแสดงตรงหน้าเพจเป็น

{"temperature":"10","humidity":"20"}

2.ว่ากันด้วยเรื่องของ Firebase

ถ้าใครได้ดูงาน google I/O ที่ผ่านมามีการพูดถึง firebase ด้วย แล้ว Firebase คืออะไร? ถ้าเข้าไปอ่านใน wiki มีคำอธิบายไว้ว่า

Firebase is a cloud services provider and backend as a service company.

ซึ่งเอาเข้าจริงแล้วที่เราจะใช้ในรอบนี้มันคือ real time database ซึ่งเป็นส่วนนึงของ service

Firebase’s primary product is a realtime database which provides an API that allows developers to store and sync data across multiple clients.

เอาง่ายๆคือเราจะใช้ firebase ในการเป็น database เก็บข้อมูล ซึ่งในที่นี้คือเก็บข้อมูลลงบนคลาวด์ สิ่งที่ควรรู้อีกอย่างก็คือ firebase มันเป็น noSQL ถ้าเคยใช้ noSQL ตัวอื่นมาก่อนแล้วก้เข้าใจได้ไม่ยาก (เช่น MongoDB, Cassandra, ฯลฯ) คือพวกนี้มันจะไม่เก็บข้อมูลเป็นตาราง แต่มันจะเก็บเป็น key-value pair แทน ซึ่งในเว็บ firebase เองก็บอกไว้ว่าเป็น JSON

Data in your Firebase database is stored as JSON and synchronised in realtime to every connected client.

ก่อนอื่นเราต้องลงทะเบียนสมัครสมาชิกของ firebase ก่อนครับ ถ้าลงทะเบียนแล้วก็ log in เข้าไป ทีนี้เราก็สร้าง app ใหม่ ตรงนี้เลยฮะ

ช่อง name คือเราตั้งชื่อให้กับ app ซึ่งโดยปกติมันจะทำให้ตรงกัน แต่เราจะปรับเองก็ได้ ซึ่งพยายามคิดชื่อให้อย่าซ้ำกับชาวบ้าน

หลังจากกรอกข้อมูลเรียบร้อยเสร็จเราก็จะได้ที่เอาไว้สำหรับเก็บข้อมูลสำหรับโปรเจคเราแล้ว จากนั้นเราก็กด Manage Appหลังจากเข้าไปแล้วจะพบว่าข้อมูลมันโล่งเลย “This location is empty!” ซึ่งนั่นก็ถูกแล้ว เพราะเรายังไม่ได้โยนข้อมูลเข้าไปเก็บมันเลย ขั้นต่อไปคือเชื่อม Hapi เข้ากับ Firebase

ก่อนอื่นเลยเราต้องติดตั้ง firebase ก่อน

npm install –save firebase

จากนั้นเราก็ใส่บรรทัดนี้เข้าไปใน server.js เพื่อเป็นการเรียก firebase

const firebase = require(‘firebase’);

ทีนี้เราต้องใส่การอ้างอิง (reference) จาก server เราไปยังที่อยู่ของ app ใน firebase ที่เราสร้างไว้ ซึ่งที่จริงแล้วมันจะมีประเด็นเรื่องความปลอดภัยด้วย เพราะการเซ็ตตาม tutorial เป็นไปเพื่อความง่าย ซึ่งทำให้คนอื่นสามารถส่งอะไรเข้าฐานข้อมูลได้ ฉะนั้นถ้าจะทำต่อจริงจังควรศึกษาเรื่องการจัดการกับ security และ rules ด้วย

เราเข้าไปที่ app ที่เราได้สร้างไว้แล้วนำ URL มาใส่ (สมมุติอันนี้ตั้ง name ชื่อ “hfa-article”)

const myFirebaseRef = new firebase(“https://hfa-article.firebaseio.com/");

ในส่วน ฟังก์ชัน test อย่างที่เคยบอกไว้ว่ามันเป็นส่วนที่เราจะโยนข้อมูลจาก jsonp เนี่ยลงไปใน database เราก็เขียนโค้ดด้านล่างลงไปใน test การทำงานมันตอนแรกก็ด้วยการสร้างหัวข้อย่อยจากตัว app (สร้าง child นั่นเอง คือเป็น child ของ app) โดยเรากำหนด child สองตัวตามตัวแปรที่เราจะโยนมา จากนั้นเราก็โยนด้วยการใช้ .push จะเห็นว่าเราเอา object ชื่อ parts ที่สร้างไว้ตอนแรกมาโยนเข้าไป (หรือเอาจริงๆจะโยน request.param.temperature ก็ยังได้) โดยโยนเข้าไปในคีย์ “time”

var tempRef = myFirebaseRef.child(“temp”);
var humidRef = myFirebaseRef.child(“humid”);
tempRef.push({“time”: parts.temperature});
humidRef.push({“time”: parts.humidity});

จากนั้นกด save แล้ว npm start พิมพ์ URL

localhost:3000/10/20/ กด enter

หลังจากมันโผล่มาในหน้าจอแล้วให้ลองไปดูที่ app ใน firebase ของเรา ถ้าไม่มีอะไรผิดพลาดข้อมูลก็ควรจะถูกส่งมาแล้ว

3.Angular + Firebase (ใน client-side)

Angular คือ framework (ในขณะที่ React, jquery เป็น library) ตัวหนึ่งที่เอาไว้จัดการในส่วน client-side หรือก็คือหน้าเพจเรา มันถูกสร้างมาเพื่อตอบสนองต่อความท้าทายของการทำเว็บแอพซึ่งในยุคปัจจุบันมีแนวโน้มที่หน้าเว็บหนึ่งๆจะมีความซับซ้อนมากขึ้น

“AngularJS (commonly referred to as “Angular” or “Angular.js“) is an open-source web application framework mainly maintained by Google and by a community of individuals and corporations to address many of the challenges encountered in developing single-page applications.” — wikipedia

ส่วนถ้าใครเคยเขียน jQuery มาก่อน ผมแนะนำให้เข้าไปอ่านในนี้ครับ น่าจะทำให้เข้าใจได้ไวขึ้น “Thinking in AngularJS” if I have a jQuery background?

ขอเกริ่นไว้แค่นี้ก่อนฮะ ถ้าสนใจก็ลองหาอ่านเพิ่มกันดู โอเคเรามาต่อเรื่องของเรากัน ตอนนี้เรามีตัวเก็บข้อมูลแล้ว ระบบหลังบ้านก็พร้อมแล้ว ได้เวลาจับข้อมูลมาแสดง ซึ่งในส่วนนี้เราจะใช้ firebase ทำงานร่วมกับ angular นะฮะ

ก็เปิดไฟล์ index.html ที่เราเอาไปใส่ไว้ในโฟลเดอร์ public ในตอนแรก ซึ่งตอนนี้ยังมีแค่ Hello world อยู่

เพื่อความสะดวกของคนเขียนบทความเองจึงขอยกโค้ดมาทั้งหมดก่อนแล้วไว้อธิบายแยกทีหลัง

จะเห็นว่ามีการกำหนด reference ก่อน

// database reference
var ref = new Firebase(“https://hfa-article.firebaseio.com/");
var tempRef = ref.child(“temp”);
var humidRef = ref.child(“humid”);

โดยเริ่มจาก ref เป็นการกำหนดตัวอ้างอิงไปยัง url ที่เราได้สร้าง app บน firebase service จากนั้นพวก tempRef และ humidRef เป็นการอ้างอิงไปยังตัวลูก temp และ humid

จากนั้นเราจะไปเรียกข้อมูลมา ซึ่งเท่าที่ดูใน guide ผมต้องการข้อมูลในลักษณะ list อะไรทำนองนั้น จึงต้องเรียก event ที่ชื่อ “child_added“

The child_added event is typically used when retrieving a list of items from the database. Unlike value which returns the entire contents of the location, child_added is triggered once for each existing child and then again every time a new child is added to the specified path.

ซึ่งใช้ร่วมกับ .on สมมุติว่าผมอยากได้ข้อมูลของ temp -> tempRef.on(“child_added”);

ซึ่งจริงๆแค่นี้ก็ใช้งานได้ แต่เพื่อกันเหนียวหรือเพื่อเช็คว่ามีการเรียกข้อมูลเกิดขึ้นจริงหรือมีเออเร่อเกิดขึ้นตรงไหนหรือเปล่า ผมเลยต้องเพิ่มไปสองฟังก์ชัน(callback function) นั่นก็คือ function สำหรับเช็คค่า และ function สำหรับ handle error ดูอันแรกก่อนตรงที่เราใส่ parameter เป็น snapshot ตัวนี้เป็นตัวเอาไว้เช็คว่ามีการส่งค่าเกิดขึ้นจริง ซึ่งต้องใช้ร่วมกับ val() ซึ่งมันจะคืนค่ามาเป็น JavaScript object ของข้อมูลที่เราโยงไว้กับตัวอ้างอิง (ในที่นี้ก็คือ tempRef ซึ่งอ้างอิงไปยังตัวลูก temp ของแอพ hfa-article) เนื่องจากเรามีตัวลูกชื่อ time อยู่ข้างใน temp อีก ตอนพิมพ์ค่าออกมาเราเลยใช้เป็น snapshot.val().time

ฉะนั้นโค้ดที่ได้ออกมาเลยเป็น

tempRef.on(“child_added”, function(snapshot) {
console.log(snapshot.val().time);
}, function (errorObject) {
console.log(“The read failed: “ + errorObject.code);
});

ต่อมาเราจะทำการใส่ Firebase ลงไปใน Angular (ซึ่งตรงนี้จะใส่ได้ เราต้องติดตั้ง AngularFire ซึ่งเราได้ทำการใส่ไปแล้ว ตรง head) โดยตั้งชื่อ app ของ Angular ว่า “sampleApp”

var app = angular.module(“sampleApp”, [“firebase”]);

ซึ่งหลังจากนี้จะทำให้เราสามารถโยนข้อมูลทีไ่ด้รับจาก tempRef และ humidRef ได้ โดยผ่านทาง $scope และ $firebaseArray (โดย $scope เป็น service ของ Angular เอาไว้จับคู่ข้อมูลแบบ 2-way data binding และ firebaseArray เอาไว้แปลง list ข้อมูลที่ได้จาก reference มาเป็น array) ยกตัวอย่าง

$scope.temps = $firebaseArray(tempRef);

จะอธิบายได้ว่า นำข้อมูลที่ได้จาก tempRef (ซึ่งข้อมูลได้เป็น list จาก event ชื่อ “child_added”) ผ่านเข้าไปใน firebaseArray ก่อนที่จะจับมันโยงเข้ากับ $scope.temps ซึ่งตรงนี้จะนำข้อมูลไปจับคู่กับตัวแปร temps ใน HTML (เดี๋ยวเราจะมาอธิบายกันอีกที) — (ดูเพิ่มเติมเรื่อง scope ของ AngularJS)

จากนั้นเราตั้งชื่อส่วน controller ตรงนี้ว่า “sampleCtrl” จะได้โค้ดเป็น

app.controller(“sampleCtrl”, [“$scope”, “$firebaseArray”,
function($scope, $firebaseArray) {
$scope.temps = $firebaseArray(tempRef);
$scope.humids = $firebaseArray(humidRef);
}]);

จบจากส่วน script เรามาดูในส่วน body จะเห็นว่ามี attribute คือ ng-app อยู่ ไอ่ตรงนี้มันเอาไว้กำหนดว่าเราจะให้ส่วนไหนใน html อยู่ในขอบเขตของ app บ้าง ซึ่งนั่นก็คือเราจะให้ sampleApp ที่เรากำหนดไว้ทำงานในระดับไหนบ้าง

ng–app : This directive is used to flag the html element that Angular should consider to be the root element of our application. This gives application developers the freedom to tell Angular if the entire html page or only a portion of it should be treated as the Angular application. –angularJS_tutorial

จากนั้นเรามาดูตรง ng-controller นั่นก็คือเรากำลังเรียก controller ที่ชื่อ sampleCtrl เราก็ตามไปดูตรง script ว่ามันทำอะไรบ้าง จะเห็นว่ามันมี scope ที่ตอนนี้มีข้อมูลของ temperature และ humid อยู่ในรูป array เราจะต้องนำมาใช้ต่อ โดยการใช้ ng-repeat โดย “temp in temps” หมายความว่าใน array ที่ชื่อ temps ($scope.temps) เรากำหนดให้ตัวแปร temp แทนตัวลูกแต่ละตัวใน array โดย {{temp.time}} ก็แสดงข้อมูลของ key ที่ชื่อ time (โดยที่ temp ใน {{ }} คือตัวเดียวกับ temp ที่เราตั้งชื่อ ใน “temp in temps”
– เรื่อง ng-controller, ng-repeat อ่านเพิ่มเติมได้ angularJS_tutorial

ซึ่งหากไม่มีอะไรผิดพลาดก็ npm start จากนั้นเข้าไปที่ http://localhost:2000/test จะได้ตาม screenshot

ก็เอวังด้วยประการฉะนี้

เรื่องเกือบสั้น สำหรับ วันวาเลนไทน์... - Suraporn Menn Koetsawang | Facebook

ผมว่า Bayesian’s lover’s dilemma มันมีปัญหาอย่างนึง คือเงื่อนไขมันต้องขยายเป็นเกม confess/silent + love/lose คือเราไม่สามารถบอกว่าคนที่ confess นั้นจะเป็นฝ่ายแพ้ได้จริงๆหากอีกฝ่าย silent เพราะมันก็มีโอกาสที่ฝ่าย silent จะบอกว่า “ค่ะ ชั้นรักคุณเช่นกัน” ถ้าเป็นเช่นนี้ก็ถือว่า win-win ทั้งคู่ เนื่องจากการที่ฝ่ายใดฝ่ายหนึ่ง silent มันไม่ได้สะท้อนถึงว่ารักไม่รัก ในแง่นี้มันน่าจะสะท้อนเรื่องกล้าหรือไม่กล้าซึ่งเป็นผลโดยตรงมาจากความกลัวว่าผู้เล่นอีกคนคิดยังไงกับเรา นั่นนำมาสู่เกมใหม่(เสนอโดยข้าพเจ้าเอง) ชื่อว่าเกมเดาใจ

ก่อนอื่นคงต้องตั้งเงื่อนไขก่อน โดยคนที่ confess นั้นก็เป็นการบ่งบอกว่าชอบอีกฝ่าย (ในแง่นี้ให้เป็นแบบนั้น เราจะตัดกรณีที่การ confess เป็นไปเพื่อผลอื่นเช่น “เลิกยุ่งเราเหอะ เราไม่น่าไปได้ไกลเกินเพื่อนนะ” เป็นต้น) ซึงทำให้ confess จะถือเป็นการบอกรักเท่านั้น แต่ทีนี้ถ้ามาคิดต่อในโลกความเป็นจริง การที่จะ confess พร้อมกันทั้งคู่นี่มันแทบจะเป็นไปไม่ได้ (คือคงมี แต่ยาก) ลองนึกภาพชายหญิงที่จู่ๆสารภาพพร้อมกันสิ ยากมาก ฉะนั้นนี่เป็นแรร์เคสมากๆ เพื่อลดความซับซ้อนเราคิดว่าเราสามารถตัดส่วนนี้ออกได้ เพราะมันไม่น่าจะเกิดขึ้นจริง ทีนี้เราคิดว่าเราสามารถใช้หัวใจเป็น value ในเกมนี้ได้ กล่าวคือถ้าทั้งคู่รักกัน ก็จะ +1 ทั้งคู่ส่วนถ้าเกิดมีใครคนใดคนนึงไม่รัก คนที่สารภาพก็จะได้ -1 ส่วนคนที่ silent ให้ถือว่าเป็น -0.5 (เฉลี่ยจาก ความรู้สึกเฉยๆซึ่งเป็น 0 กับความรู้สึกเสียใจจากเหตุผลใดก็ตามจาก -1) ส่วนถ้าเป็นเคสที่ silent ทั้งคู่ ก็ให้เป็น 0 ทั้งคู่ เพราะต่างฝ่ายต่างก็ไม่รู้อะไรเลย

จากรูปจะเห็นว่าเกมมันค่อนข้างพิลึกพิลั่นพอสมควร แต่มันน่าจะทำให้เห็นภาพว่าทำไมอย่างน้อยประชากรกลุ่มนึงถึงเลือกจะ silent ทั้งคู่ เพราะการทำแบบนี้มันไม่ต้องเสี่ยงเจอสภาวะ -1 แต่ก็นั่นแหละถ้าเกิดว่าจะเสี่ยงสารภาพไป คุณก็ต้องรอดูว่าจะ +1 ทั้งคู่ไหม แต่แน่นอนว่าการที่ใครคนใดคนนึงยอมสารภาพระยะยาวแล้วมันย่อมดีกว่าล่ะนะ (อย่างน้อยก็ยังเหลือผลรวม 0.5 ซึ่งไอ่ตรงนี้ก็มองเอาว่าไปเจอคนใหม่ที่คู่กับตัวเองละกันครับ — ถึงแม้จะเป็น 0.5 ที่ได้จาก silent ก็ตาม)

“Whereof one cannot speak, thereof one must be silent.”
- Ludwig Wittgenstein

ปล.ผิดตรงไหนก็แย้งได้นะฮะ มือสมัครเล่นฮะ

ก่อนอื่นต้องทำความเข้าใจคำว่ากลยุทธ์ของ Cynthia ก่อนครับ ผมจะยกข้อความในหนังสือเพื่อปูทางคร่าวๆสำหรับแนวคิดเบื้องต้นของ Cynthia “บางคนก็บอกว่าก่อนหน้านั้นพวกเขามองกลยุทธ์คือโจทย์ชุดหนึ่งที่ต้องหาทางแก้ให้ได้ ซึ่งเป้นมุมมองที่แพร่หลายทั้งในแวดวงวิชาการและในโลกธุรกิจ แต่ตอนนี้พวกเขามองว่ากลยุทธ์คือวิถีชีวิตของผู้นำ เป็นชุดคำถามที่พวกเขาต้องใช้ชีวิตอยู่กับมัน”

หนังเปิดเรื่องมาด้วยการตบหน้าฉาดใหญ่ถึงความมั่นอกมั่นใจแบบผิดๆของผู้บริหาร โดยเฉพาะแนวคิดที่ว่า ผู้บริหารที่มากความสามารถจะประสบความสำเร็จได้ทุกสถานการณ์ (ซึ่งแนวคิดนี้โดนโจมตีอย่างตรงไปตรงมาว่า “เป็นความหลงผิดคิดว่าตนไร้เทียมทามในหมู่ผู้บริหารชาวอเมิรกัน) ซึ่ง Cynthia ยกเคสของริชาร์ด แมนูเจียน CEO ของ แมสโคคอเปอเรชัน (Masco) บริษัทผลิตก็อกน้ำผู้สร้างนวัตกรรมจากก๊อกน้ำท่อเดียวจนสามารถเติบโตอย่างมากได้ (ใช่แล้วเขามีกลยุทธ์สร้างความแตกต่างในด้านนี้) Cynthia ตั้งคำถามกับผู้อ่านว่า ถ้าคุณเป็นริชาร์ด คุณจะกระโดดเข้าไปในธุรกิจอย่างเฟอร์นิเจอร์หรือไม่ สำหรับริชาร์ดคำตอบคือใช่ และนี่คือหายนะอย่างใหญ่หลวง เรื่องราวต่อจากนี้หาอ่านได้หนังสือ จะไม่ขอยกมาเพราะคงจะยาวไปสำหรับรีวิว

แน่นอนการเริ่มต้นมาด้วยการตบหน้าฉาดใหญ่ มันมักตามมาด้วยการลูบหลัง หรือเอาจริงๆแล้วการตบหน้าเป็นการปลุกหให้ตื่นจากภวังค์หรือความหลงผิดก็ย่อมได้ (ถ้าไม่เกิดอคติอย่างใหญ่หลวงซะก่อน) Cynthia นำผู้อ่านเข้าสู่บทเรียนในขั้นต่อไปด้วยการยกเคสของ IKEA ขึ้่นมา ใช่แล้ว IKEA เป็นบริษัทเกี่ยวกับเฟอร์นิเจอร์ที่ประสบความสำเร็จอย่างมหาศาล ผู้เขียนยก IKEA ขึ้นมาเพื่อจะบอกว่ามีอะไรที่ริชาร์ดพลาดไปสำหรับอุตสาหกรรมนี้ (ซึ่ง อุตสาหกรรมเฟอร์นินเจอร์นั้นมีปัจจัยภายนอกมากมายที่ทำให้ธุรกิจนั้นเติบโตได้ยาก Cynthia เน้นย้ำถึงความหลงผิดของผู้นำอยู่บ่อยๆที่คิดว่าธุรกิจเฟอร์นินเจอร์นั้นสามารถจัดการได้ด้วยการบริหารจัดการที่ดี และความสามารถของผู้นำ ซึ่งจริงๆแล้วก็ไม่ถูกซะทีเดียว ถ้าคุณไม่มีกลยุทธ์ที่ดี นั้นนำมาซึ่งหายนะเป็นแน่) และปัจจัยอะไรที่ทำให้ IKEA เติบโตมาได้ขนาดนี้ โดยผู้เขียนเสนอว่าสิ่งที่จำเป็นมากๆในจุดนี้คือการตั้งเป้าหมายและกำหนด vision บริษัทให้ชัดเจน โดยคุณต้องบอกได้ว่าบริษัทเป็นอะไร จะทำอะไร แตกต่างกับเจ้าอื่นๆอย่างไร (และแน่นอนของพวกนี้ต้องชัดเจนในระดับที่คนอื่นอ่านสามารถซึมซับและเข้าใจได้ทันที)

เคสต่อมาที่ Cythia ยกมาพูดถึง เป็นกรณีของกุชชีตั้งแต่จุดเริ่มต้นของการก่อตั้งบริษัท ยุครุ่งเรือง ยุคตกต่ำ และกลยุทธ์ของเด โซเล ในการแก้สถาณการณ์ บทนี้อ่านสนุกมากกว่าบทอื่นเป็นพิเศษ เพราะเรื่องราวของกุชชีที่เป็นบริษัทที่ดำเนินธุรกิจแบบครอบครัว มีความแตกแยกแตกหักไปจนถึงคราวที่บริษัทเกือบล่มสลาย ในบทนี้ Cynthia จะอธิบายวิธีที่เด โซเล แก้เกม และวิธีการสร้างระบบคุณค่าให้บริษัทกุชชีจนสามารถย้อนคืนสู่ความรุ่งเรืองได้ โดยบทนี้ Cynthia จะบอกว่าแค่จุดมุ่งหมายที่ชัดเจนของบริษัทยังไม่เพียงพอ มันยังมีอย่างอื่นให้นักกลยุทธ์ได้ขบคิดอีก

ต่อจากเคสนี้ Cynthia จึงพูดถึงวิธีการเขียนแผนกลยุทธ์รวมทั้ง key ที่สำคัญ โดยจะเน้นไปที่ระบบการสร้างคุณค่า และการเขียนวงล้อกลยุทธ์ โดยเรามีความรู้สึกว่า Cynthia จะชอบพูดถึงความ practical ของข้อมูลและให้น้ำหนักกับข้อมูลในการวางกลยุทธ์มากกว่าจะมาจากแรงบันดาลใจหรือความเชื่อส่วนตัว เช่นตอนที่เด โซเลกอบกู้กุชชี เด โซเล ก็ใช้ข้อมูลว่ากุชชีขายอะไรได้ และเจาะไปที่จุดนั้นมากกว่าจะให้เป็นเรื่องของแค่การตลาดและแรงศรัทธา

จากนั้นก็มาถึงบทที่สนุกมากของหนังสือเล่มนี้คือเรื่องของจ็อบและแอปเปิล โดยหนังสือเล่าตั้งแต่จ็อบก่อตั้ง ยันทำลายบริษัทตัวเอง ไปจนถึงวิธีการที่เขากอบกู้แอปเปิลขึ้นมาจากเรือที่ใกล้จะอัปปางเป็นเรือใหม่ (ตรงนี้มีการเล่าถึง the logic of growth ด้วย เก๋มาก)

โดยสรุปเป็นหนังสือที่พูดถึงกลยุทธ์ในน่าสนใจ มีเคสตัวอย่างที่ชัดเจน และเรื่องเล่าที่อ่านได้เพลิน แต่มันอาจสั้นไปหน่อย และดูไม่ practical เท่าที่คิดไว้ แต่ถ้าถามว่าเป็นหนังสือที่นักกลยุทธ์ควรอ่านไหม ตอบว่าใช่ ควรอ่าน

zero to one เป็นหนังสือว่าด้วยการสร้างธุรกิจจาก 0 เป็น 1 เล่มนี้ของ Thiel ต่างจากงานเขียนในประเภทนี้ทั่วไปในแง่ที่ว่า มันไม่ใช่หนังสือแนว business ที่ให้กำลังใจอะไรเลยสักนิด แถมยังสับความคิดในการก่อตั้งธุรกิจของคุณแตกออกเป็นชิ้นเล็กชิ้นน้อย ความมั่นใจในการท้าทายต่อโลกของคุณ จะถูกท้าทายด้วยแนวคิดของ Thiel ซึ่ง Thiel คาดว่าหลังจากความคิดคุณถูกสับแล้ว คุณจะสามารถประกอบมันขึ้นมาใหม่ได้ดีกว่าเดิม

ความน่าสนใจของ zero to one นั้นมีหลายประการ

อย่างแรกมันมาจากประสบการณ์โดยตรงของ CEO บริษัทจ่ายเงินผ่านอีเมลชื่อดัง PayPal, ด้วยความที่ Thiel คลุกคลีอยู่ในวงการมานาน นั่นทำให้เขามีความสามารถและประสบการณ์สูง (เราอาจยกตัวอย่างที่เขาไปลงทุนใน Facebook นี่เป้นความสามารถในการมองที่ข้าพเจ้าอยากได้)

อย่างที่สอง เนื้อเรื่องไม่ได้มีความเกรงใจใดๆทั้งสิ้น Thiel ปล่อยหมัดโจมตีแนวคิดธุรกิจต่างๆได้อย่างมองเห็นภาพ และโจมตีมันตรงๆเช่น เรื่องที่ว่า กูเกิลนั้นจริงๆแล้วเป็นบริษัทผูกขาดที่ทำตัวไม่ผูกขาด ด้วยการบอกว่าตัวเองเป็นบริษัทที่ทำธุรกิจด้านเทคโนโลยี (ซึ่งทำให้ภาพของบริษัทดูเป็นส่วนเล็กในตลาดอันกว้างใหญ่ แทนที่จะบอกว่าตัวเองเป็นเสิร์ชเอนจิ้นที่กินตลาดนี้ไปเกือบหมดแล้ว) หรืออย่างการกัด Yahoo! ที่ Thiel ตั้งคำถามว่าตกลงแล้ว Yahoo! จะขายอะไรกันแน่

อย่างที่สาม Thiel ค่อนข้างกว้างขวางในองค์ความรู้พอสมควร อย่างน้อยเขาก็รู้ว่ากำลังพูดถึงอะไร และเขารู้กว้างพอที่จะดึงเรื่องหลากหลายมาเพื่อซัพพอร์ตแนวคิดของเขา ซึ่งเราคิดว่ามันเจ๋งมากห เช่นดึงคำพูดของมาร์กซ์ที่ชื่นชมเทคโนโลยี เปรียบเทียบความคิดของนักปรัชญาสำนักต่างๆ ซึ่งนานๆทีเราจะเห็นอะไรแบบนี้ในหนังสือแนว business แต่มันก็เข้าใจได้ว่า Thiel นั้นอาจเป็นพวกศรัทธาในความสามารถสุดๆ จนลืมไปว่า ความโชคดีก็อาจจะเป็นปัจจัยหนึ่งด้วย แม้เขาจะปฏิเสธแค่ไหนก็ตาม (เช่น ถ้าเขาสอบติดต่อในด้านกฎหมายสูงขึ้นไป เขาก็คงไม่มีทางได้มาทำไอ่นี่แน่ๆ ฉะนั้นเรื่องพวกนี้มันมีบางอย่างมากกว่าที่เราคิดเสมอ)

อย่างที่สี่ Zero to one ไม่ใช่แค่หนังสือที่รวบรวมแนวคิดดาดๆ แต่มันยัง practical อีกด้วย คือคุณสามารถนำไปขบคิดธุรกิจ start-up ของคุณได้ และนี่เป้นโน้ตของ Theil ที่ว่าด้วยตั้งแต่การหาเสาะหา idea ยันการหาเพื่อนร่วมทีม และไปถึงการขายผลิตภัณฑ์ของคุณ! ซึ่งมันมีทุกขั้นตอนที่เหล่า start-up จะประสบพบเจอ

Thiel มองว่าการผูกขาดนั้นมีหลายแบบ และมีส่วนที่สร้างสรรค์อยู่ด้วย (ซึ่งในหนังสือจะเน้นด้านนี้) เช่นการผูกขาดในรูปแบบหนึ่งอาจหมายความบริษัทนั้นพัฒนาผลิตภัณฑ์จนดีไม่มีบริษัทอื่นเทียบทานได้ (เช่น google หรือ Apple) ในแง่นี้การผูกขาดจึงดูเป็นสิ่งทื่เข้าท่าสำหรับทุนนิยมที่เข้ากันได้กับบริษัท (เพราะบริษัทนั้นต้องการกำไร ในขณะที่ทุนนิยมและการแข่งขันสมบูรณ์จะพรากกำไรจากคุณไปหมด) แต่กระนั้น Thiel ก็บอกต่อว่า การผูกขาดนั้นไม่มีทางสมบูรณ์อยู่ดี เพราะโลกเรานั้นมีการเปลี่ยนแปลง ซึ่งต่างจากเกมเศรษฐี (Monopoly) ที่ตัวกระดานนั้นคงเดิม เพียงแค่คุณกวาดซื้อทั้งกระดานคุณก็ชนะแล้ว แต่โลกความเป็นจริงนั้นไม่ใช่ เพราะบริษัทใหญ่แค่ไหนก็สามารถถูก chalenge ได้ตลอดเวลา (เช่น facebook ผงาดขึ้นมา chalenge แข่งกับ Google) ฉะนั้นในโลกที่มีการเปลี่ยนแปลงอยู่ตลอด ก็ย่อมสามารถเกิดนวัตกรรมขึ้นมาได้ตลอด หากบริษัทใดที่ผูกขาดแล้วมีแนวโน้มจะขัดขวางการก้าวหน้าของสังคม ธุรกิจนั้นถือเป็นอันตรายและพวกเราควรช่วยกันต่อต้าน แต่ประวัติศาสตร์ของความก้าวหน้าที่ผ่านมาล้วนเป็นเรื่องราวของบริษัทที่ดีกว่าเข้ามาแย่งชิงการผูกขาดไปจากบัลลังก์เดิม”

ที่ Theil เห็นด้วยกับการผูกขาดบางประการนั่นเป้นเพราะว่า การผูกขาดมันคือการสร้างนวัตกรรมใหม่ๆขึ้นมา ตามคอนเซปส์ของหนังสือนั่นคือ จาก 0 เป็น 1 เราอาจตีความว่า 0 คือการที่ไม่มีแนวคิดนี้อยู่เลย ในขณะที่ 1 คือแนวคิดของนวัตกรรมใหม่ที่ผงาดขึ้นมา และผูกขาดกับตลาดนั้นไว้ (เพราะมันไม่มีคนอื่นคิดไว้ก่อน) ฉะนั้นเมื่อไม่มีการแข่งขัน คุณจึงเติบโตไปได้ไกลสุดๆ

นอกจากนั้นเราอาจจะบอกว่า Thiel เป็นพวกมองโลกในแง่ดีและอนาคตยังพอมีความชัดเจนอยู่บ้าง กล่าวคือ Theil ไม่เชื่อในเรื่องโชคชะตาเท่าไหร่ เขาเชื่อในพลังของมนุษย์มากกว่า (เราอาจบอกว่าเขาเป็นพวกมนุษย์นิยม) ซึ่งในหนังสือ Theil โจมตีแนวคิดของ มัลคอล์ม แกลดเวลล์ ในหนังสือ Outliers (เป็นหนังสือขึ้นหิ้งที่เราชื่นชอบเช่นกัน) ว่า แนวคิดการมองของมัลคอล์มนั้น เป็นแนวคิดของพวก Baby boomer ที่มักจะพูดถึงเรื่องโชคเรื่องดวงมากกว่าจะเน้นไปที่การพัฒนาตัวเองไปถึงเป้าหมาย ซึ่ง Thiel ได้เล่าไว้ในหนังสือถึงเหตุผลเหมือนกัน ว่ามันมาจากความเชื่อเรื่องเศรษฐกิจในยุคนึงที่ถูกสั่นคลอนให้เราหนีกลับไปใน comfort zone และคิดว่าในเมื่ออนาคตมันไม่แน่นอน เราจึงต้องไร้แผน (หรืออย่างมากคือ เตรียมแผนไว้ แล้วก็รอฟลุค) ซึ่งเราชอบที่ Thiel เน้นย้ำในเรื่อง “แนวคิด” ของอนาคตที่ควรมีรูปร่างแน่นอน อย่างน้อยคุณต้องมีแนวคิดว่ามันแน่นอนก่อน แล้วทำตามแผน (Thiel ยังเชื่อว่า ในโลกธุรกิจ นั้นเหมือนการเล่นหมากรุกที่ต้องไปดูหมากท้ายๆก่อน)

อย่างที่บอกไว้ว่า Theil ออกจะมนุษย์นิยม มุมมองของ Theil ที่มีต่อโลกอนาคตในเรื่องของเทคโนโลยี Theil มองว่า ท้ายสุดแล้วมนุษย์ก็สร้างจักรกลขึ้นมาไม่ใช่เพื่อให้มันแทนที่มนุษย์ แต่เพื่อให้มันเป็นเครื่องมือผ่อนแรงต่างหาก ซึ่งเขามองไว้ว่าท้ายสุดแล้ว นวัตกรรมหรือการวิเคราะห์เชิงลึกก็ยังต้องใช้มนุษย์อยู่ดี ไม่มีเครื่องจักรอะไรจะทำหน้าที่นี้ได้สมบูรณ์ แต่เราสร้างนวัตกรรมมาเพื่อให้เราวิเคราะห์อะไรต่างๆได้ง่ายขึ้น “มุมมองอันลึกซึ้งที่นำไปใช้ได้จริงจะมาจากการวิเคราะห์โดยมนุษย์เท่านั้น”

สิ่งที่ Thiel เน้นยำ้อยู่บ่อยๆ ซึ่งเราจะเจอได้ในตลอดเล่มคือแนวคิดในการเริ่มจากครองตลาดเล็กๆก่อน อาจจะด้วยการขายหรือสร้างความสัมพันธ์ ซึ่งเราต้องผูกขาดตลาดนี้ให้ได้ นอกจากนั้น Thiel ยังบอกอีกด้วยว่าให้เรามองไกล อย่างน้อยก็ต้องวางแผนล่วงหน้า อาจจะยี่สิบปีถึงสามสิบปี เพราะถ้าคุณคิดจะทำธุรกิจจริงๆ การมองเพียงระยะสั้นๆนั้นให้ผลที่ไม่ดีมากนัก

ด้วยทั้งหมดที่ว่ามานี้ ทำให้ Zero to one นั้นมีความน่าสนใจสำหรับ Start-up หรือผู้ที่เริ่มสนใจในแวดวงนี้ น่าจะจัดได้ว่าเป็นหนังสือที่ must read

Thiel พูดถึงเรื่องกฎหมายลิขสิทธิ์อยู่นิดหน่อย แต่เป็นประเด็นที่น่าสนใจ ในแง่ที่ว่ากฎหมายลิขสิทธิ์มันว่าด้วยเรื่องการผูกขาดแนวคิด “ไม่แปลกเลยถ้าจะมีคนถามว่า มันเป็นเรื่องสมควรแล้วหรือที่ใครบางคนได้รับสิทธิตามกฎหมายให้ผูกขาดเพียงเพราะเป็นคนแรกที่คิดมาได้”

“โอมเพี้ยง เดี๋ยวแผลก็หายแล้วนะลูก” ผมจำไม่ได้ว่าเคยได้ยินประโยคทำนองนี้ครั้งแรกตอนกี่ขวบ คำปลอบใจนี้ยายผมมักกล่าวขึ้นเวลาเมื่อผมเล่นซนจนหกล้ม เลือดออก ฟกช้ำ หรือเมื่อใดก็ตามที่เกิดการบาดเจ็บ แกจะทำท่าเป่าแถวๆแผล ผมจำไม่ได้ว่าตอนครั้งแรกที่ได้ยินนั้น ตัวเองเชื่อหรือเปล่าว่าแผลมันจะหายจริงๆ

เมื่อผมโตขึ้นมาอีกหน่อย ผมได้รู้จักโลกกว้างขึ้น แต่มุมมองของผมก็คงไม่ได้กว้างตามขึ้นเลย เมื่อผมได้ยินประโยคทำนองนี้อีกครั้ง ผมกลับรู้สึกต่อต้าน และเมื่อได้ยินยายกล่าวครั้งใด ผมก็มักจะสวนกลับไปทำนองว่า “โถ่ยาย ทำแบบนั้นมันไม่หายหรอกน่า”

เมื่อไม่นานมานี้ มีอะไรสักอย่างสะกิดใจให้ผมนึกถึงคำพูดนี้ขึ้นมาอีกครั้ง ผมได้ตั้งคำถามกับตัวเองว่า มันถูกต้องแล้วหรือ ที่เถียงกลับยายไป ผมว่าท่านรู้การทำเหมือนสวดคาถาโอมเพี้ยง แผลมันก็คงไม่หายหรอก อันที่จริงแล้วดูเหมือนว่าการที่แผลหายกับการสวดคาถา มันก็ไม่เกี่ยวข้องกันเสียด้วยซ้ำ แต่ที่ท่านกล่าว ก็อาจเป็นเพราะท่านเพียงแค่อยากให้เรารู้สึกดี รู้สึกว่าจะมีสิ่งดีๆมาช่วยให้เราหายเจ็บหรือลืมมันไปสักพัก หรืออะไรก็ตามแต่ ผมคิดว่าประโยคทำนองนี้ มันทำหน้าที่ได้แค่คำปลอบใจเสียมากกว่า และมันก็คงจะไม่มากไปกว่านั้น ผมว่าคงไม่มีใครคิดจริงๆจังๆหรอกว่า ไอ่การทำแบบนี้มันจะรักษาแผลทางกายภาพได้ แต่ไม่แน่แผลทางใจอาจได้รับการเยียวยาขึ้นมาสักนิด

ฉะนั้นเวลาคุณเจอเพื่อนที่กำลังอกหัก รักร้าว คุณอาจกล่าวกับเขาด้วยประโยคทำนองนี้ “เฮ้ย ไม่เป็นไรนะเว้ย เดี๋ยวก็หาย เพี้ยง!” เพราะเพื่อนของคุณไม่แน่ว่าอาจจะอาการดีขึ้นด้วยเวทย์มนต์แห่งถ้อยคำเหล่านี้ก็เป็นได้

Ghost in modernity

จริงๆเรื่องนี้ปิ๊งไอเดียหัวข้อมาได้จากการไปนั่งเรียนวิชา Localism and Globalization (ซึ่งดูเหมือนเกรดจะได้มาอย่างยากเย็น) และมานั่งเล่นเฟสเจอ อาจารย์ เจษฎาพูดเรื่องบั้งไฟพญานาคพอดี

ผมคิดว่าความเชื่อเรื่องผีสางในโลกสมัยใหม่ ได้ถูกเปลี่ยนให้กลายเป็นอย่างอื่น เป็นสิ่งอื่น กล่าวคือมันไม่ได้ทำหน้าที่ความเชื่อผีดั้งเดิมเสียแล้ว(ที่คอยกำหนดและสร้างความกลัวเพื่อควบคุมสังคม — อันนี้ในความเห็นข้าพเจ้าเอง) โดยเฉพาะสังคมเมืองที่ ปัจจุบันจะเห็นได้ว่าความเชื่อเรื่องผีสางมักถูกนำไปใช้ประโยชน์ในแง่เชิงพาณิชย์(ก็นี่มันโลกทุนนิยมนี่นะ) ยกตัวอย่างที่เห็นได้ชัดก็คือ รายการจำพวกวาไรตี้ผีๆต่างๆอย่าง คน(นม)อวดผี รายการฝรั่งอย่าง Destination truth หรือภาพยนตร์ผีๆต่างๆเป็นต้น จะเห็นได้ว่า ผี ได้กลายเป็นเครื่องบันเทิงรูปแบบหนึ่งไปแล้ว

ทุกวันนี้ด้วยความสามารถของวิทยาศาสตร์ และเทคโนโลยี ทำให้สามารถ ลดอำนาจของ ผี ที่ในอดีตเป็นเรื่องลึกลับและเป็นเรื่องของประสบการณ์ส่วนบุคคลลงไปได้ ดังที่ผู้กำกับ the conjuring เจมส์วานส์ เคยบอกไว้ประมาณว่า หนังผีของยุคนี้เนื้อเรื่องต้องย้อนอดีตไปสักหน่อย ไม่งั้นหากเป็นปัจจุบัน ใครเจอผีก็ถ่ายรูปแล้วอัพลง Instragram ทำให้ผีได้หมดความขลังลงไปเสียแล้ว ฉะนั้นผีจึงถูกลดทอนให้กลายเป็นเพียงเครื่องมือด้านอุตสาหกรรมเพื่อรับใช้ความบันเทิงและทุน ในโลกปัจจุบันนี้

แต่ถ้าเราพูดถึงชนบทจริงๆที่ห่างไกลจากเทคโนโลยีต่างๆ ผีจะยังคงสถิตอยู่ที่นั่น เพราะผีเป็นความเชื่อที่แข็งแกร่งซึ่งตกทอดมายังรุ่นต่อรุ่น และตราบใดที่ความเป็นสมัยใหม่(ทุนนิยม เทคโนโลยี เครือข่ายการเชื่อมต่อ ฯลฯ) ยังไม่เข้าครอบงำท้องถิ่นนั้น ผีก็จะยังคงสิงสถิตและคงความขลังของมันไว้ตราบนานเท่านาน

ปล.เนื้อหานี้ค่อนข้างมั่วๆหน่อยน่ะครับ notes น้อย Ref ก็น้อย ส่วนใหญ่เป็นความเห็นส่วนตัวมากกว่า
ปล.2 พยายามใช้สำนวนให้มันคล้ายหนังสือที่มันอ่านยากๆหน่อย แฮ่!

Note: ความเป็นสมัยใหม่คืออะไร?
http://vorachai-juntip.blogspot.com/2011/06/postmodernism-post-modern-postmodern.html