<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>תומרקוד</title><link>https://tomercode-hugo-blog.pages.dev/</link><description>Recent content on תומרקוד</description><generator>Hugo</generator><language>he-IL</language><lastBuildDate>Thu, 04 Jun 2026 19:54:27 +0000</lastBuildDate><atom:link href="https://tomercode-hugo-blog.pages.dev/index.xml" rel="self" type="application/rss+xml"/><item><title>עוזר אישי בווטסאפ ב-5 דק ואיך הוא באמת עובד</title><link>https://tomercode-hugo-blog.pages.dev/2026/06/5.html</link><pubDate>Thu, 04 Jun 2026 19:49:25 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2026/06/5.html</guid><description>&lt;p&gt;לפני כמה חודשים, בערך ביום ש OpenClaw יצא, ניסיתי לשחק איתו.&lt;/p&gt;
&lt;p&gt;הרעיון תפס אותי: עוזר אישי שאני יכול לכתוב לו בווטסאפ, והוא באמת יכול לעבוד בשבילי.&lt;/p&gt;
&lt;p&gt;לא רק לענות על שאלות, אלא גם לבדוק קוד, לקרוא logs, להריץ פקודות, לכתוב סיכומים, להזכיר לי דברים, ולעדכן את ההתנהגות שלו כשאני מבקש.&lt;/p&gt;</description></item><item><title>איך לעבוד עם Claude Code ו Codex מהטלפון הנייד</title><link>https://tomercode-hugo-blog.pages.dev/2026/02/claude-code-codex.html</link><pubDate>Sun, 08 Feb 2026 09:40:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2026/02/claude-code-codex.html</guid><description>&lt;p&gt;כשעובדים עם Claude Code או Codex לאורך זמן, כמעט תמיד מגיע רגע שבו צריך התערבות ידנית. אישור להריץ פקודה, שאלה על שינוי קוד, או החלטה קטנה שחוסמת את ההתקדמות.&lt;/p&gt;
&lt;p&gt;הבעיה היא שזה קורה דווקא כשאני לא ליד המחשב.&lt;/p&gt;</description></item><item><title>איך להתחיל חלק במקום עבודה חדש</title><link>https://tomercode-hugo-blog.pages.dev/2025/10/blog-post_24.html</link><pubDate>Fri, 24 Oct 2025 07:09:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2025/10/blog-post_24.html</guid><description>&lt;p&gt;להתחיל מקום חדש כמעט תמיד מלווה בהתרגשות ולחץ.&lt;/p&gt;
&lt;p&gt;מצד אחד אתה רוצה להוכיח את עצמך, מצד שני אתה לא בטוח עד הסוף מה מצופה ממך ואיך נראה שבוע או ספרינט “טוב” בעיני מי שמנהל אותך.&lt;/p&gt;</description></item><item><title>תסמונת המתחזה שלי</title><link>https://tomercode-hugo-blog.pages.dev/2025/10/blog-post.html</link><pubDate>Fri, 17 Oct 2025 04:51:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2025/10/blog-post.html</guid><description>&lt;h3&gt;&lt;/h3&gt;
&lt;p&gt;&lt;img src="https://tomercode-hugo-blog.pages.dev/images/posts/2025/10/blog-post/image-01-bfbaf80194.png" alt=""&gt;&lt;/p&gt;
&lt;h3 id="מה-לי-ולזה"&gt;מה לי ולזה&lt;/h3&gt;
&lt;p&gt;כשנכנסתי לצבא הגעתי כמעט בלי ניסיון למסלול שכולם בו כבר עשו הרבה מאוד דברים כבני נוער – חלקם עם תואר שעשו בתיכון, חלקם מתכניות סייבר יוקרתיות.
אחרי כשנתיים הציעו לי לנהל אנשים פי שניים ממני בגיל, ולעלות לדיונים עם בכירים – וגם שם אמרתי לעצמי: מה לי ולזה? איך אני יכול לנהל מישהו עם 15 שנות ניסיון?&lt;/p&gt;</description></item><item><title>איך אני נשאר רלוונטי בעידן ה-AI</title><link>https://tomercode-hugo-blog.pages.dev/2025/10/ai.html</link><pubDate>Thu, 09 Oct 2025 06:19:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2025/10/ai.html</guid><description>&lt;p&gt;בכל כמה שנים יש “רעידת אדמה” בעולם ההיי-טק.
פעם זה היה ה־Cloud, אחר כך Docker ו-Kubernetes, אחר כך המעבר למיקרו-סרוויסים.&lt;/p&gt;
&lt;p&gt;היום זה ה-AI.&lt;/p&gt;
&lt;p&gt;פתאום בכל שיחה שומעים על Copilot, על Agents, על LLMs.
כולם מדברים על איך זה ישנה את הדרך שבה אנחנו כותבים קוד, מתכננים מוצרים, ואפילו חושבים על העבודה שלנו.&lt;/p&gt;</description></item><item><title>בראסט ה Enums טובים יותר</title><link>https://tomercode-hugo-blog.pages.dev/2025/02/enums.html</link><pubDate>Wed, 19 Feb 2025 07:57:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2025/02/enums.html</guid><description>&lt;p&gt;כשאנחנו מתחילים לגעת בשפות תכנות, פעמים רבות אנחנו מנסים לחקות את מה שאנחנו כבר יודעים ומכירים משפות קודמות בשפה אחרת. זו אמנם יכולה להיות דרך להכנס לכתיבת קוד מהר יותר, אבל כשנוקטים בגישה הזו עלולים לפספס יכולות ייחודיות לשפה שנותנות דרכים הרבה יותר יעילות ועוצמתיות לפתור בעיות.&lt;/p&gt;</description></item><item><title>קודמתי לדרגת סיניור במיקרוסופט - מה למדתי בדרך</title><link>https://tomercode-hugo-blog.pages.dev/2024/11/blog-post.html</link><pubDate>Sat, 09 Nov 2024 14:30:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2024/11/blog-post.html</guid><description>&lt;p&gt;אחרי 10 שנים בתחום, ו3 שנים במיקרוסופט, סוף סוף הגעתי לדרגה המיוחלת - &lt;strong&gt;סיניור.&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;את הקריירה שלי התחלתי בצבא, 3 שנים סדיר, שנה וחצי קבע, (בתוך כל זה גם ניהלתי צוות כשנתיים), יצאתי לאזרחות להיות ״סיניור״ בסטארטאפ, הייתי שם שנתיים וקצת ואז התחלתי להתראיין למיקרוסופט.&lt;/p&gt;</description></item><item><title>Rust MPSC Channels - צ׳אנלים בראסט</title><link>https://tomercode-hugo-blog.pages.dev/2024/09/rust-mpsc-channels.html</link><pubDate>Tue, 10 Sep 2024 12:41:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2024/09/rust-mpsc-channels.html</guid><description>&lt;p&gt;אחת התכונות החזקות ביותר בראסט היא מקביליות ואסינכרוניות, וכשמדברים על תכנות אסינכרוני &lt;a href="https://docs.rs/tokio"&gt;tokio&lt;/a&gt; היא הספרייה הנפוצה ביותר. אחד הפיצ׳רים המרכזיים שטוקיו מאפשרת הוא channels, אשר מאפשרים תקשורת בין חלקים שונים בתכונה שלנו.&lt;/p&gt;
&lt;p&gt;קיימים בראסט מגוון סוגים של channels שמגיעים ממגוון ספריות (כמו &lt;a href="https://docs.rs/crossbeam-channel/latest/crossbeam_channel/"&gt;crossbeam&lt;/a&gt;, &lt;a href="https://doc.rust-lang.org/nightly/std/sync/mpsc/index.html"&gt;std::mpsc&lt;/a&gt; וכו׳). בפוסט אדבר על Tokio Channels, ומתי ואיך נשתמש בהם.&lt;/p&gt;</description></item><item><title>ראסט - פונקציית main נקיה יותר עם Result</title><link>https://tomercode-hugo-blog.pages.dev/2024/09/main-result.html</link><pubDate>Thu, 05 Sep 2024 06:26:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2024/09/main-result.html</guid><description>&lt;p&gt;כחלק &lt;a href="https://tomercode-hugo-blog.pages.dev/2023/09/rust-result.html"&gt;מהמסע שלנו לניהול שגיאות נכון&lt;/a&gt; נפל לנו האסימון שלהשתמש ב &lt;a href="https://learning-rust.github.io/docs/unwrap-and-expect/"&gt;unwrap או expect&lt;/a&gt; יכול להיות רעיון לא כל כך טוב ועלול להביא לסיום מיידי של הפרוסס שלנו במקרים שאולי לא התכוונו אליהם. אז השתמשנו ב &lt;a href="https://rust-lang.github.io/rust-clippy/master/index.html#/unwrap_used"&gt;clippy deny unwrap used&lt;/a&gt; שגרם לקומפילציה לא לעבור במידה ונכנס unwrap לקוד.&lt;/p&gt;</description></item><item><title>Rust Builder Pattern</title><link>https://tomercode-hugo-blog.pages.dev/2024/08/rust-builder-pattern.html</link><pubDate>Thu, 22 Aug 2024 05:31:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2024/08/rust-builder-pattern.html</guid><description>&lt;p&gt;אחד הדברים שלקח לי זמן להתרגל אליהם בראסט היה העובדה שאין method overloading וגם אין תמיכה בערכים דיפולטיים לפרמטרים של בפונקציות.&lt;/p&gt;
&lt;p&gt;כלומר, באותו ה namespace תוכל להיות לנו רק פונקציה אחת עם אותו השם וכשאנחנו מגדירים פונקציה אנחנו לא נוכל לקבוע לפרמטרים שלה ערכים דיפולטיים כדי להקל על המשתמש ב API. זאת להבדיל משפות כמו C#, C++, Java שתומכות ביכולות.&lt;/p&gt;</description></item><item><title>איך התחלנו לנהל שגיאות ב Rust (חלק ג' - anyhow)</title><link>https://tomercode-hugo-blog.pages.dev/2023/10/rust-anyhow.html</link><pubDate>Thu, 05 Oct 2023 08:57:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2023/10/rust-anyhow.html</guid><description>&lt;p&gt;אם הגעת לכאן במקרה אני ממליץ להתחיל בפוסט &lt;a href="https://tomercode-hugo-blog.pages.dev/2023/09/rust-result.html"&gt;הראשון&lt;/a&gt; &lt;a href="https://tomercode-hugo-blog.pages.dev/2023/09/rust-thiserror.html"&gt;והשני&lt;/a&gt; על מנת לקבל רקע.&lt;/p&gt;
&lt;p&gt;החלק השלישי במסע שלנו לניהול שגיאות היה ההטמעה של &lt;a href="https://docs.rs/anyhow"&gt;anyhow&lt;/a&gt;. הספרייה מספקת מספר פיצ&amp;rsquo;רים נחמדים מאוד שמקלים על הפיתוח ומייפים את הקוד, מייעלים את ניהול השגיאות, ואפילו עוזרים לאחר השגיאה בניתוח שלה.&lt;/p&gt;</description></item><item><title>איך התחלנו לנהל שגיאות ב Rust (חלק ב' - thiserror)</title><link>https://tomercode-hugo-blog.pages.dev/2023/09/rust-thiserror.html</link><pubDate>Sat, 23 Sep 2023 15:07:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2023/09/rust-thiserror.html</guid><description>&lt;p&gt;בפוסט הקודם דיברתי על הדרך שעשינו מקוד שיכול לקרוס בכל מקום בכל רגע, להפיכת הפרוסס ליציב הרבה יותר באמצעות שימוש ב Result, ופעפוע השגיאות שלנו עם אופרטור `?`. בפוסט הזה נדבר על אחת הספריות המרכזיות בעולם ניהול השגיאות של ראסט ונראה איך היא עוזרת לנו להפוך את ניהול השגיאות שלנו לנוח ויציב הרבה יותר.&lt;/p&gt;</description></item><item><title>איך התחלנו לנהל שגיאות ב Rust (חלק א' - Result)</title><link>https://tomercode-hugo-blog.pages.dev/2023/09/rust-result.html</link><pubDate>Fri, 15 Sep 2023 06:34:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2023/09/rust-result.html</guid><description>&lt;h3&gt;&lt;/h3&gt;
&lt;p&gt;&lt;img src="https://tomercode-hugo-blog.pages.dev/images/posts/2023/09/rust-result/image-01-d149cbfd99.png" alt=""&gt;&lt;/p&gt;
&lt;h3 id="מבוא"&gt;מבוא&lt;/h3&gt;
&lt;p&gt;גם כשעולם פיתוח התוכנה מתקדם בקצב משוגע, דבר אחד נשאר קבוע - &lt;strong&gt;שגיאות.&lt;/strong&gt; לא משנה כמה מנוסים נהיה כמפתחים, שגיאות ומקרים לא צפוים תמיד יצוצו לנו. מה שישנה בסופו של יום זה איך אנחנו מטפלים ומנהלים את אותן שגיאות.&lt;/p&gt;</description></item><item><title>Rust - שימוש ב or ו or_else</title><link>https://tomercode-hugo-blog.pages.dev/2023/09/rust-or-orelse.html</link><pubDate>Sun, 03 Sep 2023 10:56:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2023/09/rust-or-orelse.html</guid><description>&lt;p&gt;&lt;strong&gt;שימוש ב Option::or_else מול שימוש ב Option::or&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;כשאנחנו עובדים עם Rust אנחנו נתקלים הרבה פעמים במקרים בהם נרצה לטפל בהיעדר ערך, כלומר None, ובשביל זה Option נכנס לתמונה. ראסט נותנת לנו כל מיני דרכים לטפל במקרים הללו ושתיים מהדרכים הנפוצות הן &lt;strong&gt;or&lt;/strong&gt; ו- &lt;strong&gt;or_else&lt;/strong&gt;.
בפוסט הזה נדבר על מה הפונקציות האלו עושות ומתי נרצה להשתמש בכל אחת מהן.&lt;/p&gt;</description></item><item><title>פולימורפיזם ב Rust</title><link>https://tomercode-hugo-blog.pages.dev/2023/07/rust.html</link><pubDate>Wed, 05 Jul 2023 10:35:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2023/07/rust.html</guid><description>&lt;p&gt;התמזל מזלי ובחודשים האחרונים התחלתי לעבוד מאפס על פרויקט חדש ב-Rust, פרויקט שאמור בקרוב לרדת כחלק ממע&amp;rsquo; ההפעלה Windows. הכניסה ל Rust החזירה לי את התשוקה לחזור לכתוב קצת בבלוג.&lt;/p&gt;
&lt;p&gt;Rust שונה מאוד מהשפות העיקריות שעבדתי איתן לפני (python ו c#) בהרבה מובנים כמו ניהול הזיכרון, העובדה שאין קלאסים והורשה, ניהול השגיאות, והקומפיילר שעובד שונה לחלוטין.&lt;/p&gt;</description></item><item><title>שרת FastApi על דוקר ב10 דקות</title><link>https://tomercode-hugo-blog.pages.dev/2022/04/fastapi-10.html</link><pubDate>Sat, 09 Apr 2022 20:48:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2022/04/fastapi-10.html</guid><description>&lt;p&gt;דרישות: היכרות עם פייתון, עם web frameworks (כקונספט) והיכרות בסיסית עם דוקר.&lt;/p&gt;
&lt;p&gt;שתי השחקניות החזקות ביותר כיום בתחום ה web frameworks לפייתון הן &lt;a href="https://testdriven.io/blog/django-vs-flask/"&gt;django ו flask&lt;/a&gt;. הפוסט של היום מתעסק בשחקנית החדשה והסקסית בתחום שנכתבה על ידי &lt;a href="https://github.com/tiangolo"&gt;tiangolo&lt;/a&gt; ובעיני מסמלת את כל מה שטוב ויפה ב open source software.&lt;/p&gt;</description></item><item><title>Azure Functions עם פייתון בקלות</title><link>https://tomercode-hugo-blog.pages.dev/2022/04/azure-functions.html</link><pubDate>Sat, 09 Apr 2022 15:52:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2022/04/azure-functions.html</guid><description>&lt;p&gt;יכולת מאוד חזקה ומגניבה שקיימת ב Azure (ובשאר ספקי הענן) היא functions. בפוסט הזה נדבר על מה זה functions, למה זה טוב, מתי נרצה להשתמש בזה, ובנוסף נראה דוגמה פשוטה של functions ב Azure.&lt;/p&gt;</description></item><item><title>חוקים לדיזיין פשוט</title><link>https://tomercode-hugo-blog.pages.dev/2022/01/blog-post.html</link><pubDate>Sat, 22 Jan 2022 13:58:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2022/01/blog-post.html</guid><description>&lt;p&gt;בסוף שנות התשעים הגיחו לעולם מתודלוגיית הפיתוח והספר &lt;a href="https://he.wikipedia.org/wiki/Extreme_Programming"&gt;Extreme Programming&lt;/a&gt; שנוצרו (ברובם) על ידי &lt;a href="https://twitter.com/kentbeck?lang=he"&gt;Kent Beck&lt;/a&gt; (האיש המגניב בתמונה למעלה).&lt;/p&gt;
&lt;p&gt;בספר הוא הציג 4 עקרונות לעיצוב פשוט של תוכנה ואני מאמין שהעקרונות האלו נכונים היום יותר מאי פעם משום שאנחנו נמצאים בעידן בו יש כמויות עצומות של רעש בנושא דיזיין וארכיטקטורה, מאות ספרים והמון גישות.&lt;/p&gt;</description></item><item><title>ליפול מהר עם Pylint</title><link>https://tomercode-hugo-blog.pages.dev/2022/01/pylint.html</link><pubDate>Mon, 17 Jan 2022 13:07:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2022/01/pylint.html</guid><description>&lt;p&gt;אם יש downside שאני לא מפסיק לשמוע בנוגע לפייתון זה היעדר הקומפילציה. התלונה שאני שומע הכי הרבה זה - &lt;strong&gt;״לא הגיוני שאני כותב קוד וצריך לחכות עד ההרצה שלו כדי להבין אם מה שעשיתי היה בסדר!״.&lt;/strong&gt;&lt;/p&gt;</description></item><item><title>קודם כל פייפליין</title><link>https://tomercode-hugo-blog.pages.dev/2021/11/blog-post.html</link><pubDate>Thu, 18 Nov 2021 08:17:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2021/11/blog-post.html</guid><description>&lt;h2&gt;&lt;/h2&gt;
&lt;p&gt;&lt;img src="https://tomercode-hugo-blog.pages.dev/images/posts/2021/11/blog-post/image-01-091b9151c7.png" alt=""&gt;&lt;/p&gt;
&lt;h2 id="מבוא"&gt;מבוא&lt;/h2&gt;
&lt;p&gt;לרגל הגעתו של הבלוג ל150,000 כניסות החלטתי לחזור לפוסט קצר ואולי קצת פילוסופי (שאולי יחזיר לי את המוטיבציה לחזור לכתוב) על החשיבות הכנסה של continuous integration (CI) בסיסי לקוד שלנו עוד לפני שבכלל יש לנו קוד שעובד.&lt;/p&gt;</description></item><item><title>הקמת שרת PyPI ב-5 דקות</title><link>https://tomercode-hugo-blog.pages.dev/2021/02/pypi.html</link><pubDate>Mon, 01 Feb 2021 07:32:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2021/02/pypi.html</guid><description>&lt;p&gt;לאחרונה יצא לי לדבר בבלוג לא מעט על הצד היותר ״devopsי״ של פיתוח תוכנה. דיברנו קצת על &lt;a href="https://tomercode-hugo-blog.pages.dev/2020/11/venv.html"&gt;סביבות וירטואליות&lt;/a&gt;, על &lt;a href="https://tomercode-hugo-blog.pages.dev/2020/12/pip-203.html"&gt;pip&lt;/a&gt;, על &lt;a href="https://tomercode-hugo-blog.pages.dev/2021/01/pip-setuptools-5.html"&gt;יצירת חבילות&lt;/a&gt;, ואפילו על &lt;a href="https://tomercode-hugo-blog.pages.dev/2020/09/git-submodules.html"&gt;git submodules&lt;/a&gt;. הפוסט הזה ממשיך את הפוסטים הקודמים לו ומדבר עלי איך אנחנו יוצרים שרת אליו ניתן להעלות חבילות פייתון, וכן, לצרוך אותן.&lt;/p&gt;</description></item><item><title>מה ההבדל בין אוטומציה לפיתוח רגיל</title><link>https://tomercode-hugo-blog.pages.dev/2021/01/blog-post_18.html</link><pubDate>Mon, 18 Jan 2021 07:38:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2021/01/blog-post_18.html</guid><description>&lt;h2&gt;&lt;/h2&gt;
&lt;p&gt;&lt;img src="https://tomercode-hugo-blog.pages.dev/images/posts/2021/01/blog-post_18/image-01-fbbb3fd6c8.png" alt=""&gt;&lt;/p&gt;
&lt;h2 id="מבוא"&gt;מבוא&lt;/h2&gt;
&lt;p&gt;בתעשייה יש כיום שיח סוער מאוד על ההבדל בין אוטומציה לבין פיתוח. בעוד שיש אנשים שאומרים שאוטומציה זה פיתוח לכל דבר ומי שכותב אוטומציה צריך להסתכל על עצמו כעל מפתח, יש אנשים שרואים בפיתוח אוטומציה כתחום ששווה פחות, מתגמל פחות ודורש פחות הכשרה.
הפוסט הזה אינו עוד שיחת מוטיבציה עם מסר של ״גם מפתחי אוטומציה הם מפתחים וצריך להתייחס אליהם ככה״.
מטרת הפוסט היא להציג את נקודת מבטי האישית על תחום האוטומציה, על ההבדל בינו לבין תחום פיתוח התוכנה ה״רגיל״ לנסות לתת מענה לשאלה - מדוע אנשים רואים פער בין התחומים?&lt;/p&gt;</description></item><item><title>מי אני</title><link>https://tomercode-hugo-blog.pages.dev/p/blog-page.html</link><pubDate>Thu, 14 Jan 2021 11:55:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/p/blog-page.html</guid><description>&lt;p&gt;היי, אני תומר כהן, מפתח תוכנה במיקרוסופט,&lt;/p&gt;
&lt;p&gt;בין השאר אני אבא לעידו ועמית, נשוי לליאל המדהימה ומנהל &lt;a href="https://www.instagram.com/tomerco_/"&gt;קריירה תחרותית בהרמת משקולות&lt;/a&gt; וחובב אומוניות לחימה.&lt;/p&gt;
&lt;p&gt;התחלתי להתעסק במחשבים בגיל קטן, בתיכון הייתי במגמת מחשבים ובצבא ביחידה טכנולוגית..&lt;/p&gt;</description></item><item><title>יצירת חבילת pip ב-5 דקות</title><link>https://tomercode-hugo-blog.pages.dev/2021/01/pip-setuptools-5.html</link><pubDate>Sun, 10 Jan 2021 06:29:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2021/01/pip-setuptools-5.html</guid><description>&lt;h2&gt;&lt;/h2&gt;
&lt;p&gt;&lt;img src="https://tomercode-hugo-blog.pages.dev/images/posts/2021/01/pip-setuptools-5/image-01-c73cae79e7.png" alt=""&gt;&lt;/p&gt;
&lt;h2 id="מבוא"&gt;מבוא&lt;/h2&gt;
&lt;p&gt;כתבנו קוד, אנחנו מרוצים ממנו וחושבים שהוא יכול להועיל לעוד אנשים, אולי בתוך אותו ארגון בו אנחנו עובדים ואולי פשוט להוציא את החבילה לשימוש העולם.&lt;/p&gt;
&lt;p&gt;יש הרבה דרכים לחלוק קוד עם הקהילה, אבל אחת הנפוצות מבניהן היא יצירת חבילה שכל מה שהמשתמש יצטרך לעשות על מנת לצרוך אותה זה &lt;a href="https://tomercode-hugo-blog.pages.dev/2020/11/venv.html"&gt;pip install&lt;/a&gt;.&lt;/p&gt;</description></item><item><title>איך להשיג פרודוקטיביות מקסימלית?</title><link>https://tomercode-hugo-blog.pages.dev/2021/01/blog-post.html</link><pubDate>Mon, 04 Jan 2021 05:00:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2021/01/blog-post.html</guid><description>&lt;h2&gt;&lt;/h2&gt;
&lt;p&gt;&lt;img src="https://tomercode-hugo-blog.pages.dev/images/posts/2021/01/blog-post/image-01-a73fa86d72.png" alt=""&gt;&lt;/p&gt;
&lt;h2 id="מבוא"&gt;מבוא&lt;/h2&gt;
&lt;p&gt;בעולם התעסוקה כיום יש בעיה מהותית מאי פעם - &lt;strong&gt;הסחות דעת&lt;/strong&gt;. היכולת לשבת ולבצע עבודה איכותית לאורך זמן כמעט ונעלמה מהשוק, ובטח שהיא כבר לא עיקרו.&lt;/p&gt;
&lt;p&gt;בתחום התוכנה ובחברות ההייטק מרגיש לי שזה לא פחות גרוע. מגיעים לעבודה (מאוחר יחסית), עובדים חצי שעה, מגיע חבר, שותים קפה, עובדים עוד כמה דק׳, פגישת דיילי סטנדאפ (כי חייבים להתעדכן), ממשיכים לעבוד, הסלאק פתוח, מישהו צריך עזרה עם משהו שאנחנו התעסקנו בו, אז מה, לא נעזור? עולים לזום, ארוחת צהריים, קפה של אחרי, happy hour ועוד מיליון פעילויות שהחברה מארגנת. והכי חשוב - שעה ביום של ויכוחים על Naming.&lt;/p&gt;</description></item><item><title>פוסט אורח: Data Objects בפייתון - מ tuple ועד dataclass</title><link>https://tomercode-hugo-blog.pages.dev/2020/12/data-objects-tuple-dataclass.html</link><pubDate>Wed, 23 Dec 2020 07:05:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2020/12/data-objects-tuple-dataclass.html</guid><description>&lt;p&gt;פוסט אורח מאת &lt;a href="https://www.linkedin.com/in/lior-elbaz-991685199/"&gt;ליאור אלבז&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;ליאור הוא מפתח תוכנה צעיר ומוכשר מאוד, עובד כעת בחברת &lt;a href="http://deepinstinct.com/"&gt;דיפ אינסטינקט&lt;/a&gt;. ליאור משקיע את מרבית שעות היום שלו בפיתוח ובלמידה של טכנולוגיות חדשות. לא צריך לדבר איתו יותר מ5 דק׳ כדי להבין שהוא חי את עולם התוכנה ועוד יעשה דברים גדולים.&lt;/p&gt;</description></item><item><title>המדריך לבניית קריירת החלומות</title><link>https://tomercode-hugo-blog.pages.dev/2020/12/blog-post.html</link><pubDate>Thu, 17 Dec 2020 07:45:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2020/12/blog-post.html</guid><description>&lt;p&gt;הפוסט הזה שונה מהפוסטים שאני כותב בדרך כלל, לא תראו בו דוגמאות קוד ולא אדבר בו על ספרייה חדשה בפייתון.&lt;/p&gt;
&lt;p&gt;אני כותב את הפוסט הזה כי אני מאמין שהידע המקצועי שלנו הוא לא הכל ועלינו ללמוד הרבה על הפילוסופיה של שוק העבודה, על ניהול זמן ופרודקטיביות, על יחסי אנוש, ניהול סטרס וכל מה שאני מכניס תחת המטרייה של ״self development״.&lt;/p&gt;</description></item><item><title>הגרסה החדשה של pip - 20.3</title><link>https://tomercode-hugo-blog.pages.dev/2020/12/pip-203.html</link><pubDate>Sun, 13 Dec 2020 07:12:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2020/12/pip-203.html</guid><description>&lt;p&gt;אתם בטח שואלים את עצמכם - למה שאכתוב פוסט על גרסה כל כך ספציפית של pip?&lt;/p&gt;
&lt;p&gt;אז התשובה פשוטה. לפני מספר חודשים המפתחים של pip הכריזו על גרסה עם שינוי גדול ולפני כשבועיים בתאריך 30/11/20 יצאה גרסה 20.3 שכוללת שינוי די רציני. כל כך רציני שהמפתחים אשכרה עשו על זה סרטון.&lt;/p&gt;</description></item><item><title>איך decorators עובדים (פייתון)</title><link>https://tomercode-hugo-blog.pages.dev/2020/12/decorators.html</link><pubDate>Mon, 07 Dec 2020 08:16:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2020/12/decorators.html</guid><description>&lt;h3&gt;&lt;/h3&gt;
&lt;p&gt;&lt;img src="https://tomercode-hugo-blog.pages.dev/images/posts/2020/12/decorators/image-01-8d18edda1b.png" alt=""&gt;&lt;/p&gt;
&lt;h3 id="מה-זה-decorators"&gt;מה זה decorators?&lt;/h3&gt;
&lt;p&gt;דקורטורים הם קונספט פשוט ועוצמתי שקיים כמעט בכל שפת high level, נמצא בשימוש נרחב כמעט בכל פרויקט ומאפשר למשתמש להוסיף פונקציונאליות לפעולות מבלי להתערב במימוש הפעולה.&lt;/p&gt;
&lt;p&gt;לדוגמה:&lt;/p&gt;
&lt;p&gt;יכולה להיות לי הפונקציה הבאה say_hello שמדפיסה את המחרוזת hello&lt;/p&gt;</description></item><item><title>ניהול חבילות וסביבות בפייתון - pipenv</title><link>https://tomercode-hugo-blog.pages.dev/2020/11/pipenv.html</link><pubDate>Tue, 17 Nov 2020 07:55:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2020/11/pipenv.html</guid><description>&lt;p&gt;בפוסט הקודם](/2020/11/venv.html) דיברתי על היתרון של סביבה וירטואלית בפייתון והצגתי את הכלי venv.&lt;/p&gt;
&lt;p&gt;בשנת 2018 נוצר הכלי pipenv שמטרתו לפתור בעיות נפוצות ב pip, ב venv ובעבודה עם קובץ ה requirements עליו דיברנו בפוסט הקודם.&lt;/p&gt;</description></item><item><title>סביבות מבודדות בפייתון - venv &amp; pip</title><link>https://tomercode-hugo-blog.pages.dev/2020/11/venv.html</link><pubDate>Thu, 05 Nov 2020 07:56:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2020/11/venv.html</guid><description>&lt;h2&gt;&lt;/h2&gt;
&lt;p&gt;&lt;img src="https://tomercode-hugo-blog.pages.dev/images/posts/2020/11/venv/image-01-d1b73718c6.png" alt=""&gt;&lt;/p&gt;
&lt;h2 id="הקדמה"&gt;הקדמה&lt;/h2&gt;
&lt;p&gt;כשאנחנו עובדים עם פייתון ורוצים להשתמש ביכולות הקהילה העצומות שלה, נרצה להשתמש בחבילות שאנשים אחרים כתבו.&lt;/p&gt;
&lt;p&gt;לשם שיתוף החבילות, מפתחי פייתון יצרו את &lt;strong&gt;pip&lt;/strong&gt; package installer for python שמטרתו לאפשר התקנה ושדרוג פשוטים של חבילות פייתון אל מול מקור מסוים.&lt;/p&gt;</description></item><item><title>מחשבות על coupling ועל dependency injection</title><link>https://tomercode-hugo-blog.pages.dev/2020/10/coupling-dependency-injection.html</link><pubDate>Sun, 25 Oct 2020 07:23:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2020/10/coupling-dependency-injection.html</guid><description>&lt;p&gt;אם הייתי צריך לבחור עקרון אחד לכתיבת קוד טוב וללכת איתו, זה היה לכתוב קוד שהוא loosely coupled.&lt;/p&gt;
&lt;p&gt;הפוסט הבא מדבר על החשיבות של כתיבת קוד בצימודיות נמוכה ועל איך הזרקת תלויות יכולה לעזור לנו עם הנושא.&lt;/p&gt;</description></item><item><title>מה זה singleton ולמה לא כדאי להשתמש בו?</title><link>https://tomercode-hugo-blog.pages.dev/2020/10/singleton.html</link><pubDate>Sun, 18 Oct 2020 10:35:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2020/10/singleton.html</guid><description>&lt;p&gt;זהו פוסט קצר שמטרתו להציג את תבנית העיצוב singleton ומדוע אינני ממליץ להשתמש בה.&lt;/p&gt;
&lt;p&gt;הפוסט הינו חלק מסדרה שמטרתה לדבר על כתיבת קוד רע ו-anti-patterns בתחום עיצוב התוכנה.&lt;/p&gt;
&lt;h2 id="מה-זה-סינגלטון"&gt;מה זה סינגלטון&lt;/h2&gt;
&lt;p&gt;סינגלטון היא תבנית עיצוב ממשפחת ה creational, שמטרתה להגביל את יצירת המופעים של מחלקה מסוימת למופע יחיד, משתמשים בתבנית הזו על מנת שלא ליצור התנגשות בין אובייקטים בפעולות כמו כתיבה לזכרון, קובץ דאטאבייס וכו׳.&lt;/p&gt;</description></item><item><title>מה חדש בפייתון 3.9</title><link>https://tomercode-hugo-blog.pages.dev/2020/10/39.html</link><pubDate>Mon, 12 Oct 2020 07:03:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2020/10/39.html</guid><description>&lt;p&gt;בשבוע שעבר שוחררה גרסת &lt;a href="https://www.python.org/downloads/"&gt;פייתון 3.9&lt;/a&gt; והיא כרגיל מביאה עמה כל מיני דברים מעניינים.&lt;/p&gt;
&lt;p&gt;כשמשתחררת גרסה של פייתון, בדרך כלל ה release notes מחולקים לנושאים כמו:&lt;/p&gt;
&lt;p&gt;syntax features, built-in features, new features in the standard library, Interpreter improvements, and new library modules.&lt;/p&gt;</description></item><item><title>הפרדה לתתי פרויקט באמצעות git submodules</title><link>https://tomercode-hugo-blog.pages.dev/2020/09/git-submodules.html</link><pubDate>Thu, 24 Sep 2020 06:29:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2020/09/git-submodules.html</guid><description>&lt;p&gt;פעמים רבות כשאנחנו מתחילים פרויקט איננו יודעים מה יהיה גודלו הסופי, כמה מחלקות הוא יכיל, ואיך יראו התלויות. לפעמים, כמה שלא ננסה לתכנן את הכל מראש, נגיע למצב בו אנחנו רוצים להפריד חלק מה-codebase שלנו לפרויקט נפרד.&lt;/p&gt;</description></item><item><title>הדרך הנכונה היחידה לכתוב קוד?</title><link>https://tomercode-hugo-blog.pages.dev/2020/09/blog-post.html</link><pubDate>Sun, 13 Sep 2020 18:37:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2020/09/blog-post.html</guid><description>&lt;p&gt;בחמש השנים שאני כותב קוד, יצא לי לקרוא לא מעט קוד רע ולכתוב אפילו יותר קוד רע.&lt;/p&gt;
&lt;p&gt;אם אני צריך לקחת את כל חתיכות הקוד הרעות שכתבתי ולמצוא מה משותף לכולן - כנראה שהתשובה תהיה כמות הפרטים בשכבות האבסטרקציה העליונות. מטרת הפוסט הקרוב היא להעביר באופן קצר וקולע, מה היא הדרך היחידה בעיני לכתוב קוד טוב ואיך לגרום לזה לקרות כמעט כמו קסם.&lt;/p&gt;</description></item><item><title>עיצוב תוכנה - Top-down programming</title><link>https://tomercode-hugo-blog.pages.dev/2019/09/top-down-programming.html</link><pubDate>Sat, 28 Sep 2019 19:53:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2019/09/top-down-programming.html</guid><description>&lt;p&gt;בפוסט של היום אני רוצה לדבר על קונספט שישמע תחילה בסיסי ומובן מאליו, אבל לאורך הקריאה אני ממליץ מאוד לשאול את עצמינו בשיא הביקורתיות - האם כך אני באמת כותב קוד? ואם לא, אולי כדאי לי להתחיל?
כולנו יודעים שרוב התוכנות, המערכות, ואפילו הסקריפטים שאנחנו כותבים לא מסתכמים בפונקצייה אחת ולא בשתיים. ככל שתוכנה שאנחנו כותבים מורכבת יותר וככל שאנחנו נרצה להפוך את הקוד שלנו לקריא יותר וגנרי יותר כנראה יהיו בו יותר קלאסים ופונקציות.
במקום לדבר הרבה ולנסות להסביר את המונח באופן אבסטרקטי, פשוט אצלול לדוגמה (top-down לא?).
דמיינו שאתם עובדים בצוות בו עובדים עם מכונות וירטואליות על גבי vcenter (פלטפורמת ניהול vms של vmware) והאוטומציה שרצה מייצרת הרבה מכונות. את המכונות הללו אנחנו רוצים לנקות בסוף כל יום עבודה כדי לא לצבור עומס מיותר, בהנחה שאם מישהו יצטרך את אחת המכונות הוא פשוט יזיז אותם לתיקייה אחרת.&lt;/p&gt;</description></item><item><title>טיפים על פחד מהרצאות ודיבור בכנסים</title><link>https://tomercode-hugo-blog.pages.dev/2019/07/blog-post.html</link><pubDate>Sun, 07 Jul 2019 12:14:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2019/07/blog-post.html</guid><description>&lt;p&gt;לאחרונה העברתי את ההרצאה הראשונה שלי בכנס בינלאומי בהודו (Appium Conf), וחשבתי שזו הזדמנות טובה לדבר קצת על כל הנושא הזה של הרצאות ועמידה מול קהל.
מישהו פעם אמר לי שהפחד הכי גדול שקיים לאנשים בעולם זה לדבר מול קהל, ומיד לאחר מכן הפחד ממוות. אני לא יודע כמה האמרה הזו נכונה באופן מחקרי, אבל מה שבטוח, אני לגמרי מזדהה איתה.
את ההרצאה הראשונה שלי מול אנשים העברתי במקום העבודה שלי לפני כשנתיים וחצי, היו שם באיזור ה-50 איש. ראש הצוות שלי לא הגיע לפגישה המחלקתית וביקש ממני להציג במקומו את תכניות העבודה של הצוות לשנה הקרובה. ההרצאה ערכה כ 10 דק&amp;rsquo;, לדעתי עשר הדקות הארוכות בחיי. למרות שהתכוננתי, היה לי פחד במה רציני, למרות שהיו לי הערות במצגת, הסתבכתי איתן מאוד ונלחצתי, ומעצם העובדה שנלחצתי נכנסתי אפילו ליותר לחץ. אחרי כדקה של מילמולים באמצע המצגת הצלחתי להזכר במה שרציתי להגיד במצגת והמשכתי. לאחר שסיימתי את ההרצאה הייתי עם תחושה נוראית - איך בפעם הראשונה שאני מרצה אני מפשל בכזו צורה?
הרבה פעמים, לפני שאנחנו עולים לדבר או בכלל שוקלים אם להגיש מועמדות לדבר (בין אם בכנס או סתם בדיון), מה שמסתתר מאחורי המחשבות שלנו הוא בדרך כלל פחד, ואפילו חרדה שמה שנגיד לא יהיה נכון, מה יחשבו עלינו, אולי מי שאנחנו עומדים מולו בהרצאה מבין בנושא שאנחנו מדברים עליו יותר מאיתנו?
המאמר הזה עוסק בכמה טיפים &lt;strong&gt;פסיכולוגיים&lt;/strong&gt; שעזרו לי להתגבר על הפחד מלדבר מול קהל, והם מזכירים לי להרגע לפני שאני עולה לדבר או סתם כשאני שוקל הגשת מועמדות.&lt;/p&gt;</description></item><item><title>Allure Reporter - הטמעת דוחות ריצה באוטומציה</title><link>https://tomercode-hugo-blog.pages.dev/2019/06/allure-reporter.html</link><pubDate>Thu, 13 Jun 2019 06:25:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2019/06/allure-reporter.html</guid><description>&lt;p&gt;אז יש לנו מערכת אוטומציה, היא מתממשקת יופי לאפליקציה שלנו והטסטים אפילו יציבים יחסית. אבל אחרי שהם רצו, כמה קל לנו לנתח את תוצאות הריצה? האם אנחנו מבזבזים יותר זמן מהנדרש על הבנה של הבעיות שעלו בתרחיש?&lt;/p&gt;</description></item><item><title>Stop using time.sleep everywhere!</title><link>https://tomercode-hugo-blog.pages.dev/2019/03/stop-using-timesleep-everywhere.html</link><pubDate>Sun, 31 Mar 2019 07:46:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2019/03/stop-using-timesleep-everywhere.html</guid><description>&lt;p&gt;I think that almost every automation infrastructure that I have seen has the &lt;strong&gt;time.sleep()&lt;/strong&gt; method at least once.&lt;/p&gt;
&lt;p&gt;Sometimes it comes from laziness and sometimes from a lack of knowledge, but I believe that in at least 90% of the times, sleep methods should not appear in our code.&lt;/p&gt;</description></item><item><title>תבניות עיצוב ואוטומציה | Template Method Pattern</title><link>https://tomercode-hugo-blog.pages.dev/2018/10/template-method-pattern.html</link><pubDate>Tue, 23 Oct 2018 03:48:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2018/10/template-method-pattern.html</guid><description>&lt;p&gt;בתור מפתחי אוטומציה (ותוכנה בכלל) אנחנו נתקלים בלא מעט בעיות..
אנחנו לא זוכרים syntax מסוים, נזרק לנו exception שאנחנו רואים פעם ראשונה או אפילו שגיאת קומפילציה שאנחנו לא מכירים.
מה אנחנו עושים כאשר דבר כזה קורה לנו? לרוב נפנה לדר&amp;rsquo; גוגל&amp;hellip; הרי כל דבר שקרה לנו כבר קרה למישהו אחר בעבר, ובכל בעיה בה נתקלנו, אנחנו כנראה לא הראשונים שנתקלנו בה.
ב-95% מהמקרים גוגל אכן פותר לנו את הבעיה.
מה קורה כאשר אנחנו נתקלים &lt;strong&gt;בבעיית Design&lt;/strong&gt; בקוד שלנו?
אנחנו לא בטוחים כיצד לחבר את ה class-ים או שאנחנו יודעים שמה שעשינו &amp;ldquo;לא כל כך יפה&amp;rdquo; אבל אנחנו לא בטוחים כיצד לעשות זאת נכון.
&lt;strong&gt;לשם כך נוצרו Design Patterns!&lt;/strong&gt;
Desing Pattens הן הפתרונות לבעיות שלנו בעיצוב התוכנה - אלו מעין &lt;strong&gt;תבניות פתורות&lt;/strong&gt; וכל מה שנשאר למשתמש זה להתאים אותן למקרה שלו.
במילים אחרות, &lt;strong&gt;Design Patterns זה פשוט פתרון לבעיה בעיצוב הקוד.&lt;/strong&gt;
היום נדבר על תבנית העיצוב שלא דיברנו עליה עוד בעבר אבל אם אתה מתכנת כבר תקופה, סביר להניח שכבר נתקלת ב Design Pattern הזה.
באמצעות template method pattern נוכל לבצע מספר מימושים שונים לאותו שלד של אלגוריתם.
במילים פשוטות, נוכל לספר את אותו הסיפור, במספר דרכים שונות ועם התפתחויות שונות, וכל זאת כאשר יש לסיפור את אותו השם ואת אותם השמות לפרקיו.
לא לדאוג, בעוד רגע הדברים יראו פשוטים בהרבה.
אז אמרנו ש design pattern הוא פתרון לבעיה. אבל מה הבעיה שלנו כאן?
נניח ובעבודתנו החדשה קיבלנו פרויקט - אנחנו צריכים לכתוב מכונה אוטומטית אשר מכינה תה. זה יהיה פשוט מאוד לא?
כל מה שנצטרך לעשות זה ליצור מחלקה, ובתוכה פעולה מרכזית להכנת תה, ואותה פעולה תקרא למספר פעולות קטנות.
הקוד יראה כך:&lt;/p&gt;</description></item><item><title>3 דרכים לייצוב הבדיקות האוטומטיות שלנו</title><link>https://tomercode-hugo-blog.pages.dev/2018/09/3.html</link><pubDate>Fri, 28 Sep 2018 09:08:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2018/09/3.html</guid><description>&lt;p&gt;כל אחד מאיתנו חווה את זה.&lt;/p&gt;
&lt;p&gt;כתבנו test אוטומטי, דיבגנו, הכל עבד מצוין.&lt;/p&gt;
&lt;p&gt;הרצנו פעם אחת, וזה עבר באופן חלק.&lt;/p&gt;
&lt;p&gt;אבל מתי שהוא, אולי אחרי כמה פעמים שהרצנו את זה באופן ידני ואולי כשזה רץ באופן אוטומטי בתהליך CI/CD זה או אחר, הבדיקה פתאום נכשלת.&lt;/p&gt;</description></item><item><title>בדיקות לתשתית האוטומציה שלנו | סוגי הבדיקות</title><link>https://tomercode-hugo-blog.pages.dev/2018/08/blog-post.html</link><pubDate>Fri, 17 Aug 2018 09:41:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2018/08/blog-post.html</guid><description>&lt;p&gt;לאחר &lt;a href="https://tomercode-hugo-blog.pages.dev/2018/07/1.html"&gt;שבפוסט הקודם&lt;/a&gt; דיברנו על הסיבות לבדיקות תשתית האוטומציה שלנו, היום נצלול לעומק הדברים ונדבר על סוגי הבדיקות השונים.
לאחר שהשתכנענו והגענו להבנה שאנחנו עומדים לכתוב קצת (או הרבה) בדיקות לתשתית האוטומציה שלנו, חשוב שנבין אילו אופציות יש לנו, או, באילו דרכים אנחנו יכולים לבדוק את המוצר שלנו.&lt;/p&gt;</description></item><item><title>בדיקות לתשתית האוטומציה שלנו | למה?</title><link>https://tomercode-hugo-blog.pages.dev/2018/07/1.html</link><pubDate>Thu, 05 Jul 2018 04:47:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2018/07/1.html</guid><description>&lt;p&gt;לפני זמן קצר העברתי הרצאה בנושא &lt;strong&gt;בדיקות למוצר האוטומציה שלנו&lt;/strong&gt;,
בתחילת ההרצאה שאלתי את האורחים מספר שאלות.
בין השאלות היו, &amp;ldquo;מי כאן כותב אוטומציה?&amp;rdquo; (כמעט כל הקהל הרים את ידו)
&amp;ldquo;מי כאן מגדיר את עצמו כמפתח?&amp;rdquo; (ידיים בודדות)
והשאלה האחרונה הייתה - &amp;ldquo;&lt;strong&gt;מי כאן כותב בדיקות לתשתיות האוטומציה שלו?&lt;/strong&gt;&amp;rdquo;
הייתה דממה בקהל. מתוך כ-60 אנשים &lt;strong&gt;אף לא יד אחת&lt;/strong&gt;.
הנתון הזה לא הפתיע אותי במיוחד, שהרי זהו לא דבר טריוויאלי (לפחות לא כרגע).
בסוף הפוסט הקרוב אני מקווה שתוכלו להסכים איתי שבדיקות לתשתיות האוטומציה שלנו הן דבר שלא כדאי לוותר עליו.&lt;/p&gt;</description></item><item><title>אוטומציה נכונה יותר | שימוש בקבצי קונפיגורציה | קבצי Json</title><link>https://tomercode-hugo-blog.pages.dev/2018/06/json.html</link><pubDate>Fri, 08 Jun 2018 10:01:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2018/06/json.html</guid><description>&lt;p&gt;אז אחרי &lt;a href="https://tomercode-hugo-blog.pages.dev/2018/05/1.html"&gt;שבפוסט הקודם&lt;/a&gt; הבנו את החשיבות של שילוב קבצי קונפיגורציה בתרחישי האוטומציה שלנו, היום נצלול מעט יותר לעומק הדברים ונכיר דרך יותר מקובלת להשתמש בקבצי קונפיגורציה - &lt;strong&gt;קבצי Json&lt;/strong&gt;.
על מנת שנוכל להבין יותר טוב את המדריך חשוב להכיר קודם את הנושאים הבאים:&lt;/p&gt;</description></item><item><title>אוטומציה נכונה יותר | שימוש בקבצי קונפיגורציה | C# Settings</title><link>https://tomercode-hugo-blog.pages.dev/2018/05/1.html</link><pubDate>Sat, 12 May 2018 10:24:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2018/05/1.html</guid><description>&lt;p&gt;פעמים רבות בתרחישי אוטומציה ובמערכות בכלל, אנו נדרשים להשתמש במשתנים או בקבועים כמו נתיבים לקבצים, שמות של קבצים, פורטים, כתובות של אתרים וכו&amp;rsquo;..&lt;/p&gt;
&lt;p&gt;היום נדבר על החשיבות של קבצי קונפיגורציה בתשתית האוטומציה שלנו.
לפני שנצלול לעומק הדברים אני רוצה לתת דוגמה &lt;strong&gt;לקוד&lt;/strong&gt; שאני רואה לא מעט.
הקוד מתייחס למדריך שעשיתי בעבר על &lt;a href="https://tomercode-hugo-blog.pages.dev/2017/10/selenium-1.html"&gt;כתיבת תרחישי אוטומציה באמצעות Selenium&lt;/a&gt;
נסה להסתכל על הקוד ולחשוב מה הבעיה כאן&amp;hellip;&lt;/p&gt;</description></item><item><title>תבניות עיצוב ואוטומציה | Factory Pattern</title><link>https://tomercode-hugo-blog.pages.dev/2018/03/factory-pattern.html</link><pubDate>Sat, 31 Mar 2018 16:16:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2018/03/factory-pattern.html</guid><description>&lt;p&gt;בתור מפתחי אוטומציה (ותוכנה בכלל) אנחנו נתקלים בלא מעט בעיות..
אנחנו לא זוכרים syntax מסוים, נזרק לנו exception שאנחנו רואים פעם ראשונה או אפילו שגיאת קומפילציה שאנחנו לא מכירים.
מה אנחנו עושים כדבר כזה קורה לנו? לרוב נפנה לדר&amp;rsquo; גוגל&amp;hellip; הרי כל דבר שקרה לנו כבר קרה למישהו אחר בעבר, ובכל בעיה בה נתקלנו, אנחנו כנראה לא הראשונים שנתקלנו בה.
ב-95% מהמקרים גוגל אכן פותר לנו את הבעיה.
מה קורה כאשר אנחנו נתקלים &lt;strong&gt;בבעיית Design&lt;/strong&gt; בקוד שלנו?
אנחנו לא בטוחים כיצד לחבר את ה class-ים או שאנחנו יודעים שמה שעשינו &amp;ldquo;לא כל כך יפה&amp;rdquo; אבל אנחנו לא בטוחים כיצד לעשות זאת נכון.
&lt;strong&gt;לשם כך נוצרו Design Patterns!&lt;/strong&gt;
Desing Pattens הן הפתרונות לבעיות שלנו בעיצוב התוכנה - אלו מעין &lt;strong&gt;תבניות פתורות&lt;/strong&gt; וכל מה שנשאר למשתמש זה להתאים אותן למקרה שלו.
במילים אחרות, &lt;strong&gt;Design Patterns זה פשוט פתרון לבעיה בעיצוב הקוד.&lt;/strong&gt;
לאחר שהתקדמנו ולמדנו לא מעט בכל הקשור לעיצוב תוכנה מונחית עצמים, וכתיבת תרחישי אוטומציה ב Selenium ו - Appium, הגיע הזמן להמשיך ולהתקדם לנושאים הבאים.&lt;/p&gt;</description></item><item><title>אוטומציה זה אחלה, אבל מה עם לוגים?</title><link>https://tomercode-hugo-blog.pages.dev/2018/02/blog-post_5.html</link><pubDate>Thu, 29 Mar 2018 19:04:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2018/02/blog-post_5.html</guid><description>&lt;p&gt;לאחר שכבר למדנו לכתוב תרחישי בדיקות באמצעות &lt;a href="https://tomercode-hugo-blog.pages.dev/2017/10/selenium-1.html"&gt;Selenium&lt;/a&gt; ו- &lt;a href="https://tomercode-hugo-blog.pages.dev/2018/01/appium_9.html"&gt;Appium&lt;/a&gt;, וכן, למדנו את עקרונות העיצוב החשובים של תכנות מונחה עצמים. &lt;strong&gt;הגיע הזמן שנעשה צעד נוסף אל עבר בניית מערכת האוטומציה שלנו.&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;כאשר אנחנו כותבים תרחיש בדיקה הוא יכול הרבה פעמים להיות מורכב ולכלול לא מעט שלבים בדרך לסיום.&lt;/p&gt;</description></item><item><title>תבניות עיצוב ואוטומציה | Facade Pattern</title><link>https://tomercode-hugo-blog.pages.dev/2018/03/facade-pattern.html</link><pubDate>Fri, 16 Mar 2018 08:26:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2018/03/facade-pattern.html</guid><description>&lt;p&gt;בתור מפתחי אוטומציה (ותוכנה בכלל) אנחנו נתקלים בלא מעט בעיות..
אנחנו לא זוכרים syntax מסוים, נזרק לנו exception שאנחנו רואים פעם ראשונה או אפילו שגיאת קומפילציה שאנחנו לא מכירים.
מה אנחנו עושים כאשר דבר כזה קורה לנו? לרוב נפנה לדר&amp;rsquo; גוגל&amp;hellip; הרי כל דבר שקרה לנו כבר קרה למישהו אחר בעבר, ובכל בעיה בה נתקלנו, אנחנו כנראה לא הראשונים שנתקלנו בה.
ב-95% מהמקרים גוגל אכן פותר לנו את הבעיה.
מה קורה כאשר אנחנו נתקלים &lt;strong&gt;בבעיית Design&lt;/strong&gt; בקוד שלנו?
אנחנו לא בטוחים כיצד לחבר את ה class-ים או שאנחנו יודעים שמה שעשינו &amp;ldquo;לא כל כך יפה&amp;rdquo; אבל אנחנו לא בטוחים כיצד לעשות זאת נכון.
&lt;strong&gt;לשם כך נוצרו Design Patterns!&lt;/strong&gt;
Desing Pattens הן הפתרונות לבעיות שלנו בעיצוב התוכנה - אלו מעין &lt;strong&gt;תבניות פתורות&lt;/strong&gt; וכל מה שנשאר למשתמש זה להתאים אותן למקרה שלו.
במילים אחרות, &lt;strong&gt;Design Patterns זה פשוט פתרון לבעיה בעיצוב הקוד.&lt;/strong&gt;
לאחר שהתקדמנו ולמדנו לא מעט בכל הקשור לעיצוב תוכנה מונחית עצמים, וכתיבת תרחישי אוטומציה ב Selenium ו - Appium, הגיע הזמן להמשיך ולהתקדם לנושאים הבאים.&lt;/p&gt;</description></item><item><title>תבניות עיצוב ואוטומציה | Page Object Pattern</title><link>https://tomercode-hugo-blog.pages.dev/2018/02/page-object-pattern.html</link><pubDate>Sat, 10 Feb 2018 16:46:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2018/02/page-object-pattern.html</guid><description>&lt;p&gt;בתור מפתחי אוטומציה (ותוכנה בכלל) אנחנו נתקלים בלא מעט בעיות..
אנחנו לא זוכרים syntax מסוים, נזרק לנו exception שאנחנו רואים פעם ראשונה או אפילו שגיאת קומפילציה שאנחנו לא מכירים.
מה אנחנו עושים כדבר כזה קורה לנו? לרוב נפנה לדר&amp;rsquo; גוגל&amp;hellip; הרי כל דבר שקרה לנו כבר קרה למישהו אחר בעבר, ובכל בעיה בה נתקלנו, אנחנו כנראה לא הראשונים שנתקלנו בה.
ב-95% מהמקרים גוגל אכן פותר לנו את הבעיה.
מה קורה כאשר אנחנו נתקלים &lt;strong&gt;בבעיית Design&lt;/strong&gt; בקוד שלנו?
אנחנו לא בטוחים כיצד לחבר את ה class-ים או שאנחנו יודעים שמה שעשינו &amp;ldquo;לא כל כך יפה&amp;rdquo; אבל אנחנו לא בטוחים כיצד לעשות זאת נכון.
&lt;strong&gt;לשם כך נוצרו Design Patterns!&lt;/strong&gt;
Desing Pattens הן הפתרונות לבעיות שלנו בעיצוב התוכנה - אלו מעין &lt;strong&gt;תבניות פתורות&lt;/strong&gt; וכל מה שנשאר למשתמש זה להתאים אותן למקרה שלו.
במילים אחרות, &lt;strong&gt;Design Patterns זה פשוט פתרון לבעיה בעיצוב הקוד.&lt;/strong&gt;
לאחר שהתקדמנו ולמדנו לא מעט בכל הקשור לעיצוב תוכנה מונחית עצמים, וכתיבת תרחישי אוטומציה ב Selenium ו - Appium, הגיע הזמן להמשיך ולהתקדם לנושאים הבאים.
בפוסט של היום - Page Objects
&lt;strong&gt;דרישות קדם:&lt;/strong&gt; &lt;a href="https://tomercode-hugo-blog.pages.dev/2017/09/nunit-10.html"&gt;אוטומציה באמצעות NUnit&lt;/a&gt;, &lt;a href="https://tomercode-hugo-blog.pages.dev/2017/10/selenium-1.html"&gt;סדרת המדריכים של סלניום&lt;/a&gt;, &lt;a href="https://tomercode-hugo-blog.pages.dev/2018/01/appium_9.html"&gt;מבוא לAppium&lt;/a&gt;&lt;/p&gt;</description></item><item><title>הצצה אל מאחורי הקלעים של Appium</title><link>https://tomercode-hugo-blog.pages.dev/2018/02/appium.html</link><pubDate>Thu, 01 Feb 2018 03:49:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2018/02/appium.html</guid><description>&lt;p&gt;אוקי, אז למדנו קצת על הארכיטקטורה הבסיסית והמוצגת למשתמש של Appium, ראינו &lt;a href="https://tomercode-hugo-blog.pages.dev/2018/01/appium_9.html"&gt;תרחיש בדיקה לדוגמה&lt;/a&gt;, למדנו &lt;a href="https://tomercode-hugo-blog.pages.dev/2018/01/appium.html"&gt;דרכים מגניבות למצוא אלמנטים&lt;/a&gt; וראינו שתי דרכים בהן נוכל לחבר את המכשיר למחשב לצורך הרצת אוטומציה.&lt;/p&gt;
&lt;p&gt;עכשיו כשאנחנו כבר יודעים דבר או שניים, הגיע הזמן שנבין איך הדברים עובדים קצת יותר לעומק.&lt;/p&gt;</description></item><item><title>חיבור מכשיר אנדרואיד שמחובר באמצעות WiFi לצורך הרצת אוטומציה</title><link>https://tomercode-hugo-blog.pages.dev/2018/01/wifi.html</link><pubDate>Sat, 20 Jan 2018 17:14:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2018/01/wifi.html</guid><description>&lt;table align="center" cellpadding="0" cellspacing="0" class="tr-caption-container" style="margin-left: auto; margin-right: auto; text-align: center;"&gt;&lt;tbody&gt;&lt;tr&gt;&lt;td style="text-align: center;"&gt;&lt;img border="0" data-original-height="374" data-original-width="648" src="https://tomercode-hugo-blog.pages.dev/images/posts/2018/01/wifi/image-01-908ae9cb97.png"&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td class="tr-caption" style="text-align: center;"&gt;&lt;br&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;p&gt;אז &lt;a href="https://tomercode-hugo-blog.pages.dev/2018/01/blog-post_16.html"&gt;בפעם הקודמת&lt;/a&gt; למדנו איך מחברים מכשיר אנדרואיד ל-ADB באמצעות כבל USB.
העניין הוא שלא תמיד נרצה לעבוד בתצורה הזו, כבלי USB הרבה פעמים מסרבלים את ה-setup ודורשים משאבים שלא תמיד הכרחיים.
לאחר שהמכשיר חובר למחשב בADB באמצעות כבל USB, נוכל לשלוט על המכשיר ולהורות לו לתקשר עם שרת הADB שעל המחשב באמצעות WiFi.&lt;/p&gt;</description></item><item><title>מדריך | מציאת אלמנטים ב-Appium</title><link>https://tomercode-hugo-blog.pages.dev/2018/01/appium.html</link><pubDate>Fri, 19 Jan 2018 10:44:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2018/01/appium.html</guid><description>&lt;p&gt;לאחר שלמדנו איך כותבים תרחיש בדיקה בסיסי באמצעות Appium, עדיין נשארו שאלות פתוחות כמו, איך אני מוצא את האלמנטים? איך אני יודע מה שם ה Package וה Activity של האפליקציה שאני רוצה לבדוק?
בפוסט הבא נכיר את UIAutometorViewer ונעשה קצת סדר בדברים.
מומלץ מאוד לעבור לפני הקריאה על פוסט דומה שכתבתי בעבר על &lt;a href="https://tomercode-hugo-blog.pages.dev/2017/11/selenium-4-by.html"&gt;מציאת אלמנטים בSelenium&lt;/a&gt;.&lt;/p&gt;</description></item><item><title>איך מחברים את מכשיר האנדרואיד למחשב לצורך הרצת אוטומציה</title><link>https://tomercode-hugo-blog.pages.dev/2018/01/blog-post_16.html</link><pubDate>Tue, 16 Jan 2018 04:35:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2018/01/blog-post_16.html</guid><description>&lt;p&gt;במידה ואיננו מעוניינים לבצע הרצות על מכשיר וירטואלי, קיימת דרך יחסית פשוטה לחבר את המכשיר הפיזי שלנו למחשב ולהריץ את בדיקות האוטומציה עליו.&lt;/p&gt;
&lt;h3 id="ההתקנות-הנדרשות"&gt;ההתקנות הנדרשות&lt;/h3&gt;
&lt;p&gt;1. ההתקנה הראשונה שנרצה לבצע תהיה של &lt;strong&gt;&lt;a href="http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html"&gt;Java SDK&lt;/a&gt;&lt;/strong&gt; (דאג להוריד ולהתקין את הגרסה העדכנית ביותר)&lt;/p&gt;</description></item><item><title>מדריך | בדיקת אפליקציות באמצעות Appium</title><link>https://tomercode-hugo-blog.pages.dev/2018/01/appium_9.html</link><pubDate>Sun, 14 Jan 2018 06:08:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2018/01/appium_9.html</guid><description>&lt;h2 id="מה-זה-appium"&gt;מה זה Appium&lt;/h2&gt;
&lt;p&gt;Appium היא תשתית לבדיקות אוטומציה לאפליקציות עבור מכשירי mobile המריצים את מערכות ההפעלה הנפוצות ביותר כיום - Android ו- iOS.
המאמר של היום יעסוק בשימוש ב Appium על אפליקציות אנדרואיד אך ה interface זהה גם ל iOS,
כלומר, ניתן לכתוב תרחיש אחד שיוכל לרוץ על שניהם - אם כי ה setup שונה.&lt;/p&gt;</description></item><item><title>תכנות מונחה עצמים | Dependency Inversion Principle</title><link>https://tomercode-hugo-blog.pages.dev/2018/01/dependency-inversion-principle.html</link><pubDate>Fri, 05 Jan 2018 17:43:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2018/01/dependency-inversion-principle.html</guid><description>&lt;p&gt;על מנת שהמערכות, היישומים והתשתיות שאנחנו מפתחים יהיו חזקים, יציבים וניתנים לתחזוקה ולשינויים, עלינו לדעת כיצד לעצב אותם בצורה הטובה ביותר.&lt;/p&gt;
&lt;p&gt;העקרונות הבסיסיים של תכנות מונחה עצמים לרוב אינם יספיקו למפתח בכדי לכתוב מערכת ברמה גבוהה.&lt;/p&gt;</description></item><item><title>תכנות מונחה עצמים | Interface Segregation Principle</title><link>https://tomercode-hugo-blog.pages.dev/2017/12/interface-segregation-principle.html</link><pubDate>Fri, 29 Dec 2017 17:44:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2017/12/interface-segregation-principle.html</guid><description>&lt;p&gt;על מנת שהמערכות, היישומים והתשתיות שאנחנו מפתחים יהיו חזקים, יציבים וניתנים לתחזוקה ולשינויים, עלינו לדעת כיצד לעצב אותם בצורה הטובה ביותר.&lt;/p&gt;
&lt;p&gt;העקרונות הבסיסיים של תכנות מונחה עצמים לרוב אינם יספיקו למפתח בכדי לכתוב מערכת ברמה גבוהה.&lt;/p&gt;</description></item><item><title>תכנות מונחה עצמים | Liskov Subtitution Principle</title><link>https://tomercode-hugo-blog.pages.dev/2017/12/liskov-subtitution-principle.html</link><pubDate>Fri, 22 Dec 2017 16:04:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2017/12/liskov-subtitution-principle.html</guid><description>&lt;p&gt;על מנת שהמערכות, היישומים והתשתיות שאנחנו מפתחים יהיו חזקים, יציבים וניתנים לתחזוקה ולשינויים, עלינו לדעת כיצד לעצב אותם בצורה הטובה ביותר.&lt;/p&gt;
&lt;p&gt;העקרונות הבסיסיים של תכנות מונחה עצמים לרוב אינם יספיקו למפתח בכדי לכתוב מערכת ברמה גבוהה.&lt;/p&gt;</description></item><item><title>תכנות מונחה עצמים | Open/Closed Principle</title><link>https://tomercode-hugo-blog.pages.dev/2017/12/openclosed-principle.html</link><pubDate>Fri, 15 Dec 2017 08:56:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2017/12/openclosed-principle.html</guid><description>&lt;p&gt;על מנת שהמערכות, היישומים והתשתיות שאנחנו מפתחים יהיו חזקים, יציבים וניתנים לתחזוקה ולשינויים, עלינו לדעת כיצד לעצב אותם בצורה הטובה ביותר.&lt;/p&gt;
&lt;p&gt;העקרונות הבסיסיים של תכנות מונחה עצמים לרוב אינם יספיקו למפתח בכדי לכתוב מערכת ברמה גבוהה.&lt;/p&gt;</description></item><item><title>תכנות מונחה עצמים | Single Responsibilty Principle</title><link>https://tomercode-hugo-blog.pages.dev/2017/12/single-responsibilty-principle.html</link><pubDate>Fri, 08 Dec 2017 14:25:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2017/12/single-responsibilty-principle.html</guid><description>&lt;p&gt;על מנת שהמערכות, היישומים והתשתיות שאנחנו מפתחים יהיו חזקים, יציבים וניתנים לתחזוקה ולשינויים, עלינו לדעת כיצד לעצב אותם בצורה הטובה ביותר.&lt;/p&gt;
&lt;p&gt;העקרונות הבסיסיים של תכנות מונחה עצמים לרוב אינם יספיקו למפתח בכדי לכתוב מערכת ברמה גבוהה.&lt;/p&gt;</description></item><item><title>מה ההבדל בין Assert ל Exception?</title><link>https://tomercode-hugo-blog.pages.dev/2017/12/assert-exception.html</link><pubDate>Fri, 01 Dec 2017 06:20:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2017/12/assert-exception.html</guid><description>&lt;p&gt;כל תשתית לכתיבת unit tests שאני מכיר היום משתמשת במחלקה Assert בכדי לקבוע בסוף תרחיש הבדיקה, האם הבדיקה הצליחה או נכשלה.&lt;/p&gt;
&lt;h3 id="אבל-מה-ההבדל-בין-זה-לבין-throw-new-exception"&gt;אבל מה ההבדל בין זה לבין throw new Exception?&lt;/h3&gt;
&lt;p&gt;ראשית נבין איזה שימוש נרצה בדרך כלל לעשות בכל אחד מהשניים ואיך נשתמש בהם.&lt;/p&gt;</description></item><item><title>Nunit | בדיקות מבוססות נתונים - Data Driven Tests</title><link>https://tomercode-hugo-blog.pages.dev/2017/11/nunit-data-driven-tests.html</link><pubDate>Thu, 23 Nov 2017 04:12:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2017/11/nunit-data-driven-tests.html</guid><description>&lt;p&gt;פעמים רבות אנו נדרשים לבצע תרחישי בדיקה אוטומטיים על קונפיגורציות משתנות.&lt;/p&gt;
&lt;p&gt;היום אדבר ואציג מספר דרכים לביצוע בדיקות אשר מתבססות על פרמטרים.&lt;/p&gt;
&lt;p&gt;&lt;img src="https://tomercode-hugo-blog.pages.dev/images/posts/2017/11/nunit-data-driven-tests/image-01-f5cf75f1f4.png" alt=""&gt;&lt;/p&gt;
&lt;p&gt;בדוגמאות אציג:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;קבלת פרמטרים רגילים לבדיקה - Parametrized Test&lt;/li&gt;
&lt;li&gt;קבלת רשימת פרמטרים לבדיקה - TestCaseSource&lt;/li&gt;
&lt;li&gt;קבלת פרמטרים לבדיקה מקובץ חיצוני - External TestCaseSource&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;הנושא הינו נושא בסיסי ומוכר מאוד בתחום הבדיקות וחשוב להכירו לעומק.
דרישות קדם: &lt;a href="https://tomercode-hugo-blog.pages.dev/2017/09/c.html"&gt;תכנות בסיסי בC#&lt;/a&gt;, &lt;a href="https://tomercode-hugo-blog.pages.dev/2017/09/nunit-10.html"&gt;היכרות עם NUnit&lt;/a&gt;&lt;/p&gt;</description></item><item><title>מדריך | אוטומציה באמצעות Selenium | חלק 4 - מציאת אלמנטים (המחלקה By)</title><link>https://tomercode-hugo-blog.pages.dev/2017/11/selenium-4-by.html</link><pubDate>Fri, 17 Nov 2017 05:32:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2017/11/selenium-4-by.html</guid><description>&lt;p&gt;עד כה כיסינו את רוב מה שמפתח אוטומציה מתחיל באמצעות סלניום צריך לדעת.
העבודה עם כלי הבדיקות Selenium מתבססת ברובה על התממשקות &lt;a href="https://tomercode-hugo-blog.pages.dev/2017/11/selenium-3-webelement.html"&gt;לאלמנטים&lt;/a&gt; השונים בדף ה-HTML אותו נרצה לבדוק.
היום נכנס לעומק הדברים ונבין כיצד נוכל למצוא את האלמנטים הללו יותר בקלות וביעילות.
דרישות קדם: &lt;a href="https://tomercode-hugo-blog.pages.dev/2017/09/c.html"&gt;ידע בסיסי בC#&lt;/a&gt; וביצוע שלושת המדריכים הקודמים בסדרה (&lt;a href="https://tomercode-hugo-blog.pages.dev/2017/10/selenium-1.html"&gt;1&lt;/a&gt;,&lt;a href="https://tomercode-hugo-blog.pages.dev/2017/11/selenium-2-webdriver.html"&gt;2&lt;/a&gt;,&lt;a href="https://tomercode-hugo-blog.pages.dev/2017/11/selenium-3-webelement.html"&gt;3&lt;/a&gt;).&lt;/p&gt;</description></item><item><title>מדריך | אוטומציה באמצעות Selenium | חלק 3 - WebElement</title><link>https://tomercode-hugo-blog.pages.dev/2017/11/selenium-3-webelement.html</link><pubDate>Fri, 10 Nov 2017 10:51:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2017/11/selenium-3-webelement.html</guid><description>&lt;p&gt;עד כה בסדרת המדריכים - Selenium, הצגתי את &lt;a href="https://tomercode-hugo-blog.pages.dev/2017/10/selenium-1.html"&gt;היכולות הבסיסיות&lt;/a&gt; של התשתית באמצעות ביצוע תרחיש אוטומטי פשוט של חיפוש בגוגל וגלישה לאתר, לאחר מכן הצגתי את ממשק &lt;a href="https://tomercode-hugo-blog.pages.dev/2017/11/selenium-2-webdriver.html"&gt;IWebDriver&lt;/a&gt; ואת הפונקציונליות שהוא מספק.
במדריך של היום אדבר על מהו WebElement ואסקור את ממשק IWebElement.&lt;/p&gt;</description></item><item><title>מדריך | אוטומציה באמצעות Selenium | חלק 2 - אובייקט WebDriver</title><link>https://tomercode-hugo-blog.pages.dev/2017/11/selenium-2-webdriver.html</link><pubDate>Fri, 03 Nov 2017 08:41:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2017/11/selenium-2-webdriver.html</guid><description>&lt;p&gt;&lt;a href="https://tomercode-hugo-blog.pages.dev/2017/10/selenium-1.html"&gt;בפוסט הקודם&lt;/a&gt; הצגתי והסברתי בקצרה על תשתית Selenium ועל עוצמתה בכל הנוגע לאוטומציית דפדפנים.&lt;/p&gt;
&lt;p&gt;היום ובמדריכים הקרובים, אצלול ואסביר קצת יותר לעומק על המודולים השונים בתשתית ועל אופן השימוש בהם.
דרישות קדם: &lt;a href="https://tomercode-hugo-blog.pages.dev/2017/09/c.html"&gt;הכירות עם תכנות בסיסי ב C#&lt;/a&gt;, &lt;a href="https://tomercode-hugo-blog.pages.dev/2017/09/nunit-10.html"&gt;היכרות עם תשתית הבדיקה NUnit&lt;/a&gt;, &lt;a href="https://tomercode-hugo-blog.pages.dev/2017/10/selenium-1.html"&gt;קריאת המדריך הראשון על Selenium.&lt;/a&gt;
על מנת לבצע פעולות על הדפדפן אנחנו מאתחלים אובייקט WebDriver (לדוגמה Chrome) בממשק IWebDriver.&lt;/p&gt;</description></item><item><title>מדריך | אוטומציה באמצעות Selenium | חלק 1 - מבוא</title><link>https://tomercode-hugo-blog.pages.dev/2017/10/selenium-1.html</link><pubDate>Fri, 27 Oct 2017 04:27:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2017/10/selenium-1.html</guid><description>&lt;p&gt;לאחר שהבנו את &lt;a href="https://tomercode-hugo-blog.pages.dev/2017/09/5.html"&gt;יתרונות פיתוח האוטומציה&lt;/a&gt; ופיתחנו בדיקת אוטומציה ראשונה באמצעות &lt;a href="https://tomercode-hugo-blog.pages.dev/2017/09/nunit-10.html"&gt;NUnit&lt;/a&gt; הגיע הזמן שנגיע לתכלס..&lt;/p&gt;
&lt;p&gt;כיום קיימים בשוק מגוון כלים בשוק, בסגנון קוד פתוח, שמגיעים על מנת להקל, ולתת גמישות ויכולות נוספות בנושא האוטומציה.&lt;/p&gt;
&lt;h2 id="מה-זה-selenium"&gt;מה זה Selenium?&lt;/h2&gt;
&lt;p&gt;סלניום היא תשתית האוטומציה &lt;strong&gt;לדפדפנים&lt;/strong&gt; הגדולה בעולם כיום.&lt;/p&gt;</description></item><item><title>מדריך C# | שימוש ב LINQ</title><link>https://tomercode-hugo-blog.pages.dev/2017/10/c-linq.html</link><pubDate>Fri, 20 Oct 2017 04:06:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2017/10/c-linq.html</guid><description>&lt;p&gt;אחד הדברים שאנחנו המתכנתים נתקלים בהם באופן כמעט יומיומי הוא השימוש &lt;strong&gt;ברשימות ומערכים.&lt;/strong&gt;
מה שמשותף למערכים רשימות ועוד אובייקטים שמסודרים יחדיו אחד אחרי השני הוא שכולם מממשים את ממשק IEnumerable
*תנאי קדם למדריך: היכרות עם &lt;a href="https://tomercode-hugo-blog.pages.dev/2017/09/c.html"&gt;#C בסיסי&lt;/a&gt; ועם Lists.&lt;/p&gt;</description></item><item><title>מה חדש ב - C# 7?</title><link>https://tomercode-hugo-blog.pages.dev/2017/10/c-7.html</link><pubDate>Wed, 11 Oct 2017 09:53:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2017/10/c-7.html</guid><description>&lt;p&gt;גרסתה הראשונה של שפת C# יצאה ב2002 עם גרסה 1.0 של NET.&lt;/p&gt;
&lt;p&gt;מאז כל שנתיים-שלוש, מתעדכנת גרסת NET. ואיתה גם שפת C#&lt;/p&gt;
&lt;p&gt;השינויים בין הגרסאות בדרך כלל לא דרסטיים.&lt;/p&gt;
&lt;p&gt;הם בדרך כלל שינויים של &lt;strong&gt;נוחות פיתוח, יעילות וכתיבת קוד נקי יותר&lt;/strong&gt;.&lt;/p&gt;</description></item><item><title>שיפור פרודוקטיביות - מה חדש ב Visual Studio 2017?</title><link>https://tomercode-hugo-blog.pages.dev/2017/10/visual-stiudio-2017.html</link><pubDate>Wed, 04 Oct 2017 07:00:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2017/10/visual-stiudio-2017.html</guid><description>&lt;p&gt;Visual Studio 2017 היא הגרסה החדשה ביותר של סביבת הפיתוח הרשמית של Microsoft עבור NET.
אם עדייו אין לך Visual Studio 2017, היכנס &lt;a href="https://tomercode-hugo-blog.pages.dev/2017/09/visual-studio-2017.html"&gt;לכאן&lt;/a&gt; בכדי להוריד.&lt;/p&gt;
&lt;p&gt;את כל מה שחדש בסביבת הפיתוח לצערי בלתי אפשרי לפרוט בפוסט אחד,&lt;/p&gt;</description></item><item><title>מדריך: פיתוח אוטומציה באמצעות NUnit ב10 דקות</title><link>https://tomercode-hugo-blog.pages.dev/2017/09/nunit-10.html</link><pubDate>Fri, 29 Sep 2017 07:32:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2017/09/nunit-10.html</guid><description>&lt;p&gt;היום אדבר על איך לבצע בדיקה אוטומטית ראשונה עם NUnit ואציג את ההבדלים בין שלושת תשתיות הUnit Testing הגדולות ביותר עבור NET.&lt;/p&gt;
&lt;h2 id="תשתיות-הבדיקה-הגדולות-עבור-net"&gt;תשתיות הבדיקה הגדולות עבור NET.&lt;/h2&gt;
&lt;p&gt;שלושת תשתיות הבדיקה הן:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;MSTest&lt;/li&gt;
&lt;li&gt;NUnit&lt;/li&gt;
&lt;li&gt;XUnit&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;כל השלוש מגיעות בכדי להשיג יעד דומה - הפיכת כתיבת תרחישי בדיקה לקלה יותר, מהירה יותר ופשוטה יותר.&lt;/p&gt;</description></item><item><title>מהם NuGet Packages ואיך להשתמש בהם?</title><link>https://tomercode-hugo-blog.pages.dev/2017/09/nuget-packages.html</link><pubDate>Thu, 21 Sep 2017 14:12:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2017/09/nuget-packages.html</guid><description>&lt;h2 id="מה-זה-nuget"&gt;מה זה NuGet?&lt;/h2&gt;
&lt;p&gt;כמו שציינתי &lt;a href="https://tomercode-hugo-blog.pages.dev/2017/09/dll.html"&gt;בפוסט הקודם&lt;/a&gt; מספר החבילות שתשתית NET. מספקת עצום, אך &lt;strong&gt;מוגבל&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;ישנם המון מפתחים מוכשרים בארץ ובעולם שכותבים חבילות וספריות בעצמם.&lt;/p&gt;
&lt;p&gt;בעבר תהליך האינטגרציה עם חבילות חיצוניות היה לוקח הרבה זמן ודורש תחזוקה במקרים של עדכונים וכו&amp;rsquo;..&lt;/p&gt;</description></item><item><title>מהם קבצי DLL ואיך להשתמש בהם?</title><link>https://tomercode-hugo-blog.pages.dev/2017/09/dll.html</link><pubDate>Thu, 21 Sep 2017 12:00:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2017/09/dll.html</guid><description>&lt;p&gt;תשתית הפיתוח Net. מכילה מאות ספריות מובנות בהן אפשר להשתמש על מנת להקל על עצמנו בפיתוח הקוד.
היום נלמד כיצד ניתן להוסיף אותן לפרויקט שלנו ואיך להשתמש בהן.
במדריך &lt;a href="https://tomercode-hugo-blog.pages.dev/2017/09/c.html"&gt;איך ליצור מחשבון בC#&lt;/a&gt; אפשר לראות בתחילת הקוד שאנחנו כותבים את השורה&lt;/p&gt;</description></item><item><title>מדריך: איך ליצור מחשבון בC#?</title><link>https://tomercode-hugo-blog.pages.dev/2017/09/c.html</link><pubDate>Mon, 18 Sep 2017 07:33:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2017/09/c.html</guid><description>&lt;h3 id="היום-נלמד-איך-ליצור-תכנית-בסיסית-וראשונית-בהחלט-בc"&gt;היום נלמד איך ליצור תכנית בסיסית וראשונית בהחלט בC#&lt;/h3&gt;
&lt;p&gt;לאחר הפוסט הזה יהיו לכם מספיק כלים להתמודד עם שאר הלימוד הבסיסי &lt;strong&gt;בעצמכם.&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;פיתוח תוכנה הוא מקצוע שדורש הרבה השקעה ולמידה עצמית.&lt;/p&gt;
&lt;p&gt;העצה הכי טובה שלי אליכם: &lt;strong&gt;למדו כדי לעשות ולא כדי ללמוד&lt;/strong&gt;&lt;/p&gt;</description></item><item><title>מדריך: כיצד לבחור ואיך להתקין Visual Studio 2017</title><link>https://tomercode-hugo-blog.pages.dev/2017/09/visual-studio-2017.html</link><pubDate>Wed, 13 Sep 2017 03:57:00 +0000</pubDate><guid>https://tomercode-hugo-blog.pages.dev/2017/09/visual-studio-2017.html</guid><description>&lt;p&gt;הגיע הזמן שנתחיל ללכלך את הידיים שלנו ולעבוד..&lt;/p&gt;
&lt;h3 id="מה-זה-visual-studio"&gt;מה זה Visual Studio?&lt;/h3&gt;
&lt;p&gt;Visual Studio של מיקרוסופט היא אחת מסביבות פיתוח המובילות והחזקות בשוק, המאפשרת למתכנתים לפתח תוכניות מחשב ואתרי אינטרנט וכמובן, והכי חשוב, בדיקות אוטומטיות.&lt;/p&gt;</description></item></channel></rss>