רברס עם פלטפורמה: יוני 2024

פרק מספר 472 של רברס עם פלטפורמה - באמפרס מספר 83, אחרי כמעט שנה של בצורת.

רן, דותן ואלון עם סדרה של קצרצרים שתפסו את תשומת הלב בתקופה האחרונה - בלוגים מעניינים, כלים ב-Open Source, כל מיני Utilities למפתחים, Database-ים, שירותים, או סתם דברים שיכולים לעניין אותנו.

01:10 מבוא

(רן) הפעם, בגלל שהרבה הרבה זמן לא הקלטנו

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

אה - ו-Kudos על האפקטים ל-Riverside . . . .

02:30 רן

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

הראשון שבחרתי זה iTerm והשימוש ב-Z shell - דבר ראשון כשאני מקבל Mac חדש זה מתקין עליו iTerm, ככה גיליתי . . .

ניסיתי גם אחרים, זאת אומרת חוץ מהטרמינל ה-Default-י של Mac, שקיים שם תמיד.
יש עוד אחד, על מה דיברנו? . . . דיברנו על עוד איזשהו אחד שיצא לו מזמן, שאני דווקא פחות אהבתי, זוכרים איך קוראים לו? Warp!, נזכרתי.
(אלון) שכתוב ב-Rust ,יש לציין . . .
(רן) . . . והוא גם הומלץ פה בפודקאסט - זאת אומרת, מה זה “הומלץ”? הבחנו בו, ואני ניסיתי אותו במשך לפחות איזה חודש, ובסוף פחות התחברתי
אבל האמת היא שהגרסה האחרונה של iTerm מאמצת ממנו פיצ'רים, ככה ראיתי - התקנתי לא מזמן את iTerm, והדמיון מתחיל ככה לעלות, אז כנראה שהיו שם כמה פיצ'רים נחמדים.
אז Anyway, זה iTerm ו-Z shell, ו-Oh My Zsh - זה אחד הדברים הוותיקים שאני מתקין כמעט בתור דבר ראשון ב-Mac.
אבל דותן, הבחנתי שאתה דווקא מעדיף את Fish . . .
(דותן) כן . . . אני חייב להגיד קודם כל בנושא הטרמינלים, שאני די בטוח שזו פונקציה הפוכה לגיל . . . . ככל שאתה יותר צעיר, ככה אתה אוהב טרמינלים יותר “מודרניים”, כמו Warp, וככל שאתה יותר זקן, אין לך כוח לשטויות האלה . . .
(רן) כן, כן . . . . אז למשל, אחד הפיצ'רים החדשים ב-iTerm החדש שהתקנתי זה שכשאתה עושה דאבל-קליק, אז במקום לעשות Select - כאילו, במקום לעשות Copy אוטומטית - הוא מציע לך איזשהו “משהו אינטליגנטי” . . .

וזה עיצבן אותי, אז מיד כיביתי את זה . . .

אז כן, בקיצור, אני חוזר לפיצ'רים הבסיסיים, מה שאני כבר רגיל . . . אולי זה עניין של הרגל, אולי זה סתם עניין של פשטות, אבל כן, לגמרי . . .
(דותן) זה גם יכול להיות מכיל - אני למשל עכשיו עשיתי Setup ל-Mac חדש, ובפעם הראשונה לא ישבתי ועשיתי את” הטקס” של להתקין את כל התוכנות שאני רוצה, ולקחת את ה-dotfiles וכל הדברים האלה, קנפוגים על קנפוגים (Configurations) . . . פשוט לא עשיתי שום דבר מזה.

לקחתי איזה שתי תוכנות בסיסיות שאני רגיל - וזהו.

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

והאמת שזה עושה איזשהו משהו טוב, כי אז יש . . . אחד הדברים השנואים עליי דווקא במהלך עם השנים, זה Z shell - לבוא ולקנפג אותה עם Oh My Zsh וכל ה-Plug-in-ים, שזה יכול להיות טקס מייגע, למרות שיש לך כבר את כל הקונפיגורציות.
ומה ששמתי לב הוא שאחרי הקונפיגורציות, ה-Terminal שלך הוא איטי . . . - בגלל שזה Z shell וכל מיני כאלה.

אז אמרתי, טוב, זה הזדמנות לתת ל-Fish ניסיון, ובגלל שלא באתי עם כל המטענים שיש לי ב-dotfiles שלי והתחלתי מחדש, זה הלך חלק.
עכשיו, החיסרון ב-Fish זה שאתה לא יכול לזרוק עליו Shell-סקריפטים רגילים - אם יש לך אוסף של כל מיני “קשקושים שצברת עם השנים”, כל מיני קונפיגורציות, אז אתה לא יכול.

כי השפה שלו היא קצת שונה, ואפילו ה-Command-ים הם טיפה שונים.

אבל בסוף, לא יודע, אני עובד עם Fish shell, אני חושב בלי כלום - וזה 80% מכל ה-Setup שלי ב-Oh My Zsh.

ואת ה-20% הנותרים אני פשוט לא עושה . . .

(רן) ועם iTerm, עדיין?
(דותן) כן, iTerm. ניסיתי עכשיו Alacritty, שזה טרמינל יותר Light-weight, גם מבוסס Rust, ולהגיד את האמת, אני לא רואה הבדל . . . .

הרי הביצועים, זה מה שכאילו כולם אומרים - לא רואה הבדל בביצועים.

(רן) אוקיי . . . . יאללה, נקסט.

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

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

[מזה שזו ההשלמה שקיבלת, סביר שמישהו עשה את השטות הזו וגם כתב את זה במקום מספיק פומבי כדי ש-GPT התאמן עליו…]

אבל דווקא ברוב המקרים אני מוצא שזה לא רק שזה עושה אותי פרודוקטיבי - דרך אגב, בעיקר בתיעוד ודברים כאלה, זאת אומרת כתיבה של טקסט - לא רק שזה עושה אותי פרודוקטיבי, אלא שזה גם מלמד אותי לפעמים דברים חדשים, שיטות שלא הכרתי.
אז אני אוהב את קו Copilot. משתמשים?
(אלון) אני מאוד אוהב את Copilot . . .
(דותן) אני לא . . . . אבל אני עושה דבר שונה - אני לא “מתנגד AI”, אני כאילו כותב קוד, וברגע שאני מרגיש שהקוד הוא קצת “מגעיל”, או ש”הלך לי קשה” לממש משהו - אז קודם כל אני מסיים את מה שרציתי לעשות, ואז אני לוקח את כל הדבר הזה וזורק את זה ל-ChatGPT-4, ואומר לו “איך היית משפר את זה?” ו”מה היית עושה?”.

והרבה פעמים יוצא לו דווקא לתת לי כל מיני זוויות מעניינות . . . . אני לוקח את זה - וחוזר חזרה.
במקום של ה”לייצר קוד” נכוויתי כמה פעמים . . . היו לי ניסיונות כאלה, לייצר נגיד פונקציה או משהו כזה, וזה היה נראה ממש טוב, אמרתי “וואלה, איזה יופי! תאמין לי - הדבר הזה מדהים!” - וחודש אחרי זה אני קולט כל מיני באגים מוזרים . . . .
והאפקט הפסיכולוגי הוא שדווקא החלק שיוצר על ידי AI - זה החלק שלא בדקתי ב-Codebase . . . . כי אמרתי “אה, זה יוצר, זה ‘ברזל’, זה נראה טוב זה כאילו . . . “, ובסופו של דבר היה שם איזשהו באג מאוד עדין ואיזוטרי כזה, שה-AI ייצר, בביטחון מעולה כמובן - וזה מה שהכשיל אותי.
אז אחרי פעמיים-שלוש כאלה, אמרתי שאני עובר ל-Mode שבו אני כותב, נותן ל-AI לראות מה הוא חושב - ואז או לוקח הוא לא לוקח את השיפורים שלו.

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

כאילו, “תכתוב לי טסטים על הקוד” - ואתה מקבל “ערימה של טסטים”, בדרך כלל סבבה.
או כותב שני טסטים ואומר לו “תכתוב לי עוד כמה כאלה!” - כאילו, עוד טסטים, תבדוק עוד דברים - אז זה גם עובד מעולה.

ודבר נהדר - זה לא ה-Copilot, זה דווקא ה-ChatGPT - זה ה-Boilerplate.

כלומר זה לא ה-Boilerplate המעצבן של פרויקט, אלא כשאתה רוצה עכשיו לעשות איזה אלגוריתם או משהו, אז אתה אומר לו “תכתוב לי”.
ואתה מתחיל ממשהו בסיסי - ואחרי זה משפר אותו

יצא לי מקרים שהיה לנו איזה אלגוריתם שרצינו לכתוב ואמרנו “מורכב מדי” - אז כאילו לא התעסקנו עם זה בכלל, כי אמרנו “עכשיו איפה נבנה Complier-ים ועצים וכל מיני דברים “, אז אמרנו “בוא נסרוק את זה עם ChatGPT”.

ואז איזה שעתיים שיחה איתו - והיה לנו כבר קוד עובד.
זה לא עוד לא היה Production, עוד אחרי זה היה צריך כמה ימי עבודה כדי באמת לגרום . . . to” Productionize it” - אבל זה חסך, בוא נגיד, השיחה איתו חסכה Research של שבועות, שאם הייתי נותן למישהו “בוא, תתחיל לכתוב Complier, ואיך אתה מפרק עצים ומקרים וטה טה טה . . . .” - וזה עשה את זה מעולה, עם טסטים, ובאמת . . . .
אז יש מקרים מדהימים.

(דותן) כן כן - זה, אחד לאחד, גם אצלי.

כאילו, “ה-Brainstorming יחד איתו” עובד ממש טוב.
גם אם יש לך או גם אם היה לך את הפתרון בראש, ופשוט היית צריך “מישהו” במרכאות לדבר איתו - ואז להוציא את זה מהמוח שלך - זה עובד טוב.

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

מצד שני, אני מסכים שהאיכות היא טובה, בדרך כלל.

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

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

וזהו, ממש גיליתי שאני כאילו סוג-של מפתח לפי זה - זאת אומרת, כותב את ה-Template מסביב, ואז מחכה להשלמות ורואה מה יוצא.

מחליט אם אני לוקח או לא לוקח - ועושה איזה קצת Fine-Tuning.

אבל אני לגמרי מסכים ששגיאות והזיות וכאלה - זה דברים שיכולים לקרות וכואבים.

במיוחד בשפות שהן Untyped - אז שם צריך להיזהר עוד יותר.

אז כן - לא ללכת “על עיוור”.
טוב יאללה - נמשיך.

(רן) אז הכלי הבא שגיליתי שאני משתמש בו מלא, ואני גם חושב שהוזכר ממש פה בהתחלה, זה JQ

זה כלי CLI ש”מפרסר” (Parsing) מ-JSON, ויכול לבחור חלקים מתוך ה-JSON.
סופר-פשוט, סופר-שימושי - בקיצור, נחמד.
אני משתמש בו מלא ב-CLI, לפרק קבצים וככה לעבוד איתו.
אני זוכר שיש גם איזושהי גרסה חדשה שלו, שנכתבה ב-Rust - זה “JQ-משהו” . . . לא זוכר את ההמשך, שהזכרנו גם בפודקאסט [MiSawa/xq].
אבל לא משנה - מבחינתי ה-Performance שלו מספיק טוב, גם אם הוא לא הכי מהיר, אבל הוא מספיק סבבה למה שאני משתמש.
אז כן - גם אחד הכלים הראשונים שאני מתקין.

ובעולם אחר - נדבר רגע על ספר! אז לא הרבה ספרים נשארו איתי, אבל ספר אחד שאני מגלה שמדי פעם אני ככה חוזר אליו בשיחות ומזכיר ולוקח מנו רפרנסים זה ה-Google SRE Book.

ספר שהוציאו . . . זה למעשה כמה כרכים, זה לא בדיוק ספר, ולמעשה גם יש שתי גרסאות שלו, אבל זה נקרא ככה, “The Google SRE Book”, שבא ומסביר איך עושים - או לפחות איך עשו - Site Reliability Engineering בGoogle בתקופה שבו הוא נכתב.
ואחד - זה מעניין גם לדעת איך עשו, וזה גם מן הסתם דומה וזה קורה גם בחברות אחרות.
אבל יותר מעניין מזה זה עולם המושגים - מושגים כמו “Budget של שגיאות”, איך מגדירים “Uptime” וכאלה.

זה מושגים שהם שימושיים, שבין אם תסכים או לא תסכים עם ההגדרות שלהם - זה עדיין שימושי לבוא ולהגדיר ולכמת את הדברים האלה, ולהשתמש במושגים האלה ביום-יום.

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

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

(רן) כן, אז כל מי שנמצא בעולם של SRE מן הסתם - אבל גם מסביב, זאת אומרת, גם ראשי צוותים ובקיצור - אנשים שיש להם “שירותים באוויר” - מומלץ לקרוא ולפחות ככה להכיר את עולם המושגים שם.

(רן) הכלי הבא, שלדעתי גם הוזכר פה, האמת שקשה לזכור, אבל דיברנו לא מעט על כלים לניהול של Infrastructure as Code, והזכרנו אני בטוח הרבה פעמים את Terraform ודומיו. אני מגלה שאני דווקא יותר אוהב כלי אחר, שנקרא Pulumi, שהוא קצת יותר חדש, קצת יותר “צעיר” מ-Terraform.

הוא מנהל Infrastructure, זאת אומרת - אם יש לכם Deployment ב-AWS או ב-GCP או בפלטפורמות אחרות, אז במקום להשתמש ב-Console או במקום להשתמש ב-API, אתם יכולים להשתמש ב-Pulumi - או ב-Terraform או בכלים אחרים - כדי בעצם להגדיר את ה-Infrastructure שלכם.

איך נראה ה-VPC? איזה Instance-ים יש לכם? איך נראה Bucket ב-S3? - וכו'.

וזה מאוד נחמד, במיוחד כי אני עכשיו בתקופה שבה אני עובד עם כמה חשבונות AWS שונים - ואני רוצה שיהיו דברים דומים שם.

אז אני פשוט כל פעם עובר חשבון ועושה “Apply” - וזה עובד שם.

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

זאת אומרת, ב-Pulumi אתה יכול לכתוב ב-Python, אתה יכול לכתוב ב-JavaScript, אתה גם יכול לכתוב ב-Go - אבל אתה כותב “בשפה אמיתית”.
לעומת Terraform, שהוא דקלרטיבי (Declarative) - אתה כותב במשהו שנראה ככה קצת כמו JSON או YAML

והשפה שלהם, שהיא מצד אחד מאוד מתוחזקת ומשוכללת מצד שני היא שפה שונה, וצריך להכיר אותה.
ואם אתה רוצה לעשות Whatever, נגיד Reuse - לכתוב פונקציות, לעשות אבסטרקציות וכל זה - אתה צריך ללמוד את השפה של Terraform כדי לעשות את זה “נכון".

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

(אלון) אני רוצה להגיד על Terraform משהו - אני יודע שאני בדעת-מיעוט, אבל אני שונא Terraform. אני חושב שזה השטן.

והרשימת-טקסט הזאת שאי אפשר לדבג (Debug) אותה, אי אפשר לעשות לה טסטים - ורק אחרי שאתה עושה Deploy ב-Production אתה מגלה אם שברת משהו - זה פשוט אחד הדברים הגרועים שקרו לעולם התוכנה.
אני חושב ש-Pulumi כן פותר את הבעיה הזאת - אני, כאילו באמת, אני שונא את ה-Terraform הזאת, כי אי אפשר לבדוק שם דברים, ואיך אתה בודק? אתה מסתכל על ה-Plan ואז “בעיניים” ואתה בודק?

כאילו, אתה שם שם את זה ב-ChatGPT ומקווה שהוא יעלה לך על מה שפספסת?

אין לך איך לעשות לזה שום טסט, עד שאתה לא באמת מעלה את זה.

ואז - סיפור אמיתי, למשל - בשבוע שעבר מישהו העלה קוד, בטעות העיף הרשאות מאיזה Service ב-Production, והכל נעלם . . . .

עכשיו, לא הייתה שום דרך לבדוק את זה, וב-Plan לא שמו לב שהשורת-קוד נעלמה, כי היו שם כל מיני דברים - קורה, אי אפשר לתפוס הכל ב”להסתכל על קוד” - והופ! הכל הלך לפח . . . .
לא הכל הלך לפח - ה-Service הפסיק לעבוד, תקנו, הכל בסדר בסוף - אבל אני ממש לא חסיד גדול של Terraform.

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

זאת אומרת, אני חושב שהוא רגיש באותה מידה.
אבל שגיאות - בוא נגיד “יותר פשוטות”, זאת אומרת, שגיאות “Python-יות”, לא שגיאות לוגיות - ב-Pulumi קל יחסית לתפוס.

(אלון) לא, יש הבדל מהותי בין Pulumi ל-Terraform, שזה משהו שנתקלתי בו הרבה - נגיד, ב-Terraform אתה יוצר Database, ואז אחרי זה אתה צריך לזכור להעביר אותו ל-Service-ים שלך.

ב-Pulumi זה לא יתקמפל (Compile) לך - כי יצרת Database, ולא השתמשת בו.
אם אתה ב-Go נגיד, ב-Flavor של Go כותב - הוא פשוט לא יתקמפל לך, יש לך משתנה שהוא “Not used”.
וב-Terraform זה לא יקרה - הוא [Pulumi] מגן עליך הרבה הרבה יותר.
אז אני - קשה לי עם Terraform . . .

(דותן) אבל האמת שזה הסיפור של הנושא הזה - כי אני לא יודע אם לפני Terraform, אבל לפני זה היה את Ansible.

והייתה “שגעת מטורפת” על Ansible, שאני בכלל לא הבנתי אותה - שאתה בא ולוקח “ערימות של YAML-ים”, ויש לך איזשהו Server . . .
ולפני זה גם היה Chef כמובן.

אז תמיד זה הסיפור של “אני בא עם “ערימה של דקלרציות” (Declarations) - שזה כאילו דבר חיובי - ואני עושה Apply, ואז נבנה לי Cloud בדמות “הקבצים המתים, היבשים” של הקונפיגורציה שהכנתי . . . .

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

“אין לך לוגיקה - אז אין לך באגים!” . . .

אז תמיד היה את הסיפור של הנושא הזה - ואת האמת שאני לא יודע . . . לא יודע למה זה תפס וזה לא.

כאילו, Pulumi - חשבתי שהוא מת . . . . ועכשיו הפתעת אותי, רן.

(רן) יכול להיות שהוא מת, יכול להיות שרק אני משתמש . . .
(דותן) לא, אבל עכשיו כשאני כאילו “מעבד פנימה” את המחשבות, וחושב על HashiCorp ומה שקורה עם זה ו-Terraform ומה שקורה עם זה - הפוליטיקה שם וכל הריצה החוצה והזניחה של הפרויקט, שגם על זה נדבר בהמשך [וגם דיברנו בהרחבה כאן - 470 Carburetor 37 Open Source שלום לתמימות].
(רן) כן, אבל בוא רגע נפריד את הפוליטיקה מהטכנולוגיה. זאת אומרת, כן - יש שם הרבה עניין עסקי, פוליטי, Whatever איך שנקרא לזה, אבל נפריד את זה רק שנייה מהטכנולוגיה.

למרות שאוקיי - יש . . .

(דותן) אז הטכנולוגיה - “ה-Pitch היבש” [איך עוד אין דמות כזאת בלינדקאין/טוויטר/טיקטוק? קלאסי לאיזה Fake-Investor . . . ] אומר “אתה יודע מה? אם אתה הולך על שפת תכנות, אז יש לך באגים; ואם יש לך באגים - אז אכלת אותה!”.

כי שפת תכנות == באגים . . .
ואם אתה הולך על שפה דקלרטיבית, כמו XML כמו YAML - כמו Terraform, שאין שם שום לוגיקה - אז אין לך באגים.

אז אתה שמת תג לא נכון, או שאתה שמת חתיכה של קונפיגורציה לא נכונה - אז כאילו המעבר בין טעות לכשל ב-Production הוא פשוט . . .

עכשיו כתבתי איזה For-Loop של Off by 1 Zero - ואכלתי אותה כזה . . .

(רן) אז זה לא שאין לך באגים; יש לך באגים - מסוג אחר.

והאמת שכמו שאלון אמר - הם הרבה יותר גרועים . . .
זאת אומרת, באגים מסוג Infrastructure.

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

אתה עדיין צריך לעשות את המיטיגציות ולנקוט בצעדים - אבל אתה מרגיש קצת יותר “בבית” , ואז אתה עושה את זה קצת יותר טוב.

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

אז אם אתה לוקח שפה דיקלרטיבית, אז הגבלת את כל הצוות ל-10% יכולת, ואז ככה יצרת “מכנה משותף של כשל” גם.

(רן) כן, מסכים. העולם מלא Tradeoff-ים, אין מה לעשות.
(אלון) לא יודע, זה כמו שאלה קבועה של קונפיגורציה (Configuration), שאתה שם בקוד - וזה YAML או JSON או לא משנה מה - או שתכתוב קוד . . .
(דותן) השאלה היא מה אפשר “לדפוק יותר ביצירתיות” - Codebase שהוא מבוסס נטו-קונפיגורציה, או Codebase שהוא Codebase של שפת-תכנות - מה אתה יכול לדפוק יותר, בצורה יותר תכופה וגם בצורה יותר חריפה . . .
(אלון) אני חושב אבל שהרציונל הגיע מזה שכביכול SRE היו מתעסקים ב-Terraform פעם, או שפעם הייתה איזו אסכולה כזאת - אז הם “לא יודעים לתכנת”, כביכול.
(דותן) בדיוק, אני באתי מכיוון חיובי, רגע לתת לזה פרשנות של “אתה יודע מה? אם נגביל את כולם, אז יכול להיות שזה דבר טוב, להגביל את כולם” . . . בסדר.
(רן) טוב, בסדר - יאללה, בואו נמשיך, הרשימה עוד ארוכה.

(רן) עוד אייטם קטן שתפס אותי - שלדעתי אלון הביא פעם [420 Bumpers 76], לפני הרבה הרבה מאוד זמן - זה איזשהו פיצ'ר קטן שבנו מעל GitHub, מעל האתר של GitHub שנקרא GitHub 1S בזמנו.

פעם זה היה איזשהו פרויקט חיצוני, והיום זה למעשה Feature שהוא Built-in בתוך GitHub

זאת אומרת שאם אתם נמצאים בתוך איזשהו Repo - תלחצו על נקודה (“.”) במקלדת, פשוט נקודה - וזה “פותח לכם IDE”.
זה פותח לכם למעשה את VSCode בתוך הדפדפן - ואתם יכולים ככה “לטייל בקוד”, ואפילו להתקין Plug-In-ים.
ונכון שאם אין לכם הרשאות עריכה אז אתם לא תוכלו לערוך, זאת אומרת - אם אין לכם הרשאות ל-Repo אתם לא תוכלו לערוך, אתם תוכלו רק לקרוא.
אבל זה עדיין מאוד נוח לקרוא ככה קוד - אפשר לדלג להגדרה, אפשר לעשות קצת . . . בקיצור, לשנות . . .

זה סופר-סופר נוח, אפשר להשתמש אם אתם ב-Node או ב-Python, להתקין את ה-Plug-In וזה יצבע לכם את הדברים בצורה יפה ויהיה “אינטליגנטי”.
אז אם אתם רוצים לעשות איזושהי קריאה מאסיבית של קוד - אז תלחצו על נקודה ויש לכם “IDE בתוך הדפדפן” וככה הרבה יותר קל לקרוא אותו.
(אלון) קודם כל, ל-Code Discovery זה הרבה יותר נוח לעבוד עם IDE, לא רק לכתוב קוד. Code Discovery - להתחיל לחפש, לרוץ בין פונקציות, משתנה . . . עם הכל זה הרבה יותר נוח.

בזמנו, אמרתי שזה ה-Feature הכי טוב שראיתי באינטרנט . . .

(דותן) רגע, זה בקטגוריה של “תפס” עכשיו, זה מה שאנחנו אומרים? . . .
(אלון) זה בקטגוריה של “תפס” - ואני בזמנו אמרתי שהזה הדבר הכי טוב שראיתי, ו-Drop the Mic, וזהו . . .
(דותן) רגע שניכם משתמשים בזה?
(רן) אני משתמש בזה, כן . . .
(אלון) כן, בטח . . . הקיצר, זה אחלה, זה כיף, זה נחמד.
(רן) אני לא משתמש בזה כל הזמן . . . כשאני מגיע ל-Repo - שהוא לא שלי, שלא עשיתי לו Clone - ואני קורא כמה שורות, אז אני לא משתמש בזה.

אבל אם אני רוצה לקרוא קצת יותר “לעומק” - אני רוצה לדלג בין פונקציות ואני רוצה לחפש דברים - אז כן, זה נוח.

(דותן) רגע, אז בוא נסביר לקוראינו [מאזינינו?] איך מתקינים את זה . . .
(רן) אתה רק נכנס ל-Repo ב-GitHub ולוחץ על נקודה [“.”] במקלדת . . .
(דותן) אבל איך מתקינים?!
(אלון) אתה מתקין את ה-Chrome שלך או Safari - בעצם בטח לא עובד ב-Safari, אז אל תתקינו Safari . . .

אתה נכנס ל-Shell, תרשום . . . .

(דותן) זה Extension? . . . לחפש ב-GitHub?
(אלון) תרשום: “rm, רווח, מינוס rf enter” . . .
(דותן) רגע . . .
(אלון) . . . ו-Sudo! . . .
(דותן) לחצתי - וזה נראה כאילו זה לא עובד . . . אני לא רואה כלום.
(רן) רגע, רגע, תכף תכף זה יורד, תן לזה זמן . . .
(דותן) לחכות, או? . . . אתה יודע מה? - אני אריץ את זה עוד פעם!
(אלון) תריץ, תריץ עוד פעם.
(רן) רגע, לא עשית סלאש / בסוף, תעשה סלאש!
(דותן) כן, אני אריץ את זה פעמיים - בשני טרמינלים, ליתר ביטחון.

טוב - דברים שלא תפסו! בואו . . . . בחרתי אקראית, יש מלא מלא דברים שלא תפסו, כן . . . . אבל סתם ככה בחרתי אקראית - ונתקלתי ב-NFT . . .

זוכרים שלפני כמה - איזה חמש שנים או משהו? - כולם דיברו “NFT, NFT”. . .

עכשיו, כולם ידעו שזה לא יתפס, עדיין כולם דיברו
והנה, אכן - זה לא תפס . . .

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

25:47 אלון

(אלון) שלי? טוב - Flutter. דיברנו פה עליו, ה-Framework Mobile של Google.

שאז היה ראש-בראש עם React Native . . .
(רן) אנחנו עכשיו בדברים שתפסו, כן? רק נתמקד . . .
(דותן) יכול להיות שהוא אומר שתפסו . . .
(אלון) רגע, רגע, רגע, חכה לפינה . . . [דמיינו אפקטים אקראיים של Riverside, סטייל שירים ושערים . . . ] - בקיצור, אני לא יודע, האפקטים - צריך לעבוד עליהם טיפה . . .
(רן) יש להם Delay - ברגע שאני לוחץ, אז זה לוקח קצת זמן . . .
(אלון) בקיצור, היה את Flutter, שהיה מחליף של React Native והכל - והאמת שאני לא יודע מה המצב היום לגמרי, אני חייב להודות . . . .

מצד אחד, אני לא חושב שהוא השתלט על השוק; מצד שני, הוא לא נעלם.

(דותן) תשמע, בואו נעשה לכם רגע אתגר, רוצים אתגר?

(אלון) אתגר קרת או אתגר אחר?
[שבוע הספר, והבנאדם הוציא ספר וקרא לו “אוטוקורקט” - לגמרי אייטם לגיטימי לבאמפרס]

(דותן) תנו לי Framework של Google - שתפס . . .
(רן, אלון) Angular, Kubernetes . . . .
(דותן) ו-Framework אפליקטיבי?

(רן, אלון) או, נו - אתה מתחיל לצמצם . . .
(אלון) “Framework אפליקטיבי ב-PHP!” . . . .

(דותן) לא - משהו לאפליקציות, של Google - ו-Android לא נחשב . . .
(רן) זה לא של Google, זה של Android . . .
(אלון) אתה מתחיל לצמצם, כן . . . .טוב, כנראה שהתשובה היא בטח שאין משהו מיוחד . . .
(דותן) אני מבקש מקוראינו לשלוח - אם אתם יודעים, אם שמעתם, אם אתם משתמשים . . . .
(רן) אפליקטיבי? לא יודע - נגיד, אוסף ספריות ב-Java זה נחשב?
(דותן) איזה?
(רן) היה Guice, לדעתי - אבל זה ישן, כן . . .
(אלון) אבל זה Java . . .
(דותן) היה גם את Google Widget Toolkit - זה תפס בזמנו, זה עבד.

אבל מאז . . . .

(רן) Google Widget Toolkit היה זוועה, עבדתי עם זה קצת . . .
(דותן) אבל זה תפס - ויחסית לזמן זה גם עבד, זה עבד טוב.

(רן) תפס - אבל זה היה קשוח . . .

(אלון) היה להם פעם גם את ה-Design שלהם, ה-UX Design Framework הזה, איך קראו לו? עם הכפתור . . . .

(רן) Flex?
(דותן) לא, Flex זה Adobe.
(אלון) לא, אחד אחר.
(רן) לא Flex . . . . הכפתורים השטוחים האלה . . .

(אלון) עם הגדולים - הכפתור הגדול, בצד ימין למטה שתמיד היה . . . היה כזה Pattern שלהם, עם Framework, אבל לא זוכר . . . טוב, לא משנה.

(דותן) אוקיי . . . Material?
(אלון)Material!
(דותן) נו, וזה תפס?
(אלון) לתקופה . . .
(דותן) הפונט אולי נשאר איתנו - Roboto - אבל לא חושב שזה תפס . . .

(אלון) בקיצור, לפי שאלתך, אני מבין מה המצבו של Flutter כיום . . .
(דותן) כן, לדעתי כן - זה הסאבטקסט פה . . . .
(אלון) אז אם אני שואל אותך מה המוביל ב-Cross-Mobile Development?
(דותן) אני רואה את React Native, עדיין.

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

ואני נהנה לקרוא מהצד, וזה נראה שזה כלי שהפך להיות כלי עבודה.
זה כבר בלי ה-Hype, אבל זה כלי עבודה - זאת אומרת, אנשים ניגשים לזה בלי יותר מדי עכשיו . . .
זה כבר לא כזה “נוצץ” כמו שזה היה לפני, אבל משתמשים - וזה עובד.

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

ותשמע, זה עובד. אנשים ששואלים, אני עדיין ממליץ - למה להסתבך?

(רן)) אוקיי, Next. אלון?

29:40 אלון

(אלון) טוב - .NET Core!

יצא בהכרזה לפני זה, אני לא זוכר כבר כמה זמן - שנתיים? אני לא זוכר מה - זה היה החזרה של .NET Framework לבמה.
לדעתי הוא הולך - כאילו, במגמת עלייה.

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

וגם קצת במעקב - הוא די מרשים.

מבחינת Performance, חתימות זיכרון וכל מיני כאלה.

עדיין לא ברמה של Go ו-Rust ברוב המקרים, אבל הוא מרשים מאוד - ו-#C זו אחלה שפה.

אז אני חושב שבסך הכל הוא בעלייה.

(רן) תזכיר לנו - .NET Core זה בעצם ה-Framework שהוא Cross-Platform, שגם ב-Linux ואחרים ו . . .?
(אלון) כן, ה-.NET זה ה-.NET Framework החדש - ה-.NET Framework היה רץ רק על Windows, ואז היה איזה משהו שהיה נקרא בזמנו Mono, שהיה רץ על Linux - או מנסה לרוץ על Linux, מי שעבד איתו אז זה יותר “פחות עובד” מאשר “עובד”.

ואז יצא .NET Core, שזה ההבטחה שלהם של “ה-Java האמיתי”, ה-Cross Framework, ה-Cross-Platform Framework של .Net.
ובגדול - נשמע שהוא אחלה ועובד להם.

(רן) אתם משתמשים אצלכם בחברה?
(אלון) אצלנו לא - אבל געגועי ל-#C הם קיימים, אני חייב להודות.
(רן) אוקיי, אוקיי - מה הבא?

(אלון) הבא - היה פעם “ריב תקשורתי גדול” בין AWS ל-Elastic, על “האם זה הסוף של Elastic או ש-AWS נוטשים

והיה בלגן עם התביעה, ש-AWS השתמשו בשם “Elastic” בשביל ה-Elasticsearch שלהם - שלא באמת היה Elasticsearch אלא “דמוי-Elasticsearch”, או משהו כזה . . . אני כבר לא זוכר את כל הפרטים בדיוק.

[פרק 365 הקוסמי! 365 Carburetor 26 - open source politics]

(רן) היום קוראים לזה OpenSearch, דרך אגב - והמוצר חי וקיים.
(אלון) כן, אבל אז אמרו שזה הסוף של Elastic . . . היו דיבורים ש”הרגו אותם, אכלו אותם, אין להם עתיד”.

אני חושב מאז Elastic רק עלו וגדלו משמעותית . . .
אז בסוף נראה שיש מקום לכמה ביחד.

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

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

(דותן) כן, ו-Elastic היום זה לא רק Elasticsearch - זו כבר חברה-חברה . . .
(אלון) הם נחשבים Cyber Company, Security Company . . .
זהו, טוב, נראה - אולי עוד כמה שנים נבדוק מה קורה עם Redis - עכשיו שהם יצאו מה-Open Source וסגרו את הרישיון, אז יהיה מעניין לראות מה קורה איתם בעוד כמה שנים.

למרות שדותן, אתה אמרת לי “למי אכפת? כבר אין מה לפתח ב-Redis, הוא עובד” . . . כאילו, “תעזבו אותנו בשקט”.

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

זאת אומרת - שרן לא יחטוף תביעה . . .
(אלון) אם אתם תובעים אותי - תתקשרו לרן . . .

(אלון) לא, להפך - Redis עובד!
(דותן) כן, הוא מעולה, הוא מצוין, הוא יפה . . . גם הצבעים של הלוגו מדהימים . . . .
(אלון) הפרק בחסות Redis!, נותני שירות Cache מהיר, Database-ים ועוד . . .
(רן) כן, אני חייב להגיד פה שאני לא לוקח אחריות על שום דבר שאלון אומר . . . .
(אלון) גם אני לא לוקח אחריות על מה שאני אומר . . .
(רן) אבל את זה כולם יודעים . . . אני הייתי צריך להגיד את זה.

33:52 דותן

(רן) דותן - מה באמתחתך?
(דותן) טוב, אז קודם כל בחרתי לתת מקום של כבוד ל-Postgres.

אני חושב שלאורך כל הפרקים - מכמה זמן זה? עשר שנים אחורה? - Postgres הוזכר בכל מיני סיטואציות . . .
זאת אומרת, תמיד היה כזה “או, הנה Database חדש שעושה Geo, רק Geo וכו’

ואז Postgres בא עם איזשהו Extension - ואכל אותו.

וניקח נגיד לאחרונה את כל ה-Vector Databases

אז רק נגיד - בחודשים האחרונים אני רואה שה-pgvector אוכל גם את ה-Database-ים האלה.

וזה פשוט מוצר-תוכנה נפלא, שאני לא יודע . . .
כאילו, נגיד אם צוללים ל-Design שלו ולהכל - אם הוא כזה טוב חיצונית, אז הוא גם חייב להיות בנוי טוב פנימית.

אז זה חייב . . . באמת, חבל שאין חסות, לפרסם את Postgres . . .

(רן) האמת שאני חוזר ל-Postgres הרבה פעמים

רק השבוע עשיתי פרויקט קטן - הייתי צריך לעשות איזשהו חיפוש טקסטואלי ב-Corpus כזה גדול, אמרתי "יאללה, הכי פשוט Postgres”
התקנתי Postgres, ארזתי - וזה באמת סופר-קל, זה ממש כאילו, בתור כלי.
ניסיתי בהתחלה SQLite - לא סחב; עברתי ל-Postgres - וסחב כמו מלך.

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

כאילו, אתה רוצה לחזור למשהו שתמיד עבד לך.
אז נגיד אצלי זה Vim - Vim זה בית . . . זה הדבר שאני חוזר אליו, והוא תמיד עובד.
וגם Postgres זה בית . . . .

(אלון) אתה עושה פרסומות, דותן? בחסות . . . .
(דותן) אלון, אני רואה לחלוחית של דמעה בעיניים שלך . . .
(אלון) ממש, ריגשת פה, עם הבית שלך . . . .
(דותן) בואו תגידו - מה “בית” אצלכם? לאן אתם חוזרים שאתם מדוכאים מתוכנה?
(אלון) אני מרים אליך טלפון ושואל . . . .
(דותן) לא . . . לאן בתוכנה אתה חוזר כשאתה בדיכאון מתוכנה?
(אלון) לא, Postgres הוא מדהים . . . האמת, לא מזמן היה לי איזה ריב-טוויטר קטן [קשה מצוא בין העדכונים על זחלי-משי…]

שאיזשהו חברה - שמישהו רשם שהם יורדים מ-Postgres.
זה סטארטאפ עם שני לקוחות - “יורדים מ-Postgres! עוברים ל-Elastic!”.
ואני לא יודע, בסדר, כל כלי לשימוש שלו - אבל נראה לי שאפשר לסחוט מ-Postgres הרבה יותר שאתה עם שני לקוחות.
אני אישית, הגענו למצב ש-Postgres עשה חצי מיליון Records per Second הכנסנו איתו - זה עניין של אופטימיזציות ו”לסחוט את לימון”.

אבל זה כלי . . . כאילו, ה-Go-To הבסיסי כמובן זה Postgres.

יש לו את התחליפי-ענן המקבילים שלו, שאמורים להיות “אותו דבר” - שזה Aurora DB, שהוא גם Postgres בגדול אבל קצת שונה, והמקביל שלו ב-Google, שאני לא זוכר את שמו אז הוא לא יקבל חסות . .

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

לא מוצרים שעובדים - שמות שהם קליטים, לנו.

(אלון) לא פשוט ב-Google זה כנראה . . . כן, נכון - הם צריכים לתת לנו שמות משעשעים . . .
(דותן) נגיד FlotzDB - זה קליט!
(אלון) FlotzDB זה זה שם טוב ל-Database . . . מה הוא עושה, אבל? ה-FlotzDB?
(דותן) זה לא משנה . . . הוא Database רגיל, תואם Postgres והכל - אבל השם הוא זה “FlotzDB”. זה סופר -קליט . . .
(אלון) תכלס כן . . . בקיצור, אז Postgres זה אחלה. אני איתך, אני עובד איתו עדיין הרבה עם ה...
(דותן) Postgres זה בית!
(אלון) Postgres זה בית . כן, אין ספק - Postgres זה בית .
(רן) זו הסיסמה שלנו. אוקיי.

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

אז זה Atom, העורך-טקסט שהזכרנו אותו הרבה - הוא תפס ולא תפס . . . .

כי בלי Atom לא היה לנו את VSCode, אז חייבים פה להגיד מילה “לעורך הפורש” . . . .

(רן) לגמרי. כן.
(אלון) היה גם את ה... על Atom, היה פעם את הזה של Facebook, ב-React. . .
(רן) Flow?
(דותן) היה להם את Flow, שזה ה...
(אלון) לא, לא Flow - זה Nucleus!
(דותן) אוקיי, נכון.
(אלון) היה ממש IDE, מבוסס Atom . . .
(דותן) כן, זה לרגע תפס . . .
(אלון) לרגע הוא היה הדבר הכי נוצץ בשוק . . .
(דותן) נכון, נכון . . . איזה תמימים היינו. אגב - כל הדברים שלא תפסו, ואנחנו המלצנו, אז... זה אלון!

(רן) כל הדברים שלא תפסו ואנחנו המלצנו - זה אלון.

(אלון) טוב, אני רוצה להגיד - Atom היה חבר טוב. באמת, אני חייב להגיד...
(דותן) האמת שזה היה צריך להיות פרק עם עורך-דין פה בתוך הזה, כדי ש...
(אלון) לא לוקחים אחריות. רק רן נושא באחריות . . . לא, Atom באמת היה חבר ואח - עד ש-VSCode בעט אותו החוצה . . .
(דותן) כן, שזה גם סוג של הפתעה . . . אתם חייבים לומר, חייבים להודות שבאמת, VSCode - אז Microsoft עושה Code Editor בפעם ה-X, נכון? הרי הם עשו את זה כמה פעמים . . . .

מצד אחד אתה אומר, Microsoft יודעת לעשות IDEs - כי זה היה מסוף שנות ה-90.
מצד שני, אתה אומר, אוקיי, אבל זה Microsoft, אז... איך זה יקרה עוד פעם, כאילו?
וואו, חייבים להגיד שאפו על VSCode . . .

(דותן) זהו, אז שני דברים שלא תפסו, אבל אני חושב שמראש מי שחשב שיתפוס היה סופר-אופטימי, זה Storm, למי שזוכר.

זה היה Event-Based Real-Time Processing, בלה בלה בלה . . . ש-Twitter קנו, והשתמשו בזה חזק ל-Analytics בתקופה שלא היה שום פתרון טכנולוגי שייתן לזה מענה.

ואחרי זה, כמובן, התפתח כל העניין של ה-Real-Time, Event-Based, Lambda, Gamma, כל הארכיטקטורות האלה . . .

אבל Storm, איפשהו, נעלם - הוא היה מבוסס גם Scala ו-Clojure

אני מדבר מהזיכרון, אז לא לתפוס אותי במילה . . . .

ו-Scala - וואו, זה אני, כאילו, אני בא, ואין שמחה-לאיד יותר מזה . . .

כי אני אימצתי Scala בערך לשבוע - ואז אמרתי “אני לא נוגע בדבר הזה יותר בחיים”.
ואז היה קהל שלם של פאנטי-Scala [אולטראס-Scala?], שאמרו ש-”Scala זה מדהים!” ו-”Scala זה ה-Java הבא!” ו-Scala, Scala, Scala . . . .
והתעקשתי לא לגוע בזה - וזה מזל, מזל גדול.

(אלון) אני שנאתי Scala מהיום הראשון, אני תמיד הייתי בצד ההייטרי של Scala, בדעת מיעוט . . .

וכמו שאתה אומר - שמחה לאיד, איזה כיף. שנאתי אותם, שנאתי את השפה הזאת.

(דותן) כן, אני חושב שזה שפה שגם הרסה לעצמה, עם כל ה-Scala 2, Scala 2.13, 2.14, וכל הקפיצת-מינורי בגרסאות, שזה כל כך ביג דיל ושובר . . .

ואז Scala 3, ובקיצור - שיגעון.

(אלון) תן לי להרחיב לך פה בשניים - קשור ל-Scala: אחד זה שהיה את ה-Swift, שהיה לרגע Swift Server, ושחשבנו והיתה איזו הרגשה לרגע שזו תיהיה “שפת ה-Backend הבאה” - שלא הצליחה.
אבל לחילופין, מה שהאמנו בו מהרגע הראשון, זה היה Kotlin - בניגוד ל-Scala - והוא כן דווקא צמח יפה.
(דותן) נכון.
(רן) כן. דרך אגב, אני גם מהאנשים שאהבו Scala בהתחלה ואחר כך ממש ממש לא . . .

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

אבל מה שכן, יצא לי לעבוד לא מעט עם Spark בזמן האחרון - ו-Spark כידוע כתוב ב-Scala - אז עם כל זה שהשפה כאילו הולכת החוצה, יש עוד המון המון Code Base ב-Scala

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

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

(דותן) כן. טוב - אז עשיתי פה קטגוריה של “Over-Promised”, וזה בעיקר לעצבן אתכם. אז אחד זה ה-Microservices . . . .

ואני חייב להגיד - בשביל להבין את מה שאני מנסה להגיד פה, צריך רגע ללעצום עיניים ולדמיין את התקופה, של Micro Services . . .

ודמיינו כנסים - כשבכל כנס, 8 מתוך 10 הרצאות היו על “איך אני בניתי ארכיטקטורת Microservices!” ו”ולמה לפרק מוצר ל-100 פונקציות, שלכל פונקציה היא בכלל Microservices . . . ”
(אלון) כנס רברסים 2016 . . .
(דותן) אמרתי כנסים, אני לא...

וככה, לפני שאתם זורקים עליי את העגבניות, אני כבר אשחיל Kubernetes - שגם זה, לדעתי, סוג של Over-Promised גדול.

ואני בעיקר מתכוון לזה שבהרבה מקרים, אתה פשוט יכול לקחת כמה Service-ים ולסגור עניין, וזהו.
כדוגמת ECS, Fargate, Whatever . . .
לא רוצה לפרסם, אבל . . . Keep it simple, כאילו. זה...
(אלון) כבר נגמרו לנו החסויות פשוט . . .
(דותן) בדיוק, לא רוצה לפרסם יתר על המידה, כי כבר כולם דופקים פה על הדלת לחסות . . .

זהו, זה ה-2 cents שלי . . .
(אלון) אני חושב שה-Microservices - זה בגרות של התעשייה.

כאילו, היה קטע, הרי היו מונוליטים (Monolith) ענקיים - ואז, כרגיל, התעשייה הלכה לקיצון השני, שאפילו לא הייתי אומר Microservices אלא ממש Nano-Services, שכל אחד היה אומר לך על כל פונקציה קטנה “תרים איזה Service!”

(דותן) לא, זה היה מוגזם, כי זה היה דת, זה כבר היה דת . . .
(אלון) נכון.
(דותן) אני רק זוכר את כל הספרים - כאילו, מה אתה עושה עם כל הספרים האלה עכשיו? מה אתה עושה איתם? אתה יודע איזה כמויות של ספרים יצאו על Microservices?
(אלון) מה זאת אומרת “מה אתה עושה?” למה המסכים מגיעים תמיד בלי הגבהה? - כי יודעים שיש ספרי תוכנה שאין מה לעשות איתם, וזה שימוש שלהם . . .
(דותן) אה, אוקיי.
(אלון) אבל, תראה - Microservices היום נהיה הרבה יותר . . . עדיין יש Micro, כי קוראים לזה עדיין ככה, אבל זה נהיה הרבה יותר Services שהם הוליסטיים יותר, ולא Micro אלא “Normal-Size Services” . . . .

(רן) כמו שהיה לפני זה . . .
(דותן) מה שעשית כל החיים, כן . . .

(אלון) לא, היו מונוליטים עצומים פעם, אם אתה חוזר קצת אחורה - היו מונוליטים עצומים, שהיה נורא קשה לתחזק אותם. ואחרי זה . . . .
עכשיו יש איזושהי בגרות - לפרק דברים, לא ל... מצד אחד לא למיליונים, ומצד אחד לא Service אחד ענק.
(רן) זוכרים את המושג של J2EE? התקופה הזאת של Java Beans וכל זה - זאת הייתה ההגזמה לכיוון ה-Monolith.

אחר כך הייתה ההגזמה לכיוון הMicroservice.
ועכשיו אנחנו איפשהו באמצע.

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

מן הסתם, מה שאתה קונה היום זה פי כמה וכמה, מבחינת משאבים ויכולת וכו’
וגם שפות התכנות השתפרו היום בביצועים שלהן.
זאת אומרת - אותם $100 קונים הרבה יותר משאבים מאשר לפני עשר שנים.

ואז אני בא ואומר שמוצרים - נורמליים, לא... כאילו, לא שנפלת עכשיו על איזושהי הצלחה מסחרת וכו’ - מוצרים נורמליים, SaaS, Whatever, לא משנה, eCommerce - כנראה שקצב ההתפתחות שלהם היה לינארי.

זאת אומרת, אם לפני עשר שנים היו לך באופן טיפוסי 1000 User-ים, אז היום יש לך 10000 User-ים, לא משנה כאילו, בסדר גודל נורמלי.
ואם לפני עשר שנים חשבת ש-100 Request-ים לשנייה זה מטורף - אז כנראה שהיום 1000 Request-ים לשנייה זה . . .

אבל החומרה, לדעתי, גדלה בקצב יותר מהיר - אז כאילו, למה לי? למה לי לסבך דברים?

אם לא לקחת איזה שני Server-ים ולסגור את העניין? . . .
כי מבחינת ביצועים ו-Resource-ים, זה מספיק לי.

(אלון) זה דותן פה מדבר, או DHH? . . . מי פה בפודקאסט איתנו?
(דותן) אבל זה נכון . . . אבל זה נכון. כאילו, קחו את זה כחומר למחשבה.

אם היתה לך מכונה, או בוא נעשה אחרת - אם היתה לך מכונה, שהיו מבטיחים לך שיש לה ביצועים אינסופיים, אוקיי? אז אתה לוקח שתי מכונות כאלה, בשביל Redundancy.
האם היית הולך ל-Over-Engineering של Microservices, על Kubernetes וכו' - או לוקח שתי מכונות, עם הביצועים אינסופיים האלה?
אני טוען שהספרים האלה לא היו נכתבים בכלל, אם זה היה המצב . . .

(רן) האם הדובר כותב Framework דמוי-Rails בשפה כלשהי?
(דותן) כן . . .
(רן) גילוי נאות . . . כן, אז אני מסכים - אני חושב שאחד מהעניינים זה Performance

והעניין השני זה העניין של המבנה הארגוני - של אחריות ושל איך עושים Deployment וחלוקה של הצוותים וכל זה.
וגם זה אולי היה...

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

זה טרנדים, זה משתנה עם הזמן - וזה גם עוד ישתנה, המבנה הארגוני וההדרך שבה אנחנו עושים באופן טיפוסי מבנים ארגוניים בתוכנה.

(רן) כן, נכון, אני אומר רק שאחת מההבטחות - אולי לא ממומשות, אבל אחת מההבטחות - של Microservices או Services באופן כללי - זה התאמה יותר טובה למבנה הארגוני, ככה שלהגדיר ממשקים בין רכיבים ולהגדיר אחריות של מי אחראי על כל רכיב, ושהם אחראים לכל ה-life-cycle של אותו רכיב.

אם זה נגיד Service של אות’נטיקציה (Authentication) או Service של Storage - אז הם יהיו אחראים עליו, כולל ה-Deployment ו-Redundancy וכל זה.

(רן) עכשיו, יכול להיות שישנן דרכים אחרות לפתור את זה, מסכים - אבל בכל אופן זה בא, מן הסתם לפתור לא רק את הבעיה של הסקליביליות (Scalability) ו-Redundancy, אלא גם את הבעיה של איך אתה מנהל צוותי פיתוח, ואיך אתה נותן להם חופש.
(דותן) כן אז אז יש פה קטיגוריה נוספת של . . . יש לנו ככה, “Stick, didn't Stick” וכו’, יש פה Didn't Hold Data . . .
(אלון) רגע, רגע, רגע, רגע . . . רציתי שנייה לפני שאתה ממשיך הלאה, בקשר לזה, המבנה הארגוני זה - Conway Law, שאני חסיד מאוד גדול שלו.

ודבר שני, על Kubernetes - אני כן חייב להגיד שאנחנו דיברנו על Istio ושיבחנו אותו די הרבה [אפילו עם פרק ייעודי - 353 Istio] - ואני חושב שאפשר לאכול את המפרש . . .

(רן) Istio, רק נזכיר למאזינים, זה Service Mesh, איך זה נקרא? . . .
(אלון) כן, זה Service Mesh, מקביל ל-LinkerD, לא ידוע לשמצה . . . אבל Istio הוא ה-Service Mesh מבית Google - עוד הצלחה מסחרת שלהם, דותן, אם חיפשת מקודם . . . . - שנחשב די סיוט . . .

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

מדי פעם, כש-ChatGPT לא עונה לי . . . אפילו זה.

אבל Istio, ה-Service Mesh - הוא היה הבטחה מאוד גדולה, שGoogle הוציאו - והיה אמור להיות ה-Service Mesh, ל-Kubernetes או כל פתרון אחר.

הוא נולד ל-Kubernetes - ובסוף די שונאים אותו, הוא די סיוט . . .

(דותן) מגניב . . . .מגניב.

(דותן) טוב, אז שוב - קטגוריה של Didn't Hold Data: עכשיו, אני קצת מוטרד מהחשיפה המשפטית שיש לפרק הזה [באמת מזמן לא היה פרק 1 באפריל . . . ] - אז אני לא אגיד מה לא מחזיק Data, אני פשוט אגיד שיש ארץ, או חבל - מונגוליה! . . . .

(אלון) יש גם פרי דומה . . . מנגו? אתה אוהב מנגו? אגב, סתם - זו העונה עכשיו . . .

(דותן) כן, אני מאוד אוהב מנגו . . . אני חושב שה-Database, שקצת מזכיר את ה... זה פרי או ירק, מנגו?
(רן) מנגו זה פרי . . .
(דותן) אז זה מזכיר את הפרי “מנגו” . . .
(אלון) האמת שיש בו גלעין . . .
(רן) יש Delay באפקטים [ויש יתרונות לגרסת הטקסט…] - אני לוחץ, וחמש שניות אחרי זה זה מגיע . . .
(אלון) אז תגיד לנו, דותן! תשלח צ'אט, משהו . . . תקרוץ.
(רן) הכי נחמד כשאתה מפתיע . . .

(דותן) אז זהו, אז מי שהבין - לחפש Postgres . . . מי שהבין ובתחילת דרכו לשמירת Data, מה שנקרא - לחפש Postgres.

(רן) טוב, אז דברים שעבדו, דברים שנשארו איתנו ? . . .
(דותן) אז דברים שעבדו, קצת אמרנו - הרבה אמרנו - VSCode עבד, עובד, מעולה.

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

אני . . זאת אומרת, לא הייתי נגד, לא הייתי בעד - אמרתי שזה נראה לי מוזר, השפה הזאת.
אני זוכר שמה שראינו, באותו פרק, זה רק את ה-Syntax, ואמרתי “מה, זה XML חדש?” כאילו, יש פה איזשהו XSLT, לקחו אותנו לימים האלה . . .

ומה שלא ראיתי זה שזה לא ה-Syntax אלא שזה כל ה-Framework - ו-React תפס ובגדול, וזה עובד טוב.

הדבר הבא זה Rust - וגם פה הייתי סקפטי לגבי Rust . . .

ואלון לא היה סקפטי, ואני הייתי ממש בעד Go - ובגלל שהייתי פאנאט על Go, אז ראיתי דברים בצבעים, בצבעים של Go, בצבעים של Gopher . . .

וטעיתי . . . וואו, כמה טעיתי.

(אלון) דותן, מזמן לא הזכרת Rust . . .
(דותן) כן, אתה רואה? . . .
(אלון) כן . . . אגב, רגע, לפני ה-Rust והבדיחת-Rust שלך - בקשר ל-React: תגיד, איפה Vue.js עומד היום?

כי Vue היה...
(דותן) לא יודע, מבחינתי - התחלתי רק React, כי אני לא מבין למה ללכת לכל דבר אחר.
חוץ מצורך כלשהו לבלות - לבלות במקומות בשביל הכיף, ללכת לטיול בכל מיני Framework-ים אחרים . . .
אם אתה בא לעבוד - אני חושב שאתה צריך לקחת React, ורק React.
אלא אם כן אתה רוצה הרפתקה - אז אתה הולך, מטייל בכל מיני כאלה . . .

(אלון) אני אגיד לך, עוד משהו בעולם של ה-LLM-ים וה-ChatGPT - ככל ש-Framework הוא יותר גדול ובשל, יותר קל לך לעבוד איתו עם ה-ChatGPT.

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

(דותן) ואני חייב להגיד גם - הדבר הבא זה NVIDIA - NVIDIA תפס . . .

מי שזוכר, ויש לו זיכרון חזק וטוב, אז אני זוכר את כל ההכרזות - ש-”NVIDIA יוצאת משוק המשחקים” . . . . מדבר על תקופה של תחילת ה-Deep Learning.

וכש-Cuda שנולד - והסיפור של NVIDIA לא היה כזה בזנ”ט . . .

והנה - הגענו למקום שזו החברה הכי גדולה בעולם.
(רן) השנייה הכי גדולה, לא? שני טריליון דולר, משהו כזה? . . .
(אלון) לא, לא - הכי גדולה, 3.3 טריליון . . . “הפרק בחסות מניות NVIDIA! קנו מניות NVIDIA וצפו לתשואה!”

“אין זו המלצה או . . . .”
(דותן) כן, הייתי להגיד שגם על זה את יכול לחטוף תביעה . . .

(דותן) בקיצור, רן - אתה צריך עכשיו לבחור אם זה צחוק או כפיים . . . כי יש פה איזה מכפיל 60 או משהו כזה, ל-NVIDIA.

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

(רן) אז NVIDIA תפס, אתה אומר . . . כדאי לקנות, יופי.

(דותן) וזו לא המלצה, ולא זה . . . אני מחפה עליך, רן - אתה חייב להגיד שזו לא המלצה.
(רן) לגמרי, זה לא.
(אלון) אני אומר “קנו NVIDIA בסופר הקרוב לביתכם! - חלב NVIDIA, קוטג' NVIDIA, כל מוצר של NVIDIA תופס!” . . .
(רן) כן - S4 של NVIDIA!

(רן) טוב - דברים ש”למה הם לא משתפרים?”
(דותן) כן, למה? מה קורה פה? אז Linux Desktop - אני חייב להגיד שלמרות שאני מניח שיש מלא אנשים שיגידו “וואו, זה... מה אתה מדבר שטויות?” - אני חושב שהנושא של Linux Desktop Distribution פשוט עומד ולא זז.

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

(דותן) איך אני מתקין Linux?
(רן) לא, כאילו, על מה? על ה-Mac שלך? על...
(דותן) דיסקטים . . .

(רן) על מה התקנת? על מה ניסית?
(דותן) ניסיתי . . . אני ב-Mac M3, אז יש לך כמה אפשרות מאוד מאוד מוגבלות, כי ווירטואליזציה (Virtualization) וכו’ - VMware Fusion Player.

הוא חינם, והוא עובד.

(רן) הבנתי. אז סתם בשביל המשחק ניסית?
(דותן) כן, אני לא עכשיו אמחק את הכל, ו... כאילו, עכשיו אתה תגיד “זה בגלל שלא התחייבת לגמרי!”, אז...
(אלון) דותן, איך אתה יודע שמישהו משתמש ב-Linux?

(דותן) נו?
(אלון) הוא כבר יגיד לך.
(דותן) אה, נכון. איפה הצחוקים? זה בא ב-Delay . . .

(רן) עשיתי טבעי בינתיים, נטורל . . .

(דותן) והפינה הנראה-לי-הכי-לוהטת זה The Rise and Fall . . . . אז יש לי פה ככה: יש לי Terraform, ו-HashiCorp בכלל.

שזו הפתעה מוחלטת, באמת.
האמת הייתי גם צריך לשים פה Docker . . . החברה Docker.

(אלון) נכון, תכל’ס . . .

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

ואני עדיין בכל הפורומים של-Go, וכל ה-Reddit-ים וכאלה - ואני רואה “ערימות של אכזבה” מתוך הקהילה”.
כל מיני דברים שקורים ב-Go, שלא נכנסתי אליהם לעומק - אבל התלונות על הניהוג של השפה.
אז זהו, זה מה שנקרא . . .

(אלון) תראה, התלונות על Go הן בעיקר שהשפה הולכת ונהיית מסובכת ומאבדת את הפשטות שלה.

זה בעיקר התלונות על הגרסה של ה-1.23, שאמורה לצאת בקרוב - שהוסיפו Syntax, והשפה נהיית יותר מתוחכמת, וזה כבר לא כמו “אוקיי, אני עושה For-Loop - וזו הדרך היחידה”.
מה שאהבו, בניגוד ל-Scala נגיד, ש-Go היה דרך אחת לעשות דברים, בכל דבר.

“ככה עושים דברים ב-Go, זהו, אין לך דרך אחרת”.
בדרך אחרת זה ממש יהיה קשה לך לעשות את זה - והיא מכתיבה לך דרך אחת, בניגוד ל-Scala, שהיית עושה . . . פותח אחד באמצע פונקציה, עושה לולאה בשבע דרכים שונות.
אז זה היה מה שיפה.

ועכשיו פתאום נהיו יותר אופציות, והשפה קצת נפתחת . . .

(דותן) אז היד החזקה מתרופפת - וה-value העיקרי שזה זה, הולך וקטן . . .
(אלון) מצד שני, זה עדיין שפה שנורא . . . העקומת למידה היא מאוד, מאוד קלה, נורא קל להיכנס אליה.

ומבחינת Performance והכל היא . . . מה אלטרנטיבה שלך? רק Rust, כי אתה יודע . . . מה, Kotlin?

(דותן) אני אגיד לך מה - השאלה האם זה שפה שאתה נהנה לכתוב בה?

ולא נהנה כי “וואו, זה מגניב!”, אלא תזכר, בגלל שאני מכיר אותך - תזכר בימים של של #C, שהיה לך משהו “שעוטף אותך”, ואתה אומר “אתה יודע מה? אני יכול ללכת עם זה כל החיים, זה עושה הכל, אני לא צריך ללמוד שום דבר אחר”.

באותה תקופה, כן? כי באותה תקופה גם ה-Use Case-ים והדברים שאתה צריך לעשות היו גם מוגבלים.

(אלון) תראה, #C זה #C, אתה יודע . . . אהבתי אליה - ואי-שם ל-Ruby עוד, אתה יודע, “ישארו לנצח”.

אבל יש גם איזושהי הבנה, שאתה יודע - שאי אפשר לעשות הכל עם שפה אחת, כי לצערי אני מוצא את עצמי חוזר ל-Python מדי פעם

בלית-ברירה, ממש - זה ממש “בכאב לב”, לעשות דברים ב-Python, כי יש דברים שאפשר לעשות בצורה הגיונית רק ב-Python.
וזה מה שמבאס אותי, תכל’ס - שבסוף . . .

(דותן) אני יכול להגיד לך שב-Rust, מצאתי את הדבר הזה שלך ב-#C - ו-Rust עושה הכל.

[מה קורה עם Werner באמת בסיפור הזה?]
וגם במקומות של Python, אז קורה משהו מגניב - שהרבה מהתשתיות של Python מוחלפות ב-Rust, ובגלל זה, אז נגיד אם יש לך עכשיו DataFrames, ואתה חייב להשתמש ב-Python וכו’, אז אתה הולך ל-Polars.
ושם אני, במקום להשתמש ב-Python, משתמש בספרייה-נטו, בלי כל העטיפה ב-Python, נטו.

זו ספרייה של Rust, אז אני משתמש בה ישירות.

אז זה Heck מגניב שקרה בצורה, לא יודע - הקהילה גרמה לו לקרות.

(אלון) טוב, אולי נעבור ל-Rust . . .
(רן) כן, למרות שהעולם, אם אתה מסתכל, נגיד, באיזור של ה-Deep Learning, אז עדיין זה נשלט ב-Python,

ומתחת זה הכל ++C, אבל...
[שוב Werner . . . ]

(דותן) לא, אז גם שם המניות . . . תתפלא, המניות ב-Rust.

כי סתם, בוא ניקח את . . . אני מסתכל הרבה על Hugging Face ומה שהם עושים - אני מאוד אוהב את הדרך שבה הם עושים כלים.
ולמי שיבחין, מי שיחטט להם ב-Repositories ויחטט במה האנשים שלהם עושים - אתם תשימו לב שהם עושים Porting לכל התשתיות שלהם ב-Rust, מ-Python.

(רן) כן, זהו, Hugging Face זו חברה שהתחילה ב-Rust, אם אני זוכר נכון? והם אימצו דווקא . . . אני דווקא ראיתי הפוך, אני ראיתי שהם אימצו הרבה מאוד Python מאז.

אבל אולי, כמו שאתה אומר, הם אימצו כדי אחר כך לעשות לזה Port ל-Rust . . .
(דותן) יכול להיות.

01:01:40 סיכומים

(רן) בכל מקרה, הגענו לסימן השעה - וזה הזמן לסיכומים. אנחנו מבטיחים לחזור בעתיד עם פרקים עם חומר מעודכן וחדש.
אז זה היה פרק הזה של נוסטלגיה - עשינו, ככה, Review קצר על דברים שעבדו או לא, אבל בעתיד נביא דברים חדשים.
(דותן) אחוז-הפגיעה שלנו בפרקים הוא, עכשיו שאנחנו מסתכלים אחורה, זה 50% . . .
(אלון) בקיצור, אז אתה אומר להקשיב לחצי-פרק?
(דותן) לא - זה או שאנחנו צודקים, או שאנחנו לא צודקים . . . או שההמלצה טובה, או שלא.
(אלון) זה כמו הבדיחה ששניים משחקים שש בש - ואחד שואל את השני “מה הסיכוי שיצא לי שש-שש?”

השני חושב חושב וחושב - ואומר לו “50%! - או שיצא, או שלא יצא” . . .
(דותן) איך זה היה בזמן טוב? [אפקטים של מחיאות הכפיים - דמיינו סאונד של PowerPoint מ-97 . . .]

האזנה נעימה ותודה רבה לעופר פורר על התמלול!

רברס עם פלטפורמה

יום ראשון, 30 ביוני 2024

472 Bumpers 83 - Nostalgia

Outbrain