ផ្លូវសិក្សា
ផែនទីផ្លូវអ្នកអភិវឌ្ឍន៍ Go
ដំណាក់កាល 3 ដំបូងដូចគ្នាសម្រាប់អ្នកសរសេរ Go ទាំងអស់ ចាប់ពី go mod init។ បន្ទាប់មកផ្លូវបែកតាមប្រភេទការងារដែលអ្នកចង់ធ្វើ។
ជ្រើសផ្លូវ
Backend និង APIs
កំពុងមើលServices HTTP និង gRPC ដែលគេពឹងផ្អែក។
CLI និងឧបករណ៍អ្នកអភិវឌ្ឍន៍
3 ដំណាក់កាលBinary តែមួយដែល engineer ផ្សេងដំឡើង។
Cloud-native និង Platform
គ្រោងទុកControllers, operators និង control plane។
AI agents ក្នុង Go
គ្រោងទុកTool dispatch, retrieval, memory, evals។
Backend និង APIs
7 ដំណាក់កាល · 44 ប្រធានបទមូលហេតុទូទៅបំផុតដែលក្រុមជ្រើសរើស Go៖ ការគ្រប់គ្រង request, មូលដ្ឋានទិន្នន័យ និងលទ្ធភាពប្រតិបត្តិការដែលទប់បានពេលយប់ជ្រៅ។ បញ្ចប់ដោយ service ដែល engineer ផ្សេងអាចដំណើរការ និងបន្ថែមបាន។
បានធីក 0 ក្នុង 44 ប្រធានបទ
ដំណាក់កាលបីដំបូងជារួម ដូច្នេះការធីកនៅទីនេះរាប់សម្រាប់គ្រប់ផ្លូវ។
មុនដំណាក់កាល ០១
រឿងទាំងនេះមិនមែនជា Go ទេ ប៉ុន្តែវាទាំងអស់លេចឡើងក្នុងសប្តាហ៍ដំបូងរបស់អ្នកនៅក្រុម Go។
Git និងការ review កូដ
Branches, rebase, commit តូចៗ និងការអាន diff — អ្នកនឹងរៀន Go តាមរយៈ pull requests។
Terminal និងមូលដ្ឋាន Linux
ការប្រើ shell, environment variables, processes, signals, file permissions និង SSH។
HTTP និង JSON
Methods, status codes, headers, caching និងរូបរាងពិតរបស់ request នៅលើបណ្តាញ។
SQL និងការរចនាទិន្នន័យ
Joins, indexes, transactions និង normalization — Go services ភាគច្រើនជា service ទិន្នន័យ។
ផ្លូវដំណើរ
ប្រធានបទ (ចុចដើម្បីធីក) បានបញ្ចប់ ចម្ងាយដែលបានឆ្លងកាត់
មូលដ្ឋានភាសា
២–៤ សប្តាហ៍
អាន និងសរសេរ Go ធម្មតាបាន ដោយមិនចាំបាច់រកមើល syntax នៅរាល់បន្ទាត់។
សាងសង់ CLI មួយដែលអាន cart ជា JSON តាម stdin ហើយបោះពុម្ពសរុបនៃ order ជាមួយពន្ធ និងថ្លៃដឹកជញ្ជូន។
បន្តពេល អ្នកអាចពន្យល់ភាពខុសគ្នារវាង nil slice និង empty slice ព្រមទាំងមូលហេតុដែល value receiver មិនអាចកែប្រែ struct របស់វា។
សរសេរតាមរបៀប Go
៣–៥ សប្តាហ៍
សរសេរកូដដែល reviewer មើលឃើញថាជា Go ពិត មិនមែនការបកប្រែពី Java ឬ Python។
សាងសង់ package catalog ជាមួយ repository តាម interface, fake ក្នុង memory និង table-driven tests ដែលគ្របដណ្តប់ច្បាប់ domain។
បន្តពេល អ្នកបង្កើត interface តែពេលមាន implementation ទីពីរ ឬ test double ប៉ុណ្ណោះ មិនមែនទុកជាមុនទេ។
Concurrency និង Context
៤–៦ សប្តាហ៍
សរសេរកូដ concurrent ដែលត្រឹមត្រូវក្រោម -race មិនត្រឹមតែលឿនប៉ុណ្ណោះទេ។
សាងសង់ price fetcher ដែលសួរ supplier ចំនួន N ដំណាលគ្នា ជាមួយ deadline សម្រាប់ request មួយៗ, បោះបង់អ្វីដែលនៅសល់ពេលទទួលបានតម្លៃគ្រប់គ្រាន់ ហើយមិនធ្វើឱ្យ goroutine លេចធ្លាយ។
បន្តពេល អ្នកអាចមើលឃើញ goroutine leak ក្នុងការ review ហើយពន្យល់បានថាហេតុអ្វី context ប្រសើរជាង done flag រួម។
Standard Library និង Tooling
៣–៤ សប្តាហ៍
ដោះស្រាយបញ្ហាភាគច្រើនដោយ standard library មុននឹងទៅរក dependency ខាងក្រៅ។
សាងសង់ API សម្រាប់ order ជា JSON លើ net/http និង database/sql ជាមួយ graceful shutdown, timeout សម្រាប់ request និងគ្មាន dependency ខាងក្រៅឡើយ។
បន្តពេល ពេលជួបបញ្ហាថ្មី គំនិតដំបូងរបស់អ្នកគឺមើល standard library docs មិនមែន package registry ទេ។
សាងសង់ Services ជាក់ស្តែង
៦–៨ សប្តាហ៍
បញ្ចេញ service ដែល engineer ផ្សេងអាចដំណើរការ, បន្ថែម និងគ្រប់គ្រងបាន។
សាងសង់ order service ជាមួយផ្ទៃ HTTP និង gRPC, Postgres ជាមួយ migrations, worker សម្រាប់អ៊ីមែលបញ្ជាក់ និង integration tests។
បន្តពេល នៅពេល dependency យឺត ឬដាច់ service របស់អ្នកធ្លាក់ចុះដោយអាចទាយបាន មិនមែនរលំទាំងស្រុងទេ។
Production និង Performance
បន្តរហូត
ដំណើរការវា, វាស់វែងវា ហើយធ្វើឱ្យលឿនឡើងតែពេលមានទិន្នន័យបញ្ជាក់។
សាងសង់ បន្ថែម traces និង metrics ទៅ order service បន្ទាប់មកកាត់បន្ថយ p99 latency ឬ allocations ៣០% ដោយមាន profile មុន/ក្រោយជាភស្តុតាង។
បន្តពេល អ្នកមិនកែកូដសម្រាប់ performance ដោយគ្មាន benchmark ឬ profile ជាមូលដ្ឋានឡើយ។
ការរចនា និង Architecture
បន្តរហូត
ធ្វើការសម្រេចចិត្តរចនាដែលអ្នកអាចការពារបាន រួមទាំងលំនាំដែលអ្នកបានបដិសេធ។
សាងសង់ ធ្វើ refactor package ដែលរញ៉េរញ៉ៃឱ្យនៅក្រោយព្រំដែន interface ច្បាស់លាស់មួយ ដោយប្រើលំនាំក្នុងបណ្ដុំនេះ ហើយសរសេរ design doc ខ្លីដែលបញ្ជាក់ការបែងចែកនោះ។
បន្តពេល អ្នកអាចពន្យល់ថាហេតុអ្វីលំនាំមួយមិនសមស្រប បានច្បាស់ដូចការពន្យល់ថាហេតុអ្វីលំនាំមួយទៀតសមស្រប។
បន្ទាប់ពីនេះ ផ្លូវគឺជាការសាងសង់, ការវាស់វែង និងការ review ដែលធ្វើម្តងហើយម្តងទៀត។
- 01
មូលដ្ឋានភាសា
អាន និងសរសេរ Go ធម្មតាបាន ដោយមិនចាំបាច់រកមើល syntax នៅរាល់បន្ទាត់។
២–៤ សប្តាហ៍ 0/6រៀន
សាងសង់វា
CLI មួយដែលអាន cart ជា JSON តាម stdin ហើយបោះពុម្ពសរុបនៃ order ជាមួយពន្ធ និងថ្លៃដឹកជញ្ជូន។
បន្តទៅមុខពេល
អ្នកអាចពន្យល់ភាពខុសគ្នារវាង nil slice និង empty slice ព្រមទាំងមូលហេតុដែល value receiver មិនអាចកែប្រែ struct របស់វា។
- 02
សរសេរតាមរបៀប Go
សរសេរកូដដែល reviewer មើលឃើញថាជា Go ពិត មិនមែនការបកប្រែពី Java ឬ Python។
៣–៥ សប្តាហ៍ 0/6រៀន
សាងសង់វា
package catalog ជាមួយ repository តាម interface, fake ក្នុង memory និង table-driven tests ដែលគ្របដណ្តប់ច្បាប់ domain។
បន្តទៅមុខពេល
អ្នកបង្កើត interface តែពេលមាន implementation ទីពីរ ឬ test double ប៉ុណ្ណោះ មិនមែនទុកជាមុនទេ។
- 03
Concurrency និង Context
សរសេរកូដ concurrent ដែលត្រឹមត្រូវក្រោម -race មិនត្រឹមតែលឿនប៉ុណ្ណោះទេ។
៤–៦ សប្តាហ៍ 0/6រៀន
សាងសង់វា
price fetcher ដែលសួរ supplier ចំនួន N ដំណាលគ្នា ជាមួយ deadline សម្រាប់ request មួយៗ, បោះបង់អ្វីដែលនៅសល់ពេលទទួលបានតម្លៃគ្រប់គ្រាន់ ហើយមិនធ្វើឱ្យ goroutine លេចធ្លាយ។
បន្តទៅមុខពេល
អ្នកអាចមើលឃើញ goroutine leak ក្នុងការ review ហើយពន្យល់បានថាហេតុអ្វី context ប្រសើរជាង done flag រួម។
- 04
Standard Library និង Tooling
ដោះស្រាយបញ្ហាភាគច្រើនដោយ standard library មុននឹងទៅរក dependency ខាងក្រៅ។
៣–៤ សប្តាហ៍ 0/6រៀន
សាងសង់វា
API សម្រាប់ order ជា JSON លើ net/http និង database/sql ជាមួយ graceful shutdown, timeout សម្រាប់ request និងគ្មាន dependency ខាងក្រៅឡើយ។
បន្តទៅមុខពេល
ពេលជួបបញ្ហាថ្មី គំនិតដំបូងរបស់អ្នកគឺមើល standard library docs មិនមែន package registry ទេ។
- 05
សាងសង់ Services ជាក់ស្តែង
បញ្ចេញ service ដែល engineer ផ្សេងអាចដំណើរការ, បន្ថែម និងគ្រប់គ្រងបាន។
៦–៨ សប្តាហ៍ 0/7រៀន
សាងសង់វា
order service ជាមួយផ្ទៃ HTTP និង gRPC, Postgres ជាមួយ migrations, worker សម្រាប់អ៊ីមែលបញ្ជាក់ និង integration tests។
បន្តទៅមុខពេល
នៅពេល dependency យឺត ឬដាច់ service របស់អ្នកធ្លាក់ចុះដោយអាចទាយបាន មិនមែនរលំទាំងស្រុងទេ។
- 06
Production និង Performance
ដំណើរការវា, វាស់វែងវា ហើយធ្វើឱ្យលឿនឡើងតែពេលមានទិន្នន័យបញ្ជាក់។
បន្តរហូត 0/7រៀន
សាងសង់វា
បន្ថែម traces និង metrics ទៅ order service បន្ទាប់មកកាត់បន្ថយ p99 latency ឬ allocations ៣០% ដោយមាន profile មុន/ក្រោយជាភស្តុតាង។
បន្តទៅមុខពេល
អ្នកមិនកែកូដសម្រាប់ performance ដោយគ្មាន benchmark ឬ profile ជាមូលដ្ឋានឡើយ។
- 07
ការរចនា និង Architecture
ធ្វើការសម្រេចចិត្តរចនាដែលអ្នកអាចការពារបាន រួមទាំងលំនាំដែលអ្នកបានបដិសេធ។
បន្តរហូត 0/6រៀន
សាងសង់វា
ធ្វើ refactor package ដែលរញ៉េរញ៉ៃឱ្យនៅក្រោយព្រំដែន interface ច្បាស់លាស់មួយ ដោយប្រើលំនាំក្នុងបណ្ដុំនេះ ហើយសរសេរ design doc ខ្លីដែលបញ្ជាក់ការបែងចែកនោះ។
បន្តទៅមុខពេល
អ្នកអាចពន្យល់ថាហេតុអ្វីលំនាំមួយមិនសមស្រប បានច្បាស់ដូចការពន្យល់ថាហេតុអ្វីលំនាំមួយទៀតសមស្រប។
លំនាំសម្រាប់ផ្លូវនេះ
លំនាំមិនមែនជាដំណាក់កាលដែលអ្នកបញ្ចប់ទេ — វាជាភាសាដែលអ្នកទទួលបានពេលមានកូដដែលសមនឹងរៀបចំឡើងវិញ។ ខាងក្រោមនេះជាលំនាំដែលផ្លូវនេះជួបប្រទះច្រើនបំផុត។
Adapter
Wrap an incompatible API behind the interface your application already expects so the rest of the code stays unchanged.
Decorator
Add behavior around an object dynamically by wrapping it with small focused layers that share the same interface.
Proxy
Control access to another object by standing in front of it to add caching, authorization, rate limiting, or lazy loading.
លំនាំ Chain of Responsibility ក្នុង Go
បង្កើត validation និង request-processing pipelines ដោយប្រើ handlers តូចៗដែលត្រូវបានផ្សំតាម interfaces។
Facade
Provide one simplified entry point over several collaborating subsystems so callers can trigger a workflow without knowing every step.
Strategy
Encapsulate interchangeable algorithms behind one interface so callers can swap behavior without branching on concrete rules.
ធនធានដែលសមនឹងពេលវេលារបស់អ្នក
បញ្ជីខ្លីមួយ ភាគច្រើនជាឯកសារផ្លូវការ។ បញ្ចប់ទាំងនេះមុននឹងទិញវគ្គសិក្សា។
A Tour of Go
សេចក្តីផ្តើមអន្តរកម្មជាផ្លូវការ។ បញ្ចប់វាមុនរឿងផ្សេងទាំងអស់។
Effective Go
របៀបដែល Go គួរត្រូវសរសេរ ដោយផ្ទាល់ពីក្រុម Go។
Go Code Review Comments
បញ្ជីត្រួតពិនិត្យដែល reviewer Go ប្រើពិតប្រាកដលើ pull requests របស់អ្នក។
Go by Example
កម្មវិធីខ្លីៗមានពន្យល់សម្រាប់លក្ខណៈពិសេសភាសាស្ទើរតែទាំងអស់។
The Go Blog
អត្ថបទស៊ីជម្រៅជាផ្លូវការស្តីពី slices, errors, context, generics និង GC។
Standard Library Reference
រក្សាទុកជា bookmark។ ការអាន source របស់ std គឺជាផ្នែកនៃការរៀនភាសា។
Learn Go with Tests
រៀនភាសាដោយចាប់ផ្តើមពី test — ផ្លូវលឿនបំផុតទៅរកវិន័យសរសេរ test។
Go Proverbs
ប្រយោគខ្លីៗរបស់ Rob Pike ដែលពន្យល់អំណះអំណាងរចនា Go ភាគច្រើន។