Reactive Programming

ในปีนี้ได้ยินเขาพูดถึงคำว่า Reactive Programming กันพอควร

ดังนั้นก็เลยหาข้อมูลเพื่อให้รู้เรื่องกันนิดหน่อยว่า
มันคืออะไรกัน
ทำไมมันถึงน่าสนใจ
เรามาเริ่มศึกษากันเลยดีกว่า …

เริ่มต้นศึกษาก็ง่ายๆ มาก คือ ค้นหาทาง Google นี่แหละ
ก็เจอ 3 ที่หลักๆ คือ

1. Wikipedia
2. Reactive Manifesto
3. Course Reactive Programming

แต่พอไปอ่าน 2 link แรกแล้วไม่ค่อยรู้เรื่องเท่าไร
เพราะว่ามันยาวไป จับประเด็นไม่ได้
ก็เลยลงเรียนใน course ตาม link ดีกว่า
ไปฟังเขาสอนในบทแรกเรื่อง What is Reactive Programming
เลยเอามาสรุปไว้กันลืม  ดังนี้

ที่มาที่ไป เนื่องจาก ความต้องการของระบบงานที่กำลังเปลี่ยนไปอย่างสิ้นเชิง

1. จำนวนของ Server ที่จากเมื่อ 10 ปีที่แล้วอาจจะมี จำนวน server สัก 10-20 ตัว
แต่ในปัจจุบัน มี server เป็นร้อย เป็นพันเครื่อง

2. Response time ที่ต้องการเปลี่ยนจากระดับวินาที มาเป็น เสี้ยววินาที

3. เวลาของการปิดระบบเพื่อดูแลรักษา จากหลักชั่วโมง เป็นให้ไม่มีการปิดระบบ หรือเป็นศูนย์

4. ขนาดของข้อมูล จากระดับ Gigabyte มาเป็น Terabyte, Petabyte กันเลย

ดังนั้น เราจึงต้องการสถาปัตยกรรมรูปแบบใหม่

แล้วหน้าตาหรือคุณสมบัติของแบบใหม่ต้องเป็นอย่างไรล่ะ

จากปัจจุบันที่มีสถาปัตยกรรมที่ทำงานแบบการจัดการด้วย Server และ Container
คุ้นๆ ไหมล่ะ บรรดาพวก Web Server, Application Server ต่างๆ
โดยสถาปัตยกรรมแบบนี้มันไม่สามารถรองรับเรื่องความต้องการที่เปลี่ยนไปได้

ดังนั้นแนวคิดใหม่ที่มาก็คือ Reactive Application
งงกันเข้าไปอีก แต่เพื่อความไม่งง
มีการกำหนดไว้ว่า Reactive Application ต้องมีคุณสมบัติดังนี้

1. Event Driven
2. Scalable
3. Resilient
4. Responsive

ก่อนอื่นมาดูกันก่อนว่า คำว่า Reactive มันคืออะไร

Reactive คือ ตอบรับได้รวดเร็วต่อสิ่งเร้าหรือสิ่งกระตุ้น เช่น

• ตอบรับกับ Event ต่างๆ ได้ นั่นคือ Event driven
• ตอบรับกับจำนวนการใช้งานที่สูงขึ้นมากๆ นั่นคือ Scalable
• ตอบรับกับการทำงานที่ผิดพลาด เพื่อแก้ไขให้ถูกต้อง นั่นคือ Resilient
• ตอบรับกับผู้ใช้งานได้อย่างรวดเร็ว นั่นคือ Responsive

มาดูความหมายของคุณสมบัติของ Reactive Application แต่ละตัวกัน

1. Event Driven
ในรับแบบเก่าหรือปัจจุบัน ทำงานในรูปแบบของ multi-thread
และสื่อสารกันด้วยการ share ข้อมูล ซึ่งสามารถแก้ไขได้ (mutable)
ดังนั้นจึงต้องมีการ synchonize สถานะกันอยู่เสมอ
ซึ่งทำให้ส่วนต่างๆ ของระบบผูกมัดกันสุดๆ
ยิ่งถ้านำส่วนต่างๆ มารวมเพื่อทำงานร่วมกัน
ยิ่งยากไปกันใหญ่

ดังนั้นรูปแบบใหม่
ส่วนต่างๆ จะต้องแยกออกจากกันโดยเด็ดขาดหรือไม่ผูกติดกันมากไป
ด้วยการดักจับ event แทน
โดย event นั้นถูกดักจับหรือทำงานแบบ Asynchronous
ไม่มีการ blocking หรือต้องรอเข้าทำงานหรือใช้งาน

2. Scalable
การรองรับขยายระบบนั้น ทำได้ 2 แบบคือ
2.1การขยายในแนวตั้ง ( Scale up/Verizontal )
ทำได้ด้วยให้ทำงานแบบขนานในระบบแบบ Multi-core
โดยในการ Scale นั้นจะต้องลดการ share ข้อมูลและสถานะ ที่สามารถแก้ไขได้ (mutable)

2.2 การขยายออกด้วยข้าง ( Scale out/Horizontal )
ทำได้ด้วยการเพิ่มจำนวน Server เข้าไป
และจะต้องรองรับเรื่องความผิดพลาดต่างๆ ที่จะเกิดขึ้นด้วย

3. Resilient
คือระบบที่สามารถ recovery จากความผิดพลาดได้อย่างรวดเร็ว
โดยความผิดพลาดอาจจะเกิดจาก
ระบบงานทำงานผิดพลาด
Hardware ต่างๆ ทำงานผิดพลาด
การเชื่อมต่อต่างๆ ทำงานผิดพลาด

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

4. Responsive
คือการที่ระบบทำการตอบรับต่อการใช้งานจากผู้ใช้งาน
ได้อย่างรวดเร็ว แม้ว่าคนใช้งานจะมีปริมาณที่มาก
หรือจะเกิดความผิดพลาดต่างๆ ขึ้นก็ตาม

และแน่นอนว่า Responsive จะเกิดขึ้นมาได้
จะต้องสร้างระบบที่อยู่บนแนวคิดของ Event driven, Scalable และ Resilient นั่นเอง ดังรูป

แต่ก็ยังต้องให้ความสำคัญในเรื่องของ Algorithm การออกแบบระบบ
รวมทั้งรายละเอียดอื่นๆ อีกมากมาย
ไม่ใช่เพียงแค่สนใจแต่ Reactive นะครับ

มาถึงตรงนี้ ก็พอทำให้มองออกว่า Reactive application/programming เป็นอย่างไร
ซึ่งแนวคิดหลายๆ อย่างล้วนวิ่งไปทาง Function programming
ดังนั้นจึงไม่ใช่เรื่องแปลก ที่เมื่อพูดถึง Reactive programming
และจะนึกถึง Functional programming
แต่เป็นเรื่องแปลกที่ มักไม่ค่อยมีใครเข้าใจหรืออธิบาย
แนวคิดของ Reactive programming กันสักเท่าไร

อ้างอิงจาก : http://www.somkiat.cc/reactive-programming/