10 เรื่องที่โปรเจคเมเนเจอร์อยากให้ดีเวลลอปเปอร์เข้าใจ

Sep 14, 2008 by chatchai

Translated from : 10 things Project Managers wish Developers understood
Author : Frank Kelly

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

10) การท่วมล้นของข้อมูล: ผมก็อยากจะตั้งสมาธิ กับเรื่องใดเรื่องหนึ่ง เป็นอย่างๆไปเหมือนกัน แต่ผมมีคนเป็นล้านพุ่งเข้าหาผมจากทุกทิศทาง
ไม่ว่าจะเป็นโปรดักเมเนเจอร์, ซัพพอร์ท (support), เมเนจเมนท์ (management), เหล่าลูกค้ากับความต้องการต่างๆ, ดีเวลลอปเปอร์ รวมไปถึงเมเนเจอร์, อาร์คีเทค (architects) และดีเวลลอปเปอร์ในทีมอื่นๆอีก มันเป็นข้อมูลและความสัมพันธ์เป็นจำนวนมากที่ต้องบริหารจัดการ ดังนั้นอย่าแปลกใจถ้าคุณเจอกับการโต้ตอบในลักษณะต่อไปนี้

ดีเวลลอปเปอร์ : คุณยังจำปัญหาเรื่อง GUI ในสัปดาห์ที่แล้วได้หรือเปล่า?
(อีกนัยหนึ่งคือ: เจ้าปัญหาร้ายแรงนั่น ที่ผมหาทางแก้ได้ในที่สุดนั่นไง)
เมเนเจอร์: ปัญหาอันไหนละ?
(อีกนัยหนึ่งคือ: ผมเพิ่งจะใช้เวลา 3 ชั่วโมงในการตอบเมลล์กับคนอื่นอีก 14 คน และผมเหนื่อยเหลือเกิน)

9) ความกดดันในการทำงาน: เมเนเจอร์บางครั้งอาจจะตื่นเต้น และรู้สึกกดดันจนเกินไป จนพยายามที่จะ “ชี้ทางแก้ปัญหา” ให้กับดีเวลลอปเปอร์. ปฏิเสธ (อย่างสุภาพ) ไปก็ได้ถ้าหากเห็นว่ามันไม่เหมาะสม
เมื่อคุณมาเป็นเมเนเจอร์และไม่ได้เขียนโค้ดอีกต่อไป คุณจะต้องแบกรับความรับผิดชอบ(ความกังวล) ในการทำงานให้เสร็จตามกำหนด แต่คุณมีอำนาจในการควบคุมมันน้อยเหลือเกิน เหล่าเมเนเจอร์ที่ใช้เวลาเป็นดีเวลลอปเปอร์ไปด้วยในบางครั้ง มักจะคิดว่าพวกเขาสามารถที่จะชี้ทางแก้ปัญหาให้กับดีเวลลอปเปอร์คนอื่นๆได้ แต่นั่นมันไม่ได้ผลหรอก ดีเวลลอปเปอร์เป็นพวกมีความคิดสร้างสรรค์และ(ไม่ว่าจะดีหรือไม่) เป็นพวกยึดมั่นในความคิดของตัวเอง (egotistical) สูง (ผมก็เป็นหนึ่งในนั้น) และพวกเราชอบที่จะทำอะไรให้ประทับใจหัวหน้า มากกว่าที่จะแค่รับคำสั่งไปปฏิบัติตาม ผมได้เรียนรู้ที่จะถามคำถาม ในเชิงชี้นำหรือในเชิงการหาข้อมูล มากว่าการชี้ทางแก้ปัญหา ตัวอย่างเช่น

• จะมีกี่ไฟล์ที่ได้รับผมกระทบจากการแก้ปัญหานี้ละ
• การเปลี่ยนของ SQL อันนี้จะกระทบกับประสิทธิภาพการทำงานยังไง
• การเปลี่ยนของ GUI นี้จะกระทบต่อการทำงานของลูกค้าหลักของเรายังไง
• ถ้าเราแก้ปัญหานี้แล้วมันจะไปทำให้เกิดปัญหาที่อื่นหรือเปล่า

8 ) ความเสี่ยงของโปรเจค: เทคโนโลยีใหม่ = ความเสี่ยง
ทุกครั้งที่คุณเริ่มต้นโปรเจคใหม่ ดีเวลลอปเปอร์ก็ชอบที่จะใช้เทคโนโลยีใหม่ๆ แต่คุณจะทุ่มทุกอย่างลงไปกับเทคโนโลยีใหม่ไม่ได้ เทคโนโลยีใหม่ย่อมจะนำความเสี่ยงมาสู่โปรเจค ประสิทธิภาพอาจจะเพิ่มขึ้นแต่มันจะคุ้มกับความเสี่ยงหรือเปล่า
ผมเคยมีเมเนเจอร์ที่เอาแต่ปฏิเสธเทคโนโลยีใหม่ๆ เขาไม่เข้าใจถึงความต้องการของดีเวลลอปเปอร์ ในการพัฒนาตัวเองและเรียนรู้เทคโนโลยียอดฮิต (อย่างเช่น Ajax)/ เฟรมเวิร์ค (อย่างเช่น Spring) มันช่างไม่เป็นที่น่าจูงใจเอาเสียเลย อีกอย่างหนึ่งคือ เทคโนโลยีมักจะช่วยให้ทำงานได้ประสิทธิภาพมากขึ้น มันไม่ใช่แนวคิดที่มองการณ์ไกลเลย ในการเอาแต่ปฏิเสธเทคโนโลยีใหม่ๆ
ผมก็เคยมีเมเนเจอร์ ที่คอยแต่มองหาเทคโนโลยีใหม่ๆเหมือนกัน แล้วโปรเจคก็ไปติดแหง่ก อยู่กับปัญหาทางเทคนิคอันแล้วอันเล่า และไม่เคยทำให้ซอฟแวร์ทำงานได้ ภายในเวลาที่กำหนดได้เลย เนื่องจากดีเวลลอปเปอร์ต้องใช้เวลามาก ในการเรียนรู้เทคโนโลยีใหม่ๆเหล่านั้น ในฐานะที่ผมก็เป็นดีเวลลอปเปอร์ ผมเข้าใจว่าพวกเขารักที่จะเรียนรู้ แต่ในฐานะของเมเนเจอร์ ผมต้องชั่งน้ำหนัก ระหว่างแรงจูงใจของดีเวลลอปเปอร์ กับเป้าหมายในการทำให้โปรดักสำเร็จใช้งานได้

7) ประสิทธิภาพ: เมเนเจอร์ที่ยอดเยี่ยม จะกันดีเวลลอปเปอร์ออกจากเรื่องบ้าบอต่างๆ ที่เกิดขึ้นในระหว่างการบริหารงาน อย่างเช่น เสปคที่ไม่ได้เรื่อง, แนวความคิดแปลกๆ, การเปลี่ยนลำดับความสำคัญของงาน หรือการประชุมที่มากจนเกินไป
ถ้าคุณคิดว่าหัวหน้างี่เง่า (pointy haired boss) ของคุณนั้นช่างเสียสติจริงๆ รอให้คุณเห็นพวกคนที่เขาทำงานให้ก่อนเถอะ ปัญหาในการพัฒนาซอฟแวร์ในปัจจุบันก็คือ มันต้องเกี่ยวข้องกับทีมมากมายหลายทีม ทีมของดีเวลลอปเปอร์, ทีมของ QA, ซัพพอร์ท, ฝ่ายลูกค้าสัมพันธ์, ฝ่ายที่ปรึกษา และทุกคนต่างก็มีมุมมองและเป้าหมายของตัวเอง พวกเขามีมุมมองในภาพที่ใหญ่กว่า หรือเป็นอีกมุมมองหนึ่งต่างออกไปเลย ดีเวลลอปเปอร์บางคนก็พอคิดได้ว่า ขณะที่สิ่งเหล่านี้ดำเนินไปนั้น เมเนเจอร์กำลังกันเวลาไว้ เพื่อให้คุณทำงานได้อย่างมีประสิทธิภาพ และทำในสิ่งที่คุณรัก นั่นคือการเขียนโค้ด

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

5) ทำในสิ่งที่เราไม่อยากทำ: เราเรียกประชุมก็เพราะมันเป็นสิ่งที่จำเป็น
ผมรู้ว่าการประชุมนั้นขัดจังหวะการเขียนโค้ด อันเป็นกิจกรรมสุดโปรดของคุณ แต่มันก็เป็นสิ่งที่ช่วยไม่ได้เลยในบางโอกาส ผมต้องการรู้ว่า คุณเข้าไจความเป็นไปในขณะนี้หรือไม่ จริงๆแล้วผมแทบจะไม่รู้เลยว่า ความคืบหน้าเป็นอย่างไรบ้างแล้ว จนกว่ามันใกล้ๆจะเสร็จโน่นแหละ โชคดีอยู่บ้าง ในฐานะที่ผมก็เป็นดีเวลลอปเปอร์(ในบางโอกาส) ผมใช้เครื่องมือเช่น FindBugs, PMD, CheckStyle เพื่อตรวจสอบโค้ด และใช้ Unit Test กับ Code Coverage เพื่อประเมิณคุณภาพของโค้ดอย่างคร่าวๆ แต่สิ่งที่วัดได้ก็เป็นแค่ตัวแทนของค่าที่ต้องการจริง นั่นก็คือ คุณภาพของโปรดักในมุมมองของผู้ใช้งานเท่านั้นแล้วมีวิธีอื่นไหนอีก ที่จะทำให้ผมรู้ความไปต่างๆได้อย่างรวดเร็ว การประชุมไงละ ขอโทษด้วยแล้วกันนะ

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

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

ดีเวลลอปเปอร์: “คุณรู้เรื่องคลาส Finder ที่ทีม X ทำขึ้นมาหรือยัง พวกเขาสร้าง Factory เมธอดอันไหม่ที่ไม่ปลอดภัยในการทำงานกับ thread ขึ้นมา ผมคิดว่ามันบ้ามากเลยละ พวกเขาไม่รู้เลยหรือไงว่า thread pool ของเราจะ … … …”
เมเนเจอร์(ผู้ที่กำลังครุ่นคิดอย่างหนักกับเรื่องอื่นอยู่ อย่างความขึ้นต่อกันต่างๆในโปรเจค): (คิดในใจ) เขาจะคิดว่าผมเป็นพวกงี่เง่าหรือเปล่านะ ถ้าผมจะตอบแค่ว่า “หือ”

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

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

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

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

read more

Reflections on Java Reflection

Sep 14, 2008 by chatchai

Translated from : Reflections on Java Reflection

Author : Russ Olsen

Thanks to Russ who allow me to translate his blog here

Russ is also the author of Design Patterns in Ruby

ในชีวิตปกติ รีเฟลคชัน (reflection) คือภาพสะท้อนในกระจก แต่ในโลกของการเขียนโปรแกรมแล้ว รีเฟลคชันคือการที่โปรแกรม สามารถรู้ถึงโครงสร้างของตัวเอง และยังสามารถปรับเปลี่ยนโครงสร้างนั้นได้อีกด้วย Java reflection API มอบหน้าต่างให้คุณมองเข้าไปสู่ ค่าพื้นฐานต่างๆของภาษา นั่นคือ คลาส, ฟิลด์และเมท็อด ผ่านทาง Java API ธรรมดาง่ายๆ
การเข้าใจ รีเฟลคชัน จะช่วยให้คุณ เข้าใจเครื่องมือต่างๆ ที่คุณใช้อยู่ประจำวันเช่น eclipseทำ auto-completion ของชื่อเมท็อดได้อย่างไร หรือ Tomcat สามารถสร้าง servlet ขึ้นมาใช้งานได้ จากเพียงแค่ชื่อของคลาสใน web.xml ได้อย่างไร และ Spring ควบคุมการทำ dependency injection ราวกับมายากลนั้นได้อย่างไร ด้วยรีเฟลคชันคุณสามารถเขียนโค้ดที่มีความยืนหยุ่น ได้มากกว่าระดับไดนามิค นั่นคือโปรแกรมของคุณ สามารถจัดการกับคลาส ที่มันไม่เคยเจอมาก่อนเลยได้
การเรียก Class มาใช้งาน
ดังที่ผมได้พูดไปแล้วว่า แนวคิดพื้นฐานของรีแฟลคชัน คือการใช้ Java API ธรรมดาๆเข้าไปดูการทำงานข้างในของตัวโปรแกรม เนื่องจากสิ่งที่เป็นพื้นฐานที่สุดของจาวาคือคลาส (ลองเขียนจาวาโปรแกรมสักอันโดยไม่ต้องใช้คลาสดูสิ) ดังนั้นจุดเริ่มต้นที่ดีที่สุดก็คือการเรียนรู้คลาสที่ชื่อว่า “Class” ทุกคลาสในจาวาจะมีอ็อบเจกต์ตัวหนึ่งซึ่งเก็บข้อมูลทุกอย่างเกี่ยวกับคลาสนั้นไว้ อ็อบเจกต์นั้นเป็นอ็อบเจกต์ของคลาส Class คุณสามารถดึงเอาข้อมูลทุกอย่างของคลาสนั้นจากมันได้ (ต่อไปนี้จะขอเรียกอ็อบเจกต์ตัวนี้ว่า คลาสอ็อบเจกต์)เช่น ชื่อของคลาส หรือข้อมูลว่าคลาสนั้นเป็น public หรือ abstract หรือ final หรือไม่ หรือแม้กระทั่งข้อมูลของคลาสแม่ของมัน เรามาลองใช้รีเฟลคชันส่องดูคลาส Employee ง่ายๆอันนี้กัน

package com.russolsen.reflect;

public class Employee
{
   public String _firstName;
   public String _lastName;
   private int _salary;

      public Employee(){
        this( "John", "Smith", 50000);
      }

   public Employee(String fn, String ln, int salary){
      _firstName = fn;
      _lastName = ln;
      _salary = salary;
   }

   public int getSalary(){
      return _salary;
   }

   public void setSalary(int salary){
      _salary = salary;
   }

   public String toString(){
      return "Employee: " + _firstName +  " "
             + _lastName + " " + _salary;
   }

}

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

package com.russolsen.reflect;
import java.lang.reflect.Modifier;

public class GetClassExample{

   public static void main(String[] args){

      Employee employee = new Employee();

      Class klass = employee.getClass();

      System.out.println( "Class name: " + klass.getName());
      System.out.println( "Class super class: " + klass.getSuperclass());

      int mods = klass.getModifiers();
      System.out.println( "Class is public: " + Modifier.isPublic(mods));
      System.out.println( "Class is final: " +  Modifier.isFinal(mods));
      System.out.println( "Class is abstract: " + Modifier.isAbstract(mods));
   }
}

ทำการสั่งประมวลผลโค้ดข้างบนนี้แล้วคุณจะเห็น:
Class name: com.russolsen.reflect.Employee
Class super class: class java.lang.Object
Class is public: true
Class is final: false
Class is abstract: false

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

การเรียกเมท็อด getClass นั้น ไม่ได้เป็นทางเดียวในการเรียกใช้งานคลาสอ็อบเจกต์ คุณยังสามารถเรียกเอาคลาสอ็อบเจกต์ออกมาโดยตรงจากชื่อคลาสนั้นก็ได้

Class klass = Employee.class;

วิธีที่สามในการดึงคลาสออกมาใช้งานนั้น น่าสนใจทีเดียว คุณสามารถสร้างอ็อบเจกต์ของ Class จากสตริงได้ ซึ่งสตริงนั้นก็ต้องมีค่าเป็นชื่อของคลาสด้วย วิธีการก็คือเรียกเมท็อด forName ของคลาส Class

Class klass = Class.forName("com.russolsen.reflect.Employee");

System.out.println( "Class name: " + klass.getName());
System.out.println( "Class super class: " + klass.getSuperclass());

// Print out the rest...

สิ่งหนึ่งที่ต้องจดจำไว้เสมอก็คือ คุณจะต้องใช้ชื่อเต็มของคลาส ซึ่งเป็นชื่อที่รวมชื่อของ package ของคลาสนั้นด้วย คุณไม่สามารถใช้แค่ชื่อ “Employee” คุณจะต้องใช้ “com.russolsen.reflect.Employee” จากการใช้งานเมท็อด forName นั้นเราก็เริ่มจะเห็นพลังความสามารถพื้นฐานของรีเฟลคชัน นั่นคือคุณสามารถใช้ชื่อของคลาสในสตริง เพื่อสร้างคลาสอ็อบเจกต์เอามาใช้งานได้

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

package com.russolsen.reflect;

public class NewInstanceExample{
   public static void main(String[] args) throws ClassNotFoundException,
      		InstantiationException, IllegalAccessException {

      Class klass = Class.forName(args[0]);
      Object theNewObject = klass.newInstance();
      System.out.println("Just made: " + theNewObject);
   }
}

ประมวลผลโค้ดข้างบนพร้อมกับส่งค่า “com.russolsen.reflect.Employee” เข้าไปในโปรแกรม และคุณก็จะได้อ็อบเจกต์ใหม่เอี่ยมของ Employee ออกมา

Just made: Employee: John Smith 50000

ส่งประมวลผลอีกครั้ง พร้อมกับใส่ค่า “java.util.Date” แล้วคุณจะได้

Just made: Tue Feb 27 20:25:20 EST 2007

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

มากกว่าคอนสตรัคเตอร์ที่ไม่มี argument
การเรียกเมท็อด Class.newInstance นั้นก็เหมือนกับการเรียกใช้ new แบบไม่ใส่ argument แต่จะเกิดอะไรขึ้นละ ถ้าคุณเรียก newInstance บนคลาสที่ไม่มีคอนสตรัคเตอร์ที่ไม่มี argument คำตอบคือคุณจะเจอกับ InstantiationException นะสิ
ข่าวดีก็คือคุณสามารถสร้างอินสแตนของคลาสที่มี constructor แบบรับ argument ได้ เพียงแค่ต้องทำงานเพิ่มอีกนิดหน่อย สิ่งที่ต้องทำคือ หาคอนสตรัคเตอร์ที่คุณต้องการของคลาสนั้น และเรียกใช้มันพร้อมกับ ส่งค่า argument ที่ถูกต้องเข้าไป วิธีสำหรับค้นหาคอนสตรัคเตอร์ในฝันของคุณก็คือ การเรียกเมท็อด getConstructor พร้อมกับข้อมูลอธิบายลักษณะคอนสตรัคเตอร์ ที่คุณกำลังค้นหา สิ่งที่คุณจะได้กลับมาคืออ็อบเจกต์ของคลาส Constructor ซึ่งคุณสามารถนำไปใช้สร้างอินสแตนใหม่ได้
มาดูกันว่าทั้งหมดนี้ทำงานอย่างไร

      Class klass = Class.forName("com.russolsen.reflect.Employee");

      Class[] paramTypes = {
            String.class,
            String.class,
            Integer.TYPE };

      Constructor cons = klass.getConstructor(paramTypes);

      System.out.println( "Found the constructor: " + cons);

      Object[] args = {
            "Fred",
            "Fintstone",
            new Integer(90000) };

      Object theObject = cons.newInstance(args);
      System.out.println( "New object: " + theObject);

ความแตกต่างอย่างเดียว ระหว่างคอนสตรัคเตอร์แต่ละตัว ก็คือพารามิเตอร์ที่มันรับ ดังนั้นวิธีที่คุณจะบอก getConstructor ว่าคุณกำลังมองหาคอนสตรัคเตอร์ตัวไหนอยู่ ก็คือการส่งอาเรย์ของคลาสเข้าไป โดยแต่ละคลาสในอาเรย์ จะแทนแต่ละพารามิเตอร์ในคอนสตรัคเตอร์ ตัวอย่างข้างบนนั้น ทำการค้นหาคอนสตรัคเตอร์ ที่รับค่าสตริง 2 ตัวกับ int หนึ่งตัว เมื่อคุณได้คอนสตรัคเตอร์แล้ว การสร้างอ็อบเจกต์ใหม่นั้นก็แสนง่าย เพียงแค่เรียกเมท็อด newInstance โดยส่งอาเรย์อีกหนึ่งอันเข้าไป คราวนี้อาเรย์นั้นจะบรรจุค่าของ argument

มีข้อควรระวังอย่างหนึ่ง ในการกำหนดชนิดของพารามิเตอร์ สำหรับคอนสตรัคเตอร์ที่คุณกำลังค้นหาอยู่ คุณควรจะระมัดระวัง ในการแยกความแตกต่างระหว่าง argument ที่เป็น primitive กับอ็อบเจคที่เป็น wrapper ของมัน ต้องดูให้แน่ว่าคอนสตรัคเตอร์นั้นรับ argument ที่เป็น int หรือเป็นอ็อบเจกต์ของคลาส java.lang.Integer ถ้าคุณกำลังมองหาคอนสตรัคเตอร์ที่รับ wrapper ของชนิดข้อมูล primitive เช่น java.lang.Integer ก็ให้ใช้คลาสของ wrapper นั้นเลยเช่น Integer.class แต่ถ้าคุณต้องการคอนสตรัคเตอร์ที่รับค่า primitive int คุณจะต้องใช้ Integer.TYPE ซึ่งเป็นสิ่งที่ใช้แทนคลาสของ primitive int

ค้นลึกลงไปในคลาส
ดังที่คุณได้เห็นจากตัวอย่างแรก อ็อบเจกต์ของ Class สามารถให้ข้อมูลพื้นฐานทุกอย่าง เกี่ยวกับคลาสแก่คุณได้ ข้อมูลเช่นชื่อ หรือคลาสที่เป็นคลาสแม่ แต่คุณสามารถทำได้มากกว่า การเรียกดูข้อมูลในระดับพื้นฐานเช่นชื่อหรืออันดับ หรือตัวเลข serial เหล่านี้ ตัวอย่างเช่น คุณสามารถที่จะค้นหาเมท็อดที่เป็น public ทั้งหมดในคลาสโดยใช้เมท็อด getMethods

Class klass = Class.forName("com.russolsen.reflect.Employee");

Method[] methods = klass.getMethods();

for(Method m : methods ){
         System.out.println( "Found a method: " + m );
}

getMethods จะคืนกลับอาเรย์ของอ็อบเจกต์ของคลาส Method แต่ละอันคือหนึ่งเมท็อดที่เป็น public ที่สามารถเรียกใช้ได้บนอินสแตนของคลาสนั้น

Found a method: public java.lang.String com.russolsen.reflect.Employee.toString()
Found a method: public int com.russolsen.reflect.Employee.getSalary()
Found a method: public void com.russolsen.reflect.Employee.setSalary(int)
Found a method: public native int java.lang.Object.hashCode()
Found a method: public final native java.lang.Class java.lang.Object.getClass()
Found a method: public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
Found a method: public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
Found a method: public final void java.lang.Object.wait() throws java.lang.InterruptedException
Found a method: public boolean java.lang.Object.equals(java.lang.Object)
Found a method: public java.lang.String java.lang.Object.toString()
Found a method: public final native void java.lang.Object.notify()
Found a method: public final native void java.lang.Object.notifyAll()

เพราะว่าเมท็อด getMethods นั้นมองคลาสในมุมมองของผู้ใช้งานคลาสนั้น ดังนั้นอาเรย์จะบรรจุเมท็อดที่เป็น public ทั้งหมดที่ถูกประกาศไว้ในคลาสของมันเอง รวมไปถึงคลาสแม่และคลาสเหนือคลาสแม่ขึ้นไปเรื่อยๆ จนถึงคลาส Object

ถ้าคุณสนใจเมท็อดอันใดอันหนึ่งโดยเฉพาะ คุณสามารถใช้ getMethod (โปรดสังเกตุว่าชื่อเมท็อดอยู่ในรูปเอกพจน์) ซึ่งทำงานคล้ายกับ getConstructor เว้นแต่ว่าคุณจะต้องใส่ชื่อเมท็อดพร้อมกับชนิดของพารามิเตอร์ โค้ดข้างล่างนี้ทำการค้นหาเมท็อดชื่อ setSalary ซึ่งรับพารามิเตอร์เป็น int หนึ่งตัว

Class klass = Class.forName("com.russolsen.reflect.Employee");
Class[] paramTypes = {Integer.TYPE };
Method setSalaryMethod = klass.getMethod("setSalary", paramTypes);

System.out.println( "Found method: " + setSalaryMethod);

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

     Class klass = Class.forName("com.russolsen.reflect.Employee");

      Class[] paramTypes = {Integer.TYPE };
      Method setSalaryMethod = klass.getMethod("setSalary", paramTypes);

      Object theObject = klass.newInstance();
      Object[] parameters = { new Integer(90000) };

      setSalaryMethod.invoke(theObject, parameters);

ทำไมต้องมาเสียเวลากับสิ่งเหล่านี้ เพื่อแลกกับการพิมพ์แค่ theObject.setSalary(90000) ละ อืม ลองดูโค้ดข้างบนอีกสักครั้ง นอกจากชื่อคลาสในบรรทัดแรกแล้ว โปรแกรมข้างบนนั้นมีความเป็น generic ในทั้งโปรแกรม คุณสามารถใช้มันเรียกเมท็อด setSalary ของอินสแตนใดๆบนคลาสใดก็ได้ ด้วยการปรับแต่งเล็กน้อย คุณก็จะสามารถใช้โค้ดข้างบนนั้น เรียกเมท็อดใดๆบนคลาสใดๆก็ได้

เล่นกับฟิลด์ (field)
คุณไม่ได้ถูกจำกัดให้ใช้รีเฟลคชันจัดการได้เฉพาะเมท็อด คุณยังสามารถทำอะไรก็ได้กับฟิลด์อีกด้วย เราได้เห็นการใช้งาน getMethods ไปแล้ว การใช้งาน getFields นั้นก็คล้ายๆกันคือจะส่งกลับอาเรย์ของ Field แต่ละอ็อบเจกต์ในอาเรย์นั้น ก็คือแต่ละอินสแตนฟิลด์ (instance field) ที่อยู่ในคลาสนั้น รวมไปถึงอินสแตนฟิลด์ที่ถูกประกาศในคลาสแม่ของมัน

Class klass = Class.forName("com.russolsen.reflect.Employee");

System.out.println( "Class name: " + klass.getName());
Field[] fields = klass.getFields();

for(Field f : fields ){
    System.out.println( "Found field: " + f);
}

เนื่องจาก Employee มีฟิลด์แค่สองตัว ดังนั้นคุณจะได้อาเรย์ที่มีสมาชิกสองตัวกลับมา

Class name: com.russolsen.reflect.Employee
Found field: public java.lang.String com.russolsen.reflect.Employee._firstName
Found field: public java.lang.String com.russolsen.reflect.Employee._lastName

คุณสามารถที่เจาะจงดึงเอาฟิลด์อันใดอันหนึ่งมาด้วยชื่อโดยการใช้เมท็อด getField

Field field = klass.getField(“_firstName”);
System.out.println(“Found field: ” + field);

เมื่อคุณได้อ็อบเจกต์ของ Field แล้ว การดึงค่าของฟิลด์นั้นก็ง่ายพอๆกับการเรียกเมท็อด get และการกำหนดค่าให้กับฟิลด์นั้นก็เพียงแค่เรียกเมท็อด set

      Object theObject = new Employee("Tom", "Smith", 25);

      Class klass = Class.forName("com.russolsen.reflect.Employee");

      Field field = klass.getField("_firstName");

      Object oldValue = field.get(theObject);
      System.out.println( "Old first name is: " + oldValue);

      field.set( theObject, "Harry");
      Object newValue = field.get(theObject);
      System.out.println( "New first name is: " + newValue);

ส่งประมวลผลโค้ดข้างต้นแล้วมองดูฟิลด์ _firstName เปลี่ยนค่าไปให้เห็นกับตาคุณ

Old first name is: Tom
New first name is: Harry

แหกกฎ
การศึกษาเกี่ยวกับรีเฟลคชันนั้น จะครบถ้วนไปไม่ได้ หากไม่ได้พูดถึงการฝ่าฝืนกฎศักสิทธิ์อันหนึ่งของจาวาทุกคนคงรู้ดีว่าไพรเวทเมท็อด (private method) นั้นไม่สามารถเข้าถึงได้จากภายนอกคลาส ที่ประกาศมันไว้ วิธีการใช้งานทั่วไปนั้นไม่สามารถทำได้ แต่กับรีเฟลคชันแล้ว คุณแทบจะทำอะไรได้ทุกอย่าง

สิ่งแรกที่คุณต้องการในการเรียกใช้ไพรเวทเมท็อดก็คืออ็อบเจกต์ Method ของเมท็อดที่คุณต้องการเรียก คุณไม่สามารถดึงมันออกมาได้จากการเรียก getMethod เพราะ getMethod จะส่งกลับเฉพาะเมท็อดที่เป็น public เท่านั้น วิธีที่คุณจะได้มาซึ่งไพรเวทเมท็อด(หรือ protected) ก็คือการใช้ getDeclaredMethod ในขณะที่ getMethod มองคลาสในมุมมองของผู้ใช้งาน และส่งกลับเฉพาะเมท็อดที่เป็น public แต่ getDeclaredMethod จะส่งกลับทุกเมท็อดที่ถูกประกาศไว้ในคลาสนั้น ตัวอย่างข้างล่างเราใช้ getDeclaredMethod ในการดึงไพรเวทเมท็อด removeRange ของคลาส java.util.ArrayList

ArrayList list = new ArrayList();
list.add("Larry");
list.add("Moe");
list.add("Curley");

System.out.println("The list is: " + list);

Class klass = list.getClass();

Class[] paramTypes = { Integer.TYPE, Integer.TYPE };
Method m = klass.getDeclaredMethod("removeRange", paramTypes);

Object[] arguments = { new Integer(0), new Integer(2) };
m.setAccessible(true);
m.invoke(list, arguments);
System.out.println("The new list is: " + list);

เมื่อคุณได้ไพรเวทเมท็อดมาแล้ว การจะเรียกใช้มันได้ก็เพียงแค่ปิดการป้องกันสุดท้ายโดยการเรียก setAccessable

The list is: [Larry, Moe, Curley]
The new list is: [Curley]

เมท็อด removeRange จะทำการดึงเอาไอเทมในช่วงหนึ่งออกจากลิสต์ นี่อาจจะออกแนวไสยศาสตร์วูดูเลยทีเดียว คุณพึ่งจะเข้าไปเรียกไพรเวทเมท็อดของ java.util class แต่ถามว่าคุณอยากจะสร้างนิสัยในการเขียนโค้ดที่คลุมเครือ อย่างการเรียกใช้งานไพรเวทเมท็อดแบบนี้ไหมละ ก็คงไม่หรอก แต่อย่างน้อยมันก็เป็นสิ่งที่รู้กัน ว่ามีประโยชน์ ในบางสถาณการณ์ที่จำเป็นจริงๆ

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

read more

คุณว่าอยากจะเขียนยูนิตเทสรึ

Sep 14, 2008 by chatchai

เรื่อง : คุณอยากจะเขียนยูนิตเทสอย่างนั้นรึ
Translated from : So You Wanna Write A Unit Test

Author : Russ Olsen

Thanks to Russ who allow me to translate his blog here

Russ is also the author of Design Patterns in Ruby

ผมเห็นนักพัฒนา (developers) หลายๆคน มองการเขียนยูนิตเทส ในทำนองเดียวกับที่ นักบุญออกัสตินคิดต่อการสำรวมในกาม: ข้าแต่พระเจ้า ประทานพลังแก่ข้าในการเขียนยูนิตเทสเถิด, แต่ยังก่อนอย่าพึ่งเป็นตอนนี้. เรารู้ดีว่าเราควรจะเขียนยูนิตเทส แต่เราก็คอยแต่จะผัดผ่อนมันเรื่อยมา ต่อไปนี้เป็น 5 ประการที่พึงท่องไว้ในใจ ขณะที่คุณพยายามสร้างความมุ่งมั่นในการเขียนเทส

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

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

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

ถ้าหากเทสนั้นไม่ผ่านผมก็จะพึ่ง debugger เพื่อนยาก หรือใส่คำสั่งบันทึกการทำงาน (logging) ของผมเอง. ผมมันคนง่ายๆประเภทแค่ ใช่ หรือ ไม่ใช่

3.เลิกดักจับ exception.
คำถาม : อะไรคือข้อแตกต่างระหว่าง JUnit เทส นี้ :

public void testWidget() throws WidgetException {
    Widget w = new Widget();
    w.doSomething();
}

กับเทสนี้

public void testWidget() {
    try {
      Widget w = new Widget();
      w.doSomething();
    }
    catch( WidgetException we) {
      fail("widget failed", we );
    }
}

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

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

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

4. อย่าเขียน “สงครามและสันติภาพ (War And Peace)” ของเทสเมธอด
ทำไมทุกครั้งเมื่อวิศวกรบางคนเริ่มต้นเขียนยูนิตเทส เขาจะต้องย้อนเวลากลับไป เมื่อตอนราตรีฉลองจบการศึกษา (prom night) โปรแกรมเมอร์ธรรมดา ท่าทางเรียบร้อยคนหนึ่ง ผู้ไม่เคยคิดจะเขียนเมธอดยาวถึงขนาด 60 บรรทัด มาก่อนเลยในชีวิต กลับมึนเมาพ่นเอา เทสเมธอดยาว 1700 บรรทัดออกมา แบบไม่มีคอมเมนต์ ไม่มีโครงสร้าง ไม่เห็นแนวความคิด จริงที่ข้อกำหนดต่างๆย่อมแตกต่างออกไปเมื่อคุณเขียนยูนิตเทส ไม่, คุณไม่ต้องทำตามข้อตกลงไปเสียทั้งหมด และก็ไม่ต้องระวังไปเสียทุกอย่าง. แต่ขอเพียงแค่สงสารพวกเราคนที่ต้องมานั่งจัดการกับสิ่งที่คุณทำไว้บ้าง

ถ้าคุณเขียนเทสเมธอดขนาดใหญ่ ที่ไม่มีแบบแผนอะไรเลย แล้วสามารถประมวลผลได้ปกติ มันก็เยี่ยม แต่ถ้าหากมันเทสไม่ผ่านละ จุดผิดพลาดที่บรรทัด 1543 มักจะหายากกว่าจุดผิดพลาดที่ 43

5.อย่าล้มเลิกความตั้งใจ
ไปที่ร้านหนังสือที่ไหนก็ได้ หรือค้นหาในเวบไซท์ทางวิศวกรรมซอฟแวร์ ที่เวบไหนก็ได้ มันไม่เป็นการยากเลยที่จะเจอคำพูดเป็นพันๆคำ เกี่ยวกับการเขียนยูนิตเทสให้ครอบคลุมทุกด้าน สำหรับทุกๆ เส้นทางการประมวลผล (execution code path)

ในความเป็นจริงบางครั้งไม่มีเวลามากพอ หรือไม่มีความเข้าใจในโค้ดที่เราพยายามจะเทส จะทำอย่างไรละ? อืม ก็เขียนยูนิตเทสอะไรก็ได้ เท่าที่คุณจะเขียนได้นั่นละ. อย่างน้อยที่สุด เขียนแค่ยูนิตเทสที่ใช้งานโค้ดสักนิดหน่อย โดยไม่ต้องทำการทดสอบสมมุติฐาน (assertion) เลย ตัวอย่างเช่น.

public void testWidgetCreation() {
    Widget w = new Widget();
}

เทสข้างบนนั้น แม้จะห่างไกลจากทที่ควรจะเป็นมากนัก แต่มันก็ได้เทสในหลายสิ่งมากกว่าที่คุณคิด ถ้าหากว่า testWidgetCreation() สามารถผ่านเทสได้ คุณจะสามารถรู้ได้ว่า:

• Widget เป็น คลาส
• Widget ไม่ใช่ abstract
• Widget มีคอนสตรัคเตอร์เปล่าที่ไม่รับพารามิเตอร์
• คอนสตรัคเตอร์เปล่าที่ไม่รับพารามิเตอร์ของ Widget ไม่ได้มีการโยน exception ออกมา
• Widget ได้ถูกคอมไพล์แล้วและคุณมีมันอยู่ใน คลาสพาธ (class path)

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

เอาละในที่สุดเราก็ได้มันมา: เขียนยูนิตเทสที่กระชับที่สุดที่สามารถบอกคุณได้อย่างรวดเร็วว่าโค้ดของคุณทำงานได้หรือไม่ ยูนิตเทสที่ส่องทางไปยังปัญหาไม่ใช่ทำให้ลางเลือน ยูนิตเทสที่อย่างน้อยที่สุดก็มีอยู่จริงให้ใช้.

Translation Note :

• War And Peace เป็นนวนิยายคลาสสิคประพันธ์โดย Leo Tolstoy. หนังสือเล่มนี้มีเนื้อหายาวมากเป็นพันๆหน้า ผู้เขียนตั้งใจจะเปรียบเทียบว่า ยูนิตเทสควรจะกระชับไม่ใช่ยาวอย่างกับจะเขียนนวนิยายคลาสสิค

read more