( λ ) IPorsut

ของใน Go package time ที่ใช้บ่อยๆ ตอนที่ 3

2017-02-04T17:42:00.001+07:00

จากตอนที่แล้ว เราแปลงจาก time.Time ไปเป็น string กันได้แล้ว วันนี้เราจะมาดูการแปลงจาก string มาเป็น time.Time กันต่อครับ

แปลงจาก string มาเป็น Time ด้วย function time.Parse และ time.ParseInLocation

function time.Parse นั้นจะรับค่า layout คือรูปแบบการจัดเรียกของ string จริงๆจะเรียกตามที่ชินปากก็คือ format ที่มันอยู่นั่นเอง ซึ่งค่านี้ก็เหมือนกับตอนที่เราต้องการแปลงจาก time.Time ไปเป็น string ในตอนที่แล้วนั่นเอง ไม่ว่าจะแปลงจากอะไรไปเป็นอะไรก็ต้องบอก format กันก่อน และอีกค่าที่ต้องส่งให้ time.Parse ก็คือ string ที่ต้องการแปลงนั่นเอง ไปดูตัวอย่างกันดีกว่าครับ

timeString := "04/02/2017 07:55:00"

tm, err := time.Parse("02/01/2006 15:04:05", timeString)

if err != nil {

log.Fatal(err)

}

fmt.Println(tm) // Output: 2017-02-04 07:55:00 +0000 UTC

จะเห็นว่า เรายังใช้การกำหนดรูปแบบเป็นวันที่เจาะจงวันหนึ่งเช่นเดิมจาก ตอนที่แล้ว และการแปลงจาก string มาเป็น time.Time มีโอกาสที่จะมี error กลับมา เราจึงต้องเอามีการกำหนดค่าผลลัพธ์จาก time.Parse สองตำแหน่งคือตำแหน่งแรกเป็น time.Time ผลลัพธ์ที่ได้จากการแปลง และ อีกค่ากรณีแปลงไม่ได้จะมี error กลับออกมา

ข้อสังเกตุ เนื่องจาก string ที่เป็น input ของเราไม่มีข้อมูลเกี่ยวกับ timezone ดังนั้นพอเรา fmt.Println ค่าออกมาดูจะเห็น +0000 UTC นั่นคือใช้ UTC timezone นั่นเอง แต่ถ้า format string ของเราอยู่ในรูปแบบที่กำหนด timezone ได้เช่น format แบบ RFC3339 = "2006-01-02T15:04:05Z07:00" เวลาเรา time.Parse ออกมาแล้วจะได้ค่าตาม timezone ที่อยู่ใน string input เช่น

timeString := "2017-02-04T07:55:00+07:00"

tm, err := time.Parse(time.RFC3339, timeString)

if err != nil {

log.Fatal(err)

}

fmt.Println(tm) // Output: 2017-02-04 07:55:00 +0700 ICT

ทีนี้ถ้าเกิด string ที่เป็น input ของเรานั้น ไม่มีข้อมูล timezone แต่เราอยากบังคับให้ parse string นั้นเป็น timezone ที่เราต้องการ เราจะใช้ function time.ParseInLocation แทน ทำได้ดังนี้เช่น

timeString := "04/02/2017 07:55:00"
tm, err := time.ParseInLocation("02/01/2006 15:04:05", timeString, time.Local)
if err != nil {
log.Fatal(err)
}

fmt.Println(tm) // Output: 2017-02-04 07:55:00 +0700 ICT

จะเห็นว่า time.ParseInLocation รับเพิ่มอีกค่าคือ *time.Location แต่ว่าที่ผมใช้ time.Local เพราะเป็นค่าที่อยู่ใน package time กำหนดไว้ให้เป็น timezone เดียวกันกับเครื่องที่รันโปรแกรมนั่นเอง

ถ้าเกิดเราอยากได้ timezone อื่นให้เราใช้ฟังก์ชัน time.LoadLocation เช่น

timeString := "04/02/2017 07:55:00"
loc, err := time.LoadLocation("Asia/Bangkok")
if err != nil {
log.Fatal(err)
}
tm, err := time.ParseInLocation("02/01/2006 15:04:05", timeString, loc)
if err != nil {
log.Fatal(err)
}

fmt.Println(tm)

ซึ่งทำการโหลด "Asia/Bangkok" เข้ามาก่อนส่งไปให้ ParseInLocation นั่นเองครับ

ของใน Go package time ที่ใช้บ่อยๆ ตอนที่ 2

2017-01-30T00:57:00.001+07:00

ตัวแปรเวลาที่เรามี สุดท้ายโปรแกรมเราก็ต้องการเอาไปแสดงผล ซึ่งก็แสดงเป็นสตริงที่บอกเวลานั่นเองครับ เช่น 29/01/2017 คือวันที่ 29 เดือนมกราคม ปี 2017 หรือในทางกลับกันเช่นกัน เราอาจจะส่งข้อมูลเวลาในรูปแบบสตริง แล้วต้องการแปลงกลับมาเป็นตัวแปรเวลา เพื่อคำนวณค่าบางอย่างแบบที่ให้ดูในบล็อกโพสอันที่แล้ว (ของใน Go package time ที่ใช้บ่อยๆ ตอนที่ 1)

วันนี้มาดูวิธีการแปลงจาก time.Time มาเป็น string กันก่อน

แปลงจาก time.Time ไปเป็น string ด้วย method Format

method Format รับค่า pattern ที่ต้องการแปลง ว่าตำแหน่งของ วัน เดือน ปี ชั่วโมง นาที วินาที อยู่ตรงไหน และการแสดงชั่วโมงเป็นแบบ 24 ชั่วโมงหรือเป็นแบบ 12 ชั่วโมงแล้วมี AM PM แต่วิธีกำหนดรูปแบบการของ Go จะต่างกับภาษาอื่น ดูตัวอย่างเลยจะเข้าใจมากกว่า เช่น

tm := time.Date(2017, 1, 30, 13, 30, 25, 0, time.Local)

format := tm.Format("02/01/2006 15:04:05")

fmt.Println(format) // Output: 30/01/2017 13:30:25

อีกตัวอย่างแสดงเป็นแบบ AM/PM

format := tm.Format("02/01/2006 03:04:05 PM")

fmt.Println(format) // Output: 30/01/2017 01:30:25 PM

ใครที่เคยใช้ภาษาอื่นอาจจะงง เพราะจะชินกับการ format date time โดยใช้ตัวอักษรอย่าง dd/mm/yyyy แต่สำหรับ Go เลือกที่จะใช้ วันที่ 2 มกราคม ปี 2006 เวลา 15 นาฬิกา 4 นาที 5 วินาที หรือถ้าคิดเป็นแบบ AM/PM คือ วันที่ 2 มกราคม ปี 2006 เวลา 3 นาฬิกา 4 นาที 5 วินาที ตอนบ่าย

ลองเรียงใหม่ โดยเอาเดือนขึ้นก่อน

เดือน => 1

วันที่ => 2

ชั่วโมง => 3

นาที => 4

วินาที => 5

ปี => (200) 6

นั่นละครับที่มาที่ไปตลกดี เพิ่งเคยเห็นภาษาที่ใช้วิธีนี้เหมือนกัน แต่พอเราจำวันเดือนปีได้ แล้วเขียน format ก็ดูง่ายดี เพราะเราเห็น pattern ที่เป็นตัวเลขออกไปเลย

แต่จริงๆแล้ว มันมี format เวลาที่เป็นมาตรฐานที่ใช้กันบ่อยๆอยู่ package time เลยจะทำค่าคงที่ไว้ให้แล้ว ทำให้เรียกใช้และจำง่ายๆเช่น time.RFC3339 เป็นเวลามาตรฐานที่เราใช้สำหรับ JSON สำหรับเก็บค่าเวลาในรูปแบบ string ตัวอย่างการใช้งานง่ายๆเช่น

tm := time.Date(2017, 1, 30, 13, 30, 25, 0, time.Local)

format := tm.Format(time.RFC3339)

fmt.Println(format) // Output: 2017-01-30T13:30:25Z

ยังมีอีกหลายรูปแบบที่ถูกกำหนดเป็นค่าคงที่ไว้ให้แล้วดังนี้

const (
        ANSIC       = "Mon Jan _2 15:04:05 2006"
        UnixDate    = "Mon Jan _2 15:04:05 MST 2006"
        RubyDate    = "Mon Jan 02 15:04:05 -0700 2006"
        RFC822      = "02 Jan 06 15:04 MST"
        RFC822Z     = "02 Jan 06 15:04 -0700" // RFC822 with numeric zone
        RFC850      = "Monday, 02-Jan-06 15:04:05 MST"
        RFC1123     = "Mon, 02 Jan 2006 15:04:05 MST"
        RFC1123Z    = "Mon, 02 Jan 2006 15:04:05 -0700" // RFC1123 with numeric zone
        RFC3339     = "2006-01-02T15:04:05Z07:00"
        RFC3339Nano = "2006-01-02T15:04:05.999999999Z07:00"
        Kitchen     = "3:04PM"
        // Handy time stamps.
        Stamp      = "Jan _2 15:04:05"
        StampMilli = "Jan _2 15:04:05.000"
        StampMicro = "Jan _2 15:04:05.000000"
        StampNano  = "Jan _2 15:04:05.000000000"
)

วันนี้เท่านี้ก่อนครับ เดี๋ยวตอนต่อไปว่ากันด้วยการแปลงจาก string มาเป็น time.Time ด้วย function time.Parse และ time.ParseInLocation กันครับ

ของใน Go package time ที่ใช้บ่อยๆ ตอนที่ 1

2017-01-27T00:22:00.001+07:00

สำหรับเรื่อง วันที่ และ เวลา เวลาที่เราเขียน Go นั้นหลักๆเราจะเอา package time มาใช้งานครับ ซึ่งผมจะลิสต์ที่ผมได้ใช้บ่อยๆมาสรุปไว้ในโพสต์นี้ครับ

สิ่งแรกที่ต้องรู้คือ package time นั้นเก็บข้อมูลเวลาอยู่ในรูปแบบของประเภทข้อมูลที่ชื่อว่า time.Time ครับ ซึ่งตัวมันเองถ้าไปเปิดดูโค้ด ก็คือ struct แบบนึงนั่นเองครับ และ ประเภทข้อมูล time.Time ก็มี methods หลายๆตัวไว้ให้เราจัดการข้อมูลของวันที่และเวลานั่นเองครับ ต่อไปเราไปดู function ใน package time และ method ของ time.Time ที่เราใช้บ่อยๆกันต่อดีกว่าครับ

อยากได้ค่าของเวลาปัจจุบัน

แน่นอนว่าเป็นค่าเวลาที่เราต้องใช้กันบ่อยๆอยู่แล้วเวลาเขียนโปรแกรม เพราะเราอยากได้เวลาปัจจุบันมาเก็บเป็นข้อมูลเช่น ข้อมูลเมื่อตอนบันทึกข้อมูลลงฐานข้อมูล ข้อมูลเอาไว้เก็บล็อกการทำงาน ซึ่งเราจะเรียก function ชื่อว่า time.Now() ครับในการเอาค่าเวลาปัจจุบันออกมา เช่น

now := time.Now()

อยากได้จำนวน วัน, เดือน และ ปี ที่อยู่ในค่าของเวลา

ต่อไปเมื่อเรามีตัวแปรเก็บค่าของเวลาแล้ว เราอยากได้ค่า วัน, เดือน และ ปี ของวันที่และเวลาที่เก็บในตัวแปรนั้นออกมา เราก็จะเรียกใช้ method ต่างๆที่เตรียมไว้สำหรับข้อมูล time.Time ดังนี้ครับ สมมติว่าเรามีตัวแปร now เก็บค่าเวลาปัจจุบันไว้

อยากรู้วันที่เรียก

day := now.Day()

อยากรู้เดือนเรียก

month := now.Month()

อยากรู้ปีเรียก

year := now.Year()

อยากได้จำนวน ชั่วโมง, นาที และ วินาที ที่อยู่ในค่าของเวลา

ถ้าเราอยากรู้จำนวน ชั่วโมง, นาที และ วินาที ที่อยู่ในตัวแปรของเวลา เราจะเรียกใช้ methods ต่างๆดังต่อไปนี้ครับ

อยากรู้จำนวนชั่วโมง

hour := now.Hour()

อยากรู้จำนวนนาที

minute := now.Minute()

อยากรู้จำนวนวินาที

second := now.Second()

สร้างค่าเวลาด้วย function time.Date

เรารู้วิธีได้ค่าเวลาปัจจุบันไปแล้ว ต่อไปถ้าเราจะสร้างตัวแปรของเวลา โดยระบุลงไปชัดๆ ว่า วัน และ เวลาไหน เราจะใช้ fuction time.Date เข้ามาใช้ครับ ซึ่งเราต้องระบุค่าเยอะหน่อย ตัวอย่างเช่น

tm := time.Date(2017, 1, 27, 8, 30, 20, 0, time.Local)

จะเห็นว่ากำหนด arguments ไปให้ตั้ง 8 ค่า แต่ละค่าคือค่าต่อไปนี้ตามลำดับครับ

2017 => ปี 2017

1 => เดือนที่ 1 (มกราคม)

27 => วันที่ 27

8 => เวลา 8 นาฬิกา

30 => 30 นาที

20 => 20 วินาที

0 => 0 นาโนวินาที

time.Local => ค่าสุดท้ายเป็นค่าที่ระบุ time zone ครับ การที่เราใช้ตัวแปร time.Local คือให้เอาตาม time zone ที่ระบุไว้ในเครื่องที่เรารันโปรแกรมครับ

เปรียบเทียบเวลา เวลาไหนเกิดขึ้นก่อน เวลาไหนเกิดทีหลัง หรือ เป็นเวลาเดียวกัน

ต่อไปถ้าเรามีค่าของเวลาเก็บในตัวแปรสองตัว ถ้าเราอยากเปรียบเทียบค่าเวลาว่าอะไรมาก่อน อะไรมาหลัง หรือเป็นเวลาเดียวกัน เราใช้ method ที่ชื่อว่า Before, After และ Equal ช่วยครับ ตัวอย่างเช่น ผมสร้างค่าเวลาขึ้นมา 3 ค่าไว้ยกตัวอย่างดังนี้

t1 := time.Date(2017, 1, 27, 8, 30, 20, 0, time.Local)

t2 := time.Date(2017, 1, 28, 8, 30, 20, 0, time.Local)

t3 := time.Date(2017, 1, 28, 8, 30, 20, 0, time.Local)

อยากรู้ว่าเวลา t1 เป็นเวลาที่เกิดก่อน t2 หรือไม่

if t1.Before(t2) {

fmt.Println(t1, "is time before", t2)

}

อยากรู้ว่าเวลา t2 เป็นเวลาที่เกิดทีหลัง t1 หรือไม่

if t2.After(t1) {

fmt.Println(t2, "is time after", t1)

}

อยากรู้ว่าเวลา t2 เป็นเวลาเดียวกันกับ t3 หรือไม่

if t2.Equal(t3) {

fmt.Println(t2, "is the same time", t3)

}

ตอนที่ 1 เอาไว้แค่นี้ก่อน ตอนต่อไปเดี๋ยวดูเรื่องการแปลงค่าจาก string มาเป็นเวลา และ แปลงค่าจากเวลา เป็น string ในรูปแบบที่ต้องการครับ

Atom Package for Elixir

2016-11-15T21:34:00.000+07:00

ช่วงนี้เปลี่ยนมาใช้ Atom เป็น Editor หลักในการทำงาน ซึ่งงานหลักตอนนี้ก็เขียนอยู่ 2 ภาษาคือ Ruby และ Elixir โน้ตไว้หน่อยว่าลง Package เสริมอะไรบ้างสำหรับใช้เขียน Elixir

language-elixir
language-erlang
atom-elixir

ลงทั้ง elixir และ erlang เพราะยังไงก็ยังรันบน erlang vm บาง library ต้องดูโค้ด erlang บ้าง ส่วน atom-elixir ช่วยทั้ง go to definition ของ function ช่วยทั้ง ดู document ซึ่ง key ในการกดดู document ตอนแรกถูกตั้งไว้เป็น F2 ซึ่งกดบน MacOS ไม่สะดวกเลยต้อง Key mapping ให้เป็น cmd-k cmd-k คือกด cmd ค้างไว้แล้วกด k สองครั้งติด เราตั้งค่าได้ที่ไฟล์ Key map ดังนี้

'atom-text-editor:not(mini)[data-grammar^="source elixir"]':

'cmd-k cmd-k': 'atom-elixir:show-elixir-docs'

Elixir Default Arguments

2016-11-06T17:17:00.002+07:00

Function ของ Elixir สามารถกำหนดค่า Default ให้กับ Argument ได้ โดยที่เมื่อเรียกใช้ Function แล้วไม่ได้กำหนดค่าให้กับ Argument นั้น ค่าจะเป็นค่าตามที่กำหนดไว้ตอนสร้าง Function

ตัวอย่างเช่น


defmodule Say do
  def hello(to \\ "World") do
    "Hello, #{to}!"
  end
end

เมื่อเรียกใช้งาน ถ้าไม่ส่งค่าอะไรไป Argument to ก็จะมีค่าเป็น "World"


iex> Say.hello
"Hello, World!"

ถ้าส่งค่าไป Argument to ก็มีค่าตามที่ส่งไป


iex> Say.hello("iPorsut")
"Hello, iPorsut!"

Elixir สามารถกำหนด Default Arguments ที่ Arguments ตำแหน่งอื่น ที่ไม่ใช่ตำแหน่งสุดท้ายของ Function ก็ได้เช่นกัน ตัวอย่างเช่น Function find จาก module Enum ถูกประกาศไว้แบบนี้


find(enumerable, default \\ nil, fun)

จะเห็นว่า find เป็น Function ที่มี 3 Arity (3 Arguments) แต่ในตำแหน่งที่ 2 นั้นมีค่า Default เป็น nil ดังนั้นการเรียกใช้ Function find จะสามารถทำได้ 2 แบบหลักๆคือ ส่ง 2 Arguments และส่ง 3 Arguments

ถ้าส่ง 2 Arguments Elixir จะมองว่าเราส่ง enumerable และ fun แล้ว default จะมีค่าเป็น nil
ถ้าส่ง 3 Arguments Elixir จะมองว่าเราส่งทั้ง enumerable, default และ fun ตามลำดับ

ตัวอย่างอีก Function คือ IO.puts ที่เราให้แสดงผลข้อมูลออกทาง Standard Output ซึ่งปกติเวลาใช้เราก็ส่งแค่ 1 Argument เพื่อเอาค่านั้นไปแสดงเช่น


IO.puts "Hello, World"

ซึ่งก็จะแสดง "Hello, World" ที่ console ซึ่งถ้าเราดูการประกาศ IO.puts เราจะเห็นว่ากำหนดไว้แบบนี้


puts(device \\ group_leader(), item)

เมื่อเราส่งค่าเดียวเข้าไป item เลยมีค่าเท่ากับค่าที่เราส่งไป แล้ว device มีค่าเป็น group_leader() ตามที่กำหนด default เอาไว้นั่นเอง นี่ก็เป็นพฤติกรรมการเรียกใช้ Function ที่มีการกำหนด Default ให้กับ Arguments เมื่อเราเห็นการเรียกใช้จะได้เข้าใจนั่นเองว่าแต่ละค่า Arguments เป็นอะไร

Golang Block is a Statement (version. Thai)

2016-09-27T15:12:00.001+07:00

ปกติแล้ว Block ใน Go คือลำดับของ Statement ที่อยู่ภายในปีกกา { และ } เช่น

package main

import "fmt"

func main() {
 name := "iPorsut"
 fmt.Printf("Hello %s\n", name)
}

ซึ่งเมื่อผมได้ไปอ่านโค้ดตัวอย่างของ go-kit แล้วเจอการใช้งาน Block ซ้อน Block โดยที่ไม่ใช้ Block ของ function หรือ Block ของ for, if, switch แบบนี้

package main

func main() {
 // Endpoint domain.
 var sumEndpoint endpoint.Endpoint
 {
  sumDuration := duration.With("method", "Sum")
  sumLogger := log.NewContext(logger).With("method", "Sum")

  sumEndpoint = addsvc.MakeSumEndpoint(service)
  sumEndpoint = opentracing.TraceServer(tracer, "Sum")(sumEndpoint)
  sumEndpoint = addsvc.EndpointInstrumentingMiddleware(sumDuration)(sumEndpoint)
  sumEndpoint = addsvc.EndpointLoggingMiddleware(sumLogger)(sumEndpoint)
 } 
}

การที่เราสร้าง Block ใหม่ขึ้นมา scope ของตัวแปรจะอยู่ภายใน Block นั้นเท่านั้น เช่นตัวแปร sumDuration และ sumLogger สร้างภายใน Block เมื่อออกนอก Block นี้ก็ไม่สามารถอ้างอิงได้อีก

นอกจากนั้นตัวแปรชื่อเดียวกัน ที่สร้างใหม่ภายใน Block ที่ซ้อนอยู่ จะบังชื่อตัวแปรภายนอก เมื่อออกจาก scope ก็จะเป็น scope ของตัวแปรเดิม เช่น

package main

import "fmt"

func main() {
 name := "World"
 {
  name := "iPorsut"
  fmt.Printf("Hello %s\n", name)
 }
 fmt.Printf("Hello %s\n", name)
}

จะได้ผลลัพธ์เป็น

Hello iPorsut
Hello World

ผมลองไปดูที่ Golang Spec แล้วเจอจุดที่นิยามโครงสร้างแบบนี้อยู่คือในส่วนของ Block นั้นกำหนดไว้แบบนี้

Block = "{" StatementList "}" .
StatementList = { Statement ";" } .

ซึ่ง Block คือ StatementList ที่อยู่ภายใน { } และ StatementList คือ Statement ตั้งแต่ 0 ตัวขึ้นไป ต่อไปไปดูในส่วนของนิยาม Statement นั้นกำหนดไว้แบบนี้

Statement =
 Declaration | LabeledStmt | SimpleStmt |
 GoStmt | ReturnStmt | BreakStmt | ContinueStmt | GotoStmt |
 FallthroughStmt | Block | IfStmt | SwitchStmt | SelectStmt | ForStmt |
 DeferStmt .

SimpleStmt = EmptyStmt | ExpressionStmt | SendStmt | IncDecStmt | Assignment | ShortVarDecl .

จุดน่าสนใจคือ Block ก็คือ Statement แบบหนึ่งนั่นเอง ด้วยนิยามแบบนี้จะเห็นว่าเราสามารถเขียน Block ซ้อนๆกันได้ เพราะ Block ก็คือ Statement แบบหนึ่งนั่นเอง

Golang Block is a Statement (version. English)

2016-09-27T15:12:00.000+07:00

Usually, Block in Golang is a sequence of statements in bracket { and }. Example

package main

import "fmt"

func main() {
 name := "iPorsut"
 fmt.Printf("Hello %s\n", name)
}

When I had read go-kit Example, I found it uses nested Block like this.

package main

func main() {
 // Endpoint domain.
 var sumEndpoint endpoint.Endpoint
 {
  sumDuration := duration.With("method", "Sum")
  sumLogger := log.NewContext(logger).With("method", "Sum")

  sumEndpoint = addsvc.MakeSumEndpoint(service)
  sumEndpoint = opentracing.TraceServer(tracer, "Sum")(sumEndpoint)
  sumEndpoint = addsvc.EndpointInstrumentingMiddleware(sumDuration)(sumEndpoint)
  sumEndpoint = addsvc.EndpointLoggingMiddleware(sumLogger)(sumEndpoint)
 } 
}

When we create nested Block. A declaration inside a Block have scope only inside Block. So 'sumDuration' and 'sumLogger' variables cannot use after outside Block.

Variable inner Block shadow a variable outer Block if it has a same name. Example.

package main

import "fmt"

func main() {
 name := "World"
 {
  name := "iPorsut"
  fmt.Printf("Hello %s\n", name)
 }
 fmt.Printf("Hello %s\n", name)
}

Output:

Hello iPorsut
Hello World

I had seen in the Golang Spec. I found definition of structure of Block like this.

Block = "{" StatementList "}" .
StatementList = { Statement ";" } .

It means Block is composed by StatementList inside bracket { } and StatementList is Statement zero or more. The definition of Statement is

Statement =
 Declaration | LabeledStmt | SimpleStmt |
 GoStmt | ReturnStmt | BreakStmt | ContinueStmt | GotoStmt |
 FallthroughStmt | Block | IfStmt | SwitchStmt | SelectStmt | ForStmt |
 DeferStmt .

SimpleStmt = EmptyStmt | ExpressionStmt | SendStmt | IncDecStmt | Assignment | ShortVarDecl .

We found Block, it is also a Statement too. From those definitions, we can write nested Block.

Type of Tense in Haskell

2016-09-21T11:43:00.003+07:00

I am reading the book about English Tense. It tells 12 tenses.

Past Simple
Present Simple
Future Simple
Past Continuous
Present Continuous
Future Continuous
Past Perfect
Present Perfect
Future Perfect
Past Perfect Continuous
Present Perfect Continuous
Future Perfect Continuous

It have a patterns that base Simple, Continuous, Perfect, Perfect Continuous compose with time Past, Present, Future.

I try to write it as a Haskell algebraic datatype.

data BaseTense = Simple
               | Continuous
               | Perfect
               | PerfectContinuous deriving (Show, Eq)

data TimeTense = Past
               | Present
               | Future deriving (Show, Eq)

data Tense = Tense TimeTense BaseTense deriving (Show, Eq)

We create two sum type BaseTense and TimeTense and product type Tense that compose TimeTense and BaseTense

Rust make and compare time

2016-09-20T09:34:00.001+07:00

My wife, she is learning Golang and make the exercise try to write English greetings service, that response greeting string depending period of time.

Example:

if time now between >= 00.00 and < 12.00 response "Good Morning".
if time now between >= 12.00 and < 18.00 response "Good Afternoon".
if time now between >= 18.00 and < 24.00 response "Good Evening"

You can see her repository at this link https://github.com/Kanokorn/english-greetings.

I want try to learn Rust language with her exercise too. So I write it with Iron web framework.

You can see my repository at this link https://github.com/iporsut/rust-iron-english-greeting.

I learnt many thing about Rust when I do this exercise. Such as how to create time value and compare it.

Rust use time library https://crates.io/crates/time for manage about time.

You can get time now by call time::now() that return time::Tm struct value.

time::Tm struct have fields.


pub struct Tm {
    pub tm_sec: i32,
    pub tm_min: i32,
    pub tm_hour: i32,
    pub tm_mday: i32,
    pub tm_mon: i32,
    pub tm_year: i32,
    pub tm_wday: i32,
    pub tm_yday: i32,
    pub tm_isdst: i32,
    pub tm_utcoff: i32,
    pub tm_nsec: i32,
}

I want to get 00:00, 12:00, 18:00 and 24:00 time of same day of now. I must copy and clear tm_hour, tm_min, tm_sec, tm_nsec fields value.

I decide to create new function receive now value and create new mut value copy value from arguments and hour value for clear.


fn set_hour(t: time::Tm, hour: i32) -> time::Tm {
    let mut t = t;
    t.tm_hour = hour;
    t.tm_min = 0;
    t.tm_sec = 0;
    t.tm_nsec = 0;
    t
}

I can make function like this because time::Tm implement Copy, Clone trait.

I can compare time like a number because time::Tm implement Eq and PartialEq, Ord, PartialOrd trait.

    fn handler(_: &mut Request) -> IronResult<response> {
        let now = time::now();

        let midnight = set_hour(now, 0);
        let midday = set_hour(now, 12);
        let sunset = set_hour(now, 18);
        let midnightnextday = set_hour(now, 24);

        let greeting = if now >= midnight && now < midday {
            "Good Morning".to_string()
        } else if now >= midday && now < sunset {
            "Good Afternoon".to_string()
        } else if now >= sunset && now < midnightnextday {
            "Good Evening".to_string()
        } else {
            "Hello".to_string()
        };

        Ok(Response::with((status::Ok, greeting)))
    }

This is a powerful of Rust Generic and Trait.

Rust lang count characters in UTF-8 text file.

2016-09-16T22:17:00.002+07:00

Today I'm try to learn Rust language by write a small program. I choose to write character counting in text file that UTF-8 encoding.

This is a example when I run the program.

This is a soucecode.


use std::io::prelude::*;
use std::env;
use std::fs::File;

fn main() {
    let filename = env::args().nth(1).unwrap();
    let mut f = File::open(filename).unwrap();
    let mut s = String::new();
    f.read_to_string(&mut s).unwrap();
    println!("{}", s.trim_right().chars().count());
}

First line in main function, I use env::args().nth(1) for get the filename from command line arguments. You can see that I must call .unwrap() because return type of nth(1) is a type Option<Self::Item>. It maybe a value String or None. So when we call unwrap() if value is None it will panic and if value is not None it will return that value.

Next line, I use File::open for open file and use unwrap again because return type of open() is Result<File>. It maybe a File or Err. So when we call unwrap() if value is Err it will panic and if value is File it will return File value to f.

Next line, I make a new String.

Next line, I use method read_to_string for read a content in file to string s and unwrap() again because return type of read_to_string is Result<usize>. It maybe a usize or Err. So when we call unwrap() if value is Err it will panic and if value is usize it will return usize value.

Next line, I use println for print a value of s.trim_right().chars().count() that cut the right space and call chars() that return Chars type. It is a iterator for unicode char in String. Then we can use count() in Chars type for counting character in format Unicode.

This is a repository for this program https://github.com/iporsut/rust-utf8count

สร้าง Docker Image from scratch

2016-09-15T16:25:00.001+07:00

ปกติการสร้าง Docker Image เราจะใช้การสร้าง Dockerfile โดยที่บรรทัดแรกจะระบุว่าเอา Image ไหนเป็น base โดยใช้คำสั่ง FROM เช่น เอาจาก ubuntu เป็น base ก็เขียนแบบนี้

FROM ubuntu

ทีนี้ถ้าเราอยากสร้างแค่ Image ที่มีโปรแกรม binary ของเราทำงานทันที เราสร้างได้โดยใช้ base จาก scratch ซึ่งเป็น base image พิเศษ ไม่ต้อง pull เพราะเมื่อ Docker เห็น scratch จะรู้ว่าเราต้องการสร้าง Image โดยไม่ต้องใช้อะไรเป็น base เลย ตัวอย่างเช่นผมสร้างโปรแกรมง่ายๆให้ปริ้น Hello, World! ที่หน้าจอ แล้วต้องการเอาไปรันภายใต้ Docker container ผมสามารถสร้าง Image ได้แบบนี้

FROM scratch
COPY ./hello /hello
ENTRYPOINT ["/hello"]

เมื่อรัน sudo docker build -t hello .

เราก็จะได้ image ใหม่ชื่อ hello

ทดลองรัน image ขึ้นมาดูโดยสั่ง sudo docker run hello เราก็จะเห็นผลลัพธ์แบบนี้ครับ

อธิบาย Actor Model ด้วย Erlang

2015-07-30T21:38:00.001+07:00

บอกพี่ +Adisorn Chockaumnuai เดี๋ยวเขียน blog อธิบายเรื่อง Actor Model ให้ แต่ขออธิบายโดยโค้ด Erlang นะ เพราะผมยังไม่เคยใช้ Actor Model ของภาษาอื่น เริ่มเลยแล้วกัน

Actor Model คือวิธีการออกแบบที่เราให้สิ่งต่างๆเป็น Actor และสื่อสารกันโดยการส่ง message ไปมาระหว่าง Actor ถ้ามองแบบเทียบกับการออกแบบ แบบ Object ก็คล้ายๆกัน แต่ต่างกันตรง การส่ง message ของ OOP มักจะอยู่ในรูปของ method ที่ทำงานเป็นแบบ sequential แต่สำหรับ Actor Model การส่ง message ไปหา Actor จะเป็นแบบ concurrent คือเราส่งไปได้เลย ไม่ต้องรอ (non-blocking/async) เหมือนกับการส่งจดหมาย ที่จะส่งเข้ากล่องรับจดหมายไปก่อนเลย ไม่ต้องรอว่าคนรับจะอ่านจดหมายเราตอนไหน การส่งจดหมายแต่ละครั้งก็ต้องส่งโดยระบุชื่อ ที่อยู่ผู้รับให้ชัดเจน ถ้าเราต้องการให้เขาตอบกลับ ก็ต้องระบุชื่อที่อยู่ผู้ส่งให้ชัดเจนเช่นกัน

ตัวอย่างเช่น

Actor1            —— Hello —>             Actor2
Actor1            <— Hi —                 Actor2

ดูตัวอย่างโค้ดของ Erlang เลยแล้วกัน

สำหรับ Erlang Actor ก็คือ process แต่ละ process ที่ถูกสร้างขึ้นมานั่นเอง สำหรับ erlang สร้าง process ใหม่ได้ด้วยฟังก์ชัน spawn เพื่อบอกให้ทำงานฟังก์ชันโดยแยกเป็น process ใหม่ แล้วจะได้ process id เป็นหมายเลขอ้างอิงของ process นั้นๆเช่น ซึ่งการจะส่ง message เราต้องใช้ process id เนี่ยแหละ แทนชื่อที่อยู่ผู้รับ แบบการส่งจดหมาย ถ้ามีฟังก์ชันดังนี้

-module(account).

-export([add/2]).

add(A, B) ->

A+B.

แล้วใน erlang shell ผมลองสั่งแบบนี้

> account:add(10,20).

30

จะได้ผลลัพธ์ออกมาเป็น 30 เลย แบบนี้คือการเรียกฟังก์ชันให้ทำงานธรรมดา ไม่ได้สร้างออกไปเป็น process ใหม่ แต่ถ้าผมเรียกแบบนี้

> spawn(account, add, [10,20]).
<0.38.0>

จะเห็นหมายเลข process id เป็น <0.38.0> ออกมาแทน นั่นคือ PID ของ process ใหม่ และเราไม่เห็นผลลัพธ์การทำงานที่ shell เพราะว่ามันทำงานที่อีก process

ทีนี้มาดูโค้ดอีกแบบกัน

-module(account).

-export([account/1]).

account(Balance) ->

        receive

                {deposit, Amount} ->

                        account(Balance + Amount);

                {witdraw, Amount} ->

                        account(Balance - Amount);

                {balance, Sender} ->

                        Sender ! {balance, Balance},

                        account(Balance);

                _otherwise ->

                        account(Balance)

        end.

receive end เป็น block ที่บอกให้ process ที่กำลังรัน account อยู่ให้หยุดรอรับ message ที่เข้ามาที่ process โดยที่ภายใน receive end จะเป็น pattern matching ว่าถ้ามี message เข้ามาใน pattern ทางด้านซ้ายของ -> จะทำงานทางด้านขวา

จากโค้ด ผมออกแบบให้รองรับ message 4 pattern ด้วยกันคือ

{deposit, Amount} -> โดยที่ตรง Amount เป็นค่าที่ต้องการเอามาเพิ่มเข้าไปที่ balance โดยเราจะเรียก account อีกรอบพร้อมกำหนด balance ใหม่เข้าไปเพื่อรอรับ message ต่อไป

{witdraw, Amount} -> เหมือนกับ deposit แต่เราทำการลบค่า balance ออกแทน

{balance, Sender} -> โดยที่ Sender ต้องเป็น process id ที่ต้องการรู้ค่า balance เราจะส่ง ค่า balance ตอบกลับไปให้ process นั้น

_otherwise -> โดยที่การใช้ _ บอกว่าเป็นค่าอะไรก็ได้ เราจะไม่ทำอะไร เราจะแค่กลับไปรอรับ message อื่นต่อไป

นี่คือตัวอย่างการส่ง message ไปมากับ process account โดยที่ Erlang ใช้สัญลักษณ์ ! ในการส่ง message โดยให้ PID อยู่ด้านซ้าย และ message อยู่ด้านขวา

1> c(account).
{ok,account}
2> Acc = spawn(account, account, [100]).
<0.39.0>
3> Acc ! {balance, self()}.
{balance,<0.32.0>}
4> flush().
Shell got {balance,100}
ok
5> Acc ! {deposit, 500}.
{deposit,500}
6> Acc ! {balance, self()}.
{balance,<0.32.0>}
7> flush().
Shell got {balance,600}
ok
8> Acc ! {witdraw, 200}.
{witdraw,200}
9> Acc ! {balance, self()}.
{balance,<0.32.0>}
10> flush().
Shell got {balance,400}
ok
11>

ที่เห็นเป็นการติดต่อกันระหว่าง 2 process คือ process ของ Shell และ process ของ account นั่นเอง ใน shell ถ้าเราจะดู message ที่ส่งมาแล้วค้างอยู่จะใช้คำสั่ง flush() ออกมานั่นเอง

เท่านี้น่าจะพอเข้าใจ Actor Model ซึ่งในภาษาอื่นที่รองรับการเขียนแบบ Model นี้ก็มีอะไรคล้ายๆกันแบบนี้เช่นกัน แค่เขียนด้วย syntax ที่ต่างกันนั่นเอง

vim การเลื่อน indent เวลาอยู่ใน mode insert, normal หรือ visual

2015-06-15T06:53:00.002+07:00

เวลาใช้งาน vim ถ้าเราต้องค่าให้มัน auto indent ให้ เช่นแบบนี้

au BufEnter *.scss set tabstop=4 shiftwidth=4 expandtab

เวลาเรากด enter ขึ้นบรรทัดใหม่ มันก็จะขยับ indent ให้เองเช่น

เห็นตำแหน่ง cursor ตรงบรรทัดที่ 7 นะว่ามันเลื่อน indent ให้เอง

แต่เมื่อเราอยากขยับ cursor ตรงบรรทัดที่ 7 ไปซ้ายสุดล่ะ เพื่อเขียน selector ของ css อันใหม่ ก่อนหน้านี้ผมต้องกดลบเอาเอง แล้วที่นี้ผมตั้ง tab เป็น space เอาไว้ ต้องลบที่ละ 1 space เสียเวลามาก หรือไม่ก็ต้องกด esc กลับไป normal command mode ก่อนอีก ก็เสียเวลาเช่นกัน

วันนี้เลยลองไปค้นดูเจอที่นี่ http://stackoverflow.com/questions/4559896/vim-how-to-tab-backward

เลยรู้วิธีที่จะเลื่อนตำแหน่ง cursor หรือจัด indent ของทั้งบรรทัด แม้จะอยู่คนละ mode ก็ตาม ดังนี้

ถ้าอยู่ใน insert mode ให้กด:

    C-d - เลื่อน indent ไปทางซ้าย
    C-t - เลื่อน indent ไปทางขวา

ถ้าอยู่ใน normal (command) mode:

    << - เลื่อน indent ไปทางซ้าย
    >> - เลื่อน indent ไปทางขวา

ถ้าอยู่ใน visual mode และทำการเลือก text หลายๆบรรทัดเอาไว้:

    < - เลื่อน indent ไปทางซ้าย
    > - เลื่อน indent ไปทางขวา

เพียงเท่านี้ ก็ทำให้ใช้งานได้เร็วขึ้นอีก เพราะไม่เสียเวลาเคาะลบเองแล้ว

ลูกค้า ไม่เท่ากับ ผู้ใช้งาน

2015-06-12T00:04:00.002+07:00

สำหรับอาชีพ Developer ไม่ว่าจะรับงานรูปแบบไหน ทำงานประจำบริษัท หรือ รับงาน Freelance บางทีเราก็สับสนระหว่าง ลูกค้า และ ผู้ใช้งาน

ลูกค้าคือใครได้บ้างล่ะ เอาง่ายๆในก็คนที่ยอมจ่ายเงินให้กับสิ่งที่เราทำให้ได้

ส่วนผู้ใช้งาน อาจจะเป็นทั้งลูกค้าเราเอง และ หรือไม่ได้เป็นก็ได้

ถ้ามีคนจ้างเราพัฒนา App ตัวนึง ลูกค้าคือคนจ้างเราทำนั่นล่ะ ส่วนผู้ใช้งานคือใครบ้างก็ได้ที่โหลด App นี้ไปใช้ ส่วนผู้ใช้คือลูกค้าของคนที่จ้างเราอีกที

ในมุมของคนพัฒนา App เราอาจจะคิดถึงผู้ใช้งานเป็นหลัก จนลืมปัจจัยอื่นๆในมุมมองของลูกค้าผู้จ้างเราก็ได้ เขาอาจจะมีปัจจัยภายในองค์กรต่างๆที่เราไม่รู้ก็ได้เช่นกัน

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

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

และท้ายสุด ถ้าลูกค้าเลือกทางที่เราก็ไม่สามารถจะทำธุรกิจร่วมกันได้ต่อไป ก็ต้องบอกกันตรงๆ และแยกทางกันไป

Code ที่ดี จะทำงานกันเป็น Team

2015-06-11T06:33:00.002+07:00

เมื่อวานผมลอง Refactor งานที่ทำในส่วนของ Javascript ที่ใช้ Angular.js เป็น framework ช่วยเขียน ซึ่งตอนแรก ส่วนที่ทำ โค้ดจะแบบเป็น tempalte html และมี controller ใช้ service เป็นส่วนที่รับหน้าที่เรียก API หลังบ้านเอาข้อมูลกลับมา ส่วน controller จะเรียกใช้ service อีกที เพื่อ binding ข้อมูลกับ tempalte

สิ่งที่เกิดขึ้นก่อนที่จะแก้เมื่อวานคือ controller ใหญ่มาก ไฟล์ขนาด 170 กว่าบรรทัด ส่วน service เล็กนิดเดียว เพราะทำหน้าที่แค่เรียก HTTP API แล้วก็ส่ง promise กลับ

ใน controller เนี่ยทำแทบทุกอย่าง ทั้ง Binding UI template ทั้งมี Logic ในการแสดงผล Logic ในการปรับแต่งข้อมูลที่รับมาแล้วจาก service มีเรื่องการ sorting ด้วย รวมอัดใน controller เต็มไปหมด

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

ผลที่ได้จากการ Refactor เมื่อวานคือ Controller จาก 170 กว่า เหลือ 40 กว่าบรรทัด เพราะลองแบ่งดีๆจะพบว่า Controller ควรทำหน้าที่ binding ข้อมูลกับ UI เท่านั้น ไม่ควรมี Logic อะไรมากมาย ส่วนเรื่องการเตรียมข้อมูล หรือ Logic ผมทำการเพิ่มอีก Service นึงเข้ามาจัดการให้ และ ยังแยก ส่วนที่เป็น model ของ record ที่จะแสดงในตารางตรง UI ออกมาด้วยเพื่อให้เป็น Logic ของแต่ละ record

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

มนุษย์ เป็นสัตว์ที่ต้องการ ความเข้าใจ

2015-06-09T22:28:00.002+07:00

ใช้แล้ว เราก็เป็นสัตว์แบบหนึ่งบนโลกใบนี้นั่นแหละ และเราก็พอจะรู้ตัวเรากันเองว่า เราเป็นสัตว์สังคม คือต้องอยู่อาศัยกันเป็นกลุ่ม พึ่งพากันและกันถึงจะอยู่รอด

ไม่ว่าจะเป็นคนเด่นดัง มีตำแหน่งใหญ่โตแค่ไหน มนุษย์ทุกคน ก็ยังเป็นมนุษย์นั่นละ ซึ่งอยากรู้สึกว่า

"มีคนเข้าใจ"

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

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

ป.ล. เป็นความรู้ที่ลองสรุปในมุมของตัวเองหลังจากอ่านหนังสือ "เงียบ ให้ถูกจังหวะ คนชนะ ไม่พูดมาก" Just Listen: Discover the Secret to Getting Through to Absolutely Anyone ; Mark Goulston เขียน; นุชนาฎ เนตรประเสริฐศรี แปล (ยังอ่านไม่จบ)

Listen to your code.

2015-06-08T23:35:00.002+07:00

"Listen to the technical people. If they are complaining about the difficulty of making changes, then take such complaints seriously and give them time to fix things. " - Martin Fowler (Is Design Dead?)

เมื่อวานกับวันนี้ เกิดปัญหากับระบบที่กำลังพัฒนาอยู่ ทุกคนต่างช่วยกันหาทางออก หาทางแก้ ไม่ว่าจะดูที่ Log ไม่ว่าจะดูที่ Dashboard ของการ monitor ระบบ ช่วยกันทุกๆทางที่จะเป็นไปได้

สุดท้ายเราทุกคนตัดสินใจมาดูที่ Code เปิดโค้ดออกที่จอใหญ่ แล้วดูด้วยกัน แทบทุกตำแหน่ง ทั้ง Dev ทั้งทีม PO ทั้ง ที่ปรึกษาของระบบรอบข้างที่เราไปติดต่อด้วย ทุกคนช่วยกันดูที่ Code

แม้เราจะไม่ได้เจอจุดพลาดอะไรร้ายแรง แต่เราก็เห็นร่วมกันว่าควรจะปรับปรุงตรงไหน เห็นด้วยกันว่าโค้ดที่เราทำยังอ่านยากยังไง ได้จุดที่เอาไปปรับปรุงเพื่อให้เราพลาดน้อยลง

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

ทางทีดีหมั่นดูและรับฟังโค้ดเรากันบ่อยๆครับ และค่อยๆปรับปรุงไปทุกๆรอบการทำงานจะดีที่สุด

สรุปสอน Introduction Go รอบที่ 3

2015-06-06T23:57:00.001+07:00

วันนี้เป็นครั้งที่ 3 แล้วที่ช่วยๆกันสอน Go ฟรีๆ 1 วัน เราก็ได้เรียนรู้จากสองครั้งแรกกันพอสมควร กับเวลาในการสอนแค่ไม่กี่ชั่วโมง สองครั้งแรกเราลุยทำ workshop กันเลย ไม่ได้อธิบาย basic syntax อะไรทั้งสิ้น ติดปัญหากันพอสมควร โดยเฉพาะครั้งที่ 2 ที่เราเลือกให้ต่อ Mongodb กันด้วย ไหนจะเรื่องลง git เรื่อง mongodb เบื้องต้น

ทำให้รอบที่ 3 เราตัดสินใจกันว่า เราจะใช้แค่ package ที่มาพร้อมกับตอนติดตั้ง Go สอนเท่านั้น และจะมีสอน basic syntax ก่อนด้วย ในส่วนของ workshop ก็ให้ใช้เก็บใน type map ธรรมดาๆแทนการต่อ db ข้างนอก

วันนี้ผมเริ่มเปิดเรื่องให้ โดยอธิบายหลักการและเป้าหมายที่ใช้ในการออกแบบภาษา Go ของทีมงานพัฒนาภาษา โดยผมเอามาจาก slide ของ Rob Pike มีรูปจากเมียที่ทำสรุปให้ประกอบ คือรูปนี้

คือ Go นั้นยึดหลัก Clarity is key ซึ่งได้พี่หนุ่มช่วยแปลคำสวยๆให้คือคำว่า "ความชัดเจนถือเป็นหัวใจหลักของ Go" ซึ่งนำมาสู่การทำให้โค้ดสามารถอ่านเข้าใจได้ง่าย มี Concurrency ในตัวทำให้ Scale ได้ จัดการกับ Code Base ขนาดใหญ่ได้ดีเพราะตรวจสอบสิ่งที่ไม่ใช้ตั้งแต่ต้นออก เน้นการสร้าง Tool ขึ้นมาช่วยงานต่างๆ และ ย้ำว่า Go ไม่ได้เหมาะกับทุกงานทุกสถานการณ์เสมอไป

หลังจากนั้นได้ วิน ช่วยสอนต่อเป็นหลัก ผมจะเสริมๆบางเรื่องไปเรื่อยๆ วันนี้ได้จบลงตรงการสร้าง HTTP Service โดยข้อมูลส่งไปมาเป็น JSON สิ่งที่สอนไปจำได้คร่าวๆดังนี้

Basic Syntax

เรื่องการติดตั้ง
การตั้งค่า environment variable ต่างๆ GOROOT , GOPATH
การสร้าง package การสร้าง main
การประกาศตัวแปร
ประเภทข้อมูลเบื้องต้น int, string, bool
array, slice, map
เรื่อง control ต่างๆ if, for , switch

ต่อมา workshop ยังทำโจทย์เก็บข้อมูล contact ทำให้ได้เรียนรู้เรื่องต่างๆไปด้วยคือ

การสร้ง package ใหม่
การสร้าง function
การตั้งชื่อเพื่อกำหนดการเข้าถึงสิ่งต่างๆใน package
การสร้าง type struct ขึ้นเอง
การสร้าง HTTP server ด้วย package net/http
การเขียน unittest ด้วย package testing และใช้ go test ช่วย run test
การ encode / decode JSON
การเขียน httptest

สุดท้ายมีเวลาอีกนิด ผมสอนเรื่อง method และ interface ไปนิดหน่อย

จะเห็นว่าผมสอนพื้นฐานกันมาถึงแค่เรื่อง function ใน package แล้วก็เอาไปทำ HTTP Service กันก่อนเลย เพราะเนื่องจากข้อจำกัดของเวลา ทำให้ผมตัดสินใจมาทางนี้ เพราะเท่านี้ก็สามารถนำเอาไปใช้ประโยชน์ได้จริงๆแล้ว

ส่วนเรื่อง Method และ Interface เป็นสิ่งที่จะทำให้เราเขียน Go ได้สำนวน (Idiom) Go มากยิ่งขึ้น ผมคิดว่าคงต้องใช้เวลาเพิ่มอีกถึงจะเข้าใจได้กว่านี้เลยไม่เน้นมากในเวลาวันเดียว

ส่วนเรื่อง Concurrency วันนี้ไม่ได้พูดถึงเลย คิดกันไว้ว่าเราจะเปิดเฉพาะ Concurrency with Go แยกต่างหากเลย แต่ว่าคงขอซ้อมสอนกันเองก่อน

ขอบคุณทุกๆท่านที่มาฟังเราสอนวันนี้ครับ ผิดพลาดประการใด ขอนำไปปรับปรุงในการสอนครั้งต่อๆไป

User Stories and Scenario Template

2015-06-05T02:16:00.001+07:00

กำลังอ่านหนังสือ Agile with Guts - A pragmatic guide to value-driven development ได้บอก template ของการเขียน User stories ได้แบบนี้

As a <who?>

In order to <how?>

I want to <what?>

นั่นคืออยู่ในรูปของ ใคร? (who) ต้องการที่จะทำให้เกิดอะไร? (how) และจะใช้วิธีการไหน? (what)

ส่วนถ้าใครเคยอ่านเกี่ยวกับเรื่อง BDD (Behavior Driven Development) หรือ SBE (Specification by Example) คงเคยเห็นรูปแบบนี้

Given

When

Then

รูปแบบนี้เอาไว้ยกตัวอย่าง Scenario ที่เกิดขึ้นของ User stories นั่นเอง

ตัวอย่างเช่น

As a ลูกค้า เป็นสมาชิก Online Banking

In order ตรวจสอบยอดเงินคงเหลือในบัญชี

I want to สามารถเข้าสู่ระบบแล้วกดดูยอดเงินคงเหลือล่าสุดได้

Scenario ที่ 1

Given ลูกค้าที่มีเงินในบัญชี 1000 บาท และเป็น สมาชิก Online Banking เข้าสู่ระบบแล้ว

When เลือกเมนู ตรวจสอบยอดเงินคงเหลือ

Then ควรจะต้องเห็นยอดเงินในบัญชีแสดง 1,000 บาท

Methods have a Context

2015-06-04T00:27:00.000+07:00

สมัยเรียน Object Oriented Programming (OOP) แรกๆ นั้นเข้าใจว่า OOP ช่วยให้เราจำลองโลกจริงๆให้เราสามารถเขียนโปรแกรมได้อ่านง่าย และ เข้าใจได้ง่ายมากขึ้น

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

มีข้อมูลอยู่ในตัวแปร D

มีฟังก์ชัน A , B , C ดังนี้

function A(D) {
b = B(D)
c = C(D, b)
}

function B(D) {
return D.x + 10
}

function C(D, n) {
return D.y + n
}

จะเห็นว่าฟังก์ชัน A , B และ C ต้องส่งค่า D ไปด้วยเสมอ การทำงานของ A, B และ C เกี่ยวข้องกับข้อมูลของ D เสมอ

ในโลกของ OOP เราสามารถสร้าง D เป็น Object แทนที่จะเป็นตัวแปรแยกแล้วส่งเข้าฟังก์ชัน แล้วสร้าง A, B และ C เป็น Method สำหรับ Object D ทั้ง A, B และ C ทำงานภายใต้ context ของ D เสมอนั่นเอง

ทำให้เวลาสร้าง A, B และ C พารามิเตอร์จะเหลือแค่แบบนี้

class D {
    function A() {
b = B()
c = C(b)
    }
    function B() {
    }
    function C(n) {
    }
}

เวลาเรียกใช้ A ก็แค่ D.A()

จะเห็นว่า method เราจะอ่านง่ายขึ้น ทดสอบได้ง่ายขึ้นด้วยนั่นเองเพราะเราสามารถ เปลี่ยนแปลงค่า context ของ D ได้ง่ายตอนทดสอบนั่นเอง

Javascript map function

2015-06-02T23:49:00.002+07:00

Array ของ javascript มีฟังก์ชัน map ที่จะรับค่าฟังก์ชันเข้าไปแล้วจะทำการวนซ้ำในข้อมูลแต่ละตัวของ Array เพื่อเรียกฟังก์ชันนั้นให้ทำงานโดยส่งแต่ละค่าใน Array ไปเป็น parameter ของ function เช่น

var list = [1, 2, 3];
var result = list.map(function(e) {
return e + 5;
});
console.log(result);

จะแสดง

[6, 7, 8]

จะเห็นว่าเมื่อทำงานเสร็จ จะได้ผลลัพธ์เป็น Array ขนาดเท่าเดิม ที่แต่ละค่าเป็นผลลัพธ์จากการทำงานของ function ที่ส่งเข้าไปนั่นเอง

อีกตัวอย่างเช่น

var names = ["James", "John", "Jane"];

var sayHello = names.map(function(name) {
return "Hello " + name;
});
console.log(sayHello);

จะแสดง

[ 'Hello James', 'Hello John', 'Hello Jane' ]

Javascript forEach

2015-06-01T23:52:00.003+07:00

Javascript มีฟังก์ชัน forEach ให้ใช้ในการวนซ้ำโดยการสั่ง function เข้าไปแล้ว forEach จะทำการวนแต่ละรอบของใน Array แล้วเรียก function ให้เอง ตัวอย่างเช่น

var arr = [1,2,3,4,5];

arr.forEach(function(elem) {
console.log(elem);
});

จะได้ผลลัพธ์

1
2
3
4
5

ถ้าต้องการเลข index ด้วยให้กำหนด arguments ที่สองให้กับ function ที่ส่งเข้าไป เช่น

var arr = [1,2,3,4,5];

arr.forEach(function(elem, index) {
console.log("index: ", index, ", elem: " + elem);
});

จะได้ผลลัพธ์

index: 0 , elem: 1
index: 1 , elem: 2
index: 2 , elem: 3
index: 3 , elem: 4
index: 4 , elem: 5

Clojure letfn

2015-05-30T06:58:00.001+07:00

เคยโพสต์เกี่ยวกับ let ของ Clojure ไปแล้ว ก่อนหน้านี้ วันนี้จะมาดูอีกรูปแบบในการสร้าง scope ของ function คือ letfn

letfn ต่างจาก let คือเราสามารถสร้าง function ได้ เช่น

(letfn [(say [name] (str "Good morning " name))]
    (say "iPorsut")
)

เราสามารถเอา letfn มาช่วยสร้างฟังก์ชันที่เป็น lazy-seq แล้วสร้างอีก function ครอบเพื่อเลือกว่าจะเอาแค่กี่ค่าแรกได้ เช่น สร้างฟังก์ชันที่เลือกค่า Fibonacci ออกมา เหมือนกับโจทย์นี้ Fibonacci Sequence ได้ดังนี้

(defn fibo[n]
(letfn [
     (lazy-fibo
        ([] (lazy-fibo 1 1))
        ([p c] (cons p (lazy-seq (lazy-fibo c (+ p c))))))]
     (take n (lazy-fibo))))

จริงๆเราก็สามารถใช้ let และ fn ช่วยสร้างฟังก์ชันได้ แต่ว่าถ้าใช้แบบนั้น เราจะไม่สามารถเรียก recursive function ได้เพราะไม่สามารถอ้างอิงชื่อฟังก์ชันได้แบบที่ letfn ทำได้นั่นเอง

Referential transparency

2015-05-27T06:23:00.002+07:00

ในโลกของการเขียนโปรแกรมแบบ Functional Programming มีคุณสมบัตินึงที่เราจะเห็นกันบ่อยๆนั่นก็คือ Referential transparency หมายถึง

การเรียก function ด้วย arguments แบบเดิม จะได้ค่ากลับมาเป็นค่าเดิมเสมอ

function ที่มีคุณสมบัตินี้ จะทำให้การทำงานของโปรแกรมทดสอบได้ง่าย และ ยังสามารถใช้เทคนิคในการจำผลลัพธ์ของการเรียกใช้งานด้วย arguments ก่อนเอาไว้ได้อีกด้วย

ตัวอย่าง function ที่มีคุณสมบัติ Referentially transparent ยกตัวอย่างด้วย Clojure

(defn add2
[x]
(+ x 2))

จะเห็นว่า function นี้ใส่ค่าจำนวนเต็มอะไรไปจะได้ผลลัพธ์เป็นค่านั้นบวกกับ 2 เสมอ

ตัวอย่าง function ที่ไม่เป็น Referentially transparent เช่นฟังก์ชันที่ยุ่งเกี่ยวกับ Input/Output หรือฟังก์ชันที่ยุ่งเกี่ยวกับ เวลา และ การ random เช่น

(defn now [] (java.util.Date.))

(defn gen-number [] (rand))

(println "Hello World")

สุดท้าย ไม่ว่าคุณจะลองเขียนโปรแกรมในลักษณะ Functional Programming หรือไม่ ก็ขอให้เราเขียนโค้ดแยกระหว่างส่วนที่เป็น Referential transparency ออกจากส่วนที่ไม่เป็น เพื่อเราจะได้ทดสอบได้ง่ายๆ โดยเฉพาะส่วนที่เป็น Business Logic ต่างๆสามารถแยกออกมา เวลาเขียน Unit test ก็จะทำให้ง่ายขึ้นมาก

แก้เชือก

2015-05-26T16:31:00.003+07:00

เวลาที่เชือกพันกัน หรือพวกหูฟังพันกัน (แค่จับใส่กระเป๋า ก็พันกันเองได้) เราแก้โดยการเลือกค่อยๆ คลายทีละปมให้ออก ถ้าปมไหนแน่นก็จะทำให้มันหลวมๆก่อน

ในแต่ละปม จะต้องมีปลายเส้นของเชือกที่มันพันกันอยู่เสมอ ก่อนจะแก้ได้ก็ต้องหาปลายแต่ละด้านให้เจอแล้วค่อยๆไล่มาทีปมที่พันกันด้วย เพื่อเอาแต่ละด้านที่พันกันอยู่ออก

เมื่อกลับมาที่การเขียนโปรแกรมของเรา เมื่อเจอปัญหาที่เราไม่รู้ว่าจุดที่เป็นปัญหาจริงๆอยู่ที่ไหน รู้แค่กว้างๆ เราก็ต้องพยายามลดขอบเขตของปัญหา โดยการไล่ที่ปลายด้านหนึ่งของข้อมูลที่เข้าไป เช่น มี API หนึ่งที่ทำแล้วเรียกไปที่ path แบบนี้

POST /customer/save

สิ่งที่เราต้องไล่หาต่อไปคือ function อะไรที่เป็น Handler ของ API path นี้ เมื่อเจอแล้วก็ไล่ไปในนั้นต่อว่า ข้อมูลที่ส่งไปกับ request เอาไปทำอะไรบ้าง จนกระทั่งเจอจุดที่ทำให้เป็นปัญหา แล้วเราก็ค่อยแยกตรงส่วนนั้น มาเขียน test เพิ่ม ในกรณีที่ test ที่เคยเขียนไปแล้วไม่ครอบคลุมปัญหาที่เกิดขึ้น

นี่เป็น pattern ในการไล่โค้ดของผมครับ เพื่อท่านใดเจอปัญหาแบบเดียวกันได้ลองเอาวิธีนี้ไปใช้ดู