My Kata

PragDave เขาเคยพูดถึงประเด็น Code Kata ไว้
Kata คือ การฝึกรูปแบบการเคลื่อนที่ (patterns of movements practiced)
เป็นศัพท์ที่ใช้ในวงการพวก ศิลปะการป้องกันตัว
(ไม่รู้ว่านำไปเทียบกับ Drill ของพวกว่ายน้ำได้หรือเปล่า)

Dave เขาพูดถึงประเด็นเรื่องการฝึกเขียนโปรแกรม หรือฝึกคิดแก้โจทย์
โดยคุณสมบัติที่เขากำหนดไว้ ก็คือ

• session ของการฝึกต้องไม่ยาวนัก (~= 30 ถึง 60 นาที)
  
• scope ของเรื่องที่ฝึก ก็ต้องน้อยๆไม่เยอะนัก
  
• code (ที่ได้จากฝึกนี้) เขียนแล้วโยนทิ้งไปเฉยๆ ไม่ได้เอาไปทำอะไรต่อ
  
• ทำซ้ำ และไม่ต้องพะวงกับความผิดพลาด,
  เน้นให้ความสนใจไปที่ feedback เพื่อที่จะนำมาปรับปรุง technic ให้ดีขึ้น
  

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

อย่างกรณีของผม
ยิ่งผมเรียนรู้ ภาษา, framework หลายๆแบบยิ่งขึ้น
สัดส่วนของความชำนาญก็จะลดลง
ตอนนี้ก็เลยต้องให้ความสำคัญกับ
"การสร้างความชำนาญ" มากขึ้น

เบื้องต้นก็คือ พยายามหาโจทย์ มาฝึกทำ
อย่างโจทย์ของที่นี่ ก็น่าสนใจดี
L-99: Ninety-Nine Lisp Problems
วันนี้ก็เลยเลือกข้อง่ายสุด มาทำ 2 ข้อ

P01 (*) Find the last box of a list.
Example:
* (my-last '(a b c d))
(D)

เริ่มด้วย clisp

(defun find-last (lst)
  (if (null lst)
      nil
    (if (null (cdr lst) 1)
        lst
      (find-last (cdr lst)))))

haskell

find_last (x : []) = x
find_last (x : xs) = find_last xs 

erlang

-module(p1).
-export([find_last/1]).

find_last([X | []]) ->
    X;       
find_last([X | XS]) ->
    find_last(XS).

โจทย์แรกนี่ technic การใช้ pattern matching ชนะแฮะ
haskell ดู clean สุด
ส่วน erlang ถึงแม้จะใช้วิธีเดียวกับ haskell
แต่ syntax ไม่ clean เท่า

โจทย์ข้อต่อไป, โจทย์นี้ไม่ต่างจากโจทย์แรกเท่าไร

P02 (*) Find the last but one box of a list.
Example:
* (my-but-last '(a b c d))
(C D)

clisp

(defun but-last (lst)
  (if (null lst)
      nil
    (if (null (cdr (cdr lst)))
        lst
      (but-last (cdr lst)))))

haskell

but_last (x : []) = [x]
but_last (x : y : []) = [x, y]
but_last (x : xs) = but_last xs

erlang

-module(p02).
-export([but_last/1]).

but_last([X | []]) ->
    [X];
but_last([X | [Y | []]]) ->
    [X,Y];
but_last([X | XS]) ->
    but_last(XS).