<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom">
    <channel>
        <title>ברוך אודם - B.Cs Student</title>
        <link>https://baruchiro.online</link>
        <description>Be a Computer Science student</description>
        <lastBuildDate>Fri, 13 Dec 2024 12:28:01 GMT</lastBuildDate>
        <docs>https://validator.w3.org/feed/docs/rss2.html</docs>
        <generator>Gridsome Feed Plugin</generator>
        <language>he</language>
        <image>
            <title>ברוך אודם - B.Cs Student</title>
            <url>https://baruchiro.online/logo/LOGO.png</url>
            <link>https://baruchiro.online</link>
        </image>
        <atom:link href="https://baruchiro.online/feed.xml" rel="self" type="application/rss+xml"/>
        <item>
            <title><![CDATA[הסבר קצר על מה יפה בפתרון של Copilot Workspace]]></title>
            <link>https://baruchiro.online/copilot-workspace/</link>
            <guid>https://baruchiro.online/copilot-workspace/</guid>
            <pubDate>Fri, 13 Dec 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[עוד כלי AI, אבל אני חושב שיש בו יתרון על פני שאר הכלים שלא בדקתי, למרות שהממשק שלו מאתגר קצת בגלל זה.]]></description>
            <content:encoded><![CDATA[אני לא בקיא ועוקב אחרי כל כלי הAI שיוצאים כל רגע. יש לי מנוי לCopilot (שהחברה משלמת), מידי פעם אני פותח Chat GPT, וזהו, מספיק לי.

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

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

## התחלה

העבודה מתחילה עם כתיבת Issue בגיטאהב, ומשם בלחיצת כפתור עוברים לעבודה של הAI על מה שכתבנו, בתוך הסביבה של Copilot Workspace.

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

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

## שלב ראשון - סיעור מוחות

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

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

![סיעור מוחות](./brainstorm.png)

## שלב שני - תכנית עבודה

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

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

![תוכנית](plan.png)

## שלב שלישי - ביצוע

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

ממש באותו ממשק אני יכול לראות את התוצאות, את הdiff שנוצר ולבדוק אותו בזמן אמת:

![ביצוע](change.png)

## תיקונים

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

אני יכול ככל הנראה לפתוח PR, מה שבעצם אומר שעשיתי commit, ואז להמשיך את התיקונים שלי שלב על גבי שלב.

יש כמובן את מה שרואים בתמונות, את מנגנון השיחה ״revise״.

## כלים נוספים

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

בזכות פיצ׳ר אחר של GitHub שנקרא Codespaces, יש לנו ממש סביבות פיתוח בענן. אז כשאני לוחץ על Terminal, נפתחת לי סביבת פיתוח ויש לי גישה לטרמינל, שם אני יכול להריץ את הפרויקט שלי ולבדוק אם הוא עולה כמו שצריך.

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

![טרמינל](terminal.png)

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

מה צריך יותר מזה?]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[כיצד לבנות מוצר מבוסס קוד פתוח בצורה אחראית ובטוחה]]></title>
            <link>https://baruchiro.online/build-open-source-in-organization/</link>
            <guid>https://baruchiro.online/build-open-source-in-organization/</guid>
            <pubDate>Tue, 20 Feb 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[קוד פתוח הוא לא רק קוד, אלא גם תרבות. בפוסט הזה, אני אספר על ההשפעות של שימוש בקוד פתוח בארגון, ואתן טיפים למי שרוצה להשתמש בו בצורה נכונה.
]]></description>
            <content:encoded><![CDATA[
אני לא הראשון שכותב על זה שיש יתרונות גדולים לשימוש בקוד בפתוח בארגון.

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

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

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

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

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

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

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

3. **זמן עבודה על פרויקטים**  
  כמו שאמרתי בסעיפים הקודמים, אמנם לקחנו פרויקט "מוכן", אבל כן נידרש להתערב בו במידת הצורך.  
  זה משהו שצריך לקחת בחשבון מראש, עוד בשלב התכנון  
  - קודם כל, עבודה של המתכנתים בכניסה לפרויקט ותיקון באגים.  
  - במידה ועושים גרסאות משלנו- עוד תחזוקה ותשומת לב, משיכת עדכונים מהמקור ועוד.  
  - וכמובן, סנכרון כל פרויקטי הקוד הפתוח, ייצוגיות ועבודה על פרקטיקות, מישהו בעל נסיון בעולם הזה שיידע להתמודד עם הטמעת התרבות, אתגרים יחודיים ותמחור.
]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[איך חושבים קוד פתוח]]></title>
            <link>https://baruchiro.online/open-source-thinking/</link>
            <guid>https://baruchiro.online/open-source-thinking/</guid>
            <pubDate>Thu, 15 Feb 2024 00:00:00 GMT</pubDate>
            <description><![CDATA[באמצע יום עבודה רגיל, קלטתי שביצעתי רצף פעולות ארוך של החלטות על קוד פתוח, והבנתי ששווה לתאר רגע איך זה נראה.
]]></description>
            <content:encoded><![CDATA[
באמצע יום עבודה רגיל על פרויקט [2ms](https://github.com/Checkmarx/2ms) (שהוא במקרה גם בקוד פתוח, אבל האמת שזה לא רלוונטי לענייננו), קלטתי שביצעתי רצף פעולות ארוך של החלטות על קוד פתוח, והבנתי ששווה לתאר רגע איך זה נראה.

##  הרקע

ב[פוסט על CI Checklist](https://bscstudent.netlify.app/ci-checklist#pr-title) תיארתי איך יש לי תהליך אוטומטי שמוודא שהכותרת של הPR היא בפורמט מסוים, כדי לנהל גרסאות בצורה אוטומטית.

כרגע בכל פרויקט אני מבצע את זה בדרך אחרת, בין אם על ידי Regex או על ידי כלי ייעודי שנקרא [commitlint](https://commitlint.js.org/#/).

היום, בזמן שחזרתי לעבוד על פרויקט [2ms](https://github.com/Checkmarx/2ms), היה איזה באג לא מוסבר בתהליך האוטומטי שמבוסס על commitlint, אבל זה גרם לי לחשוב שבסה"כ המימוש בעזרת commitlint הוא די יעיל וגנרי.

## לקחת עוד צעד

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

## מציאת פתרון קיים

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

אחרי כמה חיפושים מצאתי את [dreampulse/action-lint-pull-request-title](https://github.com/dreampulse/action-lint-pull-request-title). אני מסתכל על כמה פרמטרים בפרויקט, ובגדול אני רואה שהוא לא מתוחזק, יש לו Issues & PR פתוחים שלא מקבלים מענה, והעדכון האחרון היה לפני 4 שנים (וזה היה גם העדכון הראשון).

גם פה, אותו עיקרון, שאם אני חשבתי על זה, סביר להניח שמישהו עשה את זה לפני. הרבה פעמים במקרים כאלה נמצא [Issue ששואל מה מצב הפרויקט](https://github.com/dreampulse/action-lint-pull-request-title/issues/46).  
הכותב לא קיבל תשובה אז הוא מפנה אותנו לפרויקט אחר: [Weburz/pr-lint-action](https://github.com/Weburz/pr-lint-action)

## בחינת הפתרון

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

## שימוש ושיפור מתמיד

### הגעתי עד לשלב הזה, ומי שרוצה להמשיך מכאן אני אשמח לעזור לו

אז החלטתי שאני רוצה להצטרף לפרויקט, עכשיו מגיע השלב שבו אני לומד איך משתמשים, מתחיל לבחון את הפרויקט אצלי, לראות מה לא עובד או מה הייתי רוצה עוד שיהיה נתמך, ומדווח.  
קודם כל, להביע התעניינות ולספר על באגים או על דרישות נוספות זאת כבר תרומה, מוביל הפרויקט יראה שהעבודה שלו משפיעה על עוד אנשים וזה ייתן לו כוח.  
וכמובן, אנחנו כבר מכירים את הפרויקט ואכפת לנו, אז נוכל גם להציע פתרונות לבעיות שנתקלנו בהם.
]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[צ'קליסט CI לפרויקט]]></title>
            <link>https://baruchiro.online/ci-checklist/</link>
            <guid>https://baruchiro.online/ci-checklist/</guid>
            <pubDate>Wed, 19 Jul 2023 14:53:45 GMT</pubDate>
            <description><![CDATA[בכל פעם שאני מתחיל פרויקט חדש, אישי או של העבודה, אני צריך להיזכר מחדש איזה בדיקות וכלים אני נוהג להוסיף, תלוי בשפה של הפרויקט, בצרכים שלו והאם הוא אישי או ארגוני.

אז הנה רשימה של כלים ובדיקות להוסיף לפרויקט חדש.
]]></description>
            <content:encoded><![CDATA[
בכל פעם שאני מתחיל פרויקט חדש, אישי או של העבודה, אני צריך להיזכר מחדש איזה בדיקות וכלים אני נוהג להוסיף, תלוי בשפה של הפרויקט, בצרכים שלו והאם הוא אישי או ארגוני.

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

> תשלחו לי כלים שאתם משתמשים בהם ואני אוסיף אותם לרשימה.

## Git Hooks

בפרויקטים של JavaScript אני מוסיף את [husky](https://typicode.github.io/husky/) שמאפשר לי להגדיר Git hooks (כלומר פקודות שירוצו לפני\אחרי commit/push וכו'), ובעזרתו אני יכול לחסוך למפתח טעויות פשוטות שאחרת הוא יגלה רק כשהוא יפתח PR.

את husky אני משלב עם [lint-staged](https://github.com/okonet/lint-staged) שמאפשר לי למנוע מהמפתח לקבל שגיאות שלא נגרמו על ידו, ולהריץ את הבדיקות רק על הקוד שהוא מבקש להכניס.

בשלב הזה אני מריץ את הכלים הפשוטים שחוסכים לכולנו כאב ראש:

- [ ] Linting ([ESLint](https://eslint.org/), [Stylelint](https://stylelint.io/))
- [ ] Type Checking ([TypeScript](https://www.typescriptlang.org/))
- [ ] Pretty Formatting ([Prettier](https://prettier.io/))

וזה נראה כך:

```json
# package.json
"lint-staged": {
    "**/*": "prettier --write --ignore-unknown",
    "{src,tests}/**/*.js": "eslint --fix"
}
```

```bash
# .husky/pre-commit
#!/bin/sh
. "$(dirname -- "$0")/_/husky.sh"

npx lint-staged
```

_[דוגמא מפרויקט Overlay](https://github.com/os-scar/overlay/blob/master/package.json#L64-L67)_

## Pull Request Validation

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

- [ ] Linting ([golangci-lint](https://github.com/golangci/golangci-lint), [ESLint](https://eslint.org/), [Stylelint](https://stylelint.io/), [`go mod tidy`](https://github.com/Checkmarx/2ms/blob/cf3f46a51041a8e8fe934775e295fe2ea9dc810e/.github/workflows/pr-validation.yml#L25C6-L28)) (ולא לשכוח לחפש פורמט של Github, למשל `stylelint --formatter=github` או [@jamesacarr/eslint-formatter-github-actions](https://www.npmjs.com/package/@jamesacarr/eslint-formatter-github-actions))
- [ ] Type Checking
- [ ] Unit Tests
- [ ] Build (bundle, compile, Docker)

_[דוגמא מפרויקט כספיון](https://github.com/brafdlog/caspion/blob/master/.github/workflows/ci.yml)_ (_TypeScript_)  
_[דוגמא מפרויקט 2ms](https://github.com/Checkmarx/2ms/blob/master/.github/workflows/pr-validation.yml)_ (_Go_)
\_ולא לשכוח להשתמש ב[`merge_group`](https://github.com/os-scar/overlay/blob/dcdf44f27e8c24542f1f0ca8f2b39be0e5b97d1b/.github/workflows/pr-validation.yml#L7)

### [lockfile-lint](https://github.com/lirantal/lockfile-lint)

_[JavaScript/TypeScript]_

בפרויקטים של JS, החבילות מותקנות על פי מה שכתוב בקובץ lock (`package-lock.json`/`yarn.lock`), ולכן חשוב לוודא שהקובץ הזה תקין ולא נערך בצורה לא צפויה, מכיוון שתוקף יכול לשנות את הרישום של אחת החבילות בקובץ, ואנחנו לא נשים לב, כי מי מסתכל על הקובץ הזה בכלל?

_[דוגמא מפרויקט Overlay](https://github.com/os-scar/overlay/blob/master/package.json#L24)_

### [new-dependencies-advisor](https://github.com/lirantal/github-action-new-dependencies-advisor)

_[JavaScript/TypeScript]_

כלי שמתריע על תלות חדשה שנוספת לפרויקט בקוד הנוכחי, ומציג את הציון והפידבק של [Snyk Advisor](https://snyk.io/advisor/) על החבילה החדשה.

_[דוגמא מפרויקט Overlay](https://github.com/os-scar/overlay/blob/dcdf44f27e8c24542f1f0ca8f2b39be0e5b97d1b/.github/workflows/pr-validation.yml#L15-L19)_

### [gosec](https://github.com/securego/gosec)

_[Go]_

כלי בדיקת אבטחה לGo.

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

_[דוגמא מפרויקט 2ms](https://github.com/Checkmarx/2ms/blob/master/.github/workflows/gosec.yml)_

### [Kics](https://github.com/marketplace/actions/kics-github-action)

Kics הוא מנוע לזיהוי חולשות אבטחה בInfrastructure as Code. כמעט בכל פרויקט יש לפחות קובץ Dockerfile, וKics סורק אותו למציאת בעיות פוטנציאליות.

_[דוגמא מפרויקט 2ms](https://github.com/Checkmarx/2ms/blob/cf3f46a51041a8e8fe934775e295fe2ea9dc810e/.github/workflows/pr-validation.yml#L55-L71)_

### PR title

אני משתדל להקפיד על [Conventional Commits](https://www.conventionalcommits.org/) כמו שנראה בהמשך, ולכן אני מוסיף בדיקה שהכותרת של הPR עומדת בקונבנציה. בדרך כלל אני נעזר ב[commitlint](https://commitlint.js.org/) בשביל לבדוק.

```yaml
name: Validate Conventional Commit title

on:
  pull_request:
    types: [opened, edited, synchronize, reopened]

jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - name: install commitlint
        run: npm install -g @commitlint/cli @commitlint/config-conventional
      - name: config commitlint
        run: |
          echo "module.exports = {extends: ['@commitlint/config-conventional']}" > commitlint.config.js
      - name: validate PR title
        run: |
          echo ${{ github.event.pull_request.title }} | commitlint
```

את הבדיקה הזאת צריך לתמוך על ידי ההגדרה שהכותרת של הPR תהיה גם ההודעה בcommit:

![Squash Pull Request Title](./pr-title-config.png)

_[דוגמא מפרויקט Overlay](https://github.com/os-scar/overlay/blob/master/.github/workflows/pr-title.yml)_

## CI

אז מעבר לפעולות הברורות מאליהן של העלאת חבילה לnpm, עדכון האתר או Dockerhub, יש כמה פעולות נוספות שאני מבצע.

> בעקרון רציתי לנצל את ההזדמנות לבדוק את פרויקט [allero](https://github.com/allero-io/allero) שעושה ולידציה על הCI, אבל ראיתי שהוא לא מתוחזק אז ויתרתי.

### [Semantic Release](../semantic-release/)

כדי לשמור על עקרונות [semver](https://semver.org/), אני משתמש בכלי שנקרא [semantic-release](../semantic-release/), ועל פי הפורמט של הקומיטים (שתואר בPR Title למעלה), מעדכן את מספר הגרסה ויוצר גרסה.

מצד אחד מדובר בכלי מדהים, הוא יודע כמעט בלי הגדרות מיוחדות ליצור Github Release, להעלות לnpmjs.org, ליצור changelog ולכתוב בתגובה לIssues/Pull Requests שהם נכללו בגרסה האחרונה.

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

_[דוגמא מפרויקט כספיון](https://github.com/brafdlog/caspion/blob/f847d6420ca6d97f0d96832523a66a626a0cc0a4/.github/workflows/semantic-release.yml#L27-L31)_

## ניהול פרויקט ואינטגרציות

### פינוי משימות וPull Requests שנשכחו

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

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

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

בשביל להימנע מהמבוכה הזאת, אני מבצע כמה פעולות.

#### השמה אוטומטית של Pull Request

ברגע שמישהו פותח PR, אני אוטומטית assign עליו את הPR. זה יעזור לי בהמשך כפי שתראו.

```yml
assign-author:
  runs-on: ubuntu-latest
  if: github.event_name == 'pull_request_target'
  steps:
    - uses: toshimaru/auto-author-assign@v1.6.2
```

#### התראה על Pull Request לא פעיל

יש Github Action רשמי של Github שעוזר לנו לנהל stale issues. אני משתמש בו עם פרמטרים מאוד מסוימים כדי למצוא Issues/PRs שלא פעילים כמה ימים, ואז אני כותב בהם הודעה שקוראת למפתח לעדכן מה הסטטוס, ואני מוסיף תגית מיוחדת.

#### הורדת משימה ממפתח

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

```yml
comment-on-possible-stale-issues:
  # This job uses the stale action to find inactive assigned issues and pull requests,
  # and comments on them to remind the assignee to take action.
  # If the assignee does not take action, the another action will unassign them.
  name: Comment on possible stable issues
  if: github.event_name == 'schedule' || github.event_name == 'workflow_dispatch'
  runs-on: ubuntu-latest
  steps:
    - uses: actions/stale@v8
      with:
        include-only-assigned: true
        exempt-assignees: "baruchiro"
        days-before-stale: 7
        days-before-close: -1 # Never close an issue/pr
        stale-issue-message: "Hey! This task was taken over a few days ago, but nothing has happened since then. Maybe the current contributor can comment on this?"
        stale-pr-message: "Hey! This pull request was made a few days ago and still needs changes, but nothing has happened since then. Maybe the current contributor can comment on this?"
        stale-issue-label: "Waiting for contributor"
        stale-pr-label: "Waiting for contributor"
        exempt-issue-labels: "on hold"
        exempt-pr-labels: "on hold"
        remove-stale-when-updated: true
    - uses: boundfoxstudios/action-unassign-contributor-after-days-of-inactivity@1.0.2
      with:
        last-activity: 7
        labels: "Waiting for contributor"
        exempt-assignees: "baruchiro"
        labels-to-remove: "Waiting for contributor"
        message: "Due to a long period of inactivity, this task was unassigned automatically."
```

_[דוגמא מפרויקט Overlay](https://github.com/os-scar/overlay/blob/master/.github/workflows/project-management.yaml)_

### Community tag

ב[פרק 19 של הפודקאסט "קוד פתוח"](https://myishay.podbean.com/e/פרק-19-הסודותשל-אלסטיקעם-ל/), ליזה כץ אומרת שבמבט לאחור, באלסטיק היו צריכים לסמן איזה קוד הגיע מתורמים חיצוניים, מכיוון שבגיטאהב אין את המידע הזה.

אצלנו באחד הפרויקטים התחלנו מהיום הראשון לסמן PRים שמגיעים מבחוץ:

```yml
- name: Mark as Community if PR is from a fork
  if: github.event.pull_request.head.repo.full_name != github.repository
  uses: actions/github-script@v6
  with:
    script: |
      github.rest.issues.addLabels({
        issue_number: context.issue.number,
        owner: context.repo.owner,
        repo: context.repo.repo,
        labels: ['Community']
      })
```

_[דוגמא מפרויקט 2ms](https://github.com/Checkmarx/2ms/blob/master/.github/workflows/pr-labels.yml)_

### Notify Discord

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

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

בדיסקורד זה מאוד פשוט, יוצרים Webhook ושולחים אליו הודעה.

```yml
- name: Notify Discord
  if: ${{ steps.semantic_release_info.outputs.git_tag }}
  run: |
    curl -X POST -H "Content-Type: application/json" -d "{\"content\": \"$msg\"}" ${{ secrets.DISCORD_CHECKMARX_WEBHOOK }}
    curl -X POST -H "Content-Type: application/json" -d "{\"content\": \"$msg\"}" ${{ secrets.DISCORD_MAAKAF_WEBHOOK }}
    curl -X POST -H "Content-Type: application/json" -d "{\"content\": \"$msg\"}" ${{ secrets.DISCORD_SCAR_WEBHOOK }}
  env:
    msg: 'Yay! 🎉 \n Version ${{ steps.semantic_release_info.outputs.version }} was released! \n Check it out in: ${{ steps.upload_artifacts.outputs.url }}'
```

_[דוגמא מפרויקט Overlay](https://github.com/os-scar/overlay/blob/dcdf44f27e8c24542f1f0ca8f2b39be0e5b97d1b/.github/workflows/project-management.yaml#L66-L77)_ (הודעה על `good first issue`)

## Badges

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

## תוספות מתגובות לפוסט

[ישראל המליץ בטוויטר](https://twitter.com/IsraelFruchter/status/1681352397266862098) על [cookiecutter](https://github.com/cookiecutter/cookiecutter), כלי ליצירת Templates לפרויקטים. האמת שנראה טוב ואני מקווה שביום שאני אצור פרויקט לשימוש חוזר אני אשתמש בזה (אם כי אני כבר חושב שאולי זה מוגבל רק לvariables ולא לרמה של איזה קבצים לכלול בפרויקט, אבל לא קראתי את כל התיעוד)

[מענדי המליץ בטוויטר](https://twitter.com/LandaMendy/status/1681394842264272921) על [`ts-reset`](https://github.com/total-typescript/ts-reset), זאת חבילה שקצת מתקנת Types של TypeScript. אני שומר את זה פה אבל זה כנראה שייך לפוסט מעט דומה על כלים לעבודה על פרויקטים (כאן אנחנו מתמקדים בCI)

[מענדי המליץ גם](https://twitter.com/LandaMendy/status/1681677919809069056?s=20) על [`sync-dotenv`](https://github.com/codeshifu/sync-dotenv) להוספה ל`pre-commit` _Git Hook_ שתיארתי למעלה. המטרה של הכלי הזה היא לוודא שרשימת משתני הסביבה בקובץ `.env.example` תואמת לרשימה שיש לנו ב`.env` (שכמובן לא נכנס לGit)
]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Serverless פשוט וחינמי - Google Apps Script]]></title>
            <link>https://baruchiro.online/google-apps-script/</link>
            <guid>https://baruchiro.online/google-apps-script/</guid>
            <pubDate>Thu, 21 Apr 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[אתם רוצים להריץ איזה אוטומציה או אפילו אפליקצייה קטנה, בענן, בלי להתעסק בתחזוקה או להרים שרת בבית. וכמובן בלי לשלם?
בעזרת Google Apps Script אפשר להגיע לפתרונות מדהימים!
]]></description>
            <content:encoded><![CDATA[
אוהבים להגיד שמתכנתים הם עצלנים, ולכן הם כותבים כל הזמן קוד כדי לא לעשות דברים פעמיים. אני לא ממש אוהב שאנשים מדביקים לעצמם תכונות טובות במסווה של תכונות רעות (או הפוך, לא סגור על זה. כמו פרפקציוניזם כמובן, וגם OCD), אבל בהחלט כחובב קוד, אני אוהב לעשות כל מיני אוטומציות, ובאופן כללי, לבצע פעולות שגרתיות מהר יותר ובכמות גדולה יותר (שזה בעצם היתרון של הקוד עלינו).

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

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

- [בוט בטלגרם](https://github.com/alfem/telegram-download-daemon) שאני שולח אליו קבצי מדיה, והוא מוריד אותם לvolume שיש ספריית מדיה שקוראת ממנו.
- [ציוץ מחדש של ציוצי #פיד_תכנות בטוויטר](https://twitter.com/BcsStudent1), בעזרת [NodeRed עבור טוויטר](https://flows.nodered.org/node/node-red-node-twitter)
- חישוב אוטומטי של צריכת דלק (שווה פוסט בפני עצמו ככל הנראה)  
   ![דשבורד הוצאות רכב](./car-datastudio.png)

## מה הבעיה?

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

**להריץ על איזה מחשב ישן זה קצת בעייתי:**

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

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

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

טוב, אני לא אוהב מאמרים עם הקדמות, אבל כל זה היה כדי להסביר למה הפתרון הזה פשוט ומדהים, אז לעניין:

## Google Apps Script

נבחן רגע את הדרישות שהגדרנו.

- **מחיר:** [חינם](https://developers.google.com/apps-script/guides/services/quotas) (כלומר, יש איזה רף שממנו מתחילים לשלם (freemium) אבל קשה להגיע אליו בסקריפטים אישיים).
- **גישה:** רק למשתמש יש גישה, זה מסמך/שירות של גוגל, כמו Gmail או docs (אלא אם פותחים endpoint ספציפי, נראה בהמשך).
- **תקשורת:** תמיד (אני מקווה, בטוח יותר ממחשב שמחובר אצלי לרשת הביתית).
- **ממשק חיבור:** חיבור דרך הדפדפן, מכל רשת אינטרנט.
- **נתונים:** זה קטע שממש אהבתי- אפשר תמיד לשמור את הנתונים בגליון אלקטרוני (Google Sheets), ואז אמנם הקוד רץ ומשתמש בהם, אבל אנחנו יכולים גם תמיד לגעת בהם ידנית בצורה נוחה.

**עוד כמה נתונים על פיתוח בGoogle Apps Script (GAS):**

- **שפה:** JavaScript
- **שימוש בספריות:** מנגנון ספריות ייחודי ומוגבל, זה בהחלט חסרון.
- **סביבת פיתוח:** סביבה ייחודית של Google Apps Script. היא לא משוכללת יותר מידי, ובתור מתכנת היא מרגישה קצת מוגבלת, אבל במחשבה שניה ייתכן שלאנשים שלא מתכנתים ביום יום שלהם היא דווקא תהיה פשוטה ונוחה יותר.
- יש **דיבאגר**, יש **לוגים** (ברוב המקרים). אפשר אפילו לקבל מייל אם יש **שגיאה בזמן ריצה**.
- [אפשר להתממשק בקלות להמון שירותים של גוגל](https://developers.google.com/apps-script/reference) (שזה כבר חצי מהשירותים שקיימים בעולם ;-) )

### שליחת מידע לGoogle Apps Script

> מי שחשף אותי לכל התחום הזה של GAS ולאפשרויות הגלומות בו, וגם פיתח על גביו אפליקצייה די רצינית, הוא [עמרי](https://twitter.com/xomri/), אולי הגיע הזמן שתצטרפו ותעקבו אחריו.

בGAS אפשר לפתוח לקוד גישה חיצונית לבקשות GET & POST, מה שעקרונית מאפשר לנו התממשקות עם שירותים אחרים, על ידי שליחת מידע או קבלת מידע.

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

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

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

אז הנה הקוד להתממשקות עם טלגרם:

https://gist.github.com/baruchiro/4bab7004a05292b824fbe5f6d0bfdb2e#telegram.gs

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

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

**הערה קטנה לגבי Types בקוד.**

אמנם הEditor מאוד בסיסי ותומך רק בJavaScript, אבל הוא בכל זאת תומך ב*JSDoc Types*, אז כדי לקבל עזרה עם השלמת מילים, אפשר [להגדיר Types בהערות](/jsdoc-types).

#### אז מה אנחנו רואים בקוד?

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

עוד דבר שחשוב מאוד לשים לב אליו זאת הפונקציה המיוחדת `doPost`. לא רואים שהיא מיוחדת, אבל כשמעלים את הפרויקט כWebApplication, אם שולחים בקשת POST לכתובת שקיבלנו, הבקשה תגיע ל`doPost` (ובהתאם, בקשת GET תגיע ל`doGet`).  
מכיוון שרשמנו את האפליקצייה שלנו כWebhook בטלגרם, בכל פעם שיקרה אירוע בבוט שלנו בטלגרם, אנחנו נקבל את האירוע כפרמטר של `doPost` על פי התיעוד של טלגרם.

https://gist.github.com/baruchiro/4bab7004a05292b824fbe5f6d0bfdb2e#main.gs

אני חושב שעד כאן הנושא של טלגרם, יש המון תיעוד על Telegram API, חבל להעמיס פה.

### שימוש בספריות

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

> הוראות מפורטות להגדרת אינטגרציה עם טוויטר אפשר למצוא [כאן](https://levelup.gitconnected.com/send-tweets-from-google-sheet-using-google-apps-script-d35382e901d8). אפשר גם להגיד לי מה חסר ואני אוסיף לפוסט.

כדי להוסיף את ספריית [twitter-lib](https://github.com/airhadoken/twitter-lib) יש ללחוץ על _הוספת ספריה_ בעורך הקוד:

![הוספת ספריה](./add-library.png)

בחלון ההוספה יש להכניס את מזהה הספריה (נכון לזמן כתיבת הקוד, הספריה זמינה בגרסה 25 עם המזהה `11dB74uW9VLpgvy1Ax3eBZ8J7as0ZrGtx4BPw7RKK-JQXyAJHBx98pY-7`)

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

- `OAuth1` גרסה 18: `1CXDCY5sqT9ph64fFwSzVtXnbjpSfWdRymafDrtIZ7Z_hwysTY7IIhi7s`
- `OAuth2` גרסה 41: `1B7FSrk5Zi6L1rSxxTDgDEUsPzlukDsi4KGuTMorsTQHhGBzBkMun4iDF`

### טוויטר

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

הנה הקוד:

https://gist.github.com/baruchiro/4bab7004a05292b824fbe5f6d0bfdb2e#twitter.gs

### טריגרים

![טריגרים](./triggers.png)

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

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

![הוספת טריגר](./add-trigger.png)

## סיכום

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

מה בפועל אפשר לעשות עם סקריפטים קטנים כאלה? מתברר שהרבה.  
אני חושב שעמרי מבסס את [זזנו-בוט](https://zaznoobot.herokuapp.com/) על GAS.

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

- **[סיכום פודקאסטים](<https://twitter.com/search?f=live&q=(%23%D7%A1%D7%99%D7%9B%D7%95%D7%9D_%D7%A4%D7%A8%D7%A7)%20(from%3Abaruchiro)%20filter%3Alinks&src=typed_query>):**  
  כשאני שומע פודקאסט בפלאפון, אני עושה share לבוט בטלגרם.  
  GAS מקבל את ההודעה ומחלץ מתוך הURL (בעזרת פונקציית [`IMPORTXML`](https://support.google.com/docs/answer/3093342)) את כותרת הפרק ושם הפודקאסט, ומוסיף אותם לטבלה בSheets.  
   בזמני הפנוי אני נכנס לאפליקצייה שבניתי בעזרת [Glideapps](https://www.glideapps.com/) וכותב סיכום לפרק ששמעתי. יש מיפוי אוטומטי משם הפודקאסט לתיוגים שאני רוצה להוסיף להודעה, אבל אם אני רוצה לתייג אורח למשל, אני מוסיף את התיוג שלו.  
   יש לי checkbox שאני מסמן כשהסיכום מוכן, וGAS מזהה אותו ובונה הודעה לטוויטר ולטלגרם, ומצייץ ושולח.
- **ארגון מסמכים:**  
  אני משתמש בתוכנת [paperwork](https://openpaper.work/) לתיוק המסמכים שאני מקבל בדואר ובמייל. התוכנה מסדרת אותם במבנה תיקיות וקבצים מסוים, אז יש לי פילטר במייל שמתייג הודעות קבועות שמכילות קובץ שאני רוצה לשמור, וGAS עובר על המייל אחת ל10 דקות ומוצא את ההודעות הללו, לוקח את הattachment, שומר אותו בDrive במבנה תיקיות הנכון ומשנה את התיוג של ההודעה.

### בונוס - ממשקים נוספים

קוד כל, אם קישרתם את פרויקט הGAS שלכם לGoogle Sheets, אני ממליץ לשמור את הstate שלכם בגליון (תכל'ס לא ידוע לי על דרך אחרת).

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

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

אבל חוצמיזה, אני ממליץ לכם לבדוק את [GlideApp](https://www.glideapps.com/), בניית אפליקצייה מבוססת Google Sheets. תלוי מאיזה כיוון אתם מסתכלים על זה, אבל לכאורה אפשר להגיד שקיבלתם אפליקצייה, עם צד שרת וDB, והכל בחינם וכל כך פשוט.

זהו, אני אשמח לקבל פידבק, רעיונות נוספים ובלוגים מומלצים. תודה שקראתם עד כאן!
]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[השקעות]]></title>
            <link>https://baruchiro.online/chapter3/</link>
            <guid>https://baruchiro.online/chapter3/</guid>
            <pubDate>Sat, 22 Jan 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[אז ניגש לעניין- השקעות. מה זה אומר להשקיע, למה חשוב לשים לב לכמה זמן אנחנו הולכים להשקיע, כמה זה מסוכן ומה היא רמת סיכון?
]]></description>
            <content:encoded><![CDATA[
> [קישור לפוסטים נוספים בסדרה](https://bscstudent.netlify.app/tag/%D7%9B%D7%A1%D7%A3/).

---

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

---

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

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

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

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

## אפשרויות וסוגי השקעה

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

### מיסים

על **רווחים** שהרווחנו משוק ההון, אנחנו מחויבים לשלם _מס רווחי הון_, שהוא 25%. אבל שימו לב, 25% **מהרווחים**, כלומר הוא לא יגרום לנו פתאום להפסיד כסף, אלא רק יקצץ קצת את הרווח.

יש כמה כלים להשקעות:

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

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

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

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

### איך משקיעים

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

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

## מה עושים?

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

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

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

> שאלות? רעיונות? שיתופים? עזר לכם? אני אשמח מאוד לשמוע.
]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ריבית דריבית]]></title>
            <link>https://baruchiro.online/chapter2/</link>
            <guid>https://baruchiro.online/chapter2/</guid>
            <pubDate>Sun, 16 Jan 2022 00:00:00 GMT</pubDate>
            <description><![CDATA[על המושג "ריבית דריבית", המשמעות שלו, ולמה הוא הבסיס לרעיון שכסף עובד בשבילנו.
]]></description>
            <content:encoded><![CDATA[
> [קישור לפוסטים נוספים בסדרה](https://bscstudent.netlify.app/tag/%D7%9B%D7%A1%D7%A3/).

**חידה:** אם נגיף מסוים משכפל את עצמו בכל דקה, ואחרי שעה הנגיפים ממלאים את כל המבחנה, כמה זמן ייקח להם למלא את המבחנה אם נתחיל עם 2 נגיפים?

אז הפעם נדבר על _ריבית דריבית_.

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

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

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

## מה זה ריבית דריבית?

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

אז במקרה של חסכונות והשקעות, הריבית היא הכסף **הנוסף על מה שהכנסנו** שהתווסף עם הזמן. זה יכול להיות ה3% הזה של פקדון בנקאי.

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

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

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

### מה עושים?

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

מה ההבדל בין להכניס את הכסף לחסכון **היום** לבין להתעכב ולהתלבט ולהשוות דמי ניהול ולבצע את זה רק **בשנה הבאה**? מה תהיה המשמעות של העיכוב הזה עוד 5 או 10 שנים?

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

---

עזר לכם? עדיין חוששים? משהו אחר תוקע אתכם?

שתפו אותי, נראה אם כבר עברתי את הבעיה הזאת בעצמי.
]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[מה עושים עם כסף בעובר ושב?]]></title>
            <link>https://baruchiro.online/chapter1/</link>
            <guid>https://baruchiro.online/chapter1/</guid>
            <pubDate>Sat, 25 Dec 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[מה עושים עם כסף שיש בעובר ושב, או אם רוצים לחסוך כסף שנשפך מהעובר ושב?
שיחה שהייתה לי עם חברים.
]]></description>
            <content:encoded><![CDATA[
> [קישור לפוסטים נוספים בסדרה](https://bscstudent.netlify.app/tag/%D7%9B%D7%A1%D7%A3/).

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

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

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

## אז מה עושים עם הכסף שיושב בעו"ש (או שמתרוקן ממנו)? איך חוסכים?

והתשובה, תסלחו לי שאני מרחיב וחופר:

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

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

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

### שלוש נקודות עיקריות בהקשר של מסלולי השקעה:

- **דמי ניהול**. אנחנו משלמים כסף כמובן על ניהול התיק.  
  יש דמי ניהול מצבירה- כל כמה זמן לוקחים אחוז קטנטן מהכסף שצברנו.  
  ודמי ניהול מהפקדה- לוקחים אחוז קטנטן מכל הפקדה שאנחנו מפקידים.
- **רמת סיכון**. זה כמובן נושא בפני עצמו, אבל בכמה מילים, מניות זה מסוכן (אבל לא לברוח. ללמוד!), כל "80,000 פאסיבי" מגיע עם סיכון בהתאם. אז בדרך כלל רמת הסיכון בפועל אומרת כמה מהכסף שלנו מושקע במניות, לעומת כמה ממנו מושקע באפיקים יותר בטוחים.
- **מיסים**: כסף שמרוויחים בהשקעות כאלה מחויב ב[מס רווחי הון](https://he.wikipedia.org/wiki/%D7%9E%D7%A1_%D7%A8%D7%95%D7%95%D7%97_%D7%94%D7%95%D7%9F), שהוא 25% **מהרווחים** שצברנו (ולא מסך כל הכסף, זה אומר שאין מצב שהוא יגרום לכם לקבל פחות ממה שהכנסתם). (ולא אמרתי שהוא מחייב את הפנסיה שלכם או את קרן ההשתלמות)

### מה הקשר לכסף שלנו שיושב בעובר ושב?

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

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

לתכל'ס, יכול להיות ששמעתם כבר, יש מכשיר שנקרא "[קופת גמל להשקעה](https://www.kolzchut.org.il/he/%D7%A7%D7%95%D7%A4%D7%AA_%D7%92%D7%9E%D7%9C_%D7%9C%D7%94%D7%A9%D7%A7%D7%A2%D7%94)". מותר לפתוח רק אחד כזה עבור מספר תעודת זהות מסוים, ויש לו מגבלת הפקדה של 70,000 ₪ בשנה בערך.

הכלי הזה מוגדר על ידי המדינה ומפוקח על ידה, כך ש

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

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

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

## אז מה עושים?

יש לכם כסף מיותר בעובר ושב ו\או החלטתם שאתם צריכים לחסוך?

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

> הנה סרטון שמסביר את כל העניין לאנשים פשוטים כמונו: [ליאור שפירא - מאניטיים: הדרך הכי קלה להתחיל להשקיע (בעיני)](https://www.youtube.com/watch?v=A8sYJdQuDXw)

עזר לכם? עדיין חוששים? משהו אחר תוקע אתכם?

שתפו אותי, נראה אם כבר עברתי את הבעיה הזאת בעצמי.
]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[רשימת מקורות ללימוד על השקעות]]></title>
            <link>https://baruchiro.online/invest/</link>
            <guid>https://baruchiro.online/invest/</guid>
            <pubDate>Sat, 18 Dec 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[לאחרונה ניסיתי להבין מה עושים עם הכסף שבעו"ש. כמובן שלא משאירים אותו שם. אבל למה? ומה כן אפשר לעשות?
הלוואי שהייתי כבר מומחה בזה, אבל בינתיים, הנה המקומות שמהם למדתי.
]]></description>
            <content:encoded><![CDATA[
> [קישור לפוסטים נוספים בסדרה](https://bscstudent.netlify.app/tag/%D7%9B%D7%A1%D7%A3/).

## הקדמה

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

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

### מקורות שאני למדתי מהם

- [ערך מוסף בשבילי](https://www.kan.org.il/podcast/program.aspx/?progId=2084)
  > ליאור תבורי וטל וולפסון, בוגרי משרד האוצר, משוחחים בכל פרק על מושג יסוד אחר בכלכלה. הסדרה מנגישה באופן נהיר וברור מושגים שכולנו שומעים מידי יום ולא תמיד מבינים את משמעותם.
- [# להיות על זה ביחד 💪](https://www.facebook.com/groups/riseuptogethergroup)

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

  קבוצת פייסבוק של חברת [Riseup](https://www.riseup.co.il/), חברת הייטק עם מוצר שעוזר לישראלים רגילים לשלוט בהוצאות שלהם.

- [פרוטה](https://www.pruta.co.il/),  
  ארגון קטן שעוזר בתכנון וליווי פיננסים, עם המטרה שהלקוח ייצא עם יותר ידע ויוכל להסתדר בעצמו.

- [ליאור שפירא - מאניטיים: הפודקאסט](https://anchor.fm/money-time)!  
  סדרת הסרטונים של ליאור שפירא, בפורמט של פודקאסט. זה נעשה [על פי בקשתי](https://twitter.com/LiorShapira2/status/1472840274074288133), מאוד כיף בטוויטר.
  כדי להבין למה אני כל כך אוהב את הגישה של ליאור, כדאי להאזין [לפרק השני](https://anchor.fm/money-time/episodes/2-4-e1bu0jt) שלה, בוא היא מסבירה שפחות חשוב לה לדייק ויותר חשוב לה שאנשים יידעו מה הם צריכים לעשות בלי להסתבך.

### מקורות מומלצים שפחות התחברתי אליהם

- [הסולידית](https://www.hasolidit.com/), בלוג מוכר מאוד של מישהי אנונימית על "עצמאות כלכלית דרך חיסכון אגרסיבי והשקעה פסיבית". יש שיגידו שהוא "אגרסיבי" מידי.
- [ליאור שפירא - מאניטיים](https://www.youtube.com/c/LiorSha), ערוץ יוטיוב קליל ואותנטי, בגובה העיניים, על מה אנחנו כאנשים פשוטים יכולים לדעת ולעשות לטובת העתיד הכלכלי שלנו. אני ממליץ בחום, אבל פחות התחברתי כי אני פחות בקטע של יוטיוב (אולי אני צריך להמיר את זה לפודקאסט?)
- [ידע שווה כסף](https://yeda-kesef.co.il/), אתר אינטרנט, פודקאסט, קבוצה בפייסבוק ואפילו [Quora](https://yd-swwh-ksp.quora.com/)!, הומלץ לי על ידי מתניה נזרי. אני אבדוק.
- [ברק הס ייעוץ והשקעות](https://barakhass.co.il), חברת השקעות וייעוץ, יש גם [קבוצה בפייסבוק](https://www.facebook.com/barakfinance/) וגם קבוצות ווטסאפ עם טיפים. קיבלתי עליהם המלצות מאנשים שאני מעריך את הידע הפיננסי שלהם, אבל בסוף לא הלכתי להתייעץ איתם מסיבות אישיות.

אשמח לקבל עוד מקורות ללמידה.
]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[כסף - הקדמה]]></title>
            <link>https://baruchiro.online/getting-started/</link>
            <guid>https://baruchiro.online/getting-started/</guid>
            <pubDate>Sat, 18 Dec 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[למה ועל מה אני הולך לדבר בנושא של כסף, השקעות והתנהלות פיננסית.
]]></description>
            <content:encoded><![CDATA[
> [קישור לפוסטים נוספים בסדרה](https://bscstudent.netlify.app/tag/%D7%9B%D7%A1%D7%A3/).

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

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

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

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

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

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

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

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

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

### מה עושים?

קודם כל, מתחילים להבין קצת את השפה. אספתי [רשימת מקורות](https://bscstudent.netlify.app/invest/) שלמדתי מהם או ששמעתי עליהם, ואני ממליץ לכם למצוא תוכן מקצועי **במקומות שאתם כבר נמצאים בהם**, כדי להיחשף לשפה, למושגים, ולהחלטות. (אני אשמח לקבל קישורים לעוד תכנים איכותיים)

אני מקווה לפרסם כל שבוע עוד איזה מסקנה שלמדנו או תהליך שאנחנו עושים, כדי להקל קצת על חוסר הידע והפחד.
]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[לקבל Types בJavaScript בלי לעבור לTypeScript]]></title>
            <link>https://baruchiro.online/jsdoc-types/</link>
            <guid>https://baruchiro.online/jsdoc-types/</guid>
            <pubDate>Fri, 20 Aug 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[ללא ספק, TypeScript נהיה נפוץ יותר ויותר. אם אתם מהמתנגדים, או שפשוט המעבר יעלה לכם הרבה, הנה הדרך שבה אתם יכולים להתחיל להיעזר בTypes בלי לגעת באף הגדרה של הפרויקט שלכם!
]]></description>
            <content:encoded><![CDATA[
## למה צריך Types בכלל?

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

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

למשל, גם אם לא צריך Types בשביל לזכור שבתוך `user` יש `user.name` ו`user.password`, לפעמים יש מקרים שבהם יש אובייקט מורכב מאוד, למשל במקרים שבהם מושכים הרבה נתונים מNoSQL, או מקבלים תשובה בREST API. במקרים כאלה, לזכור את מבנה האובייקט, לטייל בו ולהוציא ממנו נתונים זה כבר ממש קשה.

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

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

## אז למה לא TypeScript

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

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

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

## Types without TypeScript?

אז כן, זה אפשרי!

בVSCode אפשר להגדיר Types בתוך הערות מיוחדות, הערות [JSDoc](https://jsdoc.app/) שמיועדות לתיעוד. בסופו של דבר, TypeScript הוא הרחבה של JavaScript וכל JS יכול להיחשב כTS, אז VSCode ישתמש בכלי הTS שלו כדי להבין את הTypes ולתת לנו הצעות והערות.

זה נראה ככה:

```javascript
/**
 * @param {number} a
 * @param {number} b
 * @returns {number}
 */
function add(a, b) {
  return a + b;
}
```

כהרגלי, אני לא הולך להיכנס עמוק לתוך נושאים שאפשר בקלות לשאול את גוגל או לבדוק [בתיעוד](https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html), אז אנחנו נתמקד רק בכמה עקרונות:

### Syntax

אז מכיוון שהTypes לא משולבים בקוד, יש שילוב של תיעוד עם TypeScript. וזה מאוד פשוט בסה"כ.

```javascript
@what {TypeScript} [who]
```

כלומר, קודם כל תבוא הגדרה של JSDoc לגבי **מה** אנחנו מגדירים, למשל `param` או `return` (ונראה עוד בהמשך). לאחר מכן יבוא **הTypeScript עצמו**, בתוך סוגריים מסולסלים, ובסוף, תלוי ב"**מה**", יכול לבוא עוד משתנה שמכוון למקום הנכון.

### מה

מלבד מה שראינו בדוגמא הראשונה, על פרמטר ותוצאה של פונקציה, יש עוד שני סוגים עיקריים של הגדרת Types עם JSDoc.

```javascript
/**
 * @typedef {{name: string, password: number}} User
 */
```

ה`typedef` משמש אותנו להגדרה של Type חדש, והוא לא חייב להיות צמוד לפונקציה או לקוד אחד. אחרי שהגדרנו אותו, נוכל להשתמש בו בהמשך כדי להצהיר על מערך של Users בקלות, למשל.

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

```javascript
/**
 * @type User
 */
let user;
```

השימוש ב`type` הוא כדי לתת הגדרה למשתנה ספציפי, ללא פונקציה.

### Type Inference

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

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

אם ניקח את הדוגמא הראשונה:

```javascript
/**
 * @param {number} a
 * @param {number} b
 * @returns {number}
 */
function add(a, b) {
  return a + b;
}
```

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

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

### Import

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

אם הגדרתם אותו בעזרת `typedef`, תוכלו לייבא אותו עם `import`:

```javascript
/**
 * @typedef {import('./types').User} User
 */
```

אני ממליץ לייבא ולהצהיר עליו מחדש, כמו בדוגמא, כדי לחסוך את הכתיבה של ה`import` בכל פעם.

### ts-check

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

כדי להציג שגיאות של Types, יש להוסיף בראש הקובץ `// @ts-check`. האמת היא שניתן גם להגדיר את זה ברמת הפרויקט או בהגדרות של VSCode, אבל בגלל שזה לא ממש עבד לי, אני לא רוצה לתת פה דברים שאני לא בטוח בהם, אז פשוט תסתכלו [בתיעוד](https://code.visualstudio.com/docs/nodejs/working-with-javascript#_type-checking-javascript) ותנסו לראות אם אתם מצליחים.

## סיכום

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

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

והכי חשוב, תשקיעו את הזמן בקוד ולא בהגדרה של הTypes שלו!

> הערות? החלטתם להתחיל להשתמש? שתפו אותי :-)
]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to setup auto semantic-release]]></title>
            <link>https://baruchiro.online/semantic-release/</link>
            <guid>https://baruchiro.online/semantic-release/</guid>
            <pubDate>Tue, 27 Jul 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[Setup auto-increment, release, and changelog with semantic-release, in Github repo with Github Actions.
]]></description>
            <content:encoded><![CDATA[
## Semantic Versioning

_Semantic Versioning_ (AKA _SemVer_) is a convention for package versions. Since it is the most used convention (AFAIK, I don't know about others...), it is well documented and widely used around the open-source, so I'm not going to describe it. You can read more [here](https://semver.org/).

## Semantic Release

_Semantic Release_ is a tool to implement _SemVer_ automatically in a project.

> Fully automated version management and package publishing
> _from [Semantic Release](https://semantic-release.gitbook.io/) docs._

In this post, I want to share with you the process of adding and configuring the `semantic-release` tool, because I had to collect the information from multiple sources, even from the source code of the tool.

Let's start.

### Prerequisites

In this post, I assume you have

- [ ] a _NodeJS_ project (with a `package.json` file)
- [ ] in a _Github_ repository
- [ ] with basic knowledge in _Github Actions_
- [ ] and fearlessly use CLI and read its output

### Command Line

The `semantic-release` feels like a great tool, and it does a lot of things by default, and does them right.

The first thing you want to do is to run the tool, just like that. Don't worry, it will identify that you're not in a CI environment, and it will automatically run on _dry_ mode.

In your project folder, run `npx semantic-release`, it will print some beautifully organized output. Read that output.

First of all, it failed because of **missing tokens**, follow the links inside the errors to create the tokens.

It will not create a version (dry run), and you expect one of the next messages:

<details>
<summary><code>There is no previous release, the next release version is 1.0.0</code></summary>

If you never published a release before (and **release** means **git tag**), `semantic-release` will create a default version `1.0.0` in any way.

</details>

<details>
 <summary><code>configured to only publish from master</code></summary>

The whole line:

> `This test run was triggered on the branch foo, while semantic-release is configured to only publish from master, therefore a new version won’t be published.`

We will see the `semantic-release` is triggering a version when pushing to specific branches. If you're not in the `master` branch, the `semantic-release` will not process your git history to create a version.

</details>

<details>
 <summary><code>There are no relevant changes, so no new version is released.</code></summary>

Maybe you see messages about `Analyzing commit` because you committed some changes since your last version, but eventually, the `semantic-release` didn't find a commit message in a pattern to create a new release.

We will touch on the commit messages pattern later.

</details>

<details>
 <summary><code>Published release 1.1.0 on default channel</code></summary>

OK, but it did nothing because, with _dry-run mode_, all the actions were skipped, this is just a completion message.

</details>

### Commit Format

We ran the `semantic-release` tool with the default configurations. Before any other configuration adjustment, the most important thing you may ask is, why is `semantic-release` analyzing my commits but `There are no relevant changes`?

That is because `semantic-release` uses [commit message format](https://semantic-release.gitbook.io/semantic-release/#commit-message-format) to decide if and what version should be bumped.

Try to commit with the message `perf(pencil): remove graphiteWidth option` and see if now it's deciding to bump your version.

### Configuration

I saw the [default commit format (Angular Conventions)](https://semantic-release.gitbook.io/semantic-release/#commit-message-format) and I felt it will add overhead and will be less readable, and it is not worth the time I'm saving with automatic releasing. I wanted to change the commit format.

To do that, we need to [configure](https://semantic-release.gitbook.io/semantic-release/usage/configuration) the `semantic-release`, and since any configuration section will override the default configuration we used so far, I think the best idea is first to configure the default configuration explicitly, and then start to adjust it.

The default configuration for the relevant sections (in [`release.config.js`](https://semantic-release.gitbook.io/semantic-release/usage/configuration#configuration-file) format) is:

```javascript
module.exports = {
  branches: [
    "+([0-9])?(.{+([0-9]),x}).x",
    "master",
    "next",
    "next-major",
    {
      name: "beta",
      prerelease: true,
    },
    {
      name: "alpha",
      prerelease: true,
    },
  ],
  plugins: [
    "@semantic-release/commit-analyzer",
    "@semantic-release/release-notes-generator",
    "@semantic-release/npm",
    "@semantic-release/github",
  ],
};
```

- [Default `branches`](https://semantic-release.gitbook.io/semantic-release/usage/configuration#branches)
- [Default `plugins`](https://semantic-release.gitbook.io/semantic-release/usage/plugins#default-plugins)

#### Branch Configuration

The first configuration I wanted to change is the `branches`. For me and for now, I just need to trigger the release on the `master` branch, you can see how simple is the, just `branches: ['master']` instead of the current config.

---

##### So far so good?

You have that configuration, you may push and start using automatic release. What else?

For me, I wanted to take it few steps forward, to

- [ ] Use more convenient and readable commit messages.
- [ ] Set the commit message just before finishing the PR, and not on each commit.
- [ ] Manage a `CHANGELOG` file.
- [ ] _Bonus:_ Tweet about the new version

Let's continue.

## Custom Commit Message Convention

The default plugin [`@semantic-release/commit-analyzer`](https://github.com/semantic-release/commit-analyzer) is responsible to analyze the commit message, and it is configured by two settings:

1. The _convention_ (`preset`)
2. The _rules_ (`releaseRules`)
3. (Other options: `parserOpts`)

I decided to follow the [ESLint convention](https://github.com/conventional-changelog/conventional-changelog/tree/master/packages/conventional-changelog-eslint):

```markdown
# Format:

Tag: Short description (fixes #1234)

# Examples:

Build: Update Travis to only test Node 0.10 (refs #734)
Fix: Semi rule incorrectly flagging extra semicolon (fixes #840)
Upgrade: Esprima to 1.2, switch to using comment attachment (fixes #730)
```

This format is better, right?

To use this format, we first need to select `eslint` as our `parser`, but surprise! It is not coming with all its default available tags (the `Build`, `Fix`, `Upgrade` and more), and instead, the `@semantic-release/commit-analyzer` [will handle only a four tags](https://github.com/semantic-release/commit-analyzer/blob/4fa5c212ce40bd45c3f8b340d693d9b58f8a55d7/lib/default-release-rules.js#L23-L27):

```javascript
{tag: 'Breaking', release: 'major'},
{tag: 'Fix', release: 'patch'},
{tag: 'Update', release: 'minor'},
{tag: 'New', release: 'minor'},
```

You can keep it with this default, or if you want to add more tags, you can add your custom object to **replace** the default one.

For me, the `plugins` are now:

```javascript
plugins: [
  [
    "@semantic-release/commit-analyzer",
    {
      preset: "eslint",
    },
  ],
  [
    "@semantic-release/release-notes-generator",
    {
      preset: "eslint",
    },
  ],
  "@semantic-release/npm",
  "@semantic-release/github",
];
```

**Note** that I had to update the `@semantic-release/release-notes-generator` settings since it is also analyzing the commits to generate the release notes.

And finally, I documented the default tags in my repo, just to easily find them if I forgot.

## Conventional PullRequest title

For now, you expect the contributors to use the conventional commit messages (and you may use [commitlint](https://github.com/conventional-changelog/commitlint)). But you don't have to force it.

First of all, you can keep it optional, and if you want to trigger a new release, make sure that one of the commits in a PR is in the convention.

In my repos, I'm using two conventions, side by side:

### Merge Commit

If the Pull Request contains more than one change (and of course, in multiple commits), although it is not best practice, you know, a small repo without contributors... Anyway, in that case, I'm looking at the commits to see if there are _conventional commits_ there, and if so, I'm **merging** the PR, and the commits will be in the `master` branch and will trigger the release.

### Squash Commits

If the PR is only about one change, we don't have the commits to be conventional. Instead, we can change the **pull request title** to be conventional, and **squash** the pull request to be only one commit in `master`. In _Github_, by default, the **pull request title becomes to be the commit message in squash merge**.

To help me to remember that, I created a _Github Actions workflow_ to validate the pull request title and comment on the PR if the title does not match my convention.

```yaml
name: PR Title

on:
  pull_request:
    types: [opened, edited, synchronize, reopened]

jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - uses: deepakputhraya/action-pr-title@3864bebc79c5f829d25dd42d3c6579d040b0ef16
        name: Validate PR Title
        continue-on-error: true
        with:
          regex: '\w+:( [\w\.,]+)+( \(\w+ #\d+\))?' # Regex the title should match.
          # allowed_prefixes: 'feature,fix,JIRA' # title should start with the given prefix
          # disallowed_prefixes: 'feat/,hotfix' # title should not start with the given prefix
          # prefix_case_sensitive: false # title prefix are case insensitive
          # min_length: 5 # Min length of the title
          max_length: 50 # Max length of the title
          github_token: ${{ secrets.GITHUB_TOKEN }} # Default: ${{ github.token }}
      - uses: mshick/add-pr-comment@07f690343c25a94e24a8acb70d03c86b701ae322
        name: Comment on PR
        if: ${{ failure() }}
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          message: |
            Please fix the title of this PR.

            Example: `New: Add new feature`

            See more in `/docs/RELEASE.md`.
```

> I compared a lot of optional actions to do this validation and comment, and I'm not sure I selected the best. Please share with me your suggestions.

## Manage a CHANGELOG file

There is a practice to manage a file with all the release notes, for all the versions, listed on it.

Unfortunately, I can't think about a beautiful way to update the CHANGELOG without adding another commit after the release.

To generate the CHANGELOG and commit it, we will add two (obvious) plugins to semantic-release: [`@semantic-release/changelog`](https://github.com/semantic-release/changelog) and [`@semantic-release/git`](https://github.com/semantic-release/git).

```javascript
plugins: [
  ...
  [
   "@semantic-release/changelog",
   {
    "changelogFile": "CHANGELOG.md"
   }
  ],
  [
   "@semantic-release/git",
   {
    "assets": ["CHANGELOG.md"],
    "message": "${nextRelease.version} CHANGELOG [skip ci]\n\n${nextRelease.notes}"
   }
  ]
  '@semantic-release/npm',
  '@semantic-release/github'
]
```

**Please note** the plugins are running sequentially, and you have to put the `changelog` plugin **before** the `git` plugin.

This configuration will first update the `CHANGELOG.md` file in the local folder, and after that will commit it with a custom message, includes the `[skip ci]`, to mark this commit as out of release process.

## _Bonus:_ Tweet about a new release

Now you have a fully working process to automate your release, and more than that, I hope you got enough information to continue to adjust the process to your needs.

One more thing I'm doing is to [tweet about new releases](https://twitter.com/hashtag/send_tweet_action), to implement, follow the instructions in [ethomson/send-tweet-action](https://github.com/ethomson/send-tweet-action).

If you want to get the new version number (or any other value) from `semantic-release`, you need to put it in Environment Variables, and you can do it with [@semantic-release/exec](https://github.com/semantic-release/exec):

```javascript
plugins: [
  ...[
    "@semantic-release/exec",
    {
      successCmd: 'echo"SEMVER_VERSION=${nextRelease.version}" > $GITHUB_ENV',
    },
  ],
];
```

## Summary

> [Finally, all my configuration files](https://gist.github.com/baruchiro/3a52a9897556a880b32f74f03caca299.js).

---

Update: while writing this post to document my process, I finally found [another blog post that already documented it](https://svdoscience.com/2020-10-31/versioning-with-semantic-release), you are welcome to use both :-).

Thanks to my teammate [Leonid Weinberg](https://www.linkedin.com/in/leonid-weinberg-a45964143/) who review the article to correct language errors.
]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[איך להשפיע במקום העבודה גם בלי ותק ותפקיד]]></title>
            <link>https://baruchiro.online/work-impact/</link>
            <guid>https://baruchiro.online/work-impact/</guid>
            <pubDate>Thu, 15 Jul 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[אני בסה"כ מתכנת צעיר, בורג קטן בחברה גדולה, ואני נהנה מהמקום הזה.
אבל למרות זאת, אני מרגיש שיש לי השפעה על הארגון, ושאני מזיז דברים.
איך עושים את זה?
]]></description>
            <content:encoded><![CDATA[
כשחושבים על זה (ולא חשבתי על זה בעצמי, שמעתי באיזה פודקאסט), אנחנו בוחנים את ההתקדמות והחשיבות שלנו בחברה על פי רמת ההשפעה שלנו. למה אני רוצה להיות ראש צוות או ארכיטקט? כי טביעת האצבע שלי תהיה על הקוד או על הכיוון שהמוצר ילך אליו.

אז יש מסלולי קריירה, ואנחנו מחכים בסבלנות (או עוברים מקום עבודה בשביל אופטימיזציה) עד שיקדמו אותנו, או שאנחנו [נדחפים לפגישות ומנסים לקבל החלטה במקום מישהו אחר](http://notarbut.co/ep99/), וכל עוד זה לא קורה, אנחנו פשוט מנסים לבלוט מעל כולם.

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

## המסמך

אוי ואבוי. התחלנו?

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

אז כמובן שלא.

הנה כמה סיבות לכתיבת מסמך שמתאר את הרעיון או היוזמה שלכם:

### איפיון מלא

מכירים [Rubber ducking](https://he.wikipedia.org/wiki/%D7%A0%D7%99%D7%A4%D7%95%D7%99_%D7%A9%D7%92%D7%99%D7%90%D7%95%D7%AA_%D7%91%D7%90%D7%9E%D7%A6%D7%A2%D7%95%D7%AA_%D7%91%D7%A8%D7%95%D7%95%D7%96_%D7%92%D7%95%D7%9E%D7%99)? בתור התחלה, כתיבת מסמך בעצם גורמת לכם להסביר בצורה מדויקת את מה שאתם רוצים להגיד. כל עוד מדובר רק במחשבות שלכם, או בשיחות מסדרון שעשיתם עם חברים, יש לכם כיוון וקו מחשבה מאוד ברור, ואתם לא רואים את הסטיות והמקומות שבהם הוא נחתך. אבל כשתנסו לכתוב אותו, זה בעצם כמו להסביר לברווז גומי. אין לו מושג על מה מדובר, וצריך להסביר לו בלי הנחות יסוד.

אפשר לחפש פורמטים באינטרנט, או להתבסס על [ידע קודם](https://bscstudent.netlify.app/ihis-computers/) כדי לכתוב מסמך איפיון שיכסה את כל הדברים שאתם רוצים לכסות. אבל הכי חשוב, להשתמש במסמך ככלי. גם אם זה שלב בירוקרטי הכרחי בחברה שלכם, מהסיבות שאני מפרט פה, כדאי לנצל את הכתיבה לחידוד הרעיון.

### רצינות

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

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

### כיוון

כשצוללים לעבודה, למימוש, לפעמים שוכחים את המטרה. שוב, כמו ב[מודל עסקי](https://bscstudent.netlify.app/ihis-computers/), כל שלב נגזר מההנחות שהנחנו בשלב הקודם. במהלך העבודה אנחנו נדרשים לקבל החלטות, ולפעמים עוזר מאוד לבחון את ההתלבטויות לעומת המטרות שהצבנו בהתחלה.

## המנהל

מנהלים רוצים חדשנות, פרויקטים, יוזמות.

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

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

### עזרה

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

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

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

### חתימה

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

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

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

## הסבלנות

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

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

במקומות האלה אנחנו נבחנים. האם אנחנו באמת מאמינים בפרויקט?

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

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

---

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

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

בהצלחה!
]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to sync component state with React Router]]></title>
            <link>https://baruchiro.online/use-route-as-state/</link>
            <guid>https://baruchiro.online/use-route-as-state/</guid>
            <pubDate>Wed, 07 Jul 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[Custom hooks with the useState interface to use the React Router state as the component state.
]]></description>
            <content:encoded><![CDATA[
[![npm](https://img.shields.io/badge/npm-use--route--as--state-informational?logo=npm)](https://www.npmjs.com/package/use-route-as-state)

## Use Case

You have a webpage showing your data, and an input component that controls the filtering of that data.

**For example**, you have a simple **list of students**, and a **search box** that filters the list as you type.

You want, of course, to make the `value` of the input reactive, in order to change the subset of the data whenever the `value` changes.

But you also want the user to be able to **share a link** to the current status of the page at any time.

**In our example**, you want the contents of the search box to be represented in the URL as well, as _Query String_, for example.

![searchlist2](https://dev-to-uploads.s3.amazonaws.com/i/r6iag63d4moogzazcp5n.gif)

##### Let's see how to make the `value` from one component to be reactive to both **component state** and **Router**, with clean code.

## The Simple (but complicated) Way

We will start with the direct way. We need to **get the data from the `route`**, and **update the route on change**:

> We have a few APIs (hooks) to get the data from the _Router_. For this post I chose to use [_URL Params_](https://reactrouter.com/web/example/url-params) with [`useParams`](https://reactrouter.com/web/api/Hooks/useparams) for simpler code samples, although in a real app, _Query String_ make more sense for this kind of use case.

> **Note** that to use _URL Params_ you have to declare the params in the _Router_ `path` prop, something like `/:param1/:param2?`.

### Get the data from the `route`

When the component mounts, we need to read the _URL Params_, in case the user gets to our component from a link that should affect the state:

```react
const SearchBox = () => {
    const { param1 } = useParams()
    const [search, setSearch] = useState(param1)
}
```

But this is not enough, since route changes often don't reload the page (which is good). If there is no page reload, the state won’t change because the component is already mounted.

We need to define the _URL Param_ change as an effect:

```react
const SearchBox = () => {
    const { param1 } = useParams()
    const [search, setSearch] = useState()

    useEffect(() => setSearch(param1), [param1])
}
```

✔️ Getting the data from the `route` is done - the **state** is synced with the **route** (but the **route** is not synced with the **state**).

{% codesandbox react-router-url-parameters-forked-1ub6s module=/RouteParams.js initialpath=/li %}

### Update the route on change

Now we can update the `search` state with `setSearch`, but we want to keep the URL up to date with the latest `search`, in order to allow the user to copy the URL at any time.

The only way (that I know) to change the URL with _React Router_ is with the [`history` API](https://reactrouter.com/web/api/history):

```react
const SearchBox = () => {
  // Code from previous examples

  return (
    <div>
      <input
        type="text"
        value={search}
        onChange={(e) => history.replace("/" + e.target.value)}
      />
      <SearchList search={search} />
    </div>
  );
};
```

✔️ Update the route on change is done - change the `route` instead of the `state`, and the `state` will get updated from the `useEffect` hook.

{% codesandbox react-router-url-parameters-forked-dk35u module=/RouteParams.js initialpath=/li %}

## Interim conclusions

- It is working very well in our simple example (**even better than I thought!**)
- To use the `route` as our `state`, we used **four** hooks (`useParams`, `useState`, `useHistory` and `useEffect`) instead of **one** hook to get the `state` and a method to update it.
- We will need **more and more code** if we want to use _Query Params_ or if we want the `history.replace` function call to be more generic with the `path` argument.

Actually, the solution seems very simple at this point.

> **Spoiler**- I created a package that implements this solution.
> I must share that I wonder if I would have created this package if I had written the article earlier, and understood that the solution is simple and required.
> In any case, I felt a lack of idea-sharing of this solution, so I think it is worth writing the post and creating the package.

We need to hide all this logic in a _custom hook_.

## Organize the code

Let's move all the code to a dedicated function:

```react
const useCustomParams = () => {
  const { param1 } = useParams();
  const [search, setSearch] = useState();

  const history = useHistory();

  useEffect(() => setSearch(param1), [param1]);

  const replace = (newParam) => history.replace("/" + newParam);

  return [search, replace];
};
```

> You don't really need the `state` here, because you have a closed flow from `useParams` to the component, then with `history` back to the `useParams`.
> But you will need it for the _Query String_ case.

All that is left is not to be dependent on the `path` or specific _URL Param_:

```react
const useCustomParams = () => {
  const { params, path } = useRouteMatch();

  const history = useHistory();

  const updateParams = (updatedParams) => {
    Object.assign(params, updatedParams);
    history.push(generatePath(path, params));
  };
  return [params, updateParams];
};
```

I don't know the specific `path` or `params`, I just take, update and push them again.

{% codesandbox react-router-url-parameters-forked-6d236 module=/RouteParams.js initialpath=/li %}

---

After going through this process myself, and seeing that there was a lack of information on this subject, I created an npm package called [`use-route-as-state`](https://www.npmjs.com/package/use-route-as-state) that implements the solution described in the article.

You are welcome to [use](https://www.npmjs.com/package/use-route-as-state) and [contribute](https://github.com/baruchiro/use-route-as-state)!

Thanks to [@brafdlog](https://github.com/brafdlog) for linguistic editing and suggestions.
]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[כספיון: תוכנה חברתית לניהול מעקב אחרי ההוצאות וההכנסות שלנו]]></title>
            <link>https://baruchiro.online/caspion/</link>
            <guid>https://baruchiro.online/caspion/</guid>
            <pubDate>Mon, 05 Jul 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[איך למשוך בצורה אוטומטית את נתוני העובר ושב מחשבונות הבנק והאשראי, ולנתח אותם בכלים המועדפים עלינו או בכלים מוכרים לניהול הוצאות
]]></description>
            <content:encoded><![CDATA[
**אנחנו צריכים להכיר את ההכנסות וההוצאות שלנו**.

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

יש הרבה שאלות חשובות שצריך לשים לב אליהן, והרבה פעמים אפשר לראות באתר הבנק פילוח לפי קטגוריות, או אפילו להשתמש בשירותים חיצוניים, כמו [Riseup](https://www.riseup.co.il/), שמנסים ממש לעזור לנו לשלוט בהוצאות שלנו.

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

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

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

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

## הגישה

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

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

## קבלת הנתונים

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

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

> בשביל לפתור את הבעיה הזאת, פיתחנו את תוכנת [_כספיון_](https://brafdlog.github.io/caspion/)

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

במדריך הזה אני ממליץ להשתמש בייצוא ל**Google Sheets**, שיושב בחשבון הGoogle Drive שלכם באינטרנט ומאפשר להתממשק עם כלי ניתוח מתקדמים.

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

![import-export](./import-export.png)

כמובן, ללחוץ על כפתור _Run_.

לאחר הריצה, תוכלו לראות שהנתונים נמצאים בגליון שהתוכנה יצרה בחשבון ה[Google Drive](http://sheets.google.com/) שלכם.

![google-sheets](./google-sheets.png)

## הצגת הנתונים

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

אחרי נסיונות אני חושב שמצאתי ש[**Google Data Studio**](https://datastudio.google.com/overview) הוא הפתרון שהכי מתאים למקרה, כי הוא מאפשר מאוד בקלות להתחבר לנתונים בגליון של Google Sheets ולהציג אותם בצורות שונות וטווחי זמן שונים.

![google-data-studio](./google-data-studio.png)

העבודה עם _Google Data Studio_ דורשת התאמה, וככל שלומדים יותר על התוכנה ניתן להוציא ממנה יותר. אם זה מרגיש לכם מורכב מידי, תמיד אפשר להשתמש ב*כספיון* כדי לייצא לתוכנת [YNAB](https://www.youneedabudget.com/) שתנתח את הנתונים עבורכם.

### יצירת עותק מהTemplate

יצרתי Template בסיסי עם נתונים מומצאים מ*כספיון*. אפשר להגיע אל הTemplate מהקישור [הזה](https://datastudio.google.com/u/0/reporting/fd383078-4d62-429d-b7da-998d299f1c65/preview) וללחוץ על כפתור _USE TEMPLATE_.

תצוגות ב*Google Data Studio* מתבססות על נתונים ממקורות חיצוניים. מכיוון שהTemplate מבוסס על נתונים מזויפים שלא משותפים איתכם, תצטרכו ליצור קישור חדש לגליון שנוצר על ידי _כספיון_.

![create new data source](./create-new-data-source.png)

במסך שנפתח, ניתן לראות אפשרויות רבות לייבוא נתונים. אנחנו נבחר כמובן ב*Google Sheets*.

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

![select sheet](./select-sheet.png)

לחיצה בצד ימין למעלה על _CONNECT_.

אפשר לראות ש*GDS* זיהה את העמודות שיש לנו, ואת סוג הנתונים שבהם. כעת אפשר ללחוץ שוב בצד ימין למעלה על _ADD TO REPORT_.

## סיכום

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

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

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

> **בהצלחה!** ניתן לפנות אלינו לכל שאלה שיש.

[יהונתן גולדפרב](), [ברוך אודם](mailto:baruchiro@gmail.com)

---

### הערות וקישורים רלוונטיים

- הפרויקט שלנו מבוסס על [פרויקט ישראלי אחר](https://github.com/eshaham/israeli-bank-scrapers) שאחראי על ייצוא המידע מהבנקים.
- יש [פרויקט ישראלי נוסף](https://github.com/raziele/creditCardAnalysis) שמנתח קבצי נתונים מהבנקים, ומציג גרפים בתוך הגליון. אני מקווה שהוא [יתמוך בנו בקרוב](https://github.com/raziele/creditCardAnalysis/issues/10).
- דיוני אבטחת מידע אפשר למצוא [כאן](https://github.com/brafdlog/caspion/issues?q=is%3Aopen+is%3Aissue+label%3Asecurity) ו[כאן](https://github.com/eshaham/israeli-bank-scrapers/issues/588).
- לגבי קטגוריות לנתונים: כרגע התמיכה מאוד בסיסית, ואנחנו עוד צריכים לעבוד על זה. בינתיים אני עשיתי מיפוי ידני בGoogle Sheets משם העסק לקטגוריה שלו.
- השימוש בGoogle Data Studio עדיף על שימוש פשוט בGoogle Sheets, כי ברגע שאתה מנסה לפעול על מאגר של נתונים, ולא רק על שורה אחת, אתה מתחיל להסתבך עם שאילתת Query שאתה צריך לערוך אותה בתוך תא ודברים כאלה.
]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Starship CommandLine Upgrade]]></title>
            <link>https://baruchiro.online/oh-my-posh/</link>
            <guid>https://baruchiro.online/oh-my-posh/</guid>
            <pubDate>Tue, 22 Jun 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[שדרוג שורת הפקודה עם פרטי Git Repository, צבעים ועוד...]]></description>
            <content:encoded><![CDATA[
בעבודה אני עובד בWindows. תמיד ראיתי אנשים שמשתפים מסך עם איזה טרמינל של לינוקס, ויש להם Command Line מגניב כזה.

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

## עדכון: תשתמשו בStarship

בפודקאסט ["רברס עם פלטפורמה"](https://www.reversim.com/2021/05/410-bumpers-73.html), דותן הזכיר שהוא ראה מימוש בRust של שידרוג שורת הפקודה, שנקרא [Starship](https://starship.rs/).

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

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

שתפו איתי את ההגדרות שלכם!

### oh-my-\*

אז באופן כללי, השדרוג הזה נקרא \*oh-my-\*\*. כלומר, יש תוסף כזה לכל מיני שורות פקודה, וזאת הקונוונציה של השם.

### מה מקבלים

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

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

אפשר גם להתאים אישית את ערכת העיצוב.

### מה חשוב לדעת

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

אפשר לחפש גופני _Nerd_ [כאן](https://www.nerdfonts.com/).

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

## התוספים

- PowerShell: [oh-my-posh](https://github.com/JanDeDobbeleer/oh-my-posh)
- bash: [oh-my-bash](https://github.com/ohmybash/oh-my-bash)
- zsh: [ohmyzsh](https://github.com/ohmyzsh/ohmyzsh)
- הבנתם את הקטע...
]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[שילוב כלים לאוטומציה פשוטה וחינמית]]></title>
            <link>https://baruchiro.online/api-automations/</link>
            <guid>https://baruchiro.online/api-automations/</guid>
            <pubDate>Wed, 20 Jan 2021 00:00:00 GMT</pubDate>
            <description><![CDATA[איך לחבר כמה כלים, כדי לגרום לAPI לדבר ביניהם, מבלי לחרוג מהתכנית החינמית של כל כלי ובלי לכתוב יותר מידי קוד.]]></description>
            <content:encoded><![CDATA[
כידוע, אני חובב של דברים בחינם (או לא אוהב לשלם כסף, תלוי איך מסתכלים), וכידוע, פחות או יותר, אני חובב של פתרונות No-Code.

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

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

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

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

# Integromat

אז מתחילים מ[_Integromat_](https://www.integromat.com/), מתחרה של _Zapier_ ודומה ל*IFTTT*, למי שמכיר, והוא כלי בסיסי לכל פתרון No-Code. בIntegromat יש המון ממשקים להמון שירותים אינטרנטיים, והוא מאפשר לנו להגדיר תהליך משירות אחד לאחר, בממשק משתמש ידידותי, **ובלי לכתוב קוד**.

אז אנחנו רוצים **לבצע `HTTP Request`** לכתובת שלקחנו מתוך האפליקצייה (אתם יודעים, Network Tab, הדבר הראשון שמסתכלים באפליקציית SPA), ולקבל את רשימת האנשים שהחזיקו את החבילה.

לאחר מכן אנחנו רוצים לבדוק **האם נוסף אדם לרשימה**. מה זה אומר? שאנחנו צריכים לשמור את הכמות הקודמת. לצורך כך יש בIntegromat אפשרות לשמור נתון במין מסד נתונים מינימלי.

![filter](./integromat-filter.png)

שלב שלישי הוא לשלוח התראה במידה ובאמת החבילה עברה לאדם נוסף. אין לנו _Slack_, ובשביל להתממשק ל*Microsoft Teams* צריך אישור מנהל, אז נאלצתי לבחור בשליחת מייל.

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

![pipeline](./api-automations.png)

הבעיה היא שהתכנית החינמית לא תחזיק מעמד הרבה זמן, בגלל שכל `HTTP Request` לוקח 1.5MB (כן! מוגזם).

![subscription](./integromat-subscription.png)

מה אפשר לעשות כדי לחסוך את הבזבוז של הבקשה?

# Postman

אוקיי, את [_Postman_](https://www.postman.com/) כל מפתח חייב להכיר. כלי מאוד נוח לבצע בקשות HTTP ולנתח את הResponse.

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

המטרה היא לבצע את הבדיקה מול הAPI בתוך _Postman_, ורק כאשר המצב השתנה, לשלוח את המידע העדכני ל`Webhook` ב*Integromat* (כן, זה עוד שירות שהם תומכים, כמובן). כך אנחנו משתמשים ב*Integromat* רק כאשר באמת צריך לשלוח מייל.

בPostman יש אפשרות לכתוב בדיקות לAPI. כלומר, ניתן להריץ קוד _JavaScript_ אחרי קבלת `HTTP Response` שינתח את התשובה ויגיד _עבר_ או _נכשל_. אבל בסוף, מדובר ב*JavaScript*, וגם Postman עצמו תומך בעוד הרבה פעולות שניתן לבצע.

![postman script](./postman-script.png)

אחרי שכתבנו את ה"Test", הסקריפט שבודק אם כמות האנשים השתנתה, ובמידה וכן שולח את השם של האחרון ל*Integromat*, אנחנו רוצים להריץ אותו באופן קבוע, וגם זה נתמך ב*Postman*:

![schedule](./postnam-schedule.png)

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

רק מה? גם לPostman יש מגבלה.

![limit](./postman-limit.png)

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

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

אז העברתי את הקוד ל*NodeJS*, כמעט Copy & Paste.

## מסקנות

אממממ...

טוב, קודם כל חסכתי ענייני Auth בכך שהשתמשתי ב*Integromat*, זה באמת חוסך הרבה מכאב הראש.

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

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

# ובחינם, כמובן.
]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[WSL Troubleshooting]]></title>
            <link>https://baruchiro.online/wsl-troubleshooting/</link>
            <guid>https://baruchiro.online/wsl-troubleshooting/</guid>
            <pubDate>Tue, 01 Dec 2020 00:00:00 GMT</pubDate>
            <description><![CDATA[Sequence of operations to find connection issues and fix them in WSL.]]></description>
            <content:encoded><![CDATA[
## Related Resources

- [[WSL2] Checkpoint VPN breaks network connectivity](https://github.com/microsoft/WSL/issues/4246)
- [Networking issues while using VPN](https://github.com/microsoft/WSL/issues/416)
- [No network connection in any distribution under WSL 2](https://github.com/microsoft/WSL/issues/5336)

## Introduction

This document is written in our company in order to solve the issues with WSL2, CheckPoint VPN and other self-hosted services. **You're welcome to suggest more fixes** in this subject to make this document more general.

## Network and DNS Troubleshooting

Try each command by their order to better find the correct problem.

### Try `ping 8.8.8.8`

If it failed it means that **you don’t have an internet connection** at all.

See [this video](https://www.youtube.com/watch?v=yR2NsssY7z8) and/or [[WSL2] Checkpoint VPN breaks network connectivity (comment)](https://github.com/microsoft/WSL/issues/4246#issuecomment-691561185) to solve this issue.

Probably the base thing is to connect to the _VPN_ before _WSL2 Network Adapter_.

1. Open your WSL Terminal.
2. Disconnect from the VPN (if connected)
3. Disable the _WSL2 Network Adapter_ by `netsh interface set interface "vEthernet (WSL)" disable` or by `Get-NetAdapter -Name "vEthernet (WSL)" | Disable-NetAdapter`
4. Please make sure it disabled by `$(Get-NetAdapter -Name "vEthernet (WSL)").Status` is `Disabled`
5. Connect to the VPN
6. Enable the _WSL2 Network Adapter_ by `netsh interface set interface "vEthernet (WSL)" enable` or `Get-NetAdapter -Name "vEthernet (WSL)" | Enable-NetAdapter`
7. Validate the ping 8.8.8.8 in WSL again.

### Try `ping google.com`

If it failed it means that you have a **problem with the DNS**. You need to update the `/etc/resolve.conf` with your DNS addresses.

Run this command in PowerShell: `Get-DnsClientServerAddress -AddressFamily IPv4 | Select-Object -ExpandPropert ServerAddresses`, then take the addresses from that command, clear the `resolve.conf` file and set the first line `search {your domain}` and then the next line will be `nameserver {ip}`.

**Source:** you can use [this script](https://gist.github.com/matthiassb/9c8162d2564777a70e3ae3cbee7d2e95) (from [Networking issues while using VPN (comment)](https://github.com/microsoft/WSL/issues/416#issuecomment-407075002)) to auto-update the `resolve.conf`.

### Try `ping {internalIP}`

If it failed it means that you have a **problem with the VPN**.

### Try `ping {internal hostname}`

If it failed it means that you have a **problem with the internal DNS**.  
 Make sure you configured the DNS by the instructions in 2.

## Other connection issues

### Clone a git repo by SSH

If you’re trying to clone a private repo, you need your credentials that usually configured in the Windows system.

My suggestion is to use SSH, here is an instruction to configure the SSH keys in TFS:

- Create an SSH key in WSL with `ssh-keygen -C your.name@company.com`, and paste the `~/.ssh/id_rsa.pub` in `{tfs-host}/tfs/_details/security/keys`

- If you are getting an error with `diffie-hellman-group1-sha1,diffie-hellman-group14-sha1` (I don’t remember the original error), create/edit the `~/.ssh/config` file with:

  ```
  Host tfs2018app
      KexAlgorithms diffie-hellman-group1-sha1,diffie-hellman-group14-sha1
  ```

- Get the SSH repository URL.

- Clone.

> You can try to use the [Windows Git Credential Manager](https://docs.microsoft.com/en-us/windows/wsl/tutorials/wsl-git#git-credential-manager-setup) with/instead of using SSH, and share the consequences in this document.

### npm network timeout

If you are getting the next error when you are trying to use `npm`, please share the solution with us:

```
npm ERR! network timeout at: https://registry.npmjs.org/@babel/plugin-proposal-optional-catch-binding/-/plugin-proposal-optional-catch-binding-7.10.4.tgz
```

You can try this:

- run `Get-NetIPInterface` on windows to find `MTU` value for VPN network adapter (mine was 1350)
- run `sudo ifconfig eth0 mtu 1350` or `sudo ip link set dev eth0 mtu 1350` inside WSL to match eth0 `MTU` value with vpn network adapter value
]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[הגדרות שרת המדיה הביתי שלי]]></title>
            <link>https://baruchiro.online/home-server/</link>
            <guid>https://baruchiro.online/home-server/</guid>
            <pubDate>Fri, 06 Nov 2020 00:00:00 GMT</pubDate>
            <description><![CDATA[איך מוגדר שרת המדיה הביתי שלי, להורדת סדרות וסרטים בצורה אוטומטית, חיפוש כתוביות, התחברות מכל מכשיר וסקריפטים נוספים]]></description>
            <content:encoded><![CDATA[
יש לי בבית, ליד הWiFi, מחשב קטן בלי מסך או מקלדת. אתם יודעים, כזה שאמורים לחבר לטלוויזיה או משהו. זה "השרת" הפרטי שלי, משמש לכל מיני דברים שאני רוצה שיפעלו תמיד, כמו בוט של טלגרם, לדוגמא.

זה מאוד קל להגדיר שרת כזה כשמשתמשים ב[Docker](/docker/), ואני יכול פשוט לשתף את ההגדרות שלי עם העולם, אם גם אתם רוצים להגדיר שרת כזה.

אז הגדרות השרת שלי נמצאות [כאן](https://github.com/baruchiro/home-server), והנה קצת הסברים:

### Jellyfin

_[Jellyfin](https://jellyfin.org/)_ היא תוכנת קוד פתוח (כמובן) ל**שרת מדיה ביתי**.

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

אז מאיפה מגיעה המדיה ל*Jellyfin*?

### Jackett

קצת קשה לי להסביר על _[Jackett](https://github.com/Jackett/Jackett)_, גם אני לא יודע עד הסוף מה התהליך שקורה, אבל התפקיד של _Jackett_ הוא באופן כללי, לתת קישורים לתוכן.

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

### Deluge

מאוד פשוט, _[Deluge](https://deluge-torrent.org/)_ הוא תוכנת הורדת torrents. כמובן שהיתרון שלו בהקשר הנוכחי הוא שאפשר להריץ אותו בDocker והוא חושף ממשק Web, כך אני יכול להתחבר אליו מרחוק.

### Sonarr, Radarr, Bazarr

נשמעים שמות דומים, נכון? (וגם יש להם את אותו קטע של _Jackett_, עם האות הכפולה בסוף ;-) )

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

_[Sonarr](https://sonarr.tv/)_ אחראי על מעקב אחרי יציאה של פרקים ב**סדרות** שאתה עוקב אחריהם. אני לא משתמש בכל הפיצ'רים שיש שם, כמו למשל לוח שנה שמציג מתי פרקים מתוכננים לצאת.

_[Radarr](https://radarr.video/)_ הוא כמו _Sonarr_, רק ל**סרטים**. שניהם אחראים רק על מעקב אחרי יציאת תוכן חדש. כאשר תוכן חדש צריך להיות זמין, הם שואלים את _Jackett_ האם הוא יודע לתת להם קישור להורדה, וברגע שיש להם קישור זמין להורדה, הם שולחים אותו ל*Deluge* שיוריד אותו.

הקובץ יורד לתיקייה ש*Jellyfin* מסתכל עליה, ויודע להציג את התוכן ברגע שהוא זמין.

התפקיד של _[Bazzar](https://www.bazarr.media/)_ הוא להסתכל גם כן על התיקייה של המדיה, ולחפש **כתוביות** לתוכן שירד.

### telegram-download-deamon

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

(טוב, לא בדיוק בוט, זה יותר Telegram Client, מהסיבה שבוט מוגבל יותר בהורדה של קבצים גדולים.)

הקוד של [telegram-download-deamon](https://github.com/alfem/telegram-download-daemon) מנוהל על ידי מישהו אחר, אבל חלקים גדולים מהקוד נכתבו על ידי, ואני עוד שוקל להשתמש בfork שלי, מכיוון שנראה שלי יש יותר צורך ועניין בכלי הזה מאשר לMaintainer.

### Portainer

[Portainer](https://www.portainer.io/) הוא כלי לניהול Docker מרחוק, מאוד נוח, אפשר לראות איזה images, volumes, containers וכו' יש על המכונה כרגע, מה המצב שלהם, לראות לוגים, להיכנס לתוך הcontainers ועוד.

## מה הלאה?

אפשר להסתכל ב[branches](https://github.com/baruchiro/home-server/branches) של הקוד, לראות כל מיני כלים חדשים שאני מנסה (כשיש לי זמן, לא תמיד אני מגיע לזה). למשל, הייתי באמצע לבדוק את _[home-assistant](https://www.home-assistant.io/)_, יכולים לראות גם [כאן](/home-assistant/).

> מוזמנים להשתמש!
]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[הפחתת השימוש בעכבר והצגת טקסט על רקע שולחן העבודה]]></title>
            <link>https://baruchiro.online/gbinfo/</link>
            <guid>https://baruchiro.online/gbinfo/</guid>
            <pubDate>Sun, 18 Oct 2020 00:00:00 GMT</pubDate>
            <description><![CDATA[איך להדביק טקסט שאתם רוצים שתמיד יהיה זמין לכם, על שולחן העבודה]]></description>
            <content:encoded><![CDATA[
לאחרונה התחלתי לחשוש מהמחלה של ההייטקיסטים (ושל כל מי שיושב מול המחשב כל הזמן)- כאבים במפרק כף היד.

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

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

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

### מה אפשר לעשות?

הרבה דברים כמובן.

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

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

### הטמעה

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

### BGInfo- טקסט על שולחן העבודה

המקום הזמין שחשבתי עליו הוא _שולחן העבודה של Windows_. הוא תמיד שם, הרי. אפשר להשתמש בקיצור ", + WinKey" (כן, פסיק) כדי להציג אותו (בלי לעזוב את המקלדת).

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

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

ניתן להוריד את התוכנה [מכאן](https://docs.microsoft.com/en-us/sysinternals/downloads/bginfo).

#### הסברים טכניים

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

![background-config](./gbinfo/backround-config.png)

אגב, מה שאני עשיתי זה לייבא קובץ טקסט חיצוני שבו רשמתי את קיצורי המקשים, אבל זה לא חובה.
]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[מתגעגעים לMovie Maker?]]></title>
            <link>https://baruchiro.online/video-editor/</link>
            <guid>https://baruchiro.online/video-editor/</guid>
            <pubDate>Fri, 16 Oct 2020 00:00:00 GMT</pubDate>
            <description><![CDATA[התחליף העדכני לMovie Maker הישן, למי שצריך איזה כלי נוח לערוך סרטונים פה ושם]]></description>
            <content:encoded><![CDATA[
מה אנחנו בסך הכל צריכים? לחבר כמה סרטונים שקיבלנו בווטסאפ, לחתוך איפה שצריך, ואולי לכתוב איזה ברכה?

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

אני חושב שהרבה מאיתנו לא שמו לב לכלי החדש שהגיע להחליף את Movie Maker, (קצת באיחור אחרי שכבר כמה שנים קשה למצוא את Movie Maker).

### Windows 10 Video Editor

אז התוכנה החדשה מגיעה כחלק מWindows 10, פשוט תכתבו בתיבת החיפוש Video Editor.

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

#### אז מה יש לנו?

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

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

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

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

#### מה אין לנו?

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

#### סיכום

צריכים רגע לערוך איזה סרטון ליומולדת? משהו קליל?

תנסו רגע את Video Editor, תשחקו קצת, יש גם דברים מגניבים ובאופן כללי הוא מספיק.
]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[בואו נקים את מאגר המידע על המלצות מחשבים]]></title>
            <link>https://baruchiro.online/computer-recommendation/</link>
            <guid>https://baruchiro.online/computer-recommendation/</guid>
            <pubDate>Fri, 14 Aug 2020 11:30:00 GMT</pubDate>
            <description><![CDATA[בהמשך לפוסט על המלצות מחשב, בואו נעבוד יחד כדי להרים את המערכת הזאת לטובת כולם.
]]></description>
            <content:encoded><![CDATA[
בהמשך לפוסט על [המלצת מחשב](/ihis-computers/), הייתי מאוד רוצה להתקדם לעבר פיתוח של הפתרון הזה (או פתרון אחר, העיקר שיהיה פתרון).

---

למי שלא הולך לקרוא את [הפוסט הקודם](/ihis-computers/)- אני מחפש דרך **לעזור לאנשים לדעת מה המחשב המתאים להם**, שזה כולל **הסבר כללי** על רכיבי החומרה במחשב, מכיוון שיש כל כך הרבה שיקולים בקנייה, שככל הנראה, עם הידע הנכון, הלקוח ידע לעשות את הבחירה הנכונה יותר ממני.

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

---

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

> אני אשמח ואציע את עזרתי לכל מי שיבחר לקדם את אחד הדברים:

- [ ] **הקמת מאגר מידע שיתופי:**  
      אחת הבעיות המרכזיות היא שלא רק שהקונה לא יודע האם מעבד של AMD זה טוב כמו Intel, אלא גם מי שמבין, לא תמיד עוקב אחרי כל העדכונים והבדיקות.  
      לכן צריך ליצור **מאגר מידע שיישאר מעודכן ורחב על ידי קהילה**, ואנשים פשוטים יוכלו למצוא שם הסברים לגבי האם ולמה הם חייבים דיסק קשיח מסוג SSD.

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

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

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

---

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

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

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

תודה!
]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[בחירת תמונות לאלבום הבא]]></title>
            <link>https://baruchiro.online/photos-swipe-to-album/</link>
            <guid>https://baruchiro.online/photos-swipe-to-album/</guid>
            <pubDate>Wed, 29 Jul 2020 00:00:00 GMT</pubDate>
            <description><![CDATA[אנחנו מצד אחד מתעדים הרבה מאוד- כל הזמן מצלמים עם הפלאפון.
מצד שני, אין לנו אלבומים קשיחים, שיישארו לאורך זמן, ואנחנו צריכים להקדיש הרבה זמן כדי לבחור תמונות לאלבום.
אני מציע דרך לבחור את התמונות "על הדרך", כשיש זמן פנוי.
]]></description>
            <content:encoded><![CDATA[
אז באמת, במיוחד למי שיש ילדים קטנים, יש אלפי תמונות חמודות בפלאפון, וכמובן גם גיבוי באיזה שירות ענן, שהוא למשל (לפחות במקרה של גוגל) גם מסדר את התמונות לפי פנים וכל זה.

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

אבל מתי בעצם עושים שימוש בתמונות האלו?

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

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

## בעיות שצריך לפתור

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

## הצעה לפתרון

אני מציע לפתח **אפליקציה לפלאפון**, שתתחבר לתמונות בGoogle Photos (או לשירות אחר מתאים).

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

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

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

## מגבלות

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

> שתפו אותי אם החלטתם לפתח, או אם יש לכם מה להוסיף.
]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[מחשבון גינויים]]></title>
            <link>https://baruchiro.online/condemnation-calculator/</link>
            <guid>https://baruchiro.online/condemnation-calculator/</guid>
            <pubDate>Sun, 26 Jul 2020 00:00:00 GMT</pubDate>
            <description><![CDATA[אמור לי את מה אתה מגנה ואומר לך מי אתה]]></description>
            <content:encoded><![CDATA[
קצת קשור לפוליטיקה, אבל לא באמת, כי זה קשור לכל גווני הקשת הפוליטית ללא בחירת צד.

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

גם מדינות, אגב, צריכות לגנות כל מיני מקרים שקורים במדינות אחרות.

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

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

## הרעיון

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

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

או כיוון שונה, מפה של פוליטיקאים על פי הגינויים שלהם.

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

לא יודע, כמו שאמרתי, אני לא ממש בעניינים לא בפוליטיקה ולא בML.

> ספרו לי על עוד רעיונות, או אם התחלתם לפתח משהו כזה :-)
]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[בוט "לא רלוונטי"]]></title>
            <link>https://baruchiro.online/irrelevant-bot/</link>
            <guid>https://baruchiro.online/irrelevant-bot/</guid>
            <pubDate>Wed, 08 Jul 2020 00:00:00 GMT</pubDate>
            <description><![CDATA[קיבלתם הודעה בווטסאפ שנראית חשודה? משהו על ריקוד של אפיפיור או הודעה ממשרד הסייבר?
מה אם הייתם יכולים לשלוח את ההודעה לבוט ולשמוע שהבוט כבר ראה אותה בשנה שעברה?
]]></description>
            <content:encoded><![CDATA[
תראו, אולי יש כבר מנגנונים משוכללים לזיהוי Fake-news, אבל האמת שחיפשתי ולא מצאתי משהו דומה. כנראה שכדי לבדוק פייק ניוז טוב צריך חוקרים אנושיים שיבדקו את העובדות.

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

כשאני רואה הודעה חשודה, מעבר לסימנים המחשידים כמו מילים שנראות כמו תרגום משפה אחרת, ובקשה לשיתוף לכמה שיותר אנשים, אני מחפש אותה באתר [לא רלוונטי](https://irrelevant.org.il/). מהאתר אני מקבל שתי אבחנות עיקריות:

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

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

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

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

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

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

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

אני לא מציע פה להתחרות בחנן, אלא להיפך, לדעתי כדאי ליצור איתו קשר, כדי להיעזר בנסיון ובידע שלו.
]]></content:encoded>
        </item>
    </channel>
</rss>