הבלוג של ינון פרק

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

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

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

העבודה ב 120% מהקצב שלכם מתישה, שוחקת ומשאירה אתכם במקום מבחינה מקצועית. הרבה יותר חכם לעבוד ב 60% מהקצב שלכם ולהשקיע את הזמן שנותר בלימוד וקידום מקצועי. בעוד שנתיים ה 60% שלכם יהיה מהיר יותר מה 120% של כל המתכנתים מסביב.

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

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

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

וככה אנחנו מוצאים המון מתכנתים שלומדים JavaScript והשאלות הראשונות שישאלו יהיו איך לבנות היררכיית מחלקות כמו שאני מכיר מ Java, או למה אין פה Static Types ואיך לממש פה את ה Design Patterns שאני רגיל אליהן. וזה חבל, כי הכיף האמיתי מסתתר בשאלות כמו ״מה אפשר לעשות עם Clojure שהיה קשה בשפות אחרות?״, או ״איזה Design Patterns אנחנו עשויים למצוא בפרויקט JavaScript גדול (שלא היינו מוצאים בשפות אחרות)?״.

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

הטבלאות במערכת יהיו:

1. טבלת posts עם פרטי הפוסט ושדה id.

2. טבלת labels עם שם התווית (אותו נרצה לחבר לשאילתה) ושדה id.

3. טבלת label_posts היא טבלת החיבור שכוללת את השדות label_id ו post_id.

השאילתה הבאה מחזירה שורה לכל פוסט במערכת, והשדה labels של השאילתה מחזיק את כל התוויות כמחרוזת (מופרדות בפסיקים):

SELECT posts.id, posts.header, Group_Concat(labels.name) AS labels
FROM posts, label_posts, labels
ON posts.id = label_posts.post_id and labels.id = label_posts.label_id
GROUP by posts.id;

התוצאה על טבלת דוגמא שיצרתי נראית כך:

id|header|labels
1|one|event,work
2|two|tv

נ.ב. הפקודה Group_Concat ייחודית ל SQLite. בבסיסי נתונים אחרים יש פקודות מקבילות לדוגמא ב Postgresql וב SQL Server הפקודה היא STRING_AGG. אם אתם בעניין של SQL Server יש די הרבה תיעוד עליה ועוד דוגמאות בקישור הזה.

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

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

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

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

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

לרובי יש מנגנון חבילות שנקרא gem שמאפשר התקנת חבילות מהרשת ושילובן בפרויקט בצורה די פשוטה. הבעיה היחידה עם הג'מים היא מה קורה כשיש לנו מספר פרויקטים שכל פרויקט צריך גירסא אחרת של אותו הג'ם? הפיתרון של רובי נקרא הפונקציה gem.

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

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

קיבלתי עץ תיקיות שכלל הרבה תיקיות אמצע ריקות, דמיינו משהו שנראה כך:

.
└── a
    └── b
        ├── c
        │   └── d
        │       └── e
        │           ├── one.txt
        │           ├── three.txt
        │           └── two.txt
        ├── f
        │   └── g
        │       ├── five.txt
        │       ├── four.txt
        │       └── six.txt
        └── y
            └── seven.txt

ורציתי להיפטר מתיקיות האמצע ולהגיע למבנה כזה:

.
└── a
    ├── c
    │   ├── one.txt
    │   ├── three.txt
    │   └── two.txt
    ├── f
    │   ├── five.txt
    │   ├── four.txt
    │   └── six.txt
    └── y
        └── seven.txt

כלומר ביטול התיקיות b, d, e ו g.

דרך קלה לבטל את תיקיות האמצע תהיה להשתמש ב find:

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

2. נעביר את כל הקבצים שבה להורה שלה, ואז נמחק את התיקיה.

3. נחזור על התהליך עד שנסיים לרוץ על כל עץ התיקיות.

המתגים הרלוונטים של find הם לכן:

1. המתג -d שיגרום ל find להתחיל מהתיקיה העמוקה ביותר ולרוץ כלפי חוץ.

2. המתג -type d שיגרום ל find לרוץ רק על תיקיות.

3. המתג -exec שיאפשר לנו להריץ קוד במהלך החיפוש.

ופקודה ה find שחיברה את הכל נראתה כך:

$ find -d . -type d -exec bash -c '[[ $(ls {}/.. | wc -l | tr -d " ") == 1 ]] && (mv {}/* {}/..; rmdir {})' \;

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

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

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

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

כאנשי מקצוע שרוצים להתקדם כדאי להניח שכל האנשים שאתם מכירים עושים את אותן טעויות שאתם עושים, ועכשיו לשאול - ממי עוד אני יכול ללמוד? מאיפה אוכל לקבל פידבקים חדשים? הנה כמה רעיונות:

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

2. כתיבת פרויקט קוד פתוח שלכם.

3. השתתפות בקורס ושיתוף הפיתרונות עם המרצה והמשתתפים האחרים.

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

5. מענה על שאלות ב Stack Overflow או פורומים אחרים.

6. כתיבת פוסט בבלוג (בהנחה שיש קוראים).

ככל שבוחרים יותר אופציות כך מקבלים פידבק יותר מגוון שייתן לכם סיכוי לצאת מה Echo Chamber, ללמוד ולהשתפר.