Home on kidpeterpan.github.io

ตอนที่ 5: Functions

Tue, 04 Aug 2026 00:00:00 +0700

ตอนที่ 5 เราจะค่อย ๆ ย้ายโค้ดที่กองอยู่ใน main ออกมาแบ่งเป็น function กันบ้าง หลังจากตอนที่แล้วเราใช้ block และ control structures ควบคุม flow ของโปรแกรมได้แล้ว ในตอนนี้เราจะจัดโค้ดให้เรียกใช้ซ้ำได้ ตั้งแต่ syntax พื้นฐาน ไปจนถึงฟีเจอร์เฉพาะของ Go อย่าง multiple return values, closure และ defer แล้วปิดท้ายด้วยกฎ call by value ที่จะช่วยไขปริศนาอีกหลายอย่างในตอนถัด ๆ ไป

สิ่งที่จะได้ตอนจบบทนี้:

เขียน function ตั้งแต่ syntax พื้นฐานจนถึงการจำลอง named/optional parameters ด้วย struct
ใช้ variadic parameter รับค่าไม่จำกัด และส่ง slice เข้าไปด้วย ...
ใช้ multiple return values พร้อม error เป็นค่าสุดท้าย ตาม convention ของ Go
รู้จัก named return values และรู้ว่าทำไมควรหลีกเลี่ยง blank return
ใช้ function เป็น value เก็บในตัวแปรและ map ได้เหมือน value ทั่วไป
เขียน anonymous function และ closure เพื่อ capture ตัวแปรรอบตัว
ส่ง function เป็น parameter และ return function ออกมา (higher-order function)
ใช้ defer ผูก cleanup ให้รันอัตโนมัติทุกครั้งที่ function จบ
เข้าใจกฎ call by value — ทำไม map/slice ถึงมี behavior ต่างจากที่คิด

graph TD
 A[Function พื้นฐาน: input -> output] --> B[Return tricks: หลายค่า + named return]
 A --> C[Input tricks: variadic + struct options]
 B --> D[Function เป็น value: ตัวแปร / map]
 D --> E[Closure: capture ตัวแปรรอบตัว]
 E --> F[ส่ง function เป็น parameter: sort.Slice]
 E --> G[return function: factory]
 E --> H[defer: cleanup แบบ LIFO]
 H --> I[Call by value: copy เสมอ]

วิธีทำตามบทนี้

เราจะสร้าง project ใหม่ ชื่อ go-functions เพื่อให้ทดลองโค้ดได้โดยไม่กระทบ project จากตอนก่อน เปิด terminal แล้วรัน:

Cognitive Debt

Mon, 03 Aug 2026 00:00:00 +0700

แปลจาก Prevent cognitive debt by manually retyping LLM-generated code โดย Ankur Sethi

ปัญหาที่คนใช้ AI เขียนโค้ดทุกคนกำลังเจอ

สมมติว่าเรามี Coding Assistant (( โปรแกรม AI ที่ช่วยเขียนโค้ด เช่น Copilot หรือ Claude Code )) สักตัว แล้วปล่อยให้มันจัดการทุกอย่างในโปรเจกต์ ตั้งแต่ต้นจนจบ ฟังดูเหมือนฝันเลยใช่ไหม?

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

Just because a problem is boring doesn’t mean I want to fully offload my understanding of the solution to a machine.

ประโยคนี้คือใจความสำคัญของบทความทั้งหมด — การที่งานน่าเบื่อ ไม่ได้หมายความว่าเราอยากยกความเข้าใจ ในวิธีแก้ปัญหานั้นให้เครื่องจักรไปทั้งหมด

ตอนที่ 4: Blocks, Shadows, and Control Structures

Sun, 02 Aug 2026 00:00:00 +0700

ตอนที่ 4 เราจะปูพื้นฐาน “ตรรกะและการจัดระเบียบโปรแกรม” ของ Go หลังจากตอนที่แล้วเราจัดกลุ่มข้อมูลด้วย composite types ได้แล้ว ตอนนี้เราจะมาทำให้โปรแกรมตัดสินใจและวนซ้ำได้ด้วย block, if, for, switch และรู้ว่า goto มีอยู่จริงแต่แทบไม่ควรใช้

สิ่งที่จะได้ตอนจบบทนี้:

เข้าใจ block และกฎการมองเห็นตัวแปร (scope) ซึ่งเป็นรากของทุกอย่างที่เหลือ
รู้จัก shadowing และหลีกเลี่ยงบั๊กที่เกิดจาก :=
ใช้ if พร้อมตัวแปรที่ scope กับทั้ง if/else
ใช้ for ทั้งสี่รูปแบบ และเลือก for-range ให้ถูกงาน
ใช้ switch และ blank switch ให้สื่อเจตนา
รู้ว่าทำไม goto จึงถูกจำกัดจนแทบไร้อันตราย

graph TD
 U[Universe block: predeclared identifiers] --> P[Package block]
 P --> F[File block: imports]
 F --> Fn[Function block: params + locals]
 Fn --> B["Inner blocks: {} ของ if / for / switch"]
 B -->|declare ชื่อซ้ำกับชั้นนอก| S[Shadowing]

วิธีทำตามบทนี้

เราจะสร้าง project ชื่อ go_blocks_control แยกจาก project ตอนก่อน เพื่อทดลองโค้ดโดยไม่กระทบกัน เปิด terminal แล้วรันคำสั่งนี้:

ตอนที่ 3: Composite Types

Sat, 01 Aug 2026 00:00:00 +0700

ตอนที่ 3 เราจะเรียนรู้ composite types หรือชนิดข้อมูลที่ประกอบขึ้นจากค่าอื่น ได้แก่ array, slice, map และ struct

ถ้าตอนที่ 2 สอนให้เราเลือกชนิดของ “ค่าเดี่ยว” เช่น int, string และ bool ตอนนี้เราจะเริ่มจัดกลุ่มค่าเหล่านั้นเป็นข้อมูลที่ใช้งานจริง เช่น รายการสินค้า, คะแนนสอบ, ตารางราคา และข้อมูลผู้ใช้

สิ่งที่จะได้ตอนจบบทนี้:

เลือกใช้ array, slice, map และ struct ได้ถูกสถานการณ์
ใช้ len, cap, append, make, copy, clear ได้อย่างปลอดภัย
เข้าใจว่า slice อาจแชร์ backing array เดียวกันได้อย่างไร
เข้าใจว่า string เป็น sequence ของ byte และจัดการ Unicode ด้วย rune ได้อย่างไร
อ่าน map ด้วย comma ok idiom และใช้ map จำลอง set

graph TD
 Q[ข้อมูลที่ต้องการเก็บ] --> A{"รู้จำนวนแน่นอน?"}
 A -->|ใช่| AR[Array]
 A -->|ไม่ใช่| SL[Slice]
 Q --> M{"ค้นหาด้วย key?"}
 M -->|ใช่| MAP[Map]
 Q --> S{"หลาย field ที่สัมพันธ์กัน?"}
 S -->|ใช่| ST[Struct]
 AR -->|เป็น backing store ให้| SL

วิธีทำตามบทนี้

เราจะสร้าง project ชื่อ go_composite_types แยกจาก project ตอนก่อน เพื่อทดลองโค้ดโดยไม่กระทบกัน เปิด terminal แล้วรันคำสั่งนี้:

ตอนที่ 2: Predeclared Types and Declarations

Fri, 31 Jul 2026 00:00:00 +0700

ตอนที่ 2 เราจะเริ่มเขียน Go ที่มีข้อมูลจริงมากขึ้น หลังจากตอนที่แล้วเรามี module และ workflow fmt → vet → build แล้ว ตอนนี้เราจะเรียนรู้ว่า Go เก็บข้อมูลแต่ละแบบอย่างไร และควรประกาศตัวแปรแบบไหนให้โค้ดสื่อเจตนาได้ชัดเจน

สิ่งที่จะได้ตอนจบบทนี้:

เข้าใจ bool, integer, float, complex, string และ rune ว่าควรใช้แบบไหนกับงานแบบใด
แปลง type ได้อย่างถูกต้องเมื่อ type ไม่ตรงกัน
เลือกใช้ var, := และ const ได้เหมาะสมกับบริบท
รู้ว่าทำไม Go จึงบังคับให้จัดการ unused variable

graph TD
 A["สร้าง module"] --> B["ทดลอง zero value และ literal"]
 B --> C["เลือก type ให้เหมาะกับข้อมูล"]
 C --> D["convert เมื่อ type ไม่ตรงกัน"]
 D --> E["ประกาศด้วย var หรือ :="]
 E --> F["ใช้ const กับค่า compile time"]
 F --> G["go fmt → go vet → go build"]

วิธีทำตามบทนี้

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

ตอนที่ 1: Setting Up Your Go Environment

Thu, 30 Jul 2026 00:00:00 +0700

ตอนที่ 1 ของซีรีส์ Go เราจะตั้งค่า environment ตั้งแต่ศูนย์ — ติดตั้ง Go, เริ่มเขียนโปรแกรมแรก, เรียนรู้เครื่องมือหลักอย่าง go build, go fmt, go vet และสร้าง Makefile เพื่อ automate workflow

สิ่งที่จะได้ตอนจบบทนี้:

โปรแกรม Hello World ที่ compile เป็น native binary ได้
เข้าใจ go build, go fmt และ go vet และใช้ให้เป็นนิสัย
Makefile ที่รัน workflow fmt → vet → build ใน command เดียว
workflow มาตรฐานที่นำไปใช้กับ project อื่น ๆ ได้

graph TD
 A["Source code .go"] -->|go fmt| B["Formatted code"]
 B -->|go vet| C{"Static checks pass?"}
 C -->|yes| D["go build"]
 C -->|no| A
 D --> E["Native binary"]
 E --> F["Deploy / run"]

Step 1: ติดตั้ง Go

Go toolchain มีตัวติดตั้งสำหรับทุก platform ให้เลือกตามเครื่องที่ใช้

JetBrains Context

Thu, 23 Jul 2026 00:00:00 +0700

แปลและสรุปจาก JetBrains Context: Codebase knowledge for AI agents โดย JetBrains

ปัญหาที่ JetBrains Context พยายามแก้

Coding agent มักจะ “หลงทาง” เมื่อเจอโค้ดเบสที่ซับซ้อน — ทุกงานที่ agent ได้รับต้องเริ่มจากขั้นตอนสำรวจ (( exploration overhead - เวลาและ token ที่ agent ใช้ค้นหาไฟล์ ทำความเข้าใจ dependency และศึกษารูปแบบโค้ดที่มีอยู่ ก่อนลงมือแก้ปัญหาจริง )) ไม่ว่าจะเป็นการหาไฟล์ที่เกี่ยวข้อง ทำความเข้าใจ dependency หรือค้นหารูปแบบการเขียนโค้ดที่ทีมใช้อยู่

JetBrains Context วางตัวเองเป็น (( repository intelligence layer - เลเยอร์ที่ให้ความรู้เชิงลึกเกี่ยวกับโครงสร้างและเนื้อหาของ repository แก่ระบบอื่น ในที่นี้คือ AI agent )) ซึ่งทำให้โค้ดเบส “พร้อมสำหรับ agent” มากขึ้น — ลดขั้นตอนสำรวจ เพิ่มความเร็วในการทำงาน และลดต้นทุนเมื่อต้องทำงานกับ repository ขนาดใหญ่ระดับ production

ผลลัพธ์ที่วัดได้จริง

JetBrains ทดสอบเครื่องมือนี้บน SWE-bench 205 งาน, งานใน production monorepo 175 งาน และงาน code localization 1,953 งาน แล้วรายงานผลดังนี้:

Loop Engineering

Sat, 27 Jun 2026 00:00:00 +0700

แปลจาก Loop Engineering โดย Addy Osmani

Loop Engineering คืออะไร

“Loop engineering is replacing yourself as the person who prompts the agent. You design the system that does it instead.”

กล่าวคือ Loop Engineering (( การออกแบบลูปงาน )) คือกระบวนทัศน์ใหม่ที่เปลี่ยนมุมมองต่อการทำงานร่วมกับ AI Agent — แทนที่จะนั่ง Prompt Agent ทีละขั้นแบบ Manual เราออกแบบ ระบบ ที่จัดการ Agent เหล่านั้นแทนตัวเราเอง

ผู้นำในวงการอย่าง Peter Steinberger และ Boris Cherny ต่างชี้ไปในทิศทางเดียวกันว่า วิศวกรที่แข็งแกร่งในยุคนี้ไม่ใช่คนที่ Prompt เก่งที่สุด แต่คือคนที่ ออกแบบ Loop ได้ดีที่สุด

5 องค์ประกอบหลักของ Loop

1. Automations — ระบบอัตโนมัติสำหรับค้นหางาน

กระบวนการที่ทำงานตามตารางเวลาโดยไม่ต้องมีคนกดเริ่ม โดยมีเป้าหมายเพื่อ:

Leading Effective Engineering Teams

Sat, 13 Jun 2026 12:00:00 +0700

What Makes a Software Engineering Team Effective?

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

2. กุญแจสำคัญ 5 ประการจากงานวิจัย Project Aristotle Google ค้นพบว่า “วิธีที่คนในทีมปฏิสัมพันธ์และทำตัวต่อกัน” นั้นสำคัญกว่า “ทักษะของคนในทีม” เสียอีก โดยมีปัจจัยสำคัญ 5 ข้อเรียงตามลำดับดังนี้:

รู้สึกปลอดภัยทางจิตวิทยา (( Psychological safety - การที่คนในทีมกล้าแสดงความคิดเห็น หรือเสนอไอเดียโดยไม่กลัวว่าจะถูกตำหนิหรือถูกตัดสิน )) ซึ่งถือเป็นรากฐานที่สำคัญที่สุด
พึ่งพากันได้ (( Dependability - สมาชิกในทีมสามารถพึ่งพากันและกันในการทำงานให้เสร็จตรงตามเวลาและได้คุณภาพ ))
โครงสร้างและความชัดเจน (( Structure and clarity - ทุกคนเข้าใจเป้าหมายของโปรเจกต์และหน้าที่รับผิดชอบของตัวเองอย่างชัดเจน ))
ความหมายของงาน (( Meaning - การรู้สึกว่างานที่กำลังทำอยู่มีความหมายและมีจุดประสงค์ ))
ผลกระทบของงาน (( Impact - ความเชื่อมั่นว่างานที่ทำสามารถสร้างความเปลี่ยนแปลงที่ดีให้กับองค์กรหรือสังคมได้ ))

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

Hidden Potential

Sun, 07 Jun 2026 12:00:00 +0700

Creatures of Discomfort

วิธีที่ช่วยให้เราเรียนรู้ได้เร็วที่สุดไม่ใช่การรอจนกว่าตัวเองจะพร้อม หรือเลือกทำเฉพาะเรื่องที่เราถนัด แต่คือการเรียนรู้ที่จะ “อยู่ร่วมกับความรู้สึกอึดอัดและเป็นมิตรกับมัน” (( discomfort - ความรู้สึกไม่สบายใจหรือความยากลำบากเมื่อต้องทำสิ่งใหม่ ๆ ที่ไม่คุ้นเคย )) เราจำเป็นต้องฝึกความกล้า 3 รูปแบบ ได้แก่:

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

Human Sponges

การทำตัวให้เหมือนฟองน้ำ (( Being a sponge - การมีนิสัยรักการเรียนรู้และเปิดรับสิ่งใหม่ ๆ เสมือนฟองน้ำที่คอยซึมซับน้ำ )) เปรียบได้กับฟองน้ำทะเลที่มีความสามารถหลัก 3 ประการ คือ:

ดูดซับ
กรองออก
ประยุกต์

การทำเช่นนี้คือการเลือกสรรอย่างเหมาะสม ไม่ใช่การดูดซับทุกสิ่งเข้ามาโดยไม่คิดวิเคราะห์ (( Passive - การรับข้อมูลเข้ามาฝ่ายเดียวโดยไม่ได้วิเคราะห์หรือตอบสนองกลับ ))

หัวใจสำคัญคือการพยายามทำงานอย่างชาญฉลาด (( work smart - การทำงานที่เน้นประสิทธิภาพและการวางแผนเพื่อผลลัพธ์ที่ดีที่สุด )) แทนที่จะเป็นแค่การทำงานหนักด้วยแรงหรือเวลาเพียงอย่างเดียว (( work hard - การโหมทำงานหนักโดยไม่ได้ไตร่ตรองถึงวิธีที่ดีกว่า ))