שימוש במערכים גלובליים בGO

[nigun]

אני מאחסן משתנים בתוך מערך גלובלי (דהיינו שכל הט'רדים משתמשים באותו מערך)
הבעיה היא אסור לקרוא ולכתוב בו זמנית או לכתוב שתי כתיבות בו זמנית לאותו מערך
התחלתי להוסיף נעילות לפני כל פעולה במערך

            lock.Lock()
             G.maps[foo] ="foo"
            lock.Unlock()

            lock.RLock()
            foo := G.maps[foo]
            lock.RUnlock()

אבל זה קצת מקשה על הקריאות של הקוד (זה בסדר פעם אחת ,אבל עשרות פעמים זה חופר)
האם יש דרך יותר אלגנטית לעשות את זה?

[dovid]

ראשית למה אסור? באיזה בעיה אתה נתקל? הבעיה היא גם בקריאה?
שנית, בשביל זה יש בתכנות מושג ששמו מתודה או פונקציה, יש את זה גם בגו.

[nigun]

@dovid
פשוט לקחת לי שעה למצוא את כל המקומות שאני קורא למערך (לפעמים זה בתוך IF או בתור ערך בקריאה לפונקציה)
וזה קצת תיסכל אותי + הקוד כבר לא נראה כ"כ קריא
אז תהיתי אולי אני סתם עושה סיבובים (במיוחד שאני לא רוצה להשתמש באותו נעילה לכל המערכים אלא נעילה לכל מערך או לכל קבוצה אם הם קשורים בשימשו שלהם)
ויש משהו יותר חכם
@dovid אמר בשימוש במערכים גלובליים בGO:

שנית, בשביל זה יש בתכנות מושג ששמו מתודה או פוקנציה, יש את זה גם בגו.

כל פעם אני עושה פעולה אחרת
על מערך במבנה אחר (אני לפעמים משתמש במפה בתוך מפה בתוך מפה)
וסוג אחר (סטרינג/אינט)
מה אני ירוויח מלהכניס את זה לפונקציה?
אני אצטרך כנראה לעשות פונקציות כמספר הקריאות

במחשבה שניה
אני כן ירוויח משהו אם אני מכניס את זה לפונקציה אנונימית
כי ככה אני יוכל לבטח את השיחרור נעילה
גם במקרה של panic
(אבל האמת היא שזה סתם בית חולים מתחת לגשר
אני צריך ללמוד לכתוב קוד שאף פעם לא יגיע לNIL
לא משנה מה יקרה)

func() {
	c.mu.Lock()
	
	defer c.mu.RUnlock()

            foo := G.maps[foo]

	}()

[dovid]

לא הבנתי, יש מצב שאתה מסביר לי מקרה אחד, לדוגמה, שבו יש בעיה בלי נעילה?

[יוסף בן שמעון]

@dovid
לפי התיעוד צריך לנעול בזמן קריאה וכתיבה
וכאן יש דוגמאות לבעיות (שלא ניסיתי אותם)
חיפשתי קצת על האפשרות לעשות פונקציה לקריאה וכתיבה, זה באמת מסובך להעביר ארגומנט מפה עם טיפוסים דינמיים, להבנתי זה לא אפשרי אלא אם כן מראש מאתחלים את המפה כטיפוס דינמי.
באמת מסתבר שיש לזה איזה פתרון איפשהו

[dovid]

אז אם ככה חייבים לעשות מחלקה עוטפת לכל הmap, ובכל פעולה לעשות נעילה לפי מפתח שיועבר לפונקציה.
בכלל גישה למערך או לכל דבר אחר מהרבה מקומות בקוד בצורה לא מרוכזת ומפוקחת היא סיבה לעבור למחלקה עוטפת.

[yossiz]

https://godoc.org/sync#Map
https://github.com/orcaman/concurrent-map
https://www.google.com/search?q=go+thread+safe+map

[nigun]

@yossiz
https://github.com/orcaman/concurrent-map
נראה פתרון טוב
אבל לא ברור מה היציבות והביצועים שלו
נראה לי שווה בדיקה (על אף שאני לא מעיז להכניס את זה לפרודקשן)

עריכה: אני לא רואה אפשרות ליצור מפה בתוך מפה
אפשר להשתמש לכאורה רק במפתחות סטרינג
https://pkg.go.dev/github.com/orcaman/concurrent-map?tab=doc

[yossiz]

@nigun סתם מחשבה, אני לא יודע אם במקרה הזה אני צודק

המהנדסים של GO הם מהנדסי תוכנה מנוסים, השפה לא נוצרה ביום אחד, וזה עבר הרבה תכנון. אם אתה נתקל בדבר שלדעתך אמורה להיות פעולה בסיסית ונפוצה, אבל זה מסורבל לעשות, וכנראה לא הכי נתמך בשפה, אתה אמור לחשוב לעצמך " אולי אני עושה פה משהו לא נכון...".

במקרה הזה, אני יכול לנסות לנחש מה אתה עושה לא נכון.
(ואגב המהנדסים מגלים מה עומד מאחורי ההחלטה לא לעשות map כסוג שהוא thread safe, והם טוענים שזה שימוש לא נפוץ)

נראה לי שבתוכנה עם מקביליות שיש בו global state שנגיש לכל ה-thread-ים
א) אתה אמור לעטוף את ה-state הזה במחלקה עוטפת ו-
ב) אתה אמור כמה שאתה יכול לצמצם את הגישה ל-state הגלובלי עד כמה שאפשר לקטע קוד אחד, שלא יהיה מפוזר בהרבה מקומות. (שזה כולל שימת כל ה-state הגלובלי באובייקט אחד. וגישה אליו רק באמצעות פונקציות מוגדרות מראש)

האמת היא שנראה לי שכך ממליצים גם בלי הבעיה של גישה מקבילה.

[nigun]

@yossiz אמר בשימוש במערכים גלובליים בGO:

אם אתה נתקל בדבר שלדעתך אמורה להיות פעולה בסיסית ונפוצה, אבל זה מסורבל לעשות, וכנראה לא הכי נתמך בשפה, אתה אמור לחשוב לעצמך " אולי אני עושה פה משהו לא נכון...".

לכן פתחתי כאן את הנושא

נראה לי שבתוכנה עם מקביליות שיש בו global state שנגיש לכל ה-thread-ים
א) אתה אמור לעטוף את ה-state הזה במחלקה עוטפת ו-
ב) אתה אמור כמה שאתה יכול לצמצם את הגישה ל-state הגלובלי עד כמה שאפשר לקטע קוד אחד, שלא יהיה מפוזר בהרבה מקומות. (שזה כולל שימת כל ה-state הגלובלי באובייקט אחד. וגישה אליו רק באמצעות פונקציות מוגדרות מראש)

האמת היא שנראה לי שכך ממליצים גם בלי הבעיה של גישה מקבילה.

אני ירחיב קצת על המקרה שלי אולי זה יעזור
אני בונה מערכת טלפונית באסטריסק בשילוב אתר
באתר מתצבע ריענון כל שניה שואב נתונים על הנעשה בטלפון
אני מנסה לשמור על שימוש במשאבים כמה שיותר נמוך כי בשונה מאתר רגיל שבו אם הCPU קופץ לך לשתי שניות לא קרה כלום
אצלי זה יפריע למהלך השיחה (בהמשך אני ינסה להפריד את זה לשני שרתים, אבל כרגע זה המצב)
לכן אני מעוניין שומר את כל הנתונים ה"זמניים" בזיכרון ולא בדיסק
זה מסתכם בכ5-6 מערכים, חלקם הם סוג של עץ של מערכים עם 2-3 צאצאים( לא זוכר את הכינוי של זה)
אבל הקריאה וכתיבה נעשה מהרבה מקומות (כמובן מהאתר אבל גם מהרבה פינות ברחבי הצד הטלפוני)
בכל גישה למערך אני לרוב עושה משהו אחר (הוספה, עריכה,קריאה, הוספת איבר שהוא מערך)
אני לא רואה הדרך לעשות את זה בצורה גלובלית
ואני מודע לעובדה שזה לא מקרה נפוץ
כי לרוב או שפשוט משתמשים במסד נתונים או שמשתמשים במערך אחד או שניים אם צריכים לשמור משהו בזיכרון
אז יתכן מאוד שאני פשט צריך להוסיף הרבה נעילות ולהשלים עם זה

(אגב עשיתי משהו שאולי קצת טיפשי, ועשיתי נעילה על פונקציה שלמה שממירה את כל המידע לJSON , שכולל לפעמים גם מידע מהמסד נתונים, ובכך אני אולי יוצר נעילות מידי ארוכות וזה יתקע את שאר הערוצים
אולי בהמשך אני יעשה נעילה יותר ספציפית)

[dovid]

@nigun השאלה שלך בחלקה ספציפית לecosystem של GO, ואני לא מכיר פה מפתח בGO (אתה בעיני מישהו שהגיע לשם בטעות, אם אתה זוכר איך הגבתי לך ביום שביררת על השפה הזו).
כמו כן כל עוד הלימוד שלך יהיה ספציפי על "שיחות" אני חושב שאתה תתקשה לראות את התמונה המלאה ותישאר תקוע מאוד.

על כל פנים בחלק הארכיטקטי, אם נראה לך שאני עלול לעזור אנא פרט על אופי הקשר בין אסטריסק לGO, מה זה נקרא "באתר מתצבע ריענון כל שניה שואב נתונים על הנעשה בטלפון", מי זה האתר, GO מגישה אותו? מי מרענן את מי? איך מתבצע הריענון? מי כותב לדיסק בקשיח שני המערכות או רק אחת? אני נורא מקוה שאבין טוב כי זה כמעט אף פעם לא קרה
יש לציין שכל המושג "שיחות" ואסטריסק לא מוכר לי בכלל אז סליחה על הקושי בלהבין את ההסברים...

[dovid]

אגב בנושא ההוא אני המלצתי לך על node.
אני חושב שגם כעת בשלב זה עדיין כל רגע שאתה בGO אתה טועה, אם תילך לנוד תרגיש גן עדן ביחס לGO, שלא מביאה לך שום ייתרון.
ואת זה אני חושב כאחד שלא מחזיק כ"כ מנוד.
למה זה חשוב לי לומר את זה? כדי להסביר לך איזה תחושה עושות לי השאלות שלך בGO.

[אהרן]

@dovid

אז בסוף ברח לך..

אין מה לעשות לחברים פה בפורום אכפת אחד מהשני מכדי לעמוד במשימת התעלמות "כי אמרנו לו".

[dovid]

@אהרן אמר בשימוש במערכים גלובליים בGO:

אין מה לעשות לחברים פה בפורום אכפת אחד מהשני מכדי לעמוד במשימת התעלמות "כי אמרנו לו".

אתה דן אותי לכף חובה.
כתבתי במפורש שהוא מפסיד כל רגע, זה לא נקרא אמרנו לך, אלא זה נקרא לעזור.

[nigun]

@dovid
אני יסביר טיפה
אסטריסק זה תוכנה (שכתובה בC) שמאזינה לפורט 5060
ומקבלת שיחות טלפון ומנהלת אותם לאורך כל השיחה (כל שיחה זה ערוץ נפרד)
ניתן לתכנת את אסטריסק עם שפה פינימית שלהם או עם API שנקרא AGI
בAGI אני כותב סקריפט (לא משנה באיזו שפה) שמפעיל פקודות של אסטריסק ,וכן מקבל מידע מאסטריסק
יש גם FastAGI שזה שרת TCP שמנהל את כל השיחה מעל TCP במקום ליצור מופע חדש על כל שיחה.

עכשיו נעבור לחלק של GO
אני מחזיק אפליקציה שמפעילה שני שרתים TCP+HTTP(כך שיש לי בשימוש על המכונה אסטריסק+GO+mysql, וזהו)
ואני מגיש לאתר את המידע מהאפליקציה עם JSON (האתר נבנה ע"י מפתח צא לקוח אחר עם JS)
וכן יש לי ערכים שאני רוצה לשתפף בין הערוצים

למשל אם אני רוצה להגביל כניסה לשלוחה מסויימת לפי מספר המאזינים שהוגדר ע"י המנהל באתר
אז באתר אני שולח בקשת פוסט עם הערך 100, ואז אני מגדיר במערך ששלוחה Y = 100
ואז כל מאזין שמנסה להיכנס לשלוחה Y, אני בודק אם כמות המשתתפים גדול מהמגבלה,
ואם לא אז מעלה באחד את הערך במערך נוסף שמחזיק את מספר המאזינים בשלוחה
ומגדיר גם הורדה באחד מהמערך ביציאה, עם defer (שבעצם מבטיח לי שהפעולה תתבצע בסגירת הפונקציה),
במקביל אני מגיש לאתר את המערך של מספר המאזינים בכל השלוחות (ע"י ריענון כל שניה)

למעלה כתבתי שאני לא רוצה להשתמש במסד נתונים לכל זה (אולי אני טועה, אבל מסד נתונים נראה לי בזבוז במקרה הזה)
וכפי שאתה רואה נוצר כאן שימוש בהרבה מערכים
וכל עוד אני לא משתמש בנעילות זה ממש כיף
אבל הנעילות קצת הרס לי את החגיגה.

לגבי הויכוח העתיק go vs node

ואני לא מכיר פה מפתח בGO (אתה בעיני מישהו שהגיע לשם בטעות, אם אתה זוכר איך הגבתי לך ביום שביררת על השפה הזו).

אני מכיר כאן מפתחים שעוזרים הרבה בGO (בשונה בהרושם שקיבלתי בזמנו).

אגב בנושא ההוא אני המלצתי לך על node.
אני חושב שגם כעת בשלב זה עדיין כל רגע שאתה בGO אתה טועה, אם תילך לנוד תרגיש גן עדן ביחס לGO, שלא מביאה לך שום ייתרון.

למה אתה דן את GO לרעה (במיוחד שאתה מודה שאתה לא מונח בזה עמוק)?
תכלס מה רע בGO? ומה כל טוב בנוד?
האם נראה לך שאין שום יתרון של GO על נוד?

אגב מכל מה שכתבו לי כאן אז, הדבר היחיד שאני מסכים איתו זה שגו זו שפה שהיא strict typing
וזה קצת מעבצן לפעמים למי שבא משפות כמו PHP, אבל זה ממש לא סיבה לעזוב את GO.
אני לרוב נהנה מהגישה לביטים הנמוכים, ונראה לי שלמדתי (ועדיין לומד) מזה הרבה על איך זה עובד מאחורי הקלעים
בPHP למשל (אני לא יודע איך זה בנוד) המפתח לא יודע מה הוא עושה מאחורי הקלעים, וגם אין לו איך לדעת
לאנשים שמתעסקים בתכנות בעיקר מתוך סקרנות , זה גן עדן.
לעומת זאת, נוד נוצר מתוך זה שJS זו שפה פופולארית בצד לקוח
ומישהו הציע בא נשתמש בזה גם בצד שרת, אמנם זו לא שפה עם הסינטקס הכי חכם
אבל זה עדיף, כי זה חוסך ללמוד שפה חדשה.
אבל למי שלא מכיר JS בכלל (כמוני)
איזה סיבה יש ללמוד נוד?
הניהול של פעולות אסינכרוניות בנוד, הוא גהנום לעומת GO (סך הכל להוסיף את המילה GO לפני הפונקציה)
אני לא מכיר את נוד לעומק אז אני לא יכול להמשיך להשוות
אבל אני לא מוצא שם שום דבר משכנע
אדרבה אם מישהו ימצא? אשמח לשמוע.
(עריכה : אני מחפש בגוגל move from go to node ואני מוצא הרבה פוסטים על כאלו שעוברים מנוד לגו
ואני לא מוצא מישהו שבכלל מעלה את האופציה לעבור מגו לנוד, לא שזה קובע, אבל זה אומר דרשני)

ואת זה אני חושב כאחד שלא מחזיק כ"כ מנוד.

אז על איזה שפה אתה כן ממליץ?

אני נורא מקוה שאבין טוב כי זה כמעט אף פעם לא קרה

יש לנו איזה קטע שאתה לא מבין את השאלות שלי (ולפעמים גם כועס טיפה)
אני עדיין לא יודע איפה הנקודה? האם הכתיבה שלי לא ברורה? השאלות שלי מוזרות/הזויות?
אולי הצורת מחשבה שלי מוזרה? (במקרה הזה אין לי מה לעשות, ככה אני)
אם יש לך הערות מה אני צריך לשפר? תכתוב ,אני אשמח לשמוע.

[dovid]

@nigun פירטת נהדר, הבנתי המון. חסר אבל הצורה של הקשר בין GO לאסטריסק. זה נעשה פר שיחה, עם TCP ממושך לכל אורכה? אם זה אכן TCP, אז האם הGO הוא השרת או האסטריסק?
באופן כללי מה שהתלוננתי שאני לא מבין זה בכלל בעיה שלך, זה פשוט הפרשים גדולים בין העולמות של הפיתוח שלנו. אני כן כתבתי את זה כדי לעודד אותך להסביר ברור יותר.

[nigun]

@dovid
כל שיחה יוצרת חיבור חדש לTCP (שנשאר בחיים עד סוף השיחה)
GO הוא השרת, אסטריסק הוא הקליינט.

[dovid]

לגבי ה"ויכוח" על נוד. @אהרן צדק שיצר ה"אמרתי לך" הכריע את הכף. לא בגלל שזה לא כדאי כעת שתעבור, זה כדאי נורא, אלא בגלל שזה די ברור מראש שלא תעבור.
אתה רוצה שכנועים למה לעבור לנוד וגם אז ביקשת. אני כעת רגע יותר מאז אז אני אפרט שוב את מה שכתבו לך שם עם תוספת.
אני אשוב ואאשים אותך ב"הרגשה טובה עם עצמך" בשלושה מישורים:
א. זה מה שמקרב אותך והביא אותך לGO, לא הגעת משמה בתום לב או מ"היכרות ראשונה". אתה בנח להיות בשפה שהיא בחזית הטכנולוגיה, וממילא יש לך "למה כן" שצריך כעת לאסוף לעומתו "למה לא".
ב. הטענות שלך לגבי בעד ונגד GO, מלאות בטענות שגויות לחלוטין, שבמבט של שאלות תום ללא הרגשת "מייבין" לא היית טועה בהם.
ג. מהיכרות עם הנועזות שלך מצד אחד בGO, והבריחה מדברים פשוטים כמו JS (למשל בפרונטאנד) מלמדת על קושי להיות "תלמיד". אם אתה רוצה להיות מתכנת טוב, תהיה תלמיד כל חייך! אין בזה כל בעיה.
מילים קשות, אני מסכים. לא מבקש סליחה, כי אני בוטח בחוזקך לקבל מה שאני אומר אחרי הכנות בה ביקשת לקבל את דעתי שוב (תודה, באמת!)

למה הטענות כ"כ שגויות?
א. דוגמה מצויינת לכך ה"דרשני" לגבי ההבדלים בין שני חיפושי גוגל שערכת. אחד בודקים כמה עוברים מנוד לגו והשני להיפך. עבור מי כותבים מאמר כיצד לעבור מX לY? עבור כאלה שעוברים מהשפה הראשונה שלהם או עכ"פ שפה שהם נטועים בה כ"כ שכל דימוי צריך להיות לו מקבילה אליה. ובכן כל מי שנמצא בGO, ומכיר אותה טוב (לעזור פה בפורום זה לא היכרות) מכיר לפחות עוד כמה שפות רובם טוב יותר מGO שהיא חדשה מאוד (סביר מאוד שגם שאת נוד).
ב. אתה מדבר על הבעיה של האסינכרוניות בJS. כאילו אתה מכיר ויודע אתה אומר שבJS זה גיהנום ליד GO. שוב אל תדבר במה שאתה לא מבין ולא יודע, האסינכרוניות בJS היא נהדרת. יש בה חסרונות קטנים שמבטיח לך שייקח זמן עד שתזכה לטעום מהם, תהיה מודע לרמה/צרכים שלך!
מה שמפורסם לשלילה על האסינכרוניות של JS מחולק לשניים. אחת למתחילים שלוקח להם זמן להבין את הקונספט (של הcallback), בפרט אם הם מכירים שפה אחרת בה לא היה את המושג, הקונספט הזה גם קיים בGO וגם שמה צריך להכיר אותו. השניה זה הבעיה של הקאלבקים המקוננים, אולי מצאת את התלונה הזו בכל מיני מאמרים עתיקים, למה אתה "מאמץ" בעיה שלא נתקלת בה בחיים. היא כיום כבר לא קיימת בזכות הPromise והAsync.
(אתה כותב שאתה לא מכיר את נוד לעומק. לא! אתה לא מכיר את נוד בכלל בכלל בכלל. אם להכיר זה להבין איזה קוד שאתה רואה, אני מכיר עשרות שפות תכנות. להכיר זה לעבוד בפרודקשיין. לעומק גם אני לא מכיר את נוד, וכמעט שום דבר אני לא מכיר לעומק).
זהו גמרתי לרדת עליך (מקוה שתראה מזה הרבה תועלת!), כעת לגופו של עניין, מה טוב בנוד, ומה לא בGO.
זה בעצם חזרה קצת על מה שנאמר יופי בנושא ההוא שפתחת, רק שאדם מחליט מה הוא רוצה להבין ומה לא.
א. nodejs היא קלה מאוד לפיתוח ולהבנה.
ב. לnodejs תפורה לספק שירות וובי (הhttp וגם express הם הא' ב' של נוד, עם תשומת לב עצומה. ועיקר הפיתוח בנוד נעשה איתם), כל דבר שם יהיה פחות קוד מכל מקום אחר כמעט לעניין זה.
ג. nodejs יש קהילה תומכת וחזקה יותר. גם בפורום הזה, וגם בסטאק (פחות מחמש שאלות ביום בממוצע בGO נראה לי, זה אפס ענק) וגם בספריות וחבילות (תחשוב על רעיון לחבילה שאין עדיין בNPM). זה משליך על אין סוף דברים, למשל לבחור חבילה בGO זה מסובך, כי אין מאה מיליון שבחרו+תיעדו עבורך.
חילופיהן בGO. כעת סיבות נוספות שמתמקדות בלמה לא GO:
א. GO מקשה את החיים לטובת פיתוח נכון.
לדעתי המטרה לא תושג במקרה שלך אלא היפוכה. הקשיחות של GO מופנית בעיקר לתכנות צוות, ושהבינו טוב טוב מה היא רוצה (אחרי היכרות עם כמה שפות תכנות הרבה זמן).
ב. GO יש מקביליות אמיתית שאתה לא עושה בה שימוש. מקביליות אמיתית היא רק נזק כשלא צריך אותה. למה אתה לא צריך אותה? כי הדבר היחיד בו צריכים מקביליות אמיתית זה משימות מעבד אינטנסיביות, זה לא הבעיה שלך, לא כן?
ג. בGO צריך יותר קוד כדי לכתוב כמעט כל דבר. GO שמו דגש על פשטות והרגו כמויות רבות של קיצורי דרך.
ד. GO קיצצה מהOOP אבל מה שהיא השאירה חובה להשתמש ולהכיר (כי בGO כמו בGO החליטו חזק איך לעשות כל דבר). כיון שבניית מחלקות בצורה חכמה היא משימה לא קלה, אתה לאט לאט מתכנת באופן שGO לא בנויה אליו.

זהו, אם אתה עובר לNODEJS, אתה מקבל ראשון את פרס dovid לחשיבה מחדש

עריכה: שאלת מה אני ממליץ, השאלה למי. ללימוד תוך כדי עבודה, אני ממליץ על nodejs כמו שעשיתי. ללימוד ארוך טווח ורחב היקף אני ממליץ על C# שיש לה גם את הטיפוסיות הקשוחה וגם את הספריה של NET, וגם את השפה הנוחה והמשוכללת והמתוחזקת ביותר לדעתי. במובנים רבים C# קשה כמו GO למתחילים ובעיקר ב"תוך כדי תנועה".

[dovid]

@nigun הבנתי כעת את הרעיון.
כל שיחה יוצרת שיחת TCP מול הGO, שמחזיק מידע על כל השיחות.
זה מבנה מאוד רגיש, אתה בעצם בנית כפיל לאסטריסק. אני צריך עוד לחשוב על זה.
מה האסטריסק "אומר" לך ומה אתה יכול לענות לו? הסיבה שהוא יוזם את זה זה פקודה שלך או שזה יכולת מובנה?

[nigun]

@dovid
מתקפות זה טוב
אין לי בעיה עם זה

1. סליחה על המשפט "אני לא מכיר את נוד לעומק", זה באמת נכנס בטעות.
2. את GO בחרתי אחרי שפשוט לא הצלחתי להבין את הקטע בcallback, וכמעט נשארית בPHP רח"ל
   אחרי שהצצתי קצת בGO וראיתי כשל כך קל לעשות קוד אסינכרוני, קפצתי על העגלה, ואמנם מידי פעם אני מציץ על נוד
   אבל משום מה זה אף פעם לא מדבר אלי.
3. ממה שאני רואה בקהילה של GO, לא נראה שיש שם כ"כ הרבה שנוד זו השפה הקודמת שלהם
   ובכל מקרה את ה"ראיה, מחיפוש בגוגל הבאתי בתור הערה ולא בתור קביעה , פשוט ראיתי מנהג של כל מיני מתכנתים שכותבים פוסט אחרי שהם עוברים טכנולוגיה, ציפית למצוא משהו כזה על מעבר מGO לנוד והתפלאתי שלא מצאתי כזה
   זה מעלה אצלי חשד שאין כזה מעבר, ואם GO נורא למה אף אחד לא עושה את זה ? (או יותר נכון למה אני לא מוצא אזכור לזה?)
4. קהילה זה דבר מאוד טוב
   אבל אני לא מרגיש שיש לי פחות תמיכה בGO מאשר בPHP,
   אז למה שאני יחפש עכשיו לעבור לשפה אחרת רק בגלל ששואלים עליה יותר בסטאק?
5. מה רע במקביליות אמיתית? (כל עוד לא יוצרים מקביליות על כל צעד ושעל)
6. אני דווקא התחברתי לפשטות של GO, זה נראה לי עניין של טעם.
7. אני אמנם נתקל מידי פעם בקשיחות של GO, אבל זה לא מתסכל אותי משום מה
   מבחינתי זה לימוד שבסוף רק יחדד אותי.
8. אני לא מוצא כ"כ חבילות חסרות בGO (לפחות לדברים שאני עוסק בהם).

בקיצור כדי לעבור שפה ,אני צריך להשקיע שעות בלימוד קונספטים חדשים
אם אין לי משהו שכואב לי כיום או שאני יראה משהו מדהים בשפה אחרת ,אני לא יזוז כ"כ מהר
אבל אני רוצה לשמוע מה נוד שונה מGO, כדי שאם אני יתקע יום אחד בGO אני ידע האם נוד יפתור לי את הבעיה.

לגבי אסטריסק
אסטריסט אומר לי שערוץ חדש התחבר
אני אומר לו הפעל קובץ, הוא אומר לי "הופעל" והתקבל הקשה XYZ
השיחת TCP היא סינכרונית
יש לאסטוריסק עוד API אסינכרוני, אבל אני רק שולח שם מידי פעם פקודה
ולא יושב על זה לאורך כל השיחה.