רשומות

קודמתי לדרגת סיניור במיקרוסופט - מה למדתי בדרך

-
תמונה
אחרי 10 שנים בתחום, ו3 שנים במיקרוסופט, סוף סוף הגעתי לדרגה המיוחלת - סיניור. את הקריירה שלי התחלתי בצבא, 3 שנים סדיר, שנה וחצי קבע, (בתוך כל זה גם ניהלתי צוות כשנתיים), יצאתי לאזרחות להיות ״סיניור״ בסטארטאפ, הייתי שם שנתיים וקצת ואז התחלתי להתראיין למיקרוסופט. המגייסת פנתה אליי, היו לי ארבעה ראיונות לא רעים בכלל, ואז בשיחת השכר היא אמרה לי ״אתה מיועד לדרגת Software Engineer II״. ישר שאלתי בביטחון מופרז - ״למה לא סיניור? היום אני מתפקד כסיניור ויש לי 7 שנות ניסיון״ ואז היא ענתה משפט שלקח לי קצת זמן להבין כמה הוא נכון - ״כולם פה היו סיניור לפני שהגיעו למיקרוסופט״. אז קיבלתי את ההצעה והזכות להגשים את החלום ולהצטרף למיקרוסופט, והיום, 3 שנים אחרי קודמתי שתי דרגות (מ61 ל 63) וקיבלתי את הטייטל - סיניור. בפוסט הזה אני רוצה לשתף קצת ממה שלמדתי בדרך. למרות שבכל חברה יש מערכת קידומים שונה, אני מאמין שהנקודות הבאות יהיו רלוונטיות לכל עובד בכל חברה. חשוב לי להגיד, זה לא פוסט best practices לקידום, אלא החוויה האישית שהתאימה לפרופיל, לאישיות ולחוזקות שלי ולא בהכרח תהיה דומה בין עובד לעובד. שלושת מעג
9 תגובות
המשך לקרוא

Rust MPSC Channels - צ׳אנלים בראסט

-
תמונה
אחת התכונות החזקות ביותר בראסט היא מקביליות ואסינכרוניות, וכשמדברים על תכנות אסינכרוני tokio  היא הספרייה הנפוצה ביותר. אחד הפיצ׳רים המרכזיים שטוקיו מאפשרת הוא channels, אשר מאפשרים תקשורת בין חלקים שונים בתכונה שלנו. קיימים בראסט מגוון סוגים של channels שמגיעים ממגוון ספריות (כמו crossbeam , std::mpsc וכו׳). בפוסט אדבר על Tokio Channels, ומתי ואיך נשתמש בהם. מהם צ׳אנלים? כשם כן הם - ״ערוצים״ אשר מאפשרים דרך לשלוח נתונים בין חלקים שונים של תוכנה (בדרך כלל בין threads או tasks). צ׳אנלים מורכבים משני מרכיבים עיקריים:  שולח (Sender):  החלק ששולח נתונים ו מקבל (Receiver): החלק שמקבל נתונים. MPSC (Multi Producer Singler Consumer) הספריה tokio מאפשרת לנו שימוש בצ׳אנלים מסוג MPSC - כלומר, מספר tasks יכולים לשלוח מידע אל מקבל יחיד. וזה נותן לנו יכולת נוחה וישירה להעביר מידע מאיזה סוג שנבחר, אל task מקבל שבו נעבד את המידע ונתמודד איתו. דוגמה פשוטה: בדוגמה הזו אנחנו רואים את יצירת השולח והמקבל tx ו rx. לאחר מכן, יצירת task ברקע ששולח בלולאה 10 מספרים באמצעות tx אל ה task הראשי בו אנחנו מאזינים
הוסף רשומת תגובה
המשך לקרוא

ראסט - פונקציית main נקיה יותר עם Result

-
תמונה
כחלק מהמסע שלנו לניהול שגיאות נכון  נפל לנו האסימון שלהשתמש ב unwrap או expect  יכול להיות רעיון לא כל כך טוב ועלול להביא לסיום מיידי של הפרוסס שלנו במקרים שאולי לא התכוונו אליהם. אז השתמשנו ב clippy deny unwrap used  שגרם לקומפילציה לא לעבור במידה ונכנס unwrap לקוד. המקום היחיד בו היינו צריכים להשאיר unwrap היה בסט הוולידציות ההתחלתי בעליה של הפרוסס שלנו, בפונקציית ה main. לדוגמה - בניסיון למשוך את הקונפיגורציה הראשונית בעליה - אם נכשלנו מסיבה כלשהי נהרוג את הפרוסס. לימים פונקציית ה main הכילה יותר ויותר ולידציות כאלה ובנוסף גם התחלנו להרוג את הפרוסס שלנו כחלק מתהליך פונקציונאלי תקין במקרים מסויימים (exit code). בפוסט אנסה להציג את האלטרנטיבה שבחרנו לטיפול בשגיאות ב main באמצעות unwrap איך נראה main סטנדרטי הפריע לי בעין לראות כל כך הרבה unwrap וחיפשתי דרך נקייה יותר לנהל את השגיאות שעלולות לצוץ ב main. באחת מעשרות השיחות הטכניות שלי על ראסט עם המנטור שלי , הוא העלה את האופציה פשוט להחזיר result מפונקציית ה main וככה אם תוחזר שגיאה ב main היא תפועפע שכבה אחת והתכנית תסגר עם אותה הודעת
הוסף רשומת תגובה
המשך לקרוא

Rust Builder Pattern

-
תמונה
אחד הדברים שלקח לי זמן להתרגל אליהם בראסט היה העובדה שאין method overloading וגם אין תמיכה בערכים דיפולטיים לפרמטרים של בפונקציות. כלומר, באותו ה namespace תוכל להיות לנו רק פונקציה אחת עם אותו השם וכשאנחנו מגדירים פונקציה אנחנו לא נוכל לקבוע לפרמטרים שלה ערכים דיפולטיים כדי להקל על המשתמש ב API. זאת להבדיל משפות כמו C#, C++, Java שתומכות ביכולות. בפוסט הזה נדבר על איך Builder Pattern יכול לעזור לנו להתגבר על המגבלות הללו. מה זה Builder Pattern ה"בילדר" היא תבנית עיצוב ממשפחת ה " creational " שמאפשרת לנו לייצר אובייקטים בצורה של הדרגתית וגמישה יותר משימוש ב constructor רגיל. באמצעות הבילדר נוכל להפריד את הרכבת שדות האובייקט מיצירתו בפועל.  התבנית שמישה ב Rust במיוחד משום שבאמצעותה אנחנו יכולים לייצר מבנים (structs) מורכבים, לבחור אילו שדות נרצה לאתחל, וגם לתת ערך דיפולטי לאיזה שדה שנרצה. מימוש ה Builder נתחיל בלייצר struct פשוט של Person שיכיל שדות שנהפוך לאופציונאליים בעוד רגע באמצעות הבילדר. השלבים הבאים יהיו: 1. נייצר מבנה של PersonBuilder שיהיה אחראי על בניית הא
2 תגובות
המשך לקרוא

איך התחלנו לנהל שגיאות ב Rust (חלק ג' - anyhow)

-
תמונה
אם הגעת לכאן במקרה אני ממליץ להתחיל בפוסט הראשון והשני על מנת לקבל רקע. החלק השלישי במסע שלנו לניהול שגיאות היה ההטמעה של anyhow . הספרייה מספקת מספר פיצ'רים נחמדים מאוד שמקלים על הפיתוח ומייפים את הקוד, מייעלים את ניהול השגיאות, ואפילו עוזרים לאחר השגיאה בניתוח שלה. anyhow::Result כמו שבפוסט הקודם ראינו שאפשר להשתמש ב box dyn Error כערך החזרה של השגיאות שלנו וכך לאפשר פעפוע של כל שגיאה שמממשת את Error trait - הספרייה anyhow נותנת לנו type נוח יותר לשימוש ובשימוש בו אנחנו לא צריכים לציין את סוג השגיאה שלנו. אבל יש בעיה קטנה, אם נשתמש ב anyhow באופן הזה אמנם נרוויח את היכולת לבצע פעפוע של כל שגיאה מבלי להוסיף אותה ל TomerCodeError type שהגדרנו בפוסט הקודם, אבל אנחנו מאבדים את השימוש בשגיאה המותאמת אישית שהגדרנו ובכל יכולות ה formatting שהגדרנו לה. בשביל לפתור את הבעיה הזו כל מה שצריך לעשות זה לגרום לשגיאה שאליה anyhow::Result מתייחס להיות אותה שגיאה שהגדרנו. את זה נעשה באמצעות הגדרת alias ל type באופן הבא: כאן בעצם הגדרנו טיפוס Result משלנו, שאיבר השגיאה בו הוא TomerCodeError ועכשי
הוסף רשומת תגובה
המשך לקרוא

איך התחלנו לנהל שגיאות ב Rust (חלק ב' - thiserror)

-
תמונה
בפוסט הקודם דיברתי על הדרך שעשינו מקוד שיכול לקרוס בכל מקום בכל רגע, להפיכת הפרוסס ליציב הרבה יותר באמצעות שימוש ב Result, ופעפוע השגיאות שלנו עם אופרטור `?`. בפוסט הזה נדבר על אחת הספריות המרכזיות בעולם ניהול השגיאות של ראסט ונראה איך היא עוזרת לנו להפוך את ניהול השגיאות שלנו לנוח ויציב הרבה יותר. ברוב המקרים כשנשתמש בכל מיני ספריות צד שלישי וככל שהפרויקט שלנו הופך מורכב יותר אנחנו נתקלים ביותר ויותר סוגי שגיאות בהם אנחנו צריכים לטפל. שימוש ב thiserror הספרייה thiserror עוזרת לנו לעשות סדר בכאוס ומאפשרת לנו להגדיר טיפוס שגיאה משלנו כדי ליצור חוויית ניהול שגיאות אחידה וגנרית בכל הפרויקט. ראסט כשפה נכתבה עם דגש חזק על reducing boilerplate (כלומר - לאפשר למפתחים לא לממש מאפס ספריות וקטעי קוד תשתיתיים שהשפה או ספרייה פשוטה יכולה להנגיש לנו). באותו אופן, גם בעולם ניהול השגיאות קיימות מספר ספריות שמטרתן לגרום לנו לעבוד פחות קשה. thiserror, בין השאר מספקת לנו את ה מאקרו הפרוצדורלי  Error שאפשר להשתמש בו מעל טיפוס השגיאה אותו נרצה לייצר. כאשר נשתמש ב derive Error הטייפ שהגדרנו יממש באופן אוטו
הוסף רשומת תגובה
המשך לקרוא

איך התחלנו לנהל שגיאות ב Rust (חלק א' - Result)

-
תמונה
מבוא גם כשעולם פיתוח התוכנה מתקדם בקצב משוגע, דבר אחד נשאר קבוע - שגיאות.  לא משנה כמה מנוסים נהיה כמפתחים, שגיאות ומקרים לא צפוים תמיד יצוצו לנו. מה שישנה בסופו של יום זה איך אנחנו מטפלים ומנהלים את אותן שגיאות. בפוסט אדבר על הדרך שאני עשיתי והדברים אותם למדתי כמפתח חדש בראסט, ואיך התמודדתי עם העובדה שבראסט אין אקספשנים וגם לא קונספט של try-catch. מה עשינו לפני בשלבים ההתחלתיים של הקודבייס שלנו, כמעט כל האינטרפייסים וכל הפונקציות פשוט החזירו את הטיפוס עצמו איתו רציתי לעבוד. לדוגמה - אם יש לי אובייקט של Registry ופונקציה get_key, אותה פונקציה פשוט החזירה לי String. חשוב לציין, שעצם העובדה ש get_registry_key מחזירה String איננה הבעיה העיקרית כאן, אפשר לראות שמיד לאחר הקריאות ל open_subkey ו get_value של winreg crate מתלוות קריאות ל unwrap עליהן ארחיב ממש עוד רגע, אבל בינתיים רק אגיד שבכל מקום בו אנחנו רואים unwrap, הקוד שלנו יכול לקרוס (panic) במקרה של None או שגיאה - דבר שלרוב לא נרצה שיקרה בפרודקשן. כשהרצנו את המוצר שלנו על data אמיתי ובסקייל גבוה יותר, מהר מאוד התחלנו לקבל קריסות לא
הוסף רשומת תגובה
המשך לקרוא