ไม่กี่วันก่อนนึกขึ้นมาได้ว่าเรามี Voucher สอบ JAVA certificate ฟรี ที่ได้มาจาก Sun ตอนไปแข่ง Open Jive นี่หว่า ว่าแล้วก็ลาก @iMuping กับ @toffeetoffee มาคุยกันว่าจะเอายังไง เพราะ voucher มันจะหมดอายุสิ้นปีนี้แล้ว ก็ตกลงกันว่าไปสอบวันที่ 24 (วันนี้) เพราะเป็นวันที่ทุกคนว่างตรงกัน (วันอื่นๆ แต่ละคนก็ติดสอบกลางภาคกันหมด)

หลังตกลงกันได้ก็เข้าไปสมัครในเว็บ http://www.prometric.com/ ก็กรอกข้อมูลต่างๆ ไป พอถึงตอนกดยืนยันถึงได้รู้ว่า voucher ที่ถืออยู่ในมือนี่มูลค่า 9569 บาทเลยทีเดียว! (แพงจังวุ้ย)

เอาล่ะ สมัครเสร็จก็ต้องเตรียมตัวสอบสินะ แต่ว่าปัญหาคือ ผมกำลังอยู่ช่วงสอบกลางภาคนี่สิ 😕
แล้วจะหาเวลาไหนอ่านล่ะเนี่ย สรุปแล้วก็เหลือแค่เวลาเดียว คือคืนก่อนไปสอบ! คุณพระ! ปกติเค้าเตรียมตัวกันไม่รู้กี่เดือน กว่าจะไปสอบ ไอ้นี่อาจหาญมาจากไหน เตรียมตัวคืนเดียว เช้าไปสอบ

คืนก่อนสอบ (23 ธ.ค.) ผมกับ @imuping และ @toffeetoffee ก็นั่งสุมหัวกันตั้งแต่หนึ่งทุ่ม จ้องหน้าจอโน้ตบุ๊คที่กำลังเปิด e-book เตรียมสอบ JAVA cert. ความยาว 700-800 หน้าเห็นจะได้ นั่งอ่านกันไปแบบผ่านๆ แว้บไปกินข้าวแป๊บนึงก็มาอ่านต่อ กว่าจะจบก็ปาเข้าไปห้าทุ่ม หลังจากนั้นก็เปิดหาตัวอย่างคำถามตามอินเตอร์เน็ต ก็ตอบได้บ้างไม่ได้บ้าง ใจหนึ่งก็เผื่อไว้แล้วล่ะว่า พรุ่งนี้เจ๊งแน่ๆ (เพิ่มเติม…)

Advertisements

หลังจากคราวก่อนพูดเรื่อง Mediator ไปแล้ว คราวนี้ก็จะพูดเรื่อง Observer บ้าง 😀

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

observer
จากตัวอย่างนี้ มีคลาส UserInterface ซึ่งทำหน้าที่รับ input จาก user ส่งไปให้คลาส XValue เพื่อคำนวณ(อะไรสักอย่าง) แล้วคลาส UserInterface ก็จะวาดกราฟจากผลลัพธ์ที่คำนวณได้

จาก diagram จะเห็นว่าคลาส XValue มีการ extends คลาส Observable มา ซึ่งเป็นคลาสที่มีมาให้ในจาวาแล้ว ส่วนคลาส UserInterface ก็ implements คลาส Observer ที่มีมาให้ในจาวาเช่นกัน

เมื่อ UserInterface ทำการส่งค่า input ไปให้ XValue ค่านั้นก็จะถูกนำไปคำนวณให้ได้คำตอบออกมา แล้วทำการเปลี่ยนค่า attribute ในคลาสตัวเองให้เป็นคำตอบใหม่ที่คำนวณได้ ตอนนี้เองที่ observer จะเข้ามามีบทบาท คือหลังจากที่ XValue ทำการเปลี่ยนค่า attribute แล้วก็จะต้องเรียกใช้ method ชื่อ notifyObservers() ที่ได้จากการ extends เพื่อเตือน Observer ทุกตัวว่ามีการเปลี่ยนแปลงค่าเกิดขึ้นแล้ว (รีบเข้ามาดูเร็วๆ) นั่นหมายความว่า Observer มีได้มากกว่าหนึ่งตัว (แต่ในตัวอย่างมีแค่ตัวเดียว)

หลังจากพวก Observer รับรู้แล้วว่ามีการเปลี่ยนแปลงค่า มันก็จะเรียกใช้ method ชื่อ update(Observable o, Object arg) โดยอัตโนมัติ ทีนี้ก็อยู่ที่เราแล้วว่าจะให้มันทำอะไรในนี้

ตัวอย่างอาจจะไม่ดีเท่าไหร่ เพราะมี observer แค่ตัวเดียว ซึ่งถ้าเป็นแบบนี้ก็ใช้วิธีเรียก method get/set เอาก็ได้ แต่ถามว่าถ้ามี object ที่การทำงานขึ้นกับค่า x ใน XValue สักยี่สิบตัวล่ะ จะเรียก get/set ยี่สิบรอบมั้ย… ก็คงจะไม่ นี่แหละที่ Observer pattern จะเข้ามามีบทบาท 8)

ข้อมูลเพิ่มเติม: http://en.wikipedia.org/wiki/Observer_pattern

หลังจากเรียนวิชา Object-oriented and design pattern มาได้ครึ่งเทอม ก็ถึงเวลานำสิ่งที่ได้เรียนมามาใช้สักที ถึงจะเป็นแค่การเอามาใช้ทำการบ้านก็เถอะ เพราะการบ้านที่อาจารย์ให้ทำมันไม่ได้ง่ายอย่างที่คิดเลย ไหนๆ ก็นั่งทำความเข้าใจเรื่องที่เรียนซะตั้งนาน (ไม่งั้นทำการบ้านไม่ได้) ก็ขอเอามาเขียนลงบล็อกซะหน่อยนะครับ (ฮา)

ตอนแรกกะว่าจะเขียนทีเดียวทั้ง Mediator และ Observer ซึ่งเป็น pattern สองตัวหลักๆ ที่ต้องใช้ในการทำการบ้านนี้ แต่ว่าดูท่าจะยาวเกินไป ก็เลยขอตัดเรื่อง Observer ไปเขียนเป็นเรื่องใหม่ดีกว่า 🙂

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

mediator1
จากตัวอย่าง สมมติว่าเป็นโปรแกรมระบบข้อมูลสักอย่าง ซึ่งข้อมูลถูกเก็บอยู่ใน DataEntity (ไม่ใช่ database นะ) แล้ว user จะทำการแก้ไขข้อมูลที่เก็บไว้ใน DataEntity ผ่านทาง GUI ที่สร้างขึ้นใน UserInterface

จากแผนภาพจะเห็นได้ว่าตัวที่ทำการ implement พวก Listener มาใช้ หรือก็คือตัวที่ตอบสนองต่อเหตุการณ์ต่างๆ ที่เกิดจากผู้ใช้ก็คือคลาส Mediator ไม่ใช่ UserInterface

คลาส UserInterface เป็นเพียงตัวสร้าง component ต่างๆ เช่น drop-down list หรือปุ่มกดต่างๆ

เมื่อ Mediator รับรู้ถึงเหตุการณ์ที่เกิดจาก user (ซึ่งก็คือผู้ใช้กรอกข้อมูลเพื่อแก้ไขข้อมูลเดิมใน DataEntity) Mediator ก็จะไปทำการแก้ไขข้อมูลใน DataEntity

จะเห็นได้ว่า Mediator จะทำหน้าที่เป็นตัวกลางในการตอบสนองต่อเหตุการณ์ต่างๆ ที่เกิดขึ้น นอกจากนี้ยังใช้เป็นตัวกลางเพื่อให้ออบเจ็กต์ต่างๆ ทำงานร่วมกันได้ด้วย เช่น
mediator2
ในตัวอย่าง(ส่วนหนึ่งของการบ้านที่ต้องทำเลยนะเนี่ย) คลาส PostOffice ให้บริการระบบธนาณัติ โดยจะมีการสร้างออบเจ็กต์ของไปรษณีย์แต่ละสาขา แล้วก็สร้างออบเจ็กต์ของธนาณัติแต่ละใบเก็บไว้ใน list ของออบเจ็กต์ไปรษณีย์สาขาต่างๆ ซึ่งจากแผนภาพจะเห็นว่ามีออบเจ็กต์ของ PostOffice สามออบเจกต์ แล้วก็มีออบเจ็กต์ของ MoneyTransfer อีกสามออบเจ็กต์ ทั้งหมดทำงานร่วมกันได้ผ่านทาง Mediator นั่นคือ หากมีการส่งธนาณัติจากไปรษณีย์สาขาหนึ่งไปอีกสาขาหนึ่ง Mediator ก็จะรับหน้าที่ย้ายออบเจ็กต์ธนาณัติจากออบเจ็กต์ไปรษณีย์สาขาหนึ่งไปยังอีกสาขาหนึ่ง หรือก็คือ Mediator ทำหน้าที่ mapping ออบเจ็กต์ทุกตัวในระบบนั่นเอง

สามารถศึกษาข้อมูลเพิ่มเติมได้จาก http://en.wikipedia.org/wiki/Mediator_pattern (มีตัวอย่างโค้ดด้วย :D)

ทำไม้… ทำไม…

ทำไมเราถึงไม่หาหน่วยวัดเวลาที่มันเป๊ะกับธรรมชาติมากกว่านี้
1 วัน คือช่วงเวลาที่ดวงอาทิตย์เคลื่อนไปบนฟ้า ลับขอบฟ้าไป แล้วกลับมาโผล่ที่เดิม (เมื่อมองจากโลก) อันนี้รับได้
1 ปี คือช่วงเวลาที่โลกโคจรรอบดวงอาทิตย์ครบหนึ่งรอบพอดี อันนี้ก็พอรับได้
แต่ทำไม 1 ปี ต้องมี 12 เดือน แล้วแต่ล่ะเดือนก็ดันมีวันไม่เท่ากัน 30 บ้าง 31 บ้าง 28 บ้าง (ทุก 4 ปี กลายเป็น 29 วันอีก – -“)

บ่นมาตั้งนาน เกี่ยวอะไรกับ Java เนี่ย…
ก็คือว่า วันนี้โดนเพื่อนขอ (สั่ง) ให้ช่วยเขียน method คำนวณระยะห่างระหว่างวันสองวัน เช่น 28/06/2009 กับ 30/06/2009 ก็ห่างกันสองวัน
หลังจากนั่งงมอยู่พักหนึ่ง ก็ได้ความคิดที่จะใช้ java.util.Calendar เพราะว่ามันมี method ชื่อ getTimeInMillis() ที่ให้ค่ามิลลิวินาทีของเวลาปัจจุบันออกมา แหม… ดีจัง 🙂

ว่าแล้วข้าพเจ้าก็ละเลงหน้า Netbeans ด้วยโค้ดยุบยับ สร้าง Calendar มาสองตัว เอามาเก็บวันที่สองวัน เรียก millisecond ของทั้งคู่ เอามาลบกัน จับหารด้วย 1000,60,60 และ 24 ก็ได้ออกมาเป็นจำนวนวัน อะฮ้า~ ท่าจะเวิร์ก

ทดสอบโดยใส่วันแรกเป็น 16/06/2009 อีกวันเป็น 25/06/2009 ผลออกมาว่าห่างกัน 9 วัน
ว้าวววว… เป๊ะจริงๆ เขียนทีเดียวรันผ่าน ใช้ได้ด้วย MegaHappy ดีใจสุดๆ จริงๆ 😀

คราวนี้ลองใหม่ ใส่ 28/02/2009 กับ 01/03/2009 รันไปป๊าบบบ…

เจ๊งครับพี่น้อง ผลออกมาได้ 4 วัน!!!

งานเข้าแล้วไง ได้มาได้ไงเนี่ย สี่วัน จะบ้าเหรอ หมด 28 กุมภาฯ มันก็ขึ้นเดือนใหม่แล้วนะค้าบ
คิดไปคิดมาก็เลยสรุป(ตามความเข้าใจตัวเอง)ได้ว่า มันคิดเวลาโดยให้ทุกเดือนมี 31 วันสินะ…

มิน่าล่ะ เวลาเป็นเดือนเดียวกันมันคำนวณได้ ไม่พลาด แต่พอข้ามเดือนล่ะเจ๊ง – -”

ทำให้รู้สึกสงสัยขึ้นมาว่า ทำไม้ทำไม ต้องแบ่งเดือนให้มันไม่เท่ากันด้วย แบ่งเท่าๆ กันได้มั้ย ว่าที่โปรแกรมเมอร์อย่างผมจะได้เขียนตัวคำนวณง่ายๆ หน่อย เฮ้อ~

ตอนนี้ได้ความคิดว่า คงจะต้องเขียนเงื่อนไขคิดวันเดือนปีซะเองแล้วล่ะมั้ง แต่ว่า… ขี้เกียจอะ เอาไว้มีอารมณ์ค่อยลองเขียนแล้วกัน (โปรแกรมมิ่งก็เป็นศิลปะแขนงหนึ่งนะครับ ต้องใช้อารมณ์ในการเขียน LOL)

ปล. ตอนนี้ลองค้นไปเรื่อยๆ จนไปเจอไอ้นี่เข้า
ucar.nc2.units.DateRange

ก็ไม่รู้ว่าเวิร์กมั้ย เพราะยังไม่ได้ลอง เดี๋ยวว่างๆ ลองสักหน่อยดีกว่า 😀

วันนี้อยู่ดีๆ ก็นึกครึ้มอกครึ้มใจระหว่างนั่งเรียน Object-Oriented Programming ว่าทุกวันนี้ CPU มันเป็น multi-core แทบจะหมดแล้วนี่หว่า แล้วก็คุ้นๆ ว่าเคยอ่านบทความว่าซอฟต์แวร์ที่ผลิตออกมาส่วนใหญ่มันยังใช้งาน multi-core ได้ไม่เต็มที่ เพราะว่าโปรแกรมที่เขียนมามันก็เป็น single thread กันเกือบหมด
ว่าแล้วก็ค้นๆๆ จนไปเจอบทความใน blognone.com ที่เคยอ่านเมื่อนานมาแล้ว (แล้วก็เกือบลืมไปแล้ว – -“) เค้าพูดถึงโครงการฝึกอบรมการใช้เทคโนโลยีมัลติคอร์ ของ Intel ที่เค้าสอนการเขียนโปรแกรมเบื้องต้น แล้วก็หลักการเปลี่ยนโปรแกรมเก่าให้ทำงานแบบเชิงขนาน ซึ่งก็มีเครื่องมือมาให้ใช้อย่าง OpenMP, Intel (R) Software Development Products และ Windows Thread (Win32 API)
ประเด็นก็ไม่มีอะไรมากหรอก แค่รู้สึกว่า ในเมื่อเป็นแบบนี้แล้ว แนวโน้มการเขียนโปรแกรมในอนาคตก็คงต้องเป็นพวก multi-thread มากขึ้นเรื่อยๆ สินะ แล้วทีเรากำลังเรียนอยู่นี่มันจะเป็นไปตามแนวโน้มนั้นหรือเปล่าเนี่ย – -”
นึกๆ ดูแล้ว เราก็เรียนพวก thread, concurrency ใน JAVA Programming มาแล้วนี่หว่า ปัญหาคือ เวลาเขียนโปรแกรมเราก็ต้องคิด algorithm ให้มันเป็น multi-thread ด้วยสินะ…

source: รีวิว Intel Multi-core Programming Workshop by KaewGB