Functional Programming should be your #1 priority for 2015


OOP cannot save us from the Cloud monster anymore.
คุณอาจจะเคยได้ยินคำบางคำเช่น "Clojure", "Scala", "Erlang" หรือ "Java มี Lambdas แล้วนะเว้ย" และอาจจะรู้ว่ามีอะไรบางอย่างที่เกี่ยวกับ Functional Programming ถ้าคุณได้มีส่วนร่วมในสังคมของพัฒนาโปรแกรมใดก็ตาม เรื่องนี้เป็นเรื่องที่กำลังเป็นที่นิยมอย่างมาก

ถ้าลอง Googling คำว่า Functional Programming คุณจะเห็นว่าไม่มีอะไรใหม่เลย เพราะภาษาโปรแกรมตัวที่สองที่กล่าวถึงด้านบน มันถูกสร้างตั้งแต่ปี 1950 และถูกครอบไว้ด้วยไวยากรณ์ใหม่เท่านั้นเอง ภาษาที่ว่าคือ Lisp แล้วทำไมล่ะ ทำไมเราต้องตื่นกับมันตอนนี้ด้วย ทั้งที่มันผ่านมากว่า 60 ปีแล้ว

At the beginning, Computers were really slow

ไม่ว่าคุณจะเชื่อหรือไม่ แต่คอมพิวเตอร์ในตอนนั้นช้ากว่า DOM ในตอนนี้เสียอีก ซึ่งมี 2 แนวคิดหลักๆ ในการออกแบบและสร้างภาษาโปรแกรมขึ้นมานั่นคือ
  1. เริ่มจากสถาปัตยกรรมของ Von Neumann แล้วใส่ Abstraction เข้าไป
  2. เริ่มจากคณิตศาสตร์ และนำ Abstraction ต่างๆ ออกไป
คอมพิวเตอร์ในตอนนั้นไม่มีความสามารถในการประมวลผลมากพอที่จะประมวลผล abstractions เยอะๆ เพื่อจัดการโปรแกรมรูปแบบ functional ดังนั้นปัญหาของ Lisp คือความเร็วที่ห่วยเอามากๆ ทำให้ไม่เหมาะกับงานต่างๆ และต่อมาก็เป็นยุคของ imperative programming เข้าครองโลก โดยเฉพาะภาษา C นี่แหละ

But Computer have improved a lot

เมื่อตอนนี้เรื่องความเร็วอาจจะไม่เป็นปัญหาอีกต่อไป โปรแกรมส่วนใหญ่สามารถที่จะทำงานได้ โดยไม่ต้องสนใจว่าจะเขียนด้วยภาษาอะไร และนั่นเองคือ โอกาสที่สองของ Functional Programming ล่ะ

Functional Programming 50.5

อย่างไรก็ตามนี่ไม่ใช่บทความที่จะมาสอน Functional Programming 101 ซะทีเดียว แต่ถ้าคุณอ่านบทความนี้จบ คุณควรจะได้ไอเดียเกี่ยวกับ Function Programming และไปลุยต่อเองได้นะ (นะนะ)

Functional Programming คุณอาจจะเข้าใจได้ว่ามันคือ Programming ด้วย Functions อาจจะไม่ค่อยเห็นภาพเท่าไหร่ เอาเป็นว่าคุณจะสามารถสร้างฟังก์ชั่นจากฟังก์ชั่นอื่นๆ หรือประกอบมันขึ้นมาก็ได้ (จำฟังก์ชั่น f ∙ g ตอนเรียน Calculus หรือวิชาคณิตศาสตร์อื่นๆ ได้ไหมล่ะ นั่นแหละ)

จุดเด่นหลักๆ ของ Functional Programming ก็ตามนี้
  1. First-Class Functions
  2. High-Order Functions
  3. Pure Functions
  4. Closures
  5. Immutable State
อย่างพึ่งแคร์คำที่น่าตกใจข้างบน เดี๋ยวจะยกตัวอย่างทีละตัวให้อ่านกัน

First-Class Functions หมายถึงการที่สามารถที่จำกำหนดค่าตัวแปรต่างๆ เป็นฟังก์ชั่นได้ เราคิดว่าคุณน่าจะเจออะไรแบบนี้ใน Javascript มาแล้วล่ะ

เห็นไหมว่าโค้ดนี้พึ่งจะกำหนดตัวแปรชื่อว่า add ชี้ไปยังฟังก์ชั่นไร้นาม (anonymous function) ซึ่งรับค่า a และ b แล้วให้ค่าส่งกลับของฟังก์ชั่นเป็น a + b

High-Order Function หมายถึงการที่ฟังก์ชั่นต่างๆ สามารถให้ค่ากลับเป็นฟังก์ชั่น และรับฟังก์ชั่นเป็นพารามิเตอร์ได้ เช่นเดิมใน Javascript


และแบบนี้ใน Swift


ทั้งสองตัวอย่างเป็นตัวอย่างของ High-Order Function ถึงแม้ว่าคุณจะไม่เคยเขียนโค้ดลักษณะนี้มาก่อน แต่ก็น่าจะเห็นมาบ้างจากบางที่ที่อ่านโค้ด ลองย้อนกลับไปดูนะ

Pure Functions หมายถึงฟังก์ชั่นจะไม่เปลี่ยนค่าของค่าที่ถูกส่งเข้ามา ฟังก์ชั่นจะทำหน้าที่เพียงแค่รับค่าเข้ามา ประมวลผลและส่งคำตอบกลับไป เหมือนฟังก์ชั่นในคณิตศาสตร์เลย เช่น ถ้าคุณส่ง 2 เข้าฟังก์ชั่นชื่อ f และได้ผลลัพธ์เป็น 10 มันจะให้ค่า 10 ตลอด โดยไม่สนใจสภาวะแวดล้อม, threads หรือลำดับการประมวลผล (evaluation order) ว่าจะเป็นแบบไหน จะไม่มี side effect ใดๆ เกิดขึ้นบนโปรแกรม ซึ่งนี่เป็นแนวคิดที่ยอดเยี่ยมมาก

Closures หมายถึงคุณสามารถที่จะเข้าบันทึกค่าจากภายนอกฟังก์ชั่นมาใช้ภายในฟังก์ชั่นได้ (captureing value) และค่านั้นจะถูกใช้ด้านในเท่านั้น ไม่กระทบต่อตัวแปรด้านนอกที่ถูกนำค่ามาใช้ดังเช่นตัวแรกของเรื่อง High-Order Function ด้านบน จะเห็นว่าตัวแปร a ถูกบันทึกค่าและเข้าถึงภายในฟังก์ชั่นที่ถูกส่งกลับเท่านั้น 

Immutable State หมายถึงคุณไม่สามารถเปลี่ยนสถานะต่างๆ ของทุกอย่างในโปรแกรมได้ (แม้จะสามารถกำหนดค่าใหม่ไปก็ตาม) ลองนึกถึงค่าคงที่ในโปรแกรมนั่นล่ะ แต่ตัวอย่างนี้มาจากภาษา OCaml ซึ่งจะเห็นว่าสามารถเปลี่ยนค่า x ได้ก็จริง แต่ถึงเวลาใช้งาน ค่าที่ได้ก็จะไม่เปลี่ยนแปลง


อาจจะดูเหมือนไม่ใช่จุดเด่นที่ดีเท่าไหร่ แต่จะเห็นเองว่าสิ่งนี้มันจะช่วยชีวิตคุณได้ :P

Object-oriented Programming cannot save us anymore

ในที่สุดยุคของการมีโปรแกรมทำงานบน distributed system และการประมวลผลไปพร้อมกันก็มาถึง แต่โชคไม่ดีเท่าไหร่ที่เรายังไม่พร้อม ใน "ปัจจุบัน" รูปแบบของ concurrency และ parallelism แม้จะช่วยให้เราแก้ปัญหาได้ แต่มันก็มาพร้อมกับความยุ่งยาก

สำหรับทางเลือกที่ดีกว่านั้น เราต้องการอะไรง่ายๆ เชื่อถือได้มาทำงานตรงนี้ คุณจำสิ่งที่อ่านไปด้านบนเกี่ยวกับจุดเด่นของ Functional Programming อย่าง Pure Functions และ Immutable State ได้ไหม ? นั่นล่ะ คุณสามารถที่จะสั่งให้ฟังก์ชั่นทำงานเป็นพันๆ รอบในหน่วยประมวลผล (core) หรือเครื่อง (machine) คนละตัวกัน และจะไม่มีวันได้ค่าที่ต่างกันเหมือนเมื่อก่อน ดังนั้นคุณสามารถสั่งให้โปรแกรมทำงานตั้งแต่ 1 ถึง 1000 บนหน่วยประมวลผลคนละตัวได้เลย เท่านี้ชีวิตก็กลับมาดี๊...ดีอีกครั้ง

But why can't I keep using OOP ?

อย่างน้อยในเรื่องของ concurrency และ parallelism แหละ ที่ OOP ไม่สามารถตอบคำถามได้ต่อไป มันเป็นเพียงเพราะว่า OOP ขึ้นตรงกับการเป็น mutable state (ในภาษารูปแบบ Imperative ที่ส่วนใหญ่จะรอบรับแนวคิด OOP) โดย method ของ object ที่เราเรียกนั้นจะต้องมีการเปลี่ยนสถานะผ่าน self หรือ this ซึ่งจะเกิดความซับซ้อนเมื่อเราจะต้องทำให้ทุก thread มีค่าตรงกัน

เราไม่ได้เขียนบอกเล่าตรงนี้เพื่อแย้ง และบอกว่าคุณจะต้องเปลี่ยนจากการเขียนโปรแกรมแบบอื่นๆ มาเป็น Functional Programming (แม้ว่าบางคนจะบอกว่า "ต้อง" เปลี่ยนก็ตาม) แต่คุณจะต้องเรียนรู้มันให้เป็น เพราะภาษา Imperative ชื่อดังอย่าง Java และ C++11 ก็รองรับสิ่งที่เรียกว่า lambda expression หมดแล้ว รวมถึงเทคโนโลยีที่ใช้กันอย่างแพร่หลายเช่น Ruby, Python, Swift ก็รองรับเช่นกัน จะเรียกได้ว่าแทบทุกภาษาสมัยใหม่มีให้ใช้กันหมด

แต่เรื่องของ mutable state ก็ไม่ใช่บอกว่าต้องเลิกใช้ซะทีเดียว ยังมีสิ่งที่ต้องเป็นแบบนั้น เช่นการติดต่อกับ I/O ต่างๆ แนวคิดหลักของ Functional Programming บอกไว้ว่า "จงใช้ mutable state เท่าที่จำเป็น"

I'm not working on Clouds, do I really need Functional Programming?

ใช่,,

Functional Programming จะช่วยให้คุณเขียนโปรแกรมที่ดีขึ้นได้ และยังช่วยเรื่องของความเข้าใจได้อย่างดีในการแก้ปัญหาที่คุณต้องแก้ด้วย

I have tried. It's too complex and it has poor readability

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

สำหรับการเริ่มต้นเรียน Functional Programming อาจจะเหมือนกับการเรียนการเขียนโปรแกรมใหม่เกือบทั้งหมดเลยก็ได้ (นั่นขึ้นอยู่กับภาษาที่คุณเลือกที่จะเรียน) หลายๆ อย่างใน Functional Programming อาจจะอ่านยาก ถ้าคุณที่พื้นฐานมาจาก Imperative โดยการเขียนโปรแกรมแบบ Functional อาจจะดูประหลาดไปเลย นั่นไม่ใช่เพราะมันประหลาด เพียงแต่คุณจะยังไม่ชินกับรูปแบบของมันต่างหาก เมื่อคุณเริ่มคล่องขึ้น ทุกอย่างจะง่ายขึ้นเอง

ลองดูตัวอย่างนี้จากภาษา Functional อย่าง Haskell และ Javascript ที่เขียนในรูปแบบ Imperative





นี่เป็นโปรแกรมง่ายๆ ซึ่งจะเป็นโปรแกรมที่แสดงความยินเมื่อคะแนนที่ถูกส่งเข้ามามากกว่า 7 ซึ่ง Haskell สามารถเขียนให้จบได้ภายใน 2 บรรทัด (ไม่นับบรรทัดแรกซึ่งถือเป็น Type Annotation) ซึ่งมันจะง่ายมากๆ เมื่อคุณเข้าใจสิ่งที่เรียกว่า Pattern Matching

ลองดูอีกสักตัวอย่าง


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

So, let's get started

มีแหล่งเรียนรู้เพียบเลย สำหรับ Functional Programming แต่ที่คุณไม่ควรพลาดเลยก็มีตามนี้

  1. Principles of Functional Programming in Scala
  2. Introduction of Functional Programming (Contents)
  3. Paradigms of Computer Programming --- Fundamentals
อีกทางเลือก ถ้าถนัดการอ่านหนังสือมากกว่าก็นี่เลย

  1. Structure and Interpretation of Computer Programs
  2. How to Design Programs
  3. Concepts, Techniques and Models of Computer Programming
เท่านี้ล่ะ ขอให้ลองเปิดใจและลองดู โชคดีนะ สวัสดีปีใหม่ :)

Credithttps://medium.com/@jugoncalves/functional-programming-should-be-your-1-priority-for-2015-47dd4641d6b9

Popular posts from this blog

12 วิธี การบริการและดูแลลูกค้าในร้าน Starbucks

[Android Dev] การติดตั้ง Eclipse+AndroidSDK เพื่อพัฒนาโปรแกรมบน Android

"อีสุกอีใส" ประสบการณ์เมื่อต้องมาเป็นตอนอายุ 22