שיעור פרטי בGo עם AI
לומדים Go צעד אחר צעד, מהתוכנית הראשונה ועד שירות HTTP עמיד, עם בדיקות ומדידת ביצועים
המורה: נועם
- התוכנית עודכנה 11.2026
- עברית, ועוד 5 שפות
- 3 רמות: מתחילים · ממשיכים · מתקדמים
- 36 שיעורים · כ־19 שעות של שיעורים
Go
לומדים Go צעד אחר צעד, מהתוכנית הראשונה ועד שירות HTTP עמיד, עם בדיקות ומדידת ביצועים
12 שיעורים · 4 פרקים · שיעור חי פרטי עם המורה על הלוח
מה תדעו לעשות בסוף
- להסביר מה עושים go run ו־go build ולמה Go מתקמפלת לקובץ בינארי אחד
- להצהיר על משתנים וקבועים ולהסביר ערכי אפס והמרות מפורשות
- לכתוב תנאים ולולאות עם if, for ו־switch, כולל הצהרה מקדימה
- לכתוב פונקציות עם ערכים מרובים, closures ו־defer ולהסביר מתי defer רץ
- להשתמש ב־& וב־* כדי שפונקציה תשנה משתנה של הקורא
- לארגן פרויקט לכמה חבילות ולנהל תלויות עם go.mod
- להסביר מה slice באמת ולחזות מתי שני slices חולקים זיכרון
- להגדיר structs ו־methods ולבחור נכון בין value receiver ל־pointer receiver
- להגדיר interface ולזהות אילו טיפוסים מממשים אותו בלי implements
- לחלץ טיפוס קונקרטי מערך ממשק עם type assertion ו־type switch
- לכתוב פונקציה ו־struct גנריים עם constraints ולהחליט מתי גנריות עדיפה
- להחזיר ולבדוק שגיאות בסגנון Go ולבנות טיפוס שגיאה משלכם
- לעטוף שגיאות עם %w ולבדוק אותן עם errors.Is ו־errors.As
- להריץ goroutines עם WaitGroup ולזהות data race עם go run -race
- להגן על מצב משותף עם Mutex ולהעביר נתונים בין goroutines עם channels
- לבנות worker pool ולהסביר מי סוגר כל channel ולמה אין deadlock
- להעביר context לאורך שרשרת קריאות ולעצור עבודה בביטול או ב־timeout
- לבנות pipeline עם fan-out ו־fan-in בלי להשאיר goroutines תקועות
- להגביל מקביליות ולהפעיל משימות עם errgroup, semaphore ו־rate limiting
- לבחור בין channel, Mutex, RWMutex ו־atomic לפי המקרה
- לבנות שרת HTTP עם net/http ו־JSON API שמחזיר שגיאות עקביות
- לכתוב middleware ללוגים עם slog, לתפיסת panic ול־request ID
- לכתוב בדיקות table-driven עם fakes, httptest ו־fuzz test
- למדוד עם benchmark ו־pprof ולהקטין הקצאות בקוד חם
בסוף כל רמה המורה בודק שזה באמת ברור, לא רק שעברנו על החומר
נושאים קשורים
הקורס כולל
- שיעורים חיים 1:1 עם מורה פרטי AI על לוח
- 19 שעות של שיעורים חיים אחד על אחד
- 36 שיעורים על לוח משותף, כל אחד עם יעד ברור
- תרגול ובדיקת הבנה בכל שיעור
- סיכום אחרי כל שיעור, שנשמר בהיסטוריה
- תעודת סיום לכל רמה
- מחשב, טאבלט או טלפון
- עברית, ועוד 5 שפות
תוכנית הקורס
3 רמות · 12 פרקים · 36 שיעורים · 18 שע׳ 55 דק׳ בסך הכול
מתחיליםGo למתחילים: מאפס לקוד עובד4 פרקים • 12 שיעורים • 6 שע׳ 25 דק׳
לכתוב תוכניות Go קטנות ותקינות עם טיפוסים, פונקציות, חבילות, slices, maps ו־structs עם methods, ולהבין מה קורה בזיכרון.
יסודות: תחביר, טיפוסים וזרימת בקרה3 שיעורים • 1 שע׳ 35 דק׳
- 1למה Go, והתוכנית הראשונהתסביר/י איך תוכנית Go בנויה, מה עושים go run ו־go build, ולמה Go מקומפלת לקובץ בינארי אחד.שיעור ניסיוןכ־30 דק׳
- 2משתנים, טיפוסים בסיסיים וערכי אפסתצהיר/י משתנים וקבועים בכל הדרכים, תבחר/י טיפוס מתאים ותסביר/י ערכי אפס והמרות מפורשות.כ־35 דק׳
- 3זרימת בקרה: if, for ו־switchתכתוב/תכתבי תנאים ולולאות ב־Go, כולל if עם הצהרה מקדימה, for בשלוש צורותיו ו־switch בלי break.כ־30 דק׳
פונקציות, מצביעים וחבילות3 שיעורים • 1 שע׳ 35 דק׳
- 4פונקציות: ערכים מרובים, closures ו־deferתכתוב/תכתבי פונקציות שמחזירות כמה ערכים, תשתמש/י בפונקציה כערך וב־closure, ותסביר/י מתי defer רץ.כ־35 דק׳
- 5מצביעים והעברה לפי ערךתסביר/י ש־Go מעבירה הכול לפי ערך, ותשתמש/י ב־& וב־* כדי שפונקציה תשנה משתנה של הקורא.כ־30 דק׳
- 6חבילות ומודולים: איך מארגנים קוד Goתארגן/י פרויקט Go לכמה חבילות, תבין/י ייצוא לפי אות גדולה ותנהל/י תלויות עם go.mod.כ־30 דק׳
אוספים: Slices, Maps ומחרוזות4 שיעורים • 2 שע׳ 10 דק׳
- 7מערכים ו־Slices: len, cap ומערך הבסיסתסביר/י מה slice באמת (מצביע, אורך, קיבולת) ותחזה/י מתי שני slices חולקים את אותו זיכרון.כ־35 דק׳
- 8append, copy ו־range: לעבוד עם Slices בבטחהתשתמש/י ב־append, copy ו־range נכון, ותזהה/י את באג השיתוף שנוצר אחרי append.כ־35 דק׳
- 9Maps: מילון, comma-ok וסדר אקראיתשתמש/י ב־maps לספירה ולחיפוש, תבדוק/תבדקי קיום מפתח עם comma-ok ותימנע/י מכתיבה ל־nil map.כ־30 דק׳
- 10מחרוזות, bytes ו־runes: עברית ב־UTF-8תסביר/י למה len("שלום") הוא 8, ותעבוד/תעבדי נכון עם runes, strings.Builder וחבילת strings.כ־30 דק׳
Structs ו־Methods: לבנות טיפוסים משלך2 שיעורים • 1 שע׳ 5 דק׳
- 11Structs: הגדרה, literals ו־embeddingתגדיר/י structs למודל של נתונים אמיתיים, תיצור/תיצרי אותם נכון ותשתמש/י ב־embedding להרכבה במקום ירושה.כ־30 דק׳
- 12Methods: value receiver מול pointer receiverתצמיד/י methods לטיפוסים, תבחר/י נכון בין value ל־pointer receiver ותכתוב/תכתבי constructor בסגנון NewX.כ־35 דק׳
ממשיכיםממשיכים: ממשקים, שגיאות ומקביליות ב־Go4 פרקים • 12 שיעורים • 6 שע׳ 10 דק׳
הלומד כותב קוד Go עצמאי עם ממשקים, טיפול שגיאות נכון ו־goroutines ו־channels, ומסביר איך worker pool מסתיים בלי deadlock.
ממופה למבחן: roadmap.sh Go — Interfaces, Error Handling, Concurrency (goroutines, channels, sync)
ממשקים וגנריות4 שיעורים • 2 שע׳
- 1ממשקים: מימוש מרומז ו־method setsתגדיר interface, תזהה אילו טיפוסים מממשים אותו בלי implements, ותבין למה pointer receiver משנה את התשובה.כ־30 דק׳
- 2ערך ממשק מבפנים: any, type assertion ו־type switchתסביר ממה בנוי ערך ממשק, תחלץ ממנו טיפוס קונקרטי בבטחה, ותזהה את מלכודת ה־nil בתוך ממשק.כ־30 דק׳
- 3ממשקים קטנים בספרייה הסטנדרטית: Stringer ו־ioתשתמש ב־fmt.Stringer, io.Reader ו־io.Writer, ותיישם את הכלל 'קבל ממשקים, החזר structs'.כ־30 דק׳
- 4Generics: פרמטרי טיפוס ו־constraintsתכתוב פונקציה ו־struct גנריים עם constraints, ותדע מתי גנריות עדיפה על ממשק.כ־30 דק׳
טיפול בשגיאות3 שיעורים • 1 שע׳ 25 דק׳
- 5error הוא ממשק: if err != nil ו־return מוקדםתחזיר ותבדוק שגיאות בסגנון Go, תכתוב הודעות שגיאה טובות ותבנה טיפוס שגיאה משלך.כ־30 דק׳
- 6עטיפת שגיאות: %w, errors.Is ו־errors.Asתעטוף שגיאות עם הקשר, ותבדוק את סוגן לאורך כל השרשרת עם errors.Is ו־errors.As.כ־30 דק׳
- 7panic ו־recover: מתי, ולמה כמעט אף פעםתבחין בין שגיאה רגילה ל־panic, תבין איך defer ו־recover עוצרים קריסה, ותדע מתי זה מוצדק.כ־25 דק׳
Goroutines וזיכרון משותף2 שיעורים • 1 שע׳
- 8Goroutines ו־sync.WaitGroupתריץ פונקציות במקביל עם go, תבין למה main לא מחכה להן, ותסנכרן סיום עם WaitGroup.כ־30 דק׳
- 9Data race, sync.Mutex ו־race detectorתזהה data race, תגן על מצב משותף עם Mutex, ותשתמש ב־go run -race כדי לתפוס מרוצים.כ־30 דק׳
Channels ו־Worker Pool3 שיעורים • 1 שע׳ 45 דק׳
- 10Channels: שליחה, קבלה, חסימה ו־closeתעביר נתונים בין goroutines עם channels, תחזה מתי פעולה נחסמת, ותסגור channel נכון כדי ש־range יסתיים.כ־35 דק׳
- 11select, timeouts ו־channels מכווני כיווןתמתין לכמה channels עם select, תוסיף timeout ו־default, ותגביל channel לשליחה או קבלה בחתימת פונקציה.כ־30 דק׳
- 12Worker Pool: לבנות, לסגור ולסיים בלי deadlockתבנה worker pool עם jobs, N workers ו־results, ותסביר מי סוגר כל channel ולמה הוא מסתיים בלי deadlock.כ־40 דק׳
מתקדמיםGo מתקדמים: שירותים ברמת production4 פרקים • 12 שיעורים • 6 שע׳ 20 דק׳
לכתוב שירות Go ברמת production: דפוסי מקביליות עם context, שרת HTTP עמיד, בדיקות אמינות ומדידה ושיפור של ביצועים.
ממופה למבחן: ללא מבחן חיצוני — הרמה בנויה לפי נושאי ה־roadmap של Go ולפי המסמכים הרשמיים של go.dev
דפוסי מקביליות ב־production4 שיעורים • 2 שע׳ 5 דק׳
- 1context: ביטול, deadline ו־timeout לאורך כל השרשרתתעביר/י context דרך שרשרת קריאות ותעצור/י עבודה מיותרת בביטול או ב־timeout, בלי לדלוף goroutines.כ־30 דק׳
- 2Pipelines, fan-out/fan-in ודליפת goroutinesתבנה/י pipeline של שלבים עם fan-out ו־fan-in שנסגר נכון ולא משאיר goroutines תקועות.כ־35 דק׳
- 3errgroup, semaphore ו־rate limitingתריץ/י משימות במקביל עם הגבלת מקביליות, עצירה בשגיאה הראשונה וקצב קריאות מבוקר.כ־30 דק׳
- 4sync לעומק: Once, RWMutex, atomic ו־memory modelתבחר/י בין channel, Mutex, RWMutex ו־atomic לפי המקרה, ותסביר/י happens-before במילים שלך.כ־30 דק׳
שרת HTTP4 שיעורים • 2 שע׳ 5 דק׳
- 5net/http: Handler, ServeMux ו־routing מודרניתכתוב/י שרת HTTP עם net/http בלבד, עם routes לפי method ו־path parameters.כ־30 דק׳
- 6JSON API: קידוד, struct tags ותשובות שגיאהתבנה/י endpoint שמקבל ומחזיר JSON, מאמת קלט ומחזיר שגיאות עקביות עם status code נכון.כ־30 דק׳
- 7Middleware: לוגים עם slog, recover ו־request IDתכתוב/י middleware שעוטף handlers ללוגים מובנים, תפיסת panic ו־request ID, ותרכיב/י אותם בסדר הנכון.כ־30 דק׳
- 8שרת ב־production: timeouts ו־graceful shutdownתגדיר/י http.Server עם timeouts נכונים ותכבה/י אותו בלי לחתוך requests באמצע, כולל http.Client עם timeout.כ־35 דק׳
בדיקות2 שיעורים • 1 שע׳
- 9testing: טבלאות, subtests ו־fakes דרך ממשקיםתכתוב/י בדיקות table-driven עם subtests, ותחליף/י תלות חיצונית ב־fake דרך ממשק קטן.כ־30 דק׳
- 10httptest, race detector ב־CI ו־fuzzingתבדוק/י handlers ולקוחות HTTP עם httptest, תריץ/י בדיקות עם -race ותכתוב/י fuzz test שמוצא קלט שובר.כ־30 דק׳
ביצועים2 שיעורים • 1 שע׳ 10 דק׳
- 11Benchmarks ו־pprof: למדוד לפני שמשפריםתכתוב/י benchmark, תשווה/י גרסאות עם benchstat ותמצא/י נקודה חמה ב־CPU profile.כ־35 דק׳
- 12הקצאות זיכרון: escape analysis, GC ו־sync.Poolתזהה/י למה משתנה בורח ל־heap, תקטין/י הקצאות בקוד חם ותבין/י איך GOGC ו־GOMEMLIMIT משפיעים.כ־35 דק׳
מה צריך
- אין צורך בידע קודם ברמת המתחילים
- לרמות ממשיכים ומתקדמים: שליטה בבסיס של Go, כמו פונקציות, slices ו־structs
- מחשב עם Go מותקן, כדי להריץ את הקוד
- מחשב, טאבלט או טלפון עם מיקרופון, ודפדפן
על הקורס
קורס Go בשלוש רמות: מתחילים, ממשיכים ומתקדמים. כל שיעור פרטי נבנה סביב קוד שכותבים בעצמכם על הלוח, צעד אחר צעד, מתחביר ועד מקביליות ושירותים ברמת production. אפשר להתחיל מכל רמה ולחזור לנושא שצריך חיזוק.
למי הקורס
- מי שרוצה ללמוד Go מאפס ולכתוב תוכניות קטנות ותקינות
- מפתחים ומפתחות בשפה אחרת שעוברים ל־Go
- מי שמכיר Go ורוצה להבין ממשקים, שגיאות ומקביליות לעומק
- מי שמכין שירותי Go לעבודה אמיתית: HTTP, בדיקות וביצועים
מבחנים והסמכות
- ממשיכים: roadmap.sh Go — Interfaces, Error Handling, Concurrency (goroutines, channels, sync)
- מתקדמים: ללא מבחן חיצוני — הרמה בנויה לפי נושאי ה־roadmap של Go ולפי המסמכים הרשמיים של go.dev
קורסים נוספים במסלול
המורה שלך
נועםמורה AI פרטי, בשיעור חי על לוח משותףמורה AI פרטי שמלמד בשיחה חיה: שואל, מקשיב, מצייר על הלוח ונותן לפתור לבד עם רמזים. זוכר מה למדתם ומתחיל כל שיעור מהמקום שעצרתם.
איך נראה שיעור?
הילד מדבר עם המורה בקול, כמו בשיחת וידאו, ושואל מה שלא ברור.
המורה מסביר, כותב ומצייר על לוח משותף, והילד פותר איתו על אותו לוח.
אפשר לצלם דף עבודה או שיעורי בית וללמוד ממנו, תרגיל אחרי תרגיל.
ההורה מקבל דוח: זמן לימוד, מה הצליח ומה כדאי לחזק.
כללי השיעור
- רק לימוד
שאלות נפוצות
- איך עובד שיעור פרטי בGo?
- בוחרים Go ורמה, ומדברים עם המורה בקול. המורה שואל מה כבר ידוע, מסביר, כותב ומצייר על הלוח, ונותן לפתור לבד עם רמזים עד שהעניין ברור.
- כמה זמן לוקח הקורס Go?
- 12 שיעורים של כ־32 דקות ברמה הראשונה, בקצב שלך. אפשר לעצור, לחזור ולדלג על מה שכבר ידוע.
- צריך ידע קודם?
- לא ברמת המתחילים. בתחילת השיעור הראשון המורה בודק מה כבר ידוע ומתאים את הרמה, ואפשר להתחיל ישר מרמה מתקדמת.
- איך מתחילים בחינם?
- נכנסים עם חשבון Google או עם קוד שנשלח למייל, כותבים שם וכיתה של הילד, והשיעור מתחיל מיד. כל משפחה מקבלת 45 דקות שיעור חינם, בכל מקצוע, לפי זמן השיעור בפועל, בלי כרטיס אשראי. אחר כך בוחרים מנוי בתשלום, ומבטלים בכל עת.
- על איזה מכשיר לומדים?
- בכל מחשב, טאבלט או טלפון עם דפדפן ומיקרופון. אפשר גם להתקין את האתר כאפליקציה במסך הבית.
רוצים לנסות?
נכנסים, כותבים שם וכיתה של הילד, והשיעור מתחיל. 45 דקות שיעור חינם, בלי כרטיס אשראי.
להתחיל בחינםשיעור פרטי עם AI: מה זה ואיך זה עובד







