ทำไมต้องเรียน Go ในฐานะนักพัฒนา TypeScript

คุณคิดเป็น type อยู่แล้ว — Go ตอบแทนความสามารถนั้น

ถ้าตอนนี้คุณเขียน TypeScript อยู่ คุณเข้าใจคุณค่าของ static type, compiler error และ interface ที่ออกแบบมาอย่างตั้งใจดีอยู่แล้ว Go ต่อยอดสัญชาตญาณนั้นไปอีกขั้น: ไม่มีการลบ type ตอน runtime, ไม่มีขั้นตอนคอมไพล์แยกที่ “ข้าม” ได้ตอน develop และไม่มีโฟลเดอร์ node_modules ที่อัดแน่นด้วย dependency นับพันตัว

คอร์สนี้ถือว่าคุณคุ้นเคยกับ TypeScript และ Node.js อยู่แล้ว ทุกแนวคิดอธิบายผ่านการเปรียบเทียบ — สิ่งที่คุณรู้อยู่แล้ว กับวิธีที่ Go ทำแบบเดียวกัน (หรือเหตุผลที่ Go ทำต่างออกไป)

ทำไมต้องเรียน Go?

คอมไพล์เป็น binary ตัวเดียว

TypeScript คอมไพล์เป็น JavaScript ซึ่งยังต้องมี Node.js runtime ถึงจะรันได้ ส่วน Go คอมไพล์ตรงเป็น binary ระดับ native machine code คุณส่งแค่ไฟล์เดียว ไม่ต้องมี runtime บนเครื่องปลายทาง

// ส่ง: node dist/index.js
// ต้องการ: Node.js runtime ติดตั้งไว้แล้ว
// ขนาด: node_modules/ อาจถึง 200+ MB

// ส่ง: ./myapp (binary เดียว, ~5 MB)
// ต้องการ: ไม่มีอะไรเพิ่มบน server
// $ go build -o myapp .

Static type — ไม่มีเซอร์ไพรส์ตอน runtime

Type ของ TypeScript มีอยู่แค่ตอน development และถูกลบทิ้งก่อนโค้ดจะรัน ส่วน type ของ Go ถูก enforce โดย compiler และยังอยู่ตอน runtime โปรแกรม Go ที่คอมไพล์ผ่านจึง type-safe ตลอดการทำงาน

เริ่มต้นเร็วและ throughput สูง

Node.js (V8) เร็ว แต่มี JIT warm-up time และ garbage collector ที่จูนมาสำหรับ server ที่รันยาวๆ ส่วน Go เริ่มทำงานในระดับ millisecond, รองรับ concurrent connection หลักแสนผ่าน goroutine และ GC มี pause ต่ำกว่า millisecond สำหรับงาน CLI, microservice และเครื่องมือระดับ system แล้ว ประสิทธิภาพของ Go หาตัวจับยาก

Concurrency ระดับ first-class ด้วย goroutine

Node.js ทำงานแบบ single-threaded และใช้ event loop สำหรับ async I/O ส่วน Go ใช้ goroutine — lightweight thread ที่ Go runtime คอย multiplex ลงบน OS thread จริง คุณเขียนโค้ดที่ดูเหมือนทำงานแบบ sequential แล้วปล่อยให้ runtime จัดการ parallelism ให้ เราจะ preview เรื่องนี้ในบท mental model และลงลึกในบทถัดๆ ไป

// TypeScript: async/await + event loop
async function fetchAll(urls: string[]) {
  const results = await Promise.all(
    urls.map(url => fetch(url).then(r => r.json()))
  );
  return results;
}

// Go: goroutine + channel
func fetchAll(urls []string) []any {
    results := make([]any, len(urls))
    var wg sync.WaitGroup
    for i, url := range urls {
        wg.Add(1)
        go func(i int, url string) {
            defer wg.Done()
            // fetch logic here
            _ = i; _ = url
        }(i, url)
    }
    wg.Wait()
    return results
}

Error แบบ explicit แทน exception

TypeScript ใช้การโยน exception คุณครอบโค้ดด้วย try/catch แล้วได้แต่หวังว่าจะไม่มีอะไรหลุดรอด ส่วน Go คืน error เป็นค่าธรรมดา ทุก function ที่อาจล้มเหลวจะประกาศไว้ใน return type และคุณจัดการ error ได้ทันทีตรง call site — ไม่มีอะไรให้ “ลืม”

// TypeScript: exception สามารถ bubble ได้อย่างเงียบๆ
try {
  const data = JSON.parse(input);
  processData(data);
} catch (err) {
  console.error("something went wrong", err);
}

// Go: error คือ return value, จัดการแบบ explicit
data, err := parseInput(input)
if err != nil {
    return fmt.Errorf("failed to parse input: %w", err)
}
processData(data)

คอร์สนี้ครอบคลุมอะไรบ้าง

คอร์สนี้พาคุณจาก Go ระดับศูนย์ไปสู่การเขียน Go แบบ idiomatic พร้อมใช้งาน production โดยใช้ประสบการณ์ TypeScript ของคุณเป็นสะพาน นี่คือสิ่งที่เราจะครอบคลุม:

Module	หัวข้อ
Intro (module นี้)	ทำไมต้อง Go, การปรับ mindset, setup, hello world, layout ของโปรเจกต์
Go 101	Variables, functions, control flow, errors, structs, interfaces, collections, packages
(เร็วๆ นี้)	Goroutines, channels, HTTP servers, databases, testing

สิ่งที่ควรคาดหวัง

ทุกแนวคิดแสดงเป็นการเปรียบเทียบ TypeScript vs Go แบบ side-by-side
Playground ที่รันได้ช่วยให้คุณทดลองได้โดยตรงใน browser
Quiz ช่วยตอกย้ำแนวคิดสำคัญ
แนวคิดที่มีเฉพาะใน Go (ไม่มีใน TypeScript) เราจะระบุให้ชัดเจน

คุณไม่ต้องติดตั้งอะไรเลยก็ทำตามได้ — playground รัน Go ให้ใน browser และเมื่อพร้อมตั้งค่า local environment บท setup จะพาคุณทำทีละขั้น

Open in Playground

package main

import "fmt"

func main() {
  // ยินดีต้อนรับสู่ Go! นี่คือโปรแกรมแรกของคุณ
  // กด Run เพื่อรัน
  message := "Hello from Go!"
  fmt.Println(message)

  // Go อนุมาน type — เหมือนกับ let ใน TypeScript
  year := 2024
  fmt.Printf("Year: %d\n", year)
}