<?xml version="1.0" encoding="UTF-8"?><urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:news="http://www.google.com/schemas/sitemap-news/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml" xmlns:image="http://www.google.com/schemas/sitemap-image/1.1" xmlns:video="http://www.google.com/schemas/sitemap-video/1.1"><url><loc>https://tube.hamakor.org.il/about/instance</loc></url><url><loc>https://tube.hamakor.org.il/videos/local</loc></url><url><loc>https://tube.hamakor.org.il/w/tuLCJMwtiT9X2mjXniBn4K</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/71cf0cb7-910f-4a88-88c1-06d90aea2fcc.jpg</video:thumbnail_loc><video:title>⁧ ברוכים הבאים ל-Fediverse / גיא שפר⁩</video:title><video:description>⁧הפדיוורס (Fediverse) היא רשת חברתית קוד פתוח מושתת על סטנדרט של W3C. היא תופסת תאוצה וגדלה במליוני משתמשים בחצי שנה האחרונה. באו לשמוע איך לקחת חלק וקצת איך היא עובדת מבפנים טכנית וחברתית.⁩</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/deab1360-bb9b-427b-8728-c775dd017b35</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/pRRQsyjcgtDQSuWeW35d5K</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/d0d96929-ea0a-47d7-8f89-7fe1134cb3e3.jpg</video:thumbnail_loc><video:title>אוגוסט פינווין 2007 - דברי פתיחה וסיכום שנה</video:title><video:description>אוגוסט פינווין 2007 - דברי פתיחה וסיכום שנה</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/c138589b-0e38-4082-a16b-0733d06ce183</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/dzrchrJWF5FY2uLj2CWQDE</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/22d3890f-4714-4259-8788-1f2d26e6fd93.jpg</video:thumbnail_loc><video:title>אוגוסט פינגווין 2007 - GPLv3</video:title><video:description>אוגוסט פינגווין 2007 - GPLv3</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/65d8bc2a-3261-4bd3-a614-02b8424afc18</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/47ECJDPGLq5n1R6untPnKV</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/cf87b51f-3fee-4c71-8ec8-b77817800446.jpg</video:thumbnail_loc><video:title>אוגוסט פינגווין 2007 - אקטיביזם חברתי למתחילים</video:title><video:description>אוגוסט פינגווין 2007 - אקטיביזם חברתי למתחילים</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/1939aff0-3a38-4ab1-86d6-62f422fd9a8f</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/iom4nE2aGbYxwDXeNPtVAo</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/aec7ea07-a3c5-46f2-896e-f8b42670aa54.jpg</video:thumbnail_loc><video:title>אוגוסט פינגווין 2007 - פרוייקט "מחשב לכל ילד (OLPC)"</video:title><video:description>אוגוסט פינגווין 2007 - פרוייקט "מחשב לכל ילד (OLPC)"</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/8cca14d9-52a9-4aa5-8d9d-0f9424b2aae6</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/mdMmFLjXKKysW5oidmDiSF</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/65ea5506-e016-46b3-805a-d2cc90e6eaf8.jpg</video:thumbnail_loc><video:title>אוגוסט פינגווין 2007 - אופן אופיס בעברית</video:title><video:description>אוגוסט פינגווין 2007 - אופן אופיס בעברית</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/a3bfa685-0702-4eae-967e-e3011baa84a7</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/tRXn7JexX4ksTLCiJyccP9</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/51073954-aa27-4af9-924a-57ca1ef6d458.jpg</video:thumbnail_loc><video:title>אוגוסט פינגווין 2011 - תקציב פתוח</video:title><video:description>התקציב הפתוח מאת אדם קריב</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/e1a04ed0-894e-4f3a-b44a-39fef9c3b772</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/7wTyyaiX7mAc1QqtMfXsUm</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/4c1124b7-925f-4352-940b-0662a236a32c.jpg</video:thumbnail_loc><video:title>אוגוסט פינגווין 2011 - פרויקט BigBlueButton</video:title><video:description>המחלקה להנדסת תוכנה, מכללת שנקר מציגה את פרוייקט התירגום של מחלקה</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/34e6ebbb-8acb-473c-b36c-534d7760d4dc</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/kCCeqQSX1nuBvc6qhZYftL</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/e68d347b-7f2a-4be6-b8dc-0c44445c0142.jpg</video:thumbnail_loc><video:title>אוגוסט פינגווין 2011 - Boost.Locale</video:title><video:description>מרצה : ארתיום בייליס
 http://august.penguin.org.il/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/9efabd1d-5917-46da-b444-d997e2b3dd12</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/6yXBE2i5pAtysMJGJ5WrL1</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/9cc0abc6-6351-401d-b1d2-09faf8c266ad.jpg</video:thumbnail_loc><video:title>אוגוסט פינגווין 2011 - חיפוש עברי בקוד פתוח</video:title><video:description>חיפוש עברי בקוד פתוח - איתמר סין-הרשקו
http://august.penguin.org.il/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/2d17c48b-2223-4997-9fa2-2de8b1cff36c</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/uuGiVkcciQoAhwbCCdPitP</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/5a096079-ebad-42ea-8b16-c517059eff27.jpg</video:thumbnail_loc><video:title>אוגוסט פינגווין 2011 - דברי פתיחה וסיכום שנה</video:title><video:description>ליאור קפלן מסכם את שנת 2011
http://august.penguin.org.il/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/e6c18ca0-09d2-44d5-a292-3f5a7d841a49</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/mJvYAw1Y4rf7a7ZQKG5xNV</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/79816de5-56d7-4461-8544-79f88d2ec044.jpg</video:thumbnail_loc><video:title>אוגוסט פינגווין 2011 - פרס המקור</video:title><video:description>פרס המקור 2011
תרומה אישית לתוכנה חופשית בישראל
אלעד אלפסה - עיקר התרגומים של פדורה בשנה האחרונה הם פרי עבודתו, כמו כן תרגם ועזר לצוות ה־web של פדורה בהוספת תמיכת Bidi ל־אתר החדש של פרוייקט פדורה. בהמשך הצטרף לצוות התשתיות של פדורה ובמסגרת זו הוא ממשיך לספק תמיכה למשתמשים. בנוסף, אלעד תורם לפרויקטים נוספים כגון פרוייקט מוזילה.
נדב הראל (זוכה) - כתיבת המאיית החופשי לעברית hspell שמשמש כיום את OpenOffice ופרוייקטים נוספים ; עזרה ברשימות דיוור ופורומים ; כתב גרסה משלו למחשבון שורת הפקודה hoc ששוחררה תחת רשיון חופשי.
יובל קוג'מן - תחזוקת מספר רב של מודולים ב-CPAN, תרומה אחרת לקודים הקשורים לפרל; עזרה בפורומים מקוונים.
ירון שהרבני - מתחזק את כל התרגום של פרויקט גנום כמעט לבדו, ועוזר לתרגום פרויקטים רבים אחרים בקוד פתוח. ירון משקיע זמן רב בתרגומים מלאים ואיכותיים, ובכך עוזר גם למשתמשים שלא מבינים אנגלית להשתמש בלינוקס. https://launchpad.net/~sh-yaron 
 http://august.penguin.org.il</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/a7e67c19-d8e1-483f-856d-e0fdc793417d</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/kDPk8c8qyFz8khtaeJzCzW</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/e26049e6-aef3-4039-8f40-59ba5c7a257e.jpg</video:thumbnail_loc><video:title>אוגוסט פינגווין 2011 - פריסת מקשים במקלדת ישראלית</video:title><video:description>סיפורו של תקן ישראלי 1452 מרצה שחר שמש
http://http://august.penguin.org.il/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/9f25526f-282e-4230-9bcf-8968cb604368</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/wD7UBq4v3QPueWAYvCerBD</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/2ea8ebfb-ae5d-4a48-a45d-1d4bd8ea2d6c.jpg</video:thumbnail_loc><video:title>אוגוסט פינגווין 2009 - אסטריסק</video:title><video:description>אוגוסט פינגווין 2009 - אסטריסק</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/f820ef99-034f-4e0c-bd7d-d8a6b86fe0ff</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/cvypBubW9gJK7XnL8gZ1mn</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/38b11c10-5720-48fa-b2cf-cb5b15dbb9f7.jpg</video:thumbnail_loc><video:title>אוגוסט פינגווין 2009 - החקיקה הטכנולוגית, מורה נבוכים</video:title><video:description>אוגוסט פינגווין 2009 - החקיקה הטכנולוגית, מורה נבוכים</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/5d3510f0-dac6-4269-82e5-6c1e2182e155</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/vGVbwcjET6jNnyka7gf6ym</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/5e236c40-385d-4be4-85f9-1ba4caaeb5f2.jpg</video:thumbnail_loc><video:title>אוגוסט פינגווין 2009 - מקוד פתוח לצ'ק בטוח</video:title><video:description>אוגוסט פינגווין 2009 - מקוד פתוח לצ'ק בטוח</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/f08f8bcf-8b3a-4fc2-b9dd-dab5d17576a8</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/sZXemwicz7FBRbQLMGZyg5</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/b2d117b4-833b-4ceb-9cbb-6df0083f7adc.jpg</video:thumbnail_loc><video:title>אוגוסט פינגווין 2009 - קלטורה, נגן וידאו בקוד פתוח</video:title><video:description>אוגוסט פינגווין 2009 - קלטורה, נגן וידאו בקוד פתוח</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/daa50971-daf3-4708-975b-e5022796c572</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/155SPfckrCP5txEncU6dMg</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/b76e7194-b451-4695-b447-42cb3a115263.jpg</video:thumbnail_loc><video:title>אוגוסט פינגווין 2009 - Introduction to the open web</video:title><video:description>אוגוסט פינגווין 2009 - Introduction to the open web</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/0091fae7-471b-4d30-ba9a-76439dfad719</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/9k7Y3bchnUALFsXTpEJpLW</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/1ee0de68-a3a0-43dd-94a2-a6c1f0d24d79.jpg</video:thumbnail_loc><video:title>אוגוסט פינגווין 2009 - דבר המקור</video:title><video:description>אוגוסט פינגווין 2009 - דבר המקור</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/437488b1-ab6c-4d4b-9ae6-5a0503ad54fa</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/7veVJwAWLNFNfLrTCpkg9N</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/cb066b68-a940-49fe-a8e5-e1d1d5ebb780.jpg</video:thumbnail_loc><video:title>אוגוסט פינגווין 2008 - פעילות קוד פתוח באיגוד האינטרנט</video:title><video:description>אוגוסט פינגווין 2008 - פעילות קוד פתוח באיגוד האינטרנט</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/34abfbd7-ba46-4f9d-8f3c-d0528d687c42</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/3qQATyG2Y7fh62BaKrGjJ1</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/9e84b6cd-c31a-40d1-bb97-53499dbcfa41.jpg</video:thumbnail_loc><video:title>אוגוסט פינגווין 2008 - בלוגלי - הקמת שירות מבוסס Wordpress</video:title><video:description>אוגוסט פינגווין 2008 - בלוגלי - הקמת שירות מבוסס Wordpress</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/13aa145e-0d06-441b-b2ed-071342c6af7c</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/6jYWGvBWArExmUP62GgHi5</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/509afa67-298f-4780-8076-53817a35b757.jpg</video:thumbnail_loc><video:title>אוגוסט פינגווין 2008 - קהילת אופן אופיס וקוד פתוח בחינוך</video:title><video:description>אוגוסט פינגווין 2008 - קהילת אופן אופיס וקוד פתוח בחינוך</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/2b242c6f-9a8e-4b13-bd28-9848d567ebda</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/8AfkuR1XFjr9773NAGL65D</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/5a87d4bf-7551-4a78-b7fe-be08b718cf4e.jpg</video:thumbnail_loc><video:title>אוגוסט פינגווין 2008 - דברי סיכום ופרס המקור</video:title><video:description>אוגוסט פינגווין 2008 - דברי סיכום ופרס המקור</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/3d781801-8127-44f2-80d5-5ec3058189e1</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/morcyYEZejwvHLkXNieyuq</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/f2430776-c05a-42a5-b304-b128dcedc679.jpg</video:thumbnail_loc><video:title>אוגוסט פינגווין 2008 - אתגרים בכתיבה דו כיוונית (BIDI)</video:title><video:description>אוגוסט פינגווין 2008 - אתגרים בכתיבה דו כיוונית (BIDI)</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/a518aa75-a538-4979-8efd-0b32785d5908</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/j8iNQqjTS8pXTgXbdSHTKP</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/89b85186-a156-4a1e-a078-75248f015fc8.jpg</video:thumbnail_loc><video:title>אוגוסט פינגווין 2008 - ארגון ה-W3C בישראל</video:title><video:description>אוגוסט פינגווין 2008 - ארגון ה-W3C בישראל</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/92c9ad31-0c46-462b-a01a-0f518e762a21</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/aGQYcvNQ9mBDnbz3dyRs8j</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/6d011dcd-bffb-4743-8b05-9d2caa859512.jpg</video:thumbnail_loc><video:title>אוגוסט פינגווין 2008 - hocr - מזהה דפוס אופטי בעברית</video:title><video:description>אוגוסט פינגווין 2008 - hocr - מזהה דפוס אופטי בעברית</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/4e962d4a-b82a-483d-9dfa-0c1ea7d35d78</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/7yaEH2YfB7Poe7YQQxeYda</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/6ecccb7c-9d86-46e0-bb66-3f0e82052318.jpg</video:thumbnail_loc><video:title>אוגוסט פינגווין 2010 - שימוש יעיל ב-Fluxbox</video:title><video:description>מרצה: דניאל שקורי
מצגת: https://github.com/theosp/super-efficiency-with-fluxbox/blob/master/presentation.odp</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/3514971f-c695-4d51-af7f-b72019c53999</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/7St4Re2SbEY3BeE9HZ78eq</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/b990bb7b-7727-4ea5-ab3a-d592d8ab535f.jpg</video:thumbnail_loc><video:title>קוד פתוח בגליל 2011 - יבשת האפשרויות הבלתי מוגבלות</video:title><video:description>"יבשת האפשרויות הבלתי מוגבלות - העולם החדש של יזמות ברשת" - צחי רבאל, מנכל Extra-Brain</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/37a2b360-c00a-4007-80d4-eccf23e85f26</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/7BoFGUYgNMY9CZzShGYuGf</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/6b9347cc-5d97-4663-9a85-3e20e838ece9.jpg</video:thumbnail_loc><video:title>קוד פתוח בגליל 2011 - חוקי הברזל ליזמות מצליחה</video:title><video:description>"חוקי הברזל ליזמות מצליחה - טיפים ועצות מהשטח" - יריב רון, יזם ומשקיע במיזמי אינטרנט</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/3587d801-bd23-4f9c-bb94-091cc2af3a4e</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/aeRyWyiUdjWv12ihcc1zAi</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/dc55979a-4936-4b0d-8c4c-f7897bd7354a.jpg</video:thumbnail_loc><video:title>קוד פתוח בגליל 2011 - ממשגב לחמש יבשות בשלוש שנים</video:title><video:description>"ממשגב לחמש יבשות בשלוש שנים" - ערן גל, מנכ"ל XORCOM</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/4ad176db-065b-493b-9199-8fced4c6f279</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/veviY9dcLUo25fzq36hASX</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/f3a526aa-8ce9-4a7c-8284-a5e13ff660dd.jpg</video:thumbnail_loc><video:title>קוד פתוח בגליל 2011 - להפוך תאונת עבודה לסיפור הצלחה</video:title><video:description>"כוח הרצון וכוח הרשת - להפוך תאונת עבודה לסיפור הצלחה" - ארז בן שוהם, מפתח מערכת MyPages</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/ecbbc0c1-65ea-4b82-ab6a-95c543aa13e3</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/8Ad6MyyXierhQqexc2am3C</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/95514725-e394-46db-b3ec-0e135a2bfa7f.jpg</video:thumbnail_loc><video:title>קוד פתוח בגליל 2011 - הקוד שפתח לנו עסק</video:title><video:description>"הקוד שפתח לנו עסק" - עינת טויזר לומברוזו וליאת שדה סעדון</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/3d76b72d-6264-4fc8-8b25-0e1bf5eb6800</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/5SoTkvJRwFs7RAHXWf5fwo</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/e7d69e21-0ac5-45ae-aa72-36a510831da0.jpg</video:thumbnail_loc><video:title>קוד פתוח בגליל 2011 - שילוב ערוצי השיווק לקידום עסקים</video:title><video:description>"שילוב ערוצי השיווק באינטרנט לקידום עסקים" - חדווה גבאי netfocus</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/276dd8ba-2919-40b1-bfd1-3acd56c0085a</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/c9CJc9RPN6cwJkeDenb7CJ</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/f57630c9-a558-4c9c-a613-cd988dd67c15.jpg</video:thumbnail_loc><video:title>קוד פתוח בגליל 2011 - להכניס רגל למים</video:title><video:description>"להכניס רגל למים" - אלדד גרפונקל, מנכ"ל Softtailors</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/5a491c09-50e7-4126-bc07-9b485e986eea</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/epx8z6hVRgxpUE4Z4z5w3u</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/57549cc7-4932-49af-b364-1a41af374a9b.jpg</video:thumbnail_loc><video:title>pythonect</video:title><video:description>הרצאה על pythonect בכנס אוגוסט פינגווין 2012</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/6c90181a-c525-46f9-bb48-576cf56ff918</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/55ZCeSy3PL5mST1rTHJKkr</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/245f9708-8cb8-4c70-8f7d-11505620592e.jpg</video:thumbnail_loc><video:title>הרצאה מאוגוסט פינגווין 2012- וורדפרס, ג'ומלה, דרופל וכל מה שביניהם</video:title><video:description>הרצאה מאוגוסט פינגווין 2012- וורדפרס, ג'ומלה, דרופל וכל מה שביניהם</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/21170ad2-6521-4085-a2da-0106339f5db3</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/6bJoRH69163DbqkogLpQQy</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/99823610-8a21-492f-8d24-e6f6f43bf18b.jpg</video:thumbnail_loc><video:title>Lingnu, ניתוח שלאחר המוות. סקירה של חברת לינגנו, והסיבות שהביאו לסגירתה</video:title><video:description>Lingnu, ניתוח שלאחר המוות. סקירה של חברת לינגנו, והסיבות שהביאו לסגירתה</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/29fd41dd-623b-4346-85d0-35e059367f78</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/2kQZruDZxVmph37EK8A6WS</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/e477ec3f-69f1-4557-a067-1f8f20e7446b.jpg</video:thumbnail_loc><video:title>למה עברתי לScala? (כדי לכתוב פחות ולעשות יותר) -- שפה סטטית שמרגישה דינאמית</video:title><video:description>למה עברתי לScala? (כדי לכתוב פחות ולעשות יותר) -- שפה סטטית שמרגישה דינאמית</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/0ade762f-372c-4035-871d-08234df51f42</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/8WoBrZHLPgnsdSca99fYGN</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/08e20cd4-ed2d-4990-a98b-a41402e0d12e.jpg</video:thumbnail_loc><video:title>התנועה לזכויות דיגיטליות</video:title><video:description>התנועה לזכויות דיגיטליות</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/4048119e-fa7b-4fae-b1b3-e27d95db428e</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/mZ1M2wk3by96dG5K9Uswvb</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/a5c9a0fc-1dd2-4ce8-8e04-0de3882789d7.jpg</video:thumbnail_loc><video:title>גם רוביסטים יכולים, שימוש ב QtRuby לפיתוח יישומים גרפיים ב Qt</video:title><video:description>גם רוביסטים יכולים, שימוש ב QtRuby לפיתוח יישומים גרפיים ב Qt</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/a9eca581-ba88-493c-b104-6e41d9bf77e4</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/j9tHp1rMHk4eq7XkL2Lz9t</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/8826bd9b-9c6d-420d-975e-c47961ad82e2.jpg</video:thumbnail_loc><video:title>כתיבת יישומי ווב מודרניים באמצעות פרל</video:title><video:description>כתיבת יישומי ווב מודרניים באמצעות פרל</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/92f38675-e4a2-4510-9fb6-b8a82f9ea13f</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/a2JMEEdBSvKhNVGEXvEzqc</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/77b5dda9-4dfb-4dd8-a894-637a785ef3a6.jpg</video:thumbnail_loc><video:title>אוגוסט פינגויין 2015: Introduction to Enlightenment</video:title><video:description>הרצאתו של דניאל זאוי</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/49205c40-2414-4aac-adb8-3fe5219753bf</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/7YfdnfgHU4ZV7rjTTbDZKW</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/8ba3441c-a34c-4763-a481-11e2ceab6f86.jpg</video:thumbnail_loc><video:title>אוגוסט פינגויין 2015: Storage File Systems</video:title><video:description>מרצה: חץ בן חמו, פרילנסר שמספק שירותי תשתיות לינוקס ו- Software Defined Storage.

קישור למצגת:
https://docs.google.com/presentation/d/1HScsMC7AmuYAysGhChkheQWxw27UwgpvrYj68ZooOeI/edit#slide=id.gc56128995_1_42

0:42 מבוא
1:38 Ext4 vs XFS
3:42 BTRFS
5:52 ZFS
16:21 Ceph
19:10 Scale Up vs Scale Out - איזו מערכת קבצים לבחור?</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/38713e06-459e-47b9-8a81-80e644560d00</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/5CvdDpRx1iw8UWfZYq8FkT</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/1746ecff-ae4b-4c01-bb92-4e16c7298d68.jpg</video:thumbnail_loc><video:title>אוגוסט פינגויין 2015: Introduction to oVirt</video:title><video:description>הרצאתו של אלון מוריייניק מחברת Red Hat

oVirt - כלי גרפי לניהול מכונות וירטואליות מבוססות KVM
https://www.ovirt.org/

0:22 למה אנחנו מדברים על וירטואליזציה כשהנושאים החמים היום הם ענן ומכולות?
3:02 מה זה oVirt?
5:52 מגבלות 
9:02 מצב התמיכה והקהילה
14:20 התקנה
15:23 סקריפטים
16:25 oVirt Node
17:31 צילומי מסך
17:46 ניהול משתמשים
18:53 מידע למתנדבים</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/257d562b-9ea0-4441-940d-edb12ccae1d5</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/7NgKMsM6yDM4n2KnwQsHrS</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/908d7be3-3755-4425-976c-b082ddffa57d.jpg</video:thumbnail_loc><video:title>אוגוסט פינגויין 2015: Next generation shells</video:title><video:description>אוגוסט פינגויין 2015: Next generation shells</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/370cc132-940e-407d-ad06-8d452228b230</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/1CmyJyq2dxDpUPruvrrqHY</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/c9f055ab-5861-48b9-9780-402dd90ffff8.jpg</video:thumbnail_loc><video:title>אוגוסט פינגויין 2015: העתיד של מערכות הפעלה</video:title><video:description>מרצה: אבישי איש שלום. CTO ב- Fewbytes

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

0:30 מבוא
2:51 קצת היסטוריה
4:20 הדגמות (CentOS 6/7)
11:47 הנחות עדכניות
15:25 בעייה: אין הרשאות ברמת ה- process
19:10 Qubes - מאפשרת מתן הרשאות ברמת ה- process 
20:22 בעייה: ניהול חבילות
23:42 Omnibus - חבילה שכוללת את כל מה שצריך
25:25 בעייה: ניהול הגדרות
27:01 NixOS - כוללת ממשק מובנה לניהול הגדרות
27:37 בעייה: אוטומציה
30:13 OpenLMI - API לניהול המערכת
מערכות הפעלה מאוד מינימליות:
30:35 JeOS
31:03 סקירה קצרה של Erlang on Xen, OSv, CoreOS ו- RanchOS
31:37 Appliances
32:06 מחשוב מבוזר (Distributed Computing) ו- Grid
33:51 מערכות לניהול מחשוב מבוזר
34:34 סיכום</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/051372ef-7a0f-4327-a8ef-2d732c100cfa</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/ks7wvGEkV3uCas7DRuGR1X</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/8faecb58-988d-4a25-b4c5-eb9c9477827d.jpg</video:thumbnail_loc><video:title>אוגוסט פינגווין 2015: playing with the kernel to achieve low latency</video:title><video:description>מרצה: מתניה מוזס, עובד בחברה שמספקת שירותים לגופים פיננסיים (בנקים, חברות אשראי וכו').

בחברות האלו יש חשיבות לביצוע פעולות בזמן אמת.

השגת שיהוי (Latency) נמוכה בליבה
Latency: הזמן שלוקח לפעולה מסויימת להתבצע
בהרצאה הזו, Latency טוב יהיה נמוך מ- 20 מיקרו שניות (1 מיקרו שנייה = 1 שנייה חלקי מיליון)

ליבה:
7:20 רשת
19:34 מעבד: מה זה Context Switch
21:47 מה אפשר לעשות כדי לייעל את ה- Context Switch
29:10 צריכת חשמל

חומרה:
15:48 זיכרון (RAM)
16:20 כונן קשיח
17:10 NUMA
31:02 ביטול של פסיקות (Interrupts) לא דרושים
33:14 מספר מעבדים פעילים ומהירות שעון</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/9d82fe90-9475-43d5-b371-9ccc902965fb</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/8HpZA3jFTKGnghQw1NsNPg</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/4431e739-9b01-4245-8dc4-8961f5b0c48f.jpg</video:thumbnail_loc><video:title>אוגוסט פינגויין 2015: Appium – אוטומציה לאפליקציות Web ו־Mobile</video:title><video:description>הרצאתו של דניאל פוטרמן</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/3e784056-e79c-4ae7-a9f9-91a7ffc0959d</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/irrQuydkRwHEec3LWR4nfL</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/fcc46bda-bcbb-4bb6-a108-0b1eb52bfdd6.jpg</video:thumbnail_loc><video:title>אוגוסט פינגווין 2015 - מבוא ל־Pandas: ניתוח נתונים בפייתון</video:title><video:description>הרצאתו של דב גרובגלד
צולם ע״י מדיהלה - http://www.youtube.com/channel/UCV59TE_p4a1dKwpyzsWw45A
נערך ע״י Rabin Yasharzadehe</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/8d38df9e-c86f-4673-8349-5e411f9f7a94</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/3tSPhsqXp2B1gukQ7XXVnj</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/6a8a570a-ee93-4ac1-b399-345f4c671ae2.jpg</video:thumbnail_loc><video:title>Keynote: People Over Code - Community Lessons by Jan Wildeboer</video:title><video:description>With Open Source fast becoming the default method for software development in the open but also in companies, one serious question raises its ugly head. How do you build, nurture and foster a productive and welcoming community of contributors, users and developers? Based on the work of Pieter Hintjens, this presentation will introduce you to the results of 30 years of experience in building distributed, diverse communities using Open Source methods.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/1416acd4-269c-4582-bf56-6ad8d9e82990</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/6V7wdVSdAEdnY9TiGvCcSc</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/5c23212c-f566-4f80-9a0a-181864168287.jpg</video:thumbnail_loc><video:title>From postfix to GMail: Open Source in the SaaS era By Avishai Ish-Shalom</video:title><video:description>In recent years, the "software as a service" model has been picking up speed. Many users and organizations are moving to this model and giving up on owning and maintaining their own servers and software in favor of using a service provided by a third party.

This trend poses new challenges to the open source movement - while most software as a service providers use and contribute to open source, a large part of the software which is the base for their services is proprietary, or the service can not be run using open source. Additionally, open source software products are sometimes released when a significant portion of their functionality is based on a complementary proprietary service - for example, Android.

This situation challenges the open source software movement and raises questions about the definition of open source.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/2fe821c2-4e7d-418e-bbec-24ef9950f31b</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/b5ceWkBRNNHK8uGiteXPZE</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/1ebcd69d-66a7-436a-8936-6524fcac8ecf.jpg</video:thumbnail_loc><video:title>From bare-metal data-center to cloud infrastructure using open-source projects By Yaniv Bronheim</video:title><video:description>In this talk I'll present open source projects that provide different aspects of cloud infrastructure management flows.

We'll discuss the challenges, the existing solutions and compare the alternatives in the open-source world to understand them from the installation and operation aspects.

The goal of the session is to show and provide examples for open source projects in the cloud management world. We'll discuss Red Hat's contribution to those project, the usages, architectures and some more.

The audience will understand the needs and challenges in the world of cloud infrastructures, and should feel comfortable to try and contribute to the projects after the session.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/519149eb-dcb0-4c05-848c-081a31ec1b34</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/c8hGGsjr8FLZ89D7iR9C1k</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/9c24d5bd-2463-49d6-85dc-0dd670c56119.jpg</video:thumbnail_loc><video:title>TRex- fast open source traffic generation tool by Ido Barnea</video:title><video:description>TRex is an open source project of Traffic Generation that is based on dpdk technology.

The project started as an initiative of engineers at Cisco Israel and is now being developed by engineers from several companies.

The aim of the project is to provide a cheap (the system can run on a home computer) and high quality alternative to commercial traffic generation tools that can be found in the labs of every company developing communication gear.

In the lecture I will introduce the project and the path taken to convince a company such as Cisco to open the project's source code and to continue development in an open-source model.

About Ido Barnea

Ido is an engineer working at Cisco. He is part of the TRex project development team.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/5a190640-cd4a-4e24-a084-2c9f9977b613</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/qdumx7yg2gK41aZpKGgR6g</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/e024ffd6-c989-46fe-9387-e6cdba09689d.jpg</video:thumbnail_loc><video:title>Google vs. Oracle: progress of the lawsuit and it's effects on open source By Eli Greenbaum</video:title><video:description>In 2010 Oracle sued Google, claiming that the Android OS infringes on patents and copyrights held by Oracle. As of today, this lawsuit has received two verdicts, several significant judicial decisions, and an appeal to the US supreme court has been filed.

This case raises important questions regarding defending copyrights on software in general and the validity of open source licenses in particular. In this lecture we will give an overview of the technological and legal background of the case, and its influence on open source.

About Eli Greenbaum

Eli is a partner in the Igal Arnon law firm. He has a masters degree in practical physics from Columbia University and studied law at Yale. He has vast experience in the legal issues of open source and has authored several important articles on the subject.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/c419ba16-215d-4b4f-844c-52ffe02f3d0d</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/acbKU7DXqZQQtRbAGr4uys</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/a3d762a9-eb31-41bc-96a0-a06895a1bb83.jpg</video:thumbnail_loc><video:title>The Free Three: Data, Software and Knowledge by Yehuda Deutsch</video:title><video:description>The Public Knowledge Workshop works to increase government transparency and civilian involvement. On the way to the goal we don't compromise on the means, free software is the weapon of the electric knight.

The lecture will provide an overview of the development tools and infrastructure that is being used by the workshop - those that are aimed for a sprint, a jog, and how we plan and continue for the long range with various tools.

I have a data source - but it is in a format that is not machine-readable, how do I convert it?
I have data in an open format - where do I save it?
I have a database - how do I give others access to it?
I have a data interface - how do I display it?
About Yehuda Deutsch

Yehuda Deutsch deals day-to-day with server side development and implementing development procedures. In the Public Knowledge Workshop he manages the infrastructure and makes sure that developers can focus on developing and advancing the projects. In the Hamakor NGO he is in charge of systems written in a rare language called PHP. In his spare time he opens pull requests on github.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/4a720efe-448f-411f-afd8-4473135729d2</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/5rFgWaoh4ZzNFF9EBm1iCw</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/f7e678f1-d896-4115-a438-bf1a4e730861.jpg</video:thumbnail_loc><video:title>GNU's textutils as a power tool for big data analysis by Boaz Menuhin</video:title><video:description>The GNU textutils package was developed in the 80's but the ideas it implemented are rooted deep in the 70's as well as BSD and UNIX. Today, 30 years later, textutils is still relevant and is used as a significant tool in the toolbox of Big Data developers and analysts. The integration with cloud computing makes textutils a package that can provide, in some cases, better solutions than modern Big Data tools.

The lecture will show principles of using command-line tools, such as textutils, for Big Data tasks.

About Boaz Menuhin

Former military intelligence, Ben Gurion University computer science graduate. One of the first employees at Crosswise (sold to Oracle). Today deals with Big Data and cloud computing services.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/23fa5a50-e458-406b-b2b6-30f50209f04a</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/2LASvEcskxFXFxcswJnfQi</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/8be2f5e3-8eea-412f-9820-4e697138f65f.jpg</video:thumbnail_loc><video:title>Open source and the MEAN stack. The rise of JavaScript frameworks By Liran Tal</video:title><video:description>We will cover basics of open source software, such as origins, why to contribute to open source and how you can make a difference and impact the world with open source.

We will cover the basic of the JavaScript MEAN stack, and some of the inherent problems with the blowing ecosystem.

How we (HPE Live Network team) adopted and made use of the MEAN stack to run software.

About Liran Tal
Liran is a top contributor to the open source MEAN.io, and MEAN.JS full stack JavaScript frameworks, and nowadays leads the MEAN.JS project as part of the core team.

At Hewlett Packard Enterprise, Liran is leading the R&amp;D engineering team for HPE Live Network – HPE Software’s enterprise content marketplace, and collaboration platform, which employs a micro-services architecture based on Java, JavaScript, and the MEAN stack at-large. He loves mentoring and empowering team members, drive for better code methodology, and engage and promote open source projects.

Being an avid supporter and contributor to the open source software movement, in 2007 Liran has redefined network RADIUS management by founding, and developing daloRADIUS - a world-recognized and industry-leading open source web application.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/0e535abf-a38f-40f7-98ab-5c60c4aa6491</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/fv5wYM3DU8CT7A86xy5H17</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/06cd656b-c501-4e95-8ea3-7f49e6c7ee82.jpg</video:thumbnail_loc><video:title>Hello, World! I am an app inside a container by Ala Hino</video:title><video:description>The goal of this session is to show use cases the docker way vs. the traditional way:

*Docker fundamentals:
  - Images
  - Containers
  - Registries
* Docker vs. VM
* Use cases:
  - App development and test
  - Continous integration
  - Application deployment
* Demo (if time allows)
* Q&amp;A

About Ala Hino
Ala is in the software engineering area with more than 15 years of experience. Currently, He is a Senior Software Engineer at Red Hat, working on RHV storage. Prior to Red Hat and for more than 8 years, he was a Technical Leader at Cisco where he worked on the ISE product.

His motto is: "I don't divide the world into the weak and the strong, or the successes and the failures ... I divide the world into the learners and non-learners." - Benjamin Barber</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/756f4e08-af52-4e99-8de6-79da2055468a</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/o6bcqAfxKVC2J3Jz6LXC6G</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/c04c1a72-0fef-4914-b249-c14aa0f43ef2.jpg</video:thumbnail_loc><video:title>Offensive cyber automation by Lior Barash</video:title><video:description>We'll be talking about FOSS tools and techniques of automating offensive cyber activity for the grater good.

This is a high level tough technical talk that examines practical ways and tools that allow us to take advantage of the of the 'best defense is offense' paradigm.

Also at the end of the talk we'll spare a few minutes to consider what is required in order to move on from automation to intelligent action and how might you go about doing that.

About Lior Barash
Lior has been creating and delivering services and open source based solutions for Data networking and Cyber Security systems architecture from design to deployment for the better part of the last 15 years, he has been involved in various roles and projects practicing large scale networking and security solutions, consultant services, security assessments from the physical to the logical layers, threat modelling, computer crime investigations etc. Through the past eleven years he has been writing an lecturing about information security systems for all the major schools in Israel including academic institutes.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/b2e20db0-643b-44d2-802a-bf15d157c512</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/hddq1P4EYDuPFc1UdyW7pk</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/82b38f79-a1f0-414e-8b47-47f1b08fe276.jpg</video:thumbnail_loc><video:title>Open vSwitch introduction by Edward Haas</video:title><video:description>A pragmatic introduction to Open vSwitch (OVS), the most popular production quality, multilayer virtual switch.

Licensed under the open source Apache 2.0 license.

The talk includes a brief history and introduction, followed by creating an OVS based network on the fly.

Audience will learn what is Open vSwitch, how to create networks with it and what solutions use it today.

About Edward Haas
Edward Haas is a software engineer at Red Hat. He has been dealing with the communications field for about 20 years. In recent years he has been working on speeding up data transfer using software. Today he is part of the virtualization group at Red Hat and specializes in the subject of networking.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/8346cb52-0577-4021-83d0-cc66a1085011</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/x2PFZBaRpMQA4doHETctty</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/4f92ade7-2aea-4ba6-95e9-a7d13d5dc226.jpg</video:thumbnail_loc><video:title>How to build a Raspberry Pi OS that accepts code contributions by Guy Sheffer</video:title><video:description>This talk will go over two projects I developed: OctoPi and FullPageOS.

I will show how they are built, how the way they are built allowed me to get code contributions and let the project grow, and what was the "trick" used in the scripts that allowed the system to be built on non-ARM based computers.

We will see how a variant can be built and explain how they can be used as a template for a new independent system.

About Guy Sheffer

Guy is a developer in the free software community for over a decade. He is a maker and has a passion to create open source projects for fun. In the last two years guy founded the ShapeDo company that tracks changes (diffs) in building plans. He is willing to 3D print things as a function of how cool they are.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/fb4c6e94-648d-429d-b827-d476f38291f2</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/nsRQFouVAoQAB8AY9ox6XK</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/c5e438d7-e4a9-45b2-a4ad-2d38626952ac.jpg</video:thumbnail_loc><video:title>Opening Notes by Hamakor board representative</video:title><video:description>Opening Notes by Hamakor board representative</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/adcff6e5-500f-41cc-b6ed-6b874c5e658d</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/v5c5MBnwWWbkGWgmBb9yGa</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/c3e706fb-96d5-4176-80a0-776d2661bbe3.jpg</video:thumbnail_loc><video:title>End Notes by the Conference organizers representative</video:title><video:description>End Notes by the Conference organizers representative</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/eb6ed379-2ab1-4b01-98ac-2a9c0b4572d9</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/kckxuSabyHB1BwEDFGrdxp</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/323f640f-aa7d-4f5c-9fdc-9435f04331d9.jpg</video:thumbnail_loc><video:title>Opening Notes by Hamakor board</video:title><video:description>Opening Notes by Hamakor board</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/9b72dc1f-28bf-4ba8-8885-a7505e5eb2d5</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/oCsteECscYWUrcgJAZW3iX</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/4536b923-5c38-4184-aed7-613d5a22d6c3.jpg</video:thumbnail_loc><video:title>OpenStack as an NFV platform</video:title><video:description>OpenStack as an NFV platform</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/b7402381-b348-497e-9acb-97a5663b4399</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/4KjRuENvniE44hMV39jKY6</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/4845b7d4-5f69-49e1-908f-f25e4f494806.jpg</video:thumbnail_loc><video:title>Android Security</video:title><video:description>Android Security</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/1e580452-397a-4d16-a795-1dfb33125a11</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/kZFK64HviT3sVizmyuX5b5</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/8b809ccc-4c97-4673-8f54-1bf40d60dbbe.jpg</video:thumbnail_loc><video:title>רשת אורט וקוד פתוח</video:title><video:description>רשת אורט וקוד פתוח</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/a1eb8598-2379-424a-aee1-1a00d81209b0</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/7zdFTbNzMaPVZ2jNPWgzJo</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/76074bcd-2370-4b58-aa01-cc5d719294fa.jpg</video:thumbnail_loc><video:title>Introduction to Enlightenment</video:title><video:description>Introduction to Enlightenment</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/353a3205-b441-4e45-9d24-c7e25181a0d6</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/11Li6tsaKHmExKz2xAiPcx</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/628b0e3c-1820-4157-bf69-afb60b21582b.jpg</video:thumbnail_loc><video:title>Datable SQL by Eli Marmor</video:title><video:description>Over decades, almost no changes were made to the definition of relational databases. Recently, they are challenged by NoSQL databases that were developed to solve very specific problems.

However, it turns out that adding a tiny layer over relational databases, without breaking any backwards compatibility, triples their abilities and enables a new generation of applications.

This layer is being developed in Israel as an open source project (over PostgreSQL in the first stage). Amongst the abilities added thanks to this layer:

* Temporality that makes the tabular databases "cubic", three-dimensional, with the time dimension adding abilities that one could only dream about before.
* Making "Schema" unnecessary, so that any beginner SQL user could perform actions that only a DBA could perform in the past.
* The code implementing the program can become part of the data.
* Natural support for modern data types (such as tagging).

The lecture will include mostly a live demonstration (that's what we all like, no?)</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/001b4c2f-5a6d-446d-8133-583b5a5e9d21</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/enPEcV7TKhziqGPznAuzKE</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/d89f1fd8-a606-4506-ae83-66c4e484f78e.jpg</video:thumbnail_loc><video:title>Isreal Hiking and Biking Maps</video:title><video:description>הראל מזור מציג את פרוייקט המפות השבילים ושבילי האופניים החופשי של ישראל
מבוססת על פלטפורמת המפות הפתוחה open street maps.
הראל סיפר על הבחירה בקוד פתוח, תהליך יצירת הפרויקט ואיך בונים את הקהילה סביבו. לפרטים נוספים על הפרוייקט 
https://israelhiking.osm.org.il
לפרטים על מפגשים נוספים 
https://www.meetup.com/Open-Source-and-Free-Software-in-Israel</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/6c52cadf-b9a9-4c0e-b82b-65afc507f9e8</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/jyGHbjGFz9pU4ckWAs8RwC</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/d2900836-c16b-4d47-ab73-8b9220656c46.jpg</video:thumbnail_loc><video:title>פָּיינפון – טלפון לינוקס / צפריר כהן</video:title><video:description>פיינפון הוא טלפון שמריץ מערכת לינוקס דומה מאוד למערכת שולחנית. נדגים את השימוש בטלפון עם ההפצות וסביבות העבודה האפשריות שלו.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/9655628a-964d-4477-a294-55a78ef2eecc</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/1p1GvZdB2diL8L3WXhfMpo</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/b9cad043-f38f-463a-9856-14241945c151.jpg</video:thumbnail_loc><video:title>⁧ברוכים הבאים ל-Fediverse / גיא שפר⁩</video:title><video:description>⁧הפדיוורס (Fediverse) היא רשת חברתית קוד פתוח מושתת על סטנדרט של W3C. היא תופסת תאוצה וגדלה במליוני משתמשים בחצי שנה האחרונה. באו לשמוע איך לקחת חלק וקצת איך היא עובדת מבפנים טכנית וחברתית.⁩</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/03368987-26f9-48ca-b003-b68def9fb9b0</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/f7g2RjyixpCTHr64wGntAx</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/b5f05ba8-f94a-44eb-8bdd-944c08cd4909.jpg</video:thumbnail_loc><video:title>מה למדתי משנה של ראיונות עם אנשי קוד פתוח / דימה ברוסילובסקי</video:title><video:description>במהלך קצת יותר משנה, זכיתי להוביל פודקאסט בנושא קוד פתוח, שבמקרה נושא שם זהה. דיברנו עם קשת רחבה של אנשים, המגיעים משלל מקצועות וכולם עוסקים בצורה כזו או אחרת בקידום קוד פתוח.

בהרצאה הזו, נדבר על הקשיים שיכולים להופיע בכניסה לתחום עבור מתכנתים חדשים, על האתגרים שעומדים בפני חברות ואנשים פרטיים שמעוניינים להקים פרויקט קוד פתוח, איפה זה פוגש את הטכנולוגיה עצמה ולמה זה אמור בכלל לעניין אותנו</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/723faae7-c2ed-4a26-8cab-07e70e94a967</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/wds3VyunHrVRbBDwNpqFrk</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/c518fe6a-be40-41a8-98e9-2f5d8b9f6347.jpg</video:thumbnail_loc><video:title>Open Source, Sustainability, and CC0 / Jacob Barhak</video:title><video:description>The presenter will discuss encountered issues and limitations with current open source practices that impact on sustainability.

Those issues include: over interpretation, abandoned code, and potential conflict with external restrictions such as patents and government restrictions.

Relation to government funding policies will be discussed. A possible solution to improve incentives and sustainability will be presented while comparing GPL and CC0.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/f4af23a0-c299-4983-835e-ebf4329aac29</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/jki2Q1gGGpm3r8FPBfY4ih</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/3acc1403-e303-4bf2-8e51-34ee638dfda6.jpg</video:thumbnail_loc><video:title>Open Source - Open Choice: A DevOps Guide for OSS Adoption / הילה פיש</video:title><video:description>Choosing the right open-source project to use can be quite challenging - not knowing if it’s going to be the right fit, how it will behave, and if you end up wasting time trying to make it all work. We’ve all been there.

But what if I told you there’s a practical way to have a clear understanding of how to incorporate an OSS project in your environment?

In this talk, I’m going to speak about the DevOps perspective on open-source and the challenges Infra-focused engineers have with choosing the right project for their environment.

As a DevOps Engineer, I’ve seen a lot of things, stumbled upon a lot of non-based decisions, and so will present practical advice on how to choose an OSS project for your dev/prod environment and will talk about the business mindset you should have to evaluate the key indicators based on your needs and specific pain points.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/94761fa1-156d-4829-99e5-b0af212f5816</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/qiufA3g7bpaq85Cm2R7BQA</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/29fecaec-3478-45b0-be8f-6e53f7c41351.jpg</video:thumbnail_loc><video:title>הסכתים לחופש נולדו / עמית אהרונוביץ</video:title><video:description>הסכתים לחופש נולדו / עמית אהרונוביץ</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/c4cc61ed-be79-4d81-83c6-059a89c8528e</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/5ZPvGpDs8AuNpmXGZYrr6z</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/2d1f3fe9-4ab4-469d-a650-bf2b2e94737a.jpg</video:thumbnail_loc><video:title>יוניקוד שבור, בואו נתקן אותו! / שי ברגר</video:title><video:description>יוניקוד שבור, בואו נתקן אותו! / שי ברגר</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/28773ad7-4a3f-4558-af66-36cb7840014f</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/t8sNzRGXXWAdPKnzS8v31i</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/5464f2ca-773c-4d30-a3cf-7f7d86cba6cd.jpg</video:thumbnail_loc><video:title>⁧תמיכה בעברית ב-Gnome / יוסף אור בוצ'קו⁩</video:title><video:description>⁧תמיכה בעברית ב-Gnome / יוסף אור בוצ'קו⁩</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/dbb177df-2839-4f4c-8e6c-460030708151</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/589urEguXzUohn32Yg9U5e</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/8f5d7086-3fd5-4277-98f6-9b80546070db.jpg</video:thumbnail_loc><video:title>קיבוץ פתוח? / ירון שהרבני</video:title><video:description>קיבוץ פתוח? / ירון שהרבני</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/2163fe50-8aba-4782-85a7-e5e5baadd4b5</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/3vZ4vy6yEf8iP8RaRxJv86</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/fed8c5e7-c038-4fbb-a71c-db4fecd6efa0.jpg</video:thumbnail_loc><video:title>⁧הייתם סומכים על קוד בן 30 שנה, או למה אתם עוד משתמשים ב-GPLv2? / יהונתן קלינגר⁩</video:title><video:description>⁧רשיון ה-GPLv2 הוא אחד הרשיונות הפופולריים לתוכנה חופשית. הוא כתוב בצורה רעועה, על ידי אנשים שאינם משפטנים, ועם פרצות ותקלות ידועות. מזה שלושים שנה מתכנתים בוחרים להשתמש בו במקום בגרסאות טובות יותר. רשיון ה-GPLv3 שבא לתקנו גם הוא כבר בן כ-15 שנים, וגם אותו אולי כדאי לזנוח.⁩

בהרצאה הקצרה נבדוק מה הבעיות בGPLv2 ו3, ומדוע לא בוצעו בהם התיקונים. נראה איך בעיות אלו נוצלו לרעה על ידי אחרים, ומדוע אם אנו רוצים יותר תוכנה חופשית חייבים להפטר מ-GPL.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/146202ed-9e66-41d8-8fc9-b9d503bca58f</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/m9MTR5sUAYerckQXCvC3uS</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/066ec969-9d17-47e4-aa78-6ca9764d9d26.jpg</video:thumbnail_loc><video:title>איך ללמוד לתכנת חומרה ולספק את יצר הנוסטלגיה / שחר שמש</video:title><video:description>מחשבי שנות השמונים פופולרים שוב! ואני נתקפתי געגועים למשחק ששיחקתי לפני 40 שנה במקביל לזה שהחלטתי ללמוד איך מתכנתים חומרה.

⁧התוצאה היא פרוייקט שמנסה לבנות, פחות או יותר מאפס, מחשב חדש לגמרי תואם ל–Apple II, טוען לכתר „המחשב האישי הראשון”.⁩</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/a33101a8-adeb-4c11-9406-207c1936a082</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/fdd6BisyMn6YiYe9S8TDAU</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/f66c861a-4267-4628-901a-2bb6d135f913.jpg</video:thumbnail_loc><video:title>Ceph: The Open Source Software Defined Storage Platform / Orit Wasserman</video:title><video:description>Ceph is a mature open-source software-defined storage that provides object, block and filesystem in a single cluster. It is designed for reliability, performance, and scaling from terabytes to exabytes with no single point of failure.

This talk will describe in high level the unique Ceph architecture that allows it to scale and resilience.

In the second part I will present the Ceph foundation and how we successfully collaborate between the Ceph open source community and industry members.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/73145243-1be2-4768-abbb-6cbb18e93d44</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/wo8pUCeY4XJ3x141UPwt4o</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/4111601d-76c1-4f73-adfb-06a5f447d49b.jpg</video:thumbnail_loc><video:title>תכסיסי בדיקות שיכולים להקים או להפיל את הפרויקט שלכם / אאור שרף</video:title><video:description>אין משהו שרובנו שונאים יותר מלכתוב טסטים. אין משהו שעושה פרויקט יותר קל מאשר קיומם של טסטים טובים. לפעמים, אפשר לדפוק את המערכת ולקבל המון טסטים טובים כמעט בחינם.

אספר על כמה פרויקטים בקריירה שלי שהצליחו בגלל תכסיס בדיקות, ואפרוט את התכסיסים הנפוצים ביותר. רובם מתבססים על כלי קוד פתוח שצריכים להיות מוכרים יותר ממה שהם. כמו גיט.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/f6091735-f8e2-4dcd-9216-9eb277cdcc30</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/4pznUVR7wmt7eyAcTZrj42</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/f4c3cd35-4c72-4c13-a917-60ca398c2f94.jpg</video:thumbnail_loc><video:title>מצב התמיכה של ליבראופיס בשפות הנכתבות מימין-לשמאל / אייל רוזנברג</video:title><video:description>ליברה־אופיס הינה חבילת יישומים משרדיים, ואחד ממיזמי התוכנה החופשית הנפוצים והחיוניים ביותר למשתמשי־קצה במחשבים. זהו גם אחד ממיזמי התוכנה הגדולים, הותיקים והמורכבים ביותר. ליברה־אופיס תומך גם בעבודה בשפות הנכתבות מימין־לשמאל (RTL); תמיכה זו אינה מושלמת, אך נמצאת בתהליך של שיפור לאורך השנים. בהרצאה זו נציג בחטף את עולם השפות מימין־לשמאל (לא רק ערבית ועברית!); נסקור מספר שיפורים משמעותיים בתמיכה בהן בליברה־אופיס בשנים האחרונות; נביא דוגמאות לליקויים וחסרים מסוגים שונים המתגלעים עדיין ביישומי ליברה־אופיס; ונעמוד על אתגרי תכן יסודיים העומדים בדרך לתמיכה ""שלמה".</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/1b9617ad-8a2b-4922-8376-44eaf8503e4f</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/hLHfGixxn32N3VzK5ppeWx</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/de1f1038-845d-4231-98d6-f4c132c5b43d.jpg</video:thumbnail_loc><video:title>Meet Lago isolated testing environment - Gal Ben Haim &amp; Nadav Goldin - Pycon Israel 2017</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/87d05e23-4c97-4036-94c0-6246f10f63f7</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/izG64aBbYfQcTgvFgykCKb</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/a1305920-8572-4c93-ad29-b466a32ea2ed.jpg</video:thumbnail_loc><video:title>Matti Picus - CFFI, Ctypes, Cython The Good, The Bad and The Ugly - Pycon Israel 2017</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/8e5f9b30-bdeb-4327-a020-11654fe98770</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/b8gtdpMfiwExL3TSy1gk5z</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/1fe3dbd9-71fc-411a-b4c8-135d7f39ac82.jpg</video:thumbnail_loc><video:title>Dynamic Neural Networks with DyNet - Yoav Goldberg - Pycon Israel 2017</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/51ff2050-6998-4a3e-ac59-1d3774934d0d</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/jmRJesNvY93j8KLbB7ZaD8</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/d4b14d74-4278-4fb6-9391-1dc982db3abb.jpg</video:thumbnail_loc><video:title>Extend Docker using Python - Boaz Shuster - Pycon Israel 2017</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/94ae0470-0d99-4fed-a195-720efd7d5a55</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/6wdtmSJZ8mk89DhxSAmV9v</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/70b7b39e-73ee-470c-8b66-b0faf8c8ba39.jpg</video:thumbnail_loc><video:title>Structured Predictions an historical overview - Shai Harel - Pycon Israel 2017</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/2cb5b13f-4c02-40aa-bee2-489c6cfd6da1</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/8K3dqB9cQNxX6FNtuh56kt</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/b96334da-8992-4300-9deb-55e9073d395f.jpg</video:thumbnail_loc><video:title>Exploring and Analyzing Open Satellite Imagery data - Yaron Michl - Pycon Israel 2017</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/3eb25139-a6d1-448b-a8d8-3050188725fd</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/gWRncJ4dKJi55q2ESGvEmF</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/1c3552af-6490-4d85-8285-76ef3eba38ff.jpg</video:thumbnail_loc><video:title>Adding interactivity by extending Jupyter Notebook - Beni Cherniavsky-Paskin</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/8121aa84-75c4-418b-a38d-bcac65d4624f</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/ow3zaAfrdgF8obCrZVtZcm</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/2e5316f4-8b48-4b9f-adc5-a075ab7c1bd7.jpg</video:thumbnail_loc><video:title>Jenkins as a Python execution platform - Barak Korren - Pycon Israel 2017</video:title><video:description>The snake and the butler, Jenkins as a Python execution platform

This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/b65af2d4-b1a2-405d-bbef-a4be5a91d6fe</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/5b4Tuxq3m63uvWx3r8a4Si</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/75c5b1f5-a3bd-4d6e-8d09-1e0b35530065.jpg</video:thumbnail_loc><video:title>Bringing people together with Python and Open Source - Freddy Rolland &amp; Ori Rabin</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/21cc6366-3a33-4a73-8169-a282dc644049</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/povijBxCFJeXDok3XRomhd</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/5f514d9a-19c0-4d31-979e-b1d697adb495.jpg</video:thumbnail_loc><video:title>“bluegiraffeplaysball” or Make Passwords Great Again Using  zxcvbn - Alon Kiriati</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/bd669ba8-e68e-459a-af96-d24d952f5f5c</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/fvnpNCuvGrFLsPUoMqnyrC</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/6aefb4f5-a593-4a79-b871-2e6dcb134f14.jpg</video:thumbnail_loc><video:title>Handling geo located data in real time using Python - Jonathan Schemoul</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/7579b488-5b52-4c08-89a4-6daaad3eccb6</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/3bPxDHhTCDHjTTe4pe1uok</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/a3df3eb4-a8b9-4bce-b8ac-626bfcce0f1c.jpg</video:thumbnail_loc><video:title>Unit testing in the real world with mock - Chen Rotem Levy - Pycon Israel 2017</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/11b5041e-c4d7-4152-964b-dc5913420c6f</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/gPC2eueF7Z3HY4XYYqmdZW</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/08ac406f-69d0-44b9-a784-facca679378a.jpg</video:thumbnail_loc><video:title>Let me sleep on it improving concurrency in unexpected ways - Nir Soffer</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/801f3c68-ce69-45ed-89c0-d8964eade0f0</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/otpcZVYrrFMJ9FEaiogNrJ</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/22429ed3-d4ab-4d98-a0c5-9d8ba4e36ba8.jpg</video:thumbnail_loc><video:title>Low Level  Python a Deep dive into the python sources - Yam Peleg - Pycon Israel 2017</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/b5fc6f1e-3dab-4a50-8829-f329f189b7e4</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/3JBsJaCDZ8wMRHkfofPLHo</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/3e180d2e-97e3-4699-aeb5-561d66ac26b8.jpg</video:thumbnail_loc><video:title>Putting Things on the Internet - Yuval Adam - Pycon Israel 2017</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/16255e81-52f1-4ed7-ba5b-98ded3230188</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/5MZvf7Sf7osFkKEJcCjNt8</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/0d064342-b5c0-484b-a969-5998b1987e6c.jpg</video:thumbnail_loc><video:title>Hypothesis: Simpler Powerful Test Cases - Eli Gur - Pycon Israel 2017</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/26d07667-1573-4273-ad6f-ce34aee0f80d</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/4Cgr5UPZpDmNJo1mXaAyjX</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/2265c034-cef0-471c-ac27-1e4487f2db86.jpg</video:thumbnail_loc><video:title>A physicist's approach to Data Science - Elad Berkman - Pycon Israel 2017</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/1d5bb3ca-c059-43a0-bdd3-209c4dc95c0b</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/m8aZ77hWXpWA73o8MHia6Z</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/6d77ae0f-c596-4908-aaac-66521aaac21a.jpg</video:thumbnail_loc><video:title>Designing Pythonic APIs - Noam Elfanbaum - Pycon Israel 2017</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/a2f721ff-56ec-4adf-bbce-36f56bfe91b7</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/2cc6w1AecmgbREZ3vnG3BT</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/bfc000cf-1138-4772-850c-4ca25760c235.jpg</video:thumbnail_loc><video:title>5 Simple Steps to Create Meaningful Features from Clickstream Data - Shir Meir Lador</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/09a92862-0216-4519-9678-cecc0b552119</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/3k6oG6Wv22H4kCwq3inSoK</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/be43615c-5bca-49f4-8002-0aa3b6a68fb3.jpg</video:thumbnail_loc><video:title>Decorators for Data Science - Uri Goren - Pycon Israel 2017</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/12dcbb3d-f8e1-4dd0-9819-82b8adac8bc7</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/cLfPa3PLM21xWkY8atiDSh</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/df569ab3-29c2-4ad5-af67-0a452596cb13.jpg</video:thumbnail_loc><video:title>From plotting to chart porn - Creating slick charts with Matplotlib - Tamir Lousky - Pycon Israel</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/5f426147-7947-49ce-a242-b3eba7214450</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/eovx5fFGPoW2EfTPBQzdWq</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/44736c49-33ca-42be-af52-33c7212171e9.jpg</video:thumbnail_loc><video:title>The Fun  of Reinvention - David Beazley -  Pycon Israel 2017</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/6c6b5e19-1d75-4080-8412-eb1f19e4ec4c</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/uKFZdZ6UeiE8h9398hmFBS</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/20df8dbc-3c38-44d4-9686-48b4d5310f60.jpg</video:thumbnail_loc><video:title>Practical usage of asyncio - Sim Zacks - Pycon Israel 2017</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/e8d981d9-18d5-4533-8b1d-0d56ffdf271c</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/kijDeZL3nBuhPW36aQnrt6</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/0dcba1b6-03fb-4155-9362-a06b2f5ec47e.jpg</video:thumbnail_loc><video:title>Real Time Sensor Anomaly Detection with Sci Kit Learn and the Azure Stack - Ari Bornstein</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/9c48c468-fb29-4104-905a-3670148709cf</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/iSsXroSDpxRyKFqBkXXRSC</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/6d0e837d-dbba-44d1-8e01-e2489bfe84fc.jpg</video:thumbnail_loc><video:title>Apache beam and google cloud dataflow - Moshe Shamy - Pycon Israel 2017</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/90b72868-01fa-4369-9ac4-e940c69a6b04</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/htDrxeaLH4qVchsJufc5tV</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/4b3f3c83-b89b-441c-bccf-6483a82d48b6.jpg</video:thumbnail_loc><video:title>Time Series Analysis - When  Good Enough  is Good Enough - Boris Gorelik - Pycon Israel 2017</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/856e5faf-11f0-45a1-bf66-0204b5b4387b</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/cFtquohEYUpX3FYoHRw3Fx</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/868bd3f4-1be5-4a3d-bd2d-6a1524a418a1.jpg</video:thumbnail_loc><video:title>Gotchas of Pandas - Prabhant Singh - Pycon Israel 2017</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/5e976e8d-1177-466c-956c-bb04dfa4cf1d</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/sk2hohnu1xvPji7NHUcMWP</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/810f7c1a-a536-413a-9a96-7080ce249a0d.jpg</video:thumbnail_loc><video:title>PyTest - Gabor Szabo - Pycon Israel 2017</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/d53586f3-47f8-42ca-a9b9-905ca9ef10d7</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/aNEQHmwxGC3UrK2dz6eTAT</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/1d0453b4-1780-4770-81f4-98c3e1a7f6f3.jpg</video:thumbnail_loc><video:title>Lessons Learned Maintaining the oVirt Python SDK - Juan Hernández - Pycon Israel 2017</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/4f6665b4-8865-4b4b-a5b9-1ce0be0baf8b</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/oXaTBTpgegDoK9mpz2WA2n</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/231de6d6-bf20-439b-99ec-7146b33b5e32.jpg</video:thumbnail_loc><video:title>Programming 'brainfuck' and virtual machines - Aur Saraf - Pycon Israel 2017</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/b9dd0d83-5648-4a6f-bade-863b048591f7</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/df9T7zkDbEWwxAJyM6d2cL</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/2992174f-46ec-4a2f-9ca9-c0835cdba404.jpg</video:thumbnail_loc><video:title>Text Parsing  the Case for Monads - Yoav Luft - Pycon Israel 2017</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/63278ccb-14c9-4fa9-b155-9a2fd7ac891e</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/bG7T6bd2pH2ogaEF2G7mjW</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/e65acedd-1f95-4c9f-8eb4-5a8c416ffd3c.jpg</video:thumbnail_loc><video:title>CPython, Grumpy, PyPy - When, How, Why - Itay Weiss - Pycon Israel 2017</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/569560bc-5557-4dbd-bef5-171ffa3389ea</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/w1rg4GFm6aMjVBvdLCn7zV</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/2b4ec8d2-c759-4c1a-b452-89908c60dca8.jpg</video:thumbnail_loc><video:title>Unit tests and TDD does NOT have to be boring - Daniel (Yona) Simons - Pycon Israel 2017</video:title><video:description>This talk was presented on Pycon Israel 2017.

http://il.pycon.org/2017/
https://twitter.com/pyconil
https://www.facebook.com/pyconisrael/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/f301ba06-1dc2-48c8-916d-e3661a068a0f</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/umMVxtAgVoNwSPXqvDju9F</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/cd7f7465-0998-494c-ba9e-f1977195ea1e.jpg</video:thumbnail_loc><video:title>PyCon Israel 2017 event clip</video:title><video:description>PyCon Israel 2017 event clip</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/e5a70f1c-5897-46ef-8fed-ef7f87f861a7</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/2xvYw5ruSfpMih2cwysqYY</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/223c7358-602b-4311-bac7-4873815ae6fa.jpg</video:thumbnail_loc><video:title>Help your colleagues help themselves - a Sphinx tutorial - Dalya Gartzman - PyCon Israel 2018</video:title><video:description>Have you ever found yourself developing a tool only to find it already exists somewhere else in the code? Have you ever wondered what does AlexsCoolFunction do? Did you ever put a funny comment in your code and was upset that noone will read it? Then maybe it’s time to have a better documentation system! Join me for this tutorial, where we will sail through the onboarding stage of Sphinx - an automated documentation package, and learn how we can all collaborate better.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/0c7faafe-82dd-4c06-b551-d26ffa692058</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/mqJpnc2qy1J9ia7qE5XDWY</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/5fdb2669-e46e-43a9-ac88-6ec31034f677.jpg</video:thumbnail_loc><video:title>Closing session - PyCon Israel 2018</video:title><video:description>Closing session - PyCon Israel 2018</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/a56ac15f-9ac1-4bea-a0a7-b0a86684e340</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/miQcyxveDrE9b4GdsdJGQb</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/aea3d687-1884-40e2-a282-2c32069fc141.jpg</video:thumbnail_loc><video:title>Anomaly Detection using Neural Networks - Dean Langsam - PyCon Israel 2018</video:title><video:description>BlueVine is a leading provider of funding for small and medium sized businesses with a primary focus on speed, simplicity and transparency. Models that make decisions in real-time are a critical part of that effort and must be strictly monitored. Consequently, it is the responsibility of every data scientist at BlueVine to both develop and maintain a high level of performance for every model they own. Maintaining code is a hard task in itself and it is discussed a lot among software developers: code needs to run without errors, and more importantly - must run as expected. In data science, the notion of what’s expected becomes quite complex and sometimes not well-defined, due to the statistical nature of the problems. Without anomaly detection, it is possible for critical decisions to be made based on unexpected changes in the data or simply incorrect calculations. Therefore, it is critical to be able to detect such anomalies quickly while getting a concise message as to what is their nature. This quickly becomes a challenging task when keeping the human factor in mind - too many false positive may cause the user to become alert prone, thus rendering them useless, while a low detection rate may affect the integrity of our data. We leverage our historical data and some of the most advanced techniques in the field to classify anomalies against normal behaviour. We use Keras to train a neural network that predicts expected values in a time series using a series of previous timestamps. We also add auxiliary information for a rich multi-input prediction. If there were clear labels for anomalous data, a classifier could then be employed. This is not our case, and we need to find another strategy. We start with a trivial approach, comparing the difference between the prediction and the actual values. This method proved problematic as they would yield too many false positives and as robust thresholds would be hard to set manually for hundreds of time series. Therefore we ...</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/a4741f05-c471-47bf-ada0-88de66d6481a</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/dfANgcY2zuojG4m1wnkjMf</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/b888d199-d1e7-4708-8627-ceeeca4a5d32.jpg</video:thumbnail_loc><video:title>Model Calibration - is your model ready for the real world? - Inbar Naor - PyCon Israel 2018</video:title><video:description>Evaluating the performance of a machine learning model is important, but in many real world applications it is not enough. We often care about the confidence of the model in its predictions, its error distribution and how probability estimates are being made. Many classifiers have good overall results but bad probability estimates. For these cases, different calibration techniques have been developed over the years. Intuitively, a model is calibrated if among the samples that get 0.8 probability estimates, about 80% actually belong to the positive class. Even good data scientists sometimes forget about calibration and wrongly treat the model output as real probabilities, which could result in poor system performance or bad decision making. In this talk I will present different methods to calibrate a model such as platt scaling and isotonic regression, discuss how they behave with different classification methods and show how to test the calibration of your model. The lecture will be accompanied by code examples in python.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/63378580-db70-4615-bc0b-ac3fb935dfd0</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/cDWNkBoiSCZ2ibRoLa8iSW</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/ff379609-8178-4315-a56c-ed01ae566aff.jpg</video:thumbnail_loc><video:title>Pied PyPIer: Why packaging is important - Shay Palachy - PyCon Israel 2018</video:title><video:description>Pied PyPIer: Why packaging is important for both close and open data science projects

When working on data science projects we are often tempted to leave our code to rot in scattered notebooks or Python modules deep in the project’s repository.

However, even when you can’t release parts of your code as open source, breaking some important components into standalone Python packages can help with managing technical debt and code maintenance, facilitate in-house code reuse and repurposing, and make production-ising and deployment of code easier.

In this talk I'll try to demonstrate the ways treating your components and problem solutions as independent packages can benefit both your colleagues and (present and future) you, and review the tools Python provides for building and managing these packages, both in-company and openly.

I will also share from my experience in packaging some of my code, and discuss the extra benefits from open sourcing packages even when they are used mainly internally.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/5e60d0d7-c10a-44fb-9a60-5314fbacab16</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/7wK5tBGFBKD4K5b4zwwDX7</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/a006b292-595d-4b63-8646-9ab2ab8a326e.jpg</video:thumbnail_loc><video:title>Deep model serving - scale and ergonomics - Jenia Gorokhovsky  - PyCon Israel 2018</video:title><video:description>A serving system for Deep Learning models is a tricky design problem. It's a large scale production system, so we want it to scale well, adapt to changing traffic patterns, and have low latency. It’s also part of the Data Scientist’s core loop - so it should be very flexible, and running an experiment on live traffic should be easy. In this talk, I’ll discuss key design considerations for such a system covering both perspectives. I’ll also describe a system we built at Taboola for serving TensorFlow models. It serves billions of requests per day, spread over dozens of models, and still has pretty good ergonomics,</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/34e1b13b-5cd9-45ee-a899-8e6dc59296a0</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/mjDk1HHaq5JYwWtsCZJSZn</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/63beee96-061e-416e-8911-01b2f8d6e29c.jpg</video:thumbnail_loc><video:title>Data leakage: How to avoid one of the most deceptive mistakes - Noah Eyal Altman - PyCon Israel 2018</video:title><video:description>Data leakage: How to avoid one of the most deceptive mistakes in data science

Recently, my team started working on a project that aimed to detect fraud attacks. The performances of the initial model were excellent and we started to fantasize about moving to production. A more in-depth investigation discovered that our model suffered from data leakage. Data leakage is the creation of unexpected additional information in the training data, allowing a model or machine learning algorithm to make unrealistically good predictions. But the joy of good predictions won’t last long since the model learns from information that will not be available in real life. Data leakage is a wide field of problems ranging from the obvious mistake of using the target itself as an input to the model, to leaking of information from the future into the past. In this talk, I will explain what data leakage is, give real-world examples and share my experience with the audience. In addition, I will sharpen the differences between overfitting and data leakage and explain how to avoid both. During the talk I will also demonstrate some cool and useful pandas “good to know” tricks.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/a4912a46-3695-4135-b8a6-801c9e474ba7</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/kykhs6TSjBBwe2AqbXhcTC</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/170afbfa-152e-4113-83fb-907316c68427.jpg</video:thumbnail_loc><video:title>Conversation Intelligence -  Raphael Cohen - PyCon Israel 2018</video:title><video:description>Conversation Intelligence: Extracting Insights from Conversations

Sales conversations are a valuable and still underutilized asset for organizations. Recording and analyzing these conversations allow companies to quickly train new representatives, identify optimal behaviour, share and enforce best practices and also propagate customer requests and pain points to other parts of the organization helping product designers prioritize the best features. To create value from recorded conversations one needs a Conversation Intelligence (CI) stack. We outline the different layers of our CI stack, namely Diarization (also known as Speaker Separation), Automatic Speech Recognition (ASR) and various Natural Language Processing (NLP), Deep Learning and data science algorithms for extracting insights. CI is a relatively new field because until recently conversations were not amenable to automated analysis at scale due to the high bar of applying speech recognition. However, recent developments in ASR technology (based on Deep Learning) have given rise to significantly higher accuracy rates and with that the ability to robustly extract information from conversations. We review recent advances as well the cutting-edge approaches we use for Speaker Separation which is critical to understanding the roles various speakers play in a conversation, review latest methods for embedding a segment of speech for speaker clustering and review overall system structure for a multi-modal solution. On top of these we demonstrate how both standard and novel NLP and Data Science approaches can help reveal conversational insights including: weak language, inclusive language or identifying customer propensity to buy. The insights are drawn from over 2 million sales calls we analyzed at Chorus.ai to help our customers’ sales reps have better conversations and close more deals.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/9e6151b2-bd08-4462-bc7b-0a1c0aa9b36e</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/4XnP1gsM84PwHFBCsuMMhM</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/e12bd79b-c34d-43de-b884-c378fa8750a0.jpg</video:thumbnail_loc><video:title>Raspberry pi as a home automation controller using pymodbus - Yaacov Zamir - PyCon Israel 2018</video:title><video:description>Raspberry pi as a home automation controller using pymodbus and node-red

In this session we will introduce pymodbus, talk about the pros and cons of using serial communication in our modern publish-subscribe messaging age, and demo the use of pymodbus for home automation using Raspberry pi and node-red.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/2006c3b5-0cfe-4e34-8ad0-be14601ccda9</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/45xd111hCZLYbwupphx3LP</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/3903cd25-b84a-492a-a114-7f6b843c8042.jpg</video:thumbnail_loc><video:title>Pulling Radio Data out of Thin Air - Yuval Adam - PyCon Israel 2018</video:title><video:description>Radio waves are all around us, yet they are usually inaccessible from typical software applications. Recent years have seen an explosion of software-defined radio (SDR) applications, mainly due to the availability of cheap ($10) USB radio dongles. SDR can be utilized not only to listen to FM radio, but also to track airplanes in the sky, interact with wireless consumer electronics, and even receive satellite imagery. This interactive and fast-paced talk will provide a glimpse into the vast world of SDR, and show which tools in the Python ecosystem are available for building radio-aware applications.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/18ed9f7c-7d42-4343-a2d4-903068749967</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/oXr7C9qRKaMHZcV7Kw2gMr</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/c44bbd5c-914c-4c9f-b0c4-5528e1d80f9a.jpg</video:thumbnail_loc><video:title>PyVCR - Or how we cut our testing time from 5mins to 5s -  Nir Krakowski - PyCon Israel 2018</video:title><video:description>A few months ago we decided to upgrade our CI to include integration tests beyond the usual unit tests for our DNA synthesis and ordering platform. Rather than mocking our complex microservices environment, we chose to use VCR to record and replay the interactions. We will discuss the pros &amp; cons of using PyVCR with examples and a walk through on how to use it.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/b9e66f5e-dac3-4d59-adb2-f39ee325564f</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/iUJK9AVa5oU8MgPv5kmgMi</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/5be747c6-1f7b-4702-bb6f-3f68255857bf.jpg</video:thumbnail_loc><video:title>My journey for python3 readiness on a huge python code base - Yehuda Lavy - PyCon Israel 2018</video:title><video:description>My journey for python3 readiness in the biggest python code base I know. JP Morgan has one of the largest python code bases in the world, We will discuss the preperation steps for the upgrade to python3.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/91086009-9ab6-4653-a390-24e6587ec8ef</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/2MhszzY3KUmmz7TpzrWiPj</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/ce39e209-d28b-4808-b0e1-adce6557461d.jpg</video:thumbnail_loc><video:title>Advanced Celery Tricks - Itamar Hartstein - PyCon Israel 2018</video:title><video:description>Advanced Celery Tricks - How we adapted and extended Celery to fit our data pipeline

In Singular, we have a data pipeline which consists of hundreds of thousands of daily tasks, in varying length (from less than a second to hours per task), and with complex dependencies between them. In addition, we integrate with hundreds of third-party providers, which means that tasks are not necessarily reliable / predictable, so we need to be robust to failures and delays and be able to monitor them easily. We found Celery to be highly suitable to our needs as a task infrastructure, especially due to its distributed nature, its support for various workflows and its modular design. In particular, the fact that it is compatible with multiple technologies for conveying messages ("brokers") and storing results ("backends") greatly appealed to us.

It wasn't an immediate fit however. We needed to extend Celery so it will fit our use cases: (1) We implemented a custom backend and a custom serialization method. (2) We tweaked the behavior of Celery's workflows (chains, groups and chords). (3) We needed to be able to update code easily without restarting workers. (4) and more..

In this session we will discuss how we adapted Celery to our needs, as well as tools we developed for working with it better, and various advanced tips &amp; tricks.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/0e6bc046-5043-457a-9d51-cfd3a3f3f5fc</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/uQt5zEw3Wkxm9jFucUxwZg</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/ad6fa5ee-b401-4bab-a264-f6582e51349b.jpg</video:thumbnail_loc><video:title>Text Analysis With SpaCy, NLTK, Gensim, Skearn... - Bhargav Srinivasa Desikan - PyCon Israel 2018</video:title><video:description>Text Analysis With SpaCy, NLTK, Gensim, Skearn, Keras and TensorFlow

The explosion in Artificial Intelligence and Machine Learning is unprecedented now - and text analysis is likely the most easily accessible and understandable part of this. And with python, it is crazy easy to do this - python has been used as a parsing langauge forever, and with the rich set of Natural Language Processing and Computational Linguistic tools, it's worth doing text analysis even if you don't want to.

The purpose of this talk is to convince the python community to do text analysis - and explain both the hows and the whys. Python has traditionally been a very good parsing language, aruguably replacing perl for all text file handling tasks. Reading files, regular expressions, writring to files, crawling on the web for textual data have all been standard ways to use python - and now with the Machine Learning and AI explosion - we have a great set of tools in python to understand all the textual data we can so easily play with.

I will be briefly talking aboubt the merits, de-merits and use-cases of the most popular text processing libraries. In particular, these will be spaCy, NLTK, gensim. I will also talk about how to use traditional Machine Learning libraries for text analysis, such as scikit-learn, Keras and TensorFlow.

Pre-processing is the one of the most important steps of Text Analysis, and I will talk more about this - after all, garbage in, garbage out!

The final part of the talk will be about where to get your data - and how to create your own textual data as well. You could analyse anything, from your own emails and whatsapp conversations to freely available British Parliament transcripts!</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/e984457d-b795-4bde-9379-efbf77b5b9a9</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/6U7VktCTkbgubW8k4BNg4J</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/4b84bd35-50cb-425f-8653-ed0ccc77e8ba.jpg</video:thumbnail_loc><video:title>How Mobileye generates augmented images to boost autonomous driving - Asya Frumkin - PyCon IL 2018</video:title><video:description>Detecting lanes and road markings are some of the great challenges autonomous driving technologies face today. In Mobileye, we do it by training neural networks. This method requires an enormous amount of data from many countries, different weather conditions etc. However, in some road scenarios the available data set is still too small, or the data is not accurate. In this session, I will discuss how we developed a system that uses Python with OpenCV to generate augmented images and matching ground truth data in order to improve accuracy of neural networks.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/2fc4a239-2312-4536-88b3-c159e31fc574</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/qVfDFpwkBzi1yN3CSaXBCy</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/bb14a8b4-faf2-4477-b08f-c2da914acaf0.jpg</video:thumbnail_loc><video:title>The web is terrifying  - Sarah Bird - PyCon Israel 2018</video:title><video:description>Using PyData tools and a new dataset from Mozilla, we can explore some of the many ways we are tracked around the internet, and look at what this means now that the EU's General Data Protection Regulation (GDPR) has come into force. Sarah will also talk about becoming a software engineer, then a builder of data science tools, and her new journey into a data science.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/c9cac69b-c26c-4ebb-a579-4c3b89215d9c</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/3sEYxz4x7xfQYYF5sTqZpt</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/046c1dd1-6749-4142-a4a3-cc243dd8a55a.jpg</video:thumbnail_loc><video:title>Women in Tech/startups/coding - Does it matter? - Michal Michaeli - PyCon Israel 2018</video:title><video:description>While being geeky supposed to hold more appeal than ever, it seems it doesn’t affect women, or girls, the same way. And though the rise in technology and coding in our life is undeniable – women still take less than 20% of jobs in technology, less than 10% of startup entrepreneurs and not even 15% coders. Those numbers matter cause they tell a story and based on it we can discuss if that is how we want/need it to be. And if not – what can be done to change it.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/13eba26d-1079-43f5-8ec5-759242b0ad05</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/c3jDMhtbDCofN9g1Jfp7Jq</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/68758d11-9775-4d3e-84b1-2a2b7a2c13e3.jpg</video:thumbnail_loc><video:title>A tale of DNA, Numpy, and 3 types of Jews - Daniel Levy &amp; Luis Voloch - PyCon Israel 2018</video:title><video:description>We all know that our DNA is what makes us US. So if we have our DNA data, what can we tell about us ? Our presentation will focus on one of the problems that we’ve been working on at MyHeritage, which is telling you, based only on your DNA, what is your ethnic background.

In the talk we’ll discuss how to treat this question as a machine learning problem (using standard tools like sklearn and numpy for a distinctive set of problems), what sets it apart from classical classification problems, and our approach for answering this question using thousands of models, not too many samples, but way too many features.

We will also talk about how Jewish genealogy introduces additional difficulties.

This is joint work by Professor Yaniv Erlich, Dr Daniel Levy, and Luis Voloch.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/596781d3-31f4-4860-87af-7e778508ceac</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/6oH5vSXVeM3VoUB3rxptgV</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/b4b6b634-3234-42ba-9473-68e7fbfe773a.jpg</video:thumbnail_loc><video:title>Tidy Data in Python - Aviv Rotman - PyCon Israel 2018</video:title><video:description>If you ask any data scientist what is the most frustrating and time consuming part of a data science project, surprisingly they won't say visualization, neural network architecture, or feature engineering, they will most probably say cleaning and shaping data. The struggle to work with messy data is what can make or break a project and sometimes hide the real gems the data has to show us. Many junior data practitioners shrug off this stage as mechanic and boring, and tend to put little thought towards it. It turns out that there is a "right" way to tidy data that allows for easy analysis and visualization down the line Tidy data has a specific structure, which can be summarized in two sentences: each variable is a column; each observation is a row. The simplicity of this strategy makes it easy to understand how to tidy data, and only requires a small set of tools to deal with a wide range of messy datasets. These tools have been developed in the popular r packages dplyr and tidyr. Alas, this is not an r conference, and we are but hapless python developers. Is our fate to be left out in the cold with all our messy data?!? Not on my watch! In this talk we will learn about "tidy data", a strategy formulated by Hadley Wickham in 2014. We will also go over common cases of messy data and how to tidy them with python tools, and we will see how using this system we can quickly achieve complex analyses and intuitive visualizations.

Relevant article and blog posts:

    http://jalammar.github.io/visualizing-pandas-pivoting-and-reshaping/
    http://www.jeannicholashould.com/tidy-data-in-python.html
    https://www.jstatsoft.org/article/view/v059i10</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/2ba95f11-a31f-4020-ab16-68d1bde8d18f</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/6HCr8B4JdE7XXwLnWmc53X</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/93014992-eae4-4344-8e70-8c6b30c022cd.jpg</video:thumbnail_loc><video:title>"I Abstain" - teaching DL when to shut up - Tsvi Lev - PyCon Israel 2018</video:title><video:description>When a single decision by a deep network has significant implications (e.g. Medical, Financial, Safety), accuracy is critical. We show some novel methods (some invented at NEC and some public knowledge) to improve accuracy at the cost of 'not answering' in cases the network model feels uncertain.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/2e4da403-fbaf-4b7a-b4b3-76d3ec355b33</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/dj1d5ydVJMmzvebUmjsHf9</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/7861380e-315d-4477-80bf-01ea03129a6c.jpg</video:thumbnail_loc><video:title>Dataframe Validation In Python - A Practical Introduction - Yotam Perkal - PyCon Israel 2018</video:title><video:description>As Machine Learning models rely on data in order to make their predictions, data quality evaluation is a crucial aspect of any ML pipeline. We as Engineers/Data-Scientists, should validate our data in the same manner in which we validate our code. Data errors can lead to: Bad and costly decisions, Inaccurate predictions due to invalid data and Time waste. There is an abundance of different libraries that perform various kinds of data integrity checks. I will specifically focus on Dataframe validation.

In this talk, I will present the problem and give a practical overview (accompanied by Jupyter Notebook code examples) of three libraries that aim to address it: Voluptuous - Which uses Schema definitions in order to validate data [https://github.com/alecthomas/voluptuous] Engarde - A lightweight way to explicitly state your assumptions about the data and check that they're actually true [https://github.com/TomAugspurger/engarde] * TDDA - Test Driven Data Analysis [ https://github.com/tdda/tdda]

By the end of this talk, you will understand the Importance of data validation and get a sense of how to integrate data validation principles as part of the ML pipeline.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/63b12e1c-46b2-4530-a8b9-fa8de078e2a8</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/oJqmaNhRBazJdLmDacjvy1</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/752f174e-0cb1-4b65-8165-812b569b6662.jpg</video:thumbnail_loc><video:title>Apache Amaterasu (incubating): A CD Framework -Nadav Har Tzvi - PyCon Israel 2018</video:title><video:description>Apache Amaterasu (incubating): A CD Framework for your Big Data Pipelines

In the last few years, the DevOps movement has introduced ground breaking approaches to the way we manage the lifecycle of software development and deployment. Today organisations aspire to fully automate the deployment of microservices and web applications with tools such as Chef, Puppet and Ansible. However, the deployment of data-processing pipelines remains a relic from the dark-ages of software development.

Processing large-scale data pipelines is the main engineering task of the Big Data era, and it should be treated with the same respect and craftsmanship as any other piece of software. That is why we created Apache Amaterasu (Incubating) - an open source framework that takes care of the specific needs of Big Data applications in the world of continuous delivery.

In this session, we will take a close look at Apache Amaterasu (Incubating) a simple and powerful framework to build and dispense pipelines. Amaterasu aims to help data engineers and data scientists to compose, configure, test, package, deploy and execute data pipelines written using multiple tools, languages and frameworks. We will see what Amaterasu provides today, and how it can help existing Big Data application and demo some of the new bits that are coming in the near future.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/b8154b2f-1fa6-47b1-bfa7-f36a416d6ab4</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/pkf2JyN7CCuXLpnzV9ACWV</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/425737c9-c1f0-4942-a3ae-9c048f3c2e4f.jpg</video:thumbnail_loc><video:title>Tackling Location Based Data Challenges - Eli Safra - PyCon Israel 2018</video:title><video:description>Geographic data requires special treatment when tackling Data challenges. For example, bucketing latitude/longitude into equal size buckets may be misleading due to the curvature of the earth surface and land usage. At this talk we will discuss what Python libraries can be used for working with Geospatial data and how to use them properly.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/bcf1f78f-e699-4169-9966-e02de94ad731</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/u2xVevMN6edCLj9Qei7gNK</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/10c29936-bdff-4480-86f9-14bd1fd661b9.jpg</video:thumbnail_loc><video:title>telluric: interactive manipulation of Geospatial data - Guy Doulberg - PyCon Israel 2018</video:title><video:description>telluric: interactive manipulation of Geospatial data with Jupyter and Python

telluric library is an open source library developed by Satellogic, which aims to be an one stop source (library) for manipulating geospatial data in an interactive way. The library facilitates the use and manipulation of Geo Vectors and Geo Rasters by creating an integrated and unified API on top of a combination of domain specific python libraries, such us: rasterio, Shapely, Fiona, and more. For wide compatibility, telluric library supports all known GIS raster and vector formats. telluric library was developed with Jupyter notebook in mind, in which all operations auto-generate the appropriate visualization, and presented on top of an interactive map, with no additional effort.

In this presentation we will show how to use telluric library to manipulate geospatial information and how it integrates in a Python GIS ecosystem, explain how we utilize telluric in Satellogic for diversity of tasks like: geospatial data management, coverage analysis of satellites constellation and visualization, and commenting on the plans for the future releases.

telluric: https://telluric.readthedocs.io/en/latest/User%20Guide.html</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/e2f74bda-42b4-43ee-b141-2ef218608dd3</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/hx7raRyJ1AazGfwMdRPaC3</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/a0bcc58f-868d-4f7c-87e8-9bc10dfe35be.jpg</video:thumbnail_loc><video:title>Python tools to Manage Large Scale  - Arie Abramovici &amp; Evgeny Andzhelo - PyCon Israel 2018</video:title><video:description>Python tools to Manage Large Scale, Multi-cloud Deployments

Managing large scale deployments over multiple clouds can be a bit of a hassle. In this talk we will discuss the challenges (and opportunities) Waze found, in it's quest to Outsmart Traffic over GCP and AWS, how we overcame them. We will also showcase our open source python libraries used for that purpose.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/85ea3d91-787c-478f-923a-375a99fecd96</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/jNgHtCBGmgWX7bA49ACSyx</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/d3d9b274-1851-41ce-b36c-9379f50a61bf.jpg</video:thumbnail_loc><video:title>Boosting development in a containerised microservices env - Ron Anavi &amp; Gal Cohen - PyCon IL 2018</video:title><video:description>Boosting development in a containerised microservices environment

We started as a development team of two people working on 2 containerised services. While we were concerned about scale, we weren't concerned about scaling the team itself, so we built our services using simple makefiles and each service had its own compose file. After a few months we found ourselves working with ~20 developers from 3 different teams, across several countries, collaborating on the same project, with 25 containerised python microservices.

A major growing pain we experienced was the “onboarding” process for our new team members. In order to automate and expedite the process, we wrote deployment scripts intended to easily create new dev environments. It didn’t work out as planned and the consequence was the vast majority of developers debugging/testing their own code remotely, rather than on their local machines.

After taking some time to reflect on the topic, we set out to solve the challenge of maintaining a stable and scalable dev environment within a growing team. These efforts can be summarized as the following: - Simplify container orchestration for local development environments - Build time optimization for local and CI processes - Maintaining and developing on multiple python environments (Python2/Python3/PyPy) with minimal setup overhead - Taking care of different caching aspects related to our CI and local builds - Enabling debug of the code in the container using its python interpreter - Creation of a monitoring solution for inter-service communication

This was and continues to be a journey towards improving our processes and mindset of growing a development team while reducing unnecessary pain. After learning the lessons above, we are excited to share our experiences with the community in an effort to help us all grow and improve together.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/983a64e2-7890-46b8-a23d-af13e99d48e7</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/38QTEwYMyN9hNg2oKcWVtG</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/60fda01a-5931-4ac5-9f2d-e87d280bf638.jpg</video:thumbnail_loc><video:title>ETL-ing the Israeli Government (and living to tell the tale) - Adam Kariv - PyCon Israel 2018</video:title><video:description>In the past 8 years we've been collecting, scraping and processing government data - overcoming technical, legal and other hurdles - to create Israel's richest database of fiscal data (and growing!). In this talk I will talk about how we're doing this (we - at the Public Knowledge Workshop), and present the unique software frameworks and tools we've built to accomplish this goal. In particular, I will talk about the data-package pipelines framework, which combines a suite of standards and tools for 'packaging' data as well as a versatile engine for processing data streams.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/114a9d1c-65e1-4f97-94b8-021b9069e3ba</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/1GH2wxn8e4o3NDbnMYoAmX</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/2622ca3f-61e8-44f5-bb4b-5cba314d9380.jpg</video:thumbnail_loc><video:title>Python: Behind The Scenes - Diana Gastrin - PyCon Israel 2018</video:title><video:description>When you are writing code, you have a very clear target: that the code will run and that the output will be accurate. But have you ever stopped and thought about the language in which you are writing?

The lecture will deal with topics that programmers usually don't talk about: evaluation order, the variables environment, what happens behind the scenes, and in general - the meaning of every line of the code.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/05af08bf-3d3e-4950-b681-ef49091ad0d7</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/gKE5rYFsJLvHijs2chS4ik</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/f507f181-4cd2-40e5-b9d1-60b89e2208ec.jpg</video:thumbnail_loc><video:title>Learning to Control Any Device With Python and Salt - Mike Place - PyCon Israel 2018</video:title><video:description>From data centers with tens of thousands of servers, to cloud deployments with millions of containers and from IoT weather stations across Africa to computers labs in universities and home offices -- people use Python and Salt to control a myriad of devices.

In this talk, we'll show people without any previous systems management experience how easy it is to leverage Salt and Python to write basic modules to control anything from a laptop to a datacenter. Attendees will come away with practical knowledge about how translate their Python knowledge into systems management know-how that can be applied straight away.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/7f918710-f271-4a62-b70f-722b2eb3d549</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/5oC2XBzYStNoYUBLLtkfBM</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/6de4535a-5e12-4a3a-b6e0-f08891358a9b.jpg</video:thumbnail_loc><video:title>Developing Cloud Serverless Components in Python - Asher Sterkin - PyCon Israel 2018</video:title><video:description>Serverless cloud architectures gain momentum.The number of completely managed services and serverless computation environments (Function As a Service) is already large and growing at substantial pace. For computation services (aka Function as a Service) Python is usually supported out of the box and at least in some environments (AWS) yields superior performance. However the same is for JavaScript with a strong argument in favor of full-stack development. In this talk I will demonstrate how by applying Domain-Driven Design patterns front-end services where JavaScript might be more suitable could be delineated from core domain services where Python has a number of clear advantages.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/238d1fca-60cc-472e-8b10-aa69dc90c7bb</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/eZEsHjWH4Jxy6921pf4nGV</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/360bb53f-2bb3-4c2e-93b7-46dd43a1e270.jpg</video:thumbnail_loc><video:title>Hacking for Fun &amp; Profit: The Kubernetes Way - Demi Ben Ari &amp; Tal Peretz - PyCon Israel 2018</video:title><video:description>To defend against attacks, think like a hacker. But does that mean you need to be a DevOps expert? Security researchers today need to discover new attack techniques. However, much of their focus is diverged to backend coding. We share how to build an infrastructure for researchers that allows them concentrate on business logic and writing hacker “tasks”. Using Python, Celery, Docker and Kubernetes on Google Cloud, these tasks can then be performed in parallel and without a lot of DevOps hassle. Our technique removes two common barriers: first, long and risky deployment processes and second, low transparency within the production system.

Promise to share the stupid things too.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/7153e64e-529d-4d28-a1fa-0b0cc9dc8071</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/aajCmN5HwFCgusA77CceXn</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/f6794fa7-dc36-4263-b728-9b3aa2e347a7.jpg</video:thumbnail_loc><video:title>Dataclasses: The effortless tool to define data - Eli Gur - PyCon Israel 2018</video:title><video:description>Available starting Python 3.7, the dataclasses (introduced in PEP 557) are finally here. Amazingly simple solution for data with great exressiveness, the next generation of dicts, named tuples and records. The presentation will explain what the dataclasses are, show practical examples, and go over the main features and the key design decisions as well as the capabilities.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/4a2f6bcc-5d4b-48fb-9236-e71b1cd6f797</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/fSG6zpag5pCE7tXSBGhAhm</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/383f51a4-15bd-4630-b9fc-506d0a80a10a.jpg</video:thumbnail_loc><video:title>I Code Life – is DNA the next coding language?  - Yogev Debbi - PyCon Israel 2018</video:title><video:description>The next generation of Genetic Engineering is the ability to design and make synthetic genes - the DNA of all living organisms. This is used across multiple industries, like pharma, agriculture, chemical production and even data storage. Twist Bioscience developed disruptive technology to synthesize DNA and its Israel R&amp;D center develops software tools to design and debug DNA sequences by its customers. Yogev will describe the challenges, technology and application of the next generation of Genetic engineering, led by Nano-technology and Software.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/7873d701-24fe-48f2-872b-0f54fed0dd5c</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/qkR4JD5yr3JZLgppos5Ygd</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/933f175e-6833-4241-bc55-362aa718b17b.jpg</video:thumbnail_loc><video:title>You Have Control: Learning From Aviation -  Andrew Godwin - PyCon Israel 2018</video:title><video:description>As we move forward into the world of distributed systems, microservices, and hosted platforms, we find ourselves in a world where there are more moving parts and potential points of failure than ever, in an industry that traditionally has a poor approach to error handling and failure. What are these problems? How do we solve them not only through code, but through training and processes? And how can we learn from other industries that have tackled them before?</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/c520b24c-85ff-475d-a4c8-4c6e93f5f792</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/a7dzSSCQxS5sAGE8JZFjn4</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/2c13e470-acd9-4f55-8507-5fa46837b2e9.jpg</video:thumbnail_loc><video:title>Opening Session - PyCon Israel 2018</video:title><video:description>Opening Session - PyCon Israel 2018</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/49c0773d-5955-4a10-aca3-e1655586e0f5</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/hwPC8X7rWDuGojfUwYFJdW</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/10029b69-3217-4ef3-b69c-7f6754d3a401.jpg</video:thumbnail_loc><video:title>PyCon Israel 2018 event clip</video:title><video:description>PyCon Israel 2018 event clip</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/85dfe162-7be2-4825-9387-0aaded96a12e</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/5ewnLzKRfG731rAwqw75r1</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/79fd36b7-bf33-4fd3-b486-5475980b9528.jpg</video:thumbnail_loc><video:title>Cross platform automation in Python - Aharon Rubin - PyCon Israel 2018</video:title><video:description>Automating multiple platforms together for testing a complicated environment with complicated scenario is always a challenge. I will show a case study and how we implemented a solution that was running end to end scenario with mobile phones (iOS and Android), windows native and browser technologies. I will show how we met the challenge and orchestrated the entire testing with continuous integration (GIT and Jenkins).</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/2247f16f-765c-4e1d-8b57-421b502e778a</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/rHeo49Sg9iD7JFhSzphGZB</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/9651e306-90d9-4d89-a8df-7a03a3fbf8d6.jpg</video:thumbnail_loc><video:title>Quick and robust CLI creation with Click module by Ilia Meerovich</video:title><video:description>Slides available here: http://il.pycon.org/2016/static/sessions/ilia-meerovich.pdf</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/d03634fa-09bc-4d41-9840-47fb5de84ebd</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/miUSQR1TYc4FnghPDa8rWP</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/5e3b2ecd-254e-49bc-a0fa-38c30b968e55.jpg</video:thumbnail_loc><video:title>Poetry in Python: Using Markov Chains to Generate Texts by Omer Nevo</video:title><video:description>Slides available here: http://il.pycon.org/2016/static/sessions/omer-nevo.pdf</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/a47700ee-e98a-4f1d-919d-fbbc63e80477</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/6pmwDyUY4i89MLe1UjkNtb</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/5c7e251a-db2d-4c85-98f9-11f5e3a094ec.jpg</video:thumbnail_loc><video:title>If They Build It… They will code...(lessons from a school coding club) by Rony Sheer</video:title><video:description>Slides available here: http://il.pycon.org/2016/static/sessions/rony-sheer.pdf</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/2bc0737a-ba1a-40ec-b62c-013bac65f1b8</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/kQxMSVXbR1TwRrGXvfkhHr</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/ef5c961c-1d55-4daa-b3b8-c4e54af9d74a.jpg</video:thumbnail_loc><video:title>Pandas - not just for data scientists by Uzi Halaby-Senerman</video:title><video:description>Slides available here: http://il.pycon.org/2016/static/sessions/uzi-hs.pdf</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/a0a4ed6a-2349-475a-8514-db5e3514b55b</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/tbuM1nW66wVCmwmHt7TH5D</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/18d45000-5f73-4b01-8396-e00642060449.jpg</video:thumbnail_loc><video:title>How to Study Evolution Using Scientific Python by Yoav Ram</video:title><video:description>Slides available here:
http://il.pycon.org/2016/static/sessions/yoav-ram.pdf
and also:
https://github.com/yoavram/PyConIL2016</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/dc1dea53-fd3f-4917-9ff4-2bb75d3c1849</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/6CJGs3QoURUw9bseGjijA4</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/8c00a179-53f3-4c23-8370-b35cd2809a8f.jpg</video:thumbnail_loc><video:title>Packaging / dependecy hell in python by Niv Mizrahi</video:title><video:description>Slides available here: http://il.pycon.org/2016/static/sessions/niv-mizrahi.pdf</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/2d9ec840-031e-4738-a7a6-32960b8ae147</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/ar8GeZgRNDpCb3mvGRdAcQ</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/d375defb-6d11-479e-8407-1d613a8dd55b.jpg</video:thumbnail_loc><video:title>Running upstream Spacewalk tests using Ansible and Vagrant by Aleš Dujíček</video:title><video:description>Slides available here: http://il.pycon.org/2016/static/sessions/ales-dujicek.pdf</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/4c64956b-71da-4fb5-8fe2-fb45deb721a6</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/7bPmhrAwpF9UkGZSEb2VZo</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/a69bcbe2-75b4-4804-af4d-3701b568d9a6.jpg</video:thumbnail_loc><video:title>Optimizing Latency by Imri Goldberg</video:title><video:description>Slides available here: http://il.pycon.org/2016/static/sessions/imri-goldberg.pdf</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/32197330-7cb2-4c64-99ef-a98a1b2efcfc</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/j5QzRfdBpMPRm8eTZVrenK</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/6949fca9-b903-479c-8330-202ae3af0bf1.jpg</video:thumbnail_loc><video:title>Hacking the Selenium WebDriver by Daniel Puterman</video:title><video:description>Slides available here: http://il.pycon.org/2016/static/sessions/daniel-puterman.pdf</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/92716963-316e-4512-85f2-b3951a26c4d9</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/sQdVyqojrZVDKhimt2h7u5</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/aeda1cd7-1584-4f87-b8e6-5e753874b61c.jpg</video:thumbnail_loc><video:title>Network Analysis with Python by Orsolya Vasarhelyi</video:title><video:description>Slides available here:
http://il.pycon.org/2016/static/sessions/orsolya-vasarhelyi.pdf

and here (requires flash):
http://prezi.com/szsbgd2ortmu/?utm_campaign=share&amp;utm_medium=copy&amp;rc=ex0share</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/d949453d-4f86-479c-b489-11d869a4d624</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/gzsFgd12CggWC4fH3EHb3b</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/f8ce2069-25c4-47d0-8ec5-e28d2115e3c7.jpg</video:thumbnail_loc><video:title>Keynotes: Scaling PyData Up and Out with Anaconda by Travis Oliphant</video:title><video:description>Slides available here: http://il.pycon.org/2016/static/sessions/travis-oliphant.pdf</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/7e251086-a85b-4060-a875-8403a6b5ce2e</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/69pTLcK5grRZBBd2AH76Gp</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/faaf8c67-1bcd-4a90-bfb5-2b1e48f875ed.jpg</video:thumbnail_loc><video:title>From Experimentation to Production: Pandas and Sci-Kit learn on Azure ML by Ari Bornstein</video:title><video:description>Slides available here: http://il.pycon.org/2016/static/sessions/ari-bornstein.pdf</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/29aa5e21-f345-4228-9ec8-9a84f1906fdb</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/oZwabFxVRGv9FvtgnhooLj</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/5595385e-c904-4450-845d-61becd5bdfb6.jpg</video:thumbnail_loc><video:title>Introduction to app development with OpenStack SDK by Francesco Vollero</video:title><video:description>Slides available here: http://il.pycon.org/2016/static/sessions/francesco-vollerol.pdf</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/ba3107f9-92aa-4075-b50a-13b0250075f2</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/hXbLVduhYwGmiBSbpcB1Lk</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/e5a84f96-f328-48f4-b548-113b4f7936b6.jpg</video:thumbnail_loc><video:title>How to make Python perform like C by Ron Barak</video:title><video:description>How to make Python perform like C by Ron Barak</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/8946c411-a4ff-4cc6-bfc3-4ebc28365713</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/wGHFNpcUgpRvhF18zEMdLg</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/938c4fa0-94ec-441f-ae04-ca2f019980b3.jpg</video:thumbnail_loc><video:title>When Regular Expressions are Not Enough by Nati Cohen</video:title><video:description>Slides available here: http://il.pycon.org/2016/static/sessions/nati-cohen.pdf</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/f8a199c3-6090-4e95-9c4e-19a0f97df97f</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/iW9atubniuXDcNFFs3rUPz</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/b1cd7c30-b33b-4902-b2f3-5325704412f3.jpg</video:thumbnail_loc><video:title>Getting started with chatops in python with errbot by Guillaume Binet</video:title><video:description>Slides available here: http://il.pycon.org/2016/static/sessions/guillaume-binet.pdf</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/913a8d38-313e-4419-877b-da2a7aa1d59f</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/i5KjB3GvjeLyJ8tD5nyaWP</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/baf933e0-0557-499c-adea-9bb04e8a2ba8.jpg</video:thumbnail_loc><video:title>What's new in PyPy and what will be next by Matti Picus</video:title><video:description>Slides available here: http://il.pycon.org/2016/static/sessions/matti-picus.pdf</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/8a550798-5bb3-4696-a3e2-23acd3406e3f</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/dZxLpsrpkpZmjvgE4bK59T</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/00ca23be-5526-4b77-a6ad-d4c77f6a7002.jpg</video:thumbnail_loc><video:title>Wrestling Python into LLVM Intermediate Representation by Anna Herlihy</video:title><video:description>Slides available here: http://il.pycon.org/2016/static/sessions/anna-herlihy.pdf</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/6936a292-c94d-4a77-820d-6415777962cb</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/vdFR2xFuokHTEnX6KNYfPC</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/31bd0901-8ded-4450-848a-7331ed29417d.jpg</video:thumbnail_loc><video:title>Practical Metaclasses and Descriptors by Sim Zacks</video:title><video:description>Slides available here: http://il.pycon.org/2016/static/sessions/sim-zacks.pdf</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/ec9e807d-3361-414f-b250-8f2c1d9fcc02</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/eZWAWNHWsq7oJ5ikBDK5BC</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/57f486df-6704-44a0-88a8-3b180b4cac2d.jpg</video:thumbnail_loc><video:title>PyTest, the testing framework you've been dreaming of by Eli Gur</video:title><video:description>Slides available here: http://il.pycon.org/2016/static/sessions/eli-gur-pytest.pdf</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/715dd8f2-d419-4aa0-b081-9b7fd25112ca</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/fkKXcRDDYTsFoowfEcqThM</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/35754df7-163c-46b7-a8e4-ac1bf92c01d8.jpg</video:thumbnail_loc><video:title>Introduction to JSON Schema by Julian Berman</video:title><video:description>Slides available here: http://il.pycon.org/2016/static/sessions/julian-berman.pdf</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/742228bc-afee-4831-8d93-f0c3d24fdba9</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/66txL1dShLLGjn3jQ72uXb</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/98047a9a-c160-4230-b26d-0f67e5b70d7a.jpg</video:thumbnail_loc><video:title>Fight or Flight? - dealing with real world applications in Python by Gabor Szabo</video:title><video:description>Slides available here: http://il.pycon.org/2016/static/sessions/gabor-szabo.pdf</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/29416391-84c1-4956-9414-0f54d1a62178</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/mT5wxJ5E4n199fhsyY53ej</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/ea231d3b-e0ee-4162-8a75-b64f49d6adf4.jpg</video:thumbnail_loc><video:title>Type hints in Python by Eli Gur</video:title><video:description>Slides available here: http://il.pycon.org/2016/static/sessions/eli-gur-typehints.pdf</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/a9187ec0-e261-40fb-a531-bd837bd98dec</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/7iNdP3VZuBR8XKMAs4UyYn</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/a4cc85cd-3d8f-42e4-9b73-398f5859f548.jpg</video:thumbnail_loc><video:title>The Many Faces of Concurrency in Python by Sagiv Malihi</video:title><video:description>Slides available here:
http://il.pycon.org/2016/static/sessions/sagiv-malihi.pdf
and here:
https://docs.google.com/presentation/d/1OM3UkcwZIjESw9M4peTLRYxc327vHS2F9P_LCdAZ78g/edit?usp=sharing</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/3312f5ef-33ad-47c2-80d0-72405c61dcd5</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/6aj259NBPSqTv31WEFYnT2</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/856439b9-e480-446b-bcd4-1785cfa21673.jpg</video:thumbnail_loc><video:title>Keynotes: Growing Community That Makes a Difference by Ola Sendecka and Ola Sitarska</video:title><video:description>Slides available here: http://il.pycon.org/2016/static/sessions/ola-and-ola.pdf</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/29ca7dd3-9a4d-483f-b3c5-e45df573fcf3</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/v2LPFDXwQ81VYUdoN9nyJm</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/612186ec-9c24-4f3b-aae4-ff145b2c3cc4.jpg</video:thumbnail_loc><video:title>Python as a brain for your devices (web developement, hardware 'IoT', etc.) by Jonathan Schemoul</video:title><video:description>Python as a brain for your devices (web developement, hardware 'IoT', etc.) by Jonathan Schemoul</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/eb186335-3190-4437-83c3-281e9f084e20</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/khMCRdaGfZxRJvjVGno9Sr</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/07c7d179-06bd-4c29-93ae-cf1c83227193.jpg</video:thumbnail_loc><video:title>When Dependencies between Test Cases are Inevitable by Irina Gulina</video:title><video:description>Slides available here: http://il.pycon.org/2016/static/sessions/irina-igulina.pdf</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/9c35a89b-9142-45fe-a092-ab3af83abc8d</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/rwq6zG4Nuoh7SZwXG6tRzL</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/5c347f25-7b21-4cc8-97fd-a39cc98ed5c7.jpg</video:thumbnail_loc><video:title>Python In The Serverless Era by Benny Bauer</video:title><video:description>Slides available here: http://il.pycon.org/2016/static/sessions/benny-bauer.pdf</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/ceb3a121-f0f5-46c9-9d7a-035577f4c7d2</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/cftN5VA2kGL9Aufof7jxYD</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/355ccc91-f320-4ae4-816d-37ad33be8d79.jpg</video:thumbnail_loc><video:title>Keynotes session by Raymond Hettinger</video:title><video:description>Please note: Due to technical reasons this session is missing the recording of the laptop, which is important for this kind of a keynote. 
Nevertheless there's still tremendous value in watching the video and the slides which are available here: http://il.pycon.org/2016/static/sessions/raymond-hettinger.pdf</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/5b1a112a-3899-498c-aad1-8a1b618c44a1</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/x8UZt9srj2gCa84PRqzXoi</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/3ae1fa17-f6ee-4de8-8bf6-cbbb886118b6.jpg</video:thumbnail_loc><video:title>Generating, automating and processing 3D graphics with Blender's python API by Tamir Lousky</video:title><video:description>Slides available here: http://il.pycon.org/2016/static/sessions/tamir-lousky.pdf</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/fc26295f-211c-46fc-856f-7d38522a4251</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/jWUEVjX4rTEMbJumTnJ1CE</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/5b85611b-01b8-4480-aef1-e8f3145abc98.jpg</video:thumbnail_loc><video:title>Building Python with Bazel by Benjamin Peterson</video:title><video:description>Slides available here: http://il.pycon.org/2016/static/sessions/benjamin-peterson.pdf</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/996f1e7f-6f7d-4dbf-89e7-1134cb8c990e</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/p4AFW7vPBRZERiNm7Dh7Ho</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/8661cf6d-d91d-4083-bd2c-92130bc81c39.jpg</video:thumbnail_loc><video:title>Debugging Hung Python Processes With GDB by John Schwarz</video:title><video:description>Slides available here: http://il.pycon.org/2016/static/sessions/john-schwarz.pdf</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/bac2cc4c-293c-4d6f-99fa-e376f0375ac8</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/7VWntoaBZZ5BMLhFcLuE6W</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/f78248cb-74c0-4045-b5f8-6535d78420ef.jpg</video:thumbnail_loc><video:title>CPython byte-code and code-injection by Tom Zickel</video:title><video:description>Slides available here:
http://il.pycon.org/2016/static/sessions/tom-zickel.pdf
and here:
http://tom.zickel.org/pyconil-2016</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/381ec233-b67e-40f2-b499-6a8658267370</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/4Zxg6shP5yKT8giwUsqe8x</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/5b197bba-e650-4ca8-af75-f0d00ae1e049.jpg</video:thumbnail_loc><video:title>Deep dive into threat detection in the cloud with Spark and Python by David Melamed</video:title><video:description>Slides available here: Deep dive into threat detection in the cloud with Spark and Python by David Melamed</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/2054135f-a965-4612-ac9a-e7e5fb46cf69</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/cB1DPtHgJZnX9fncxG6NwJ</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/af7f3fc0-a9db-4b00-9329-9e7127758c6d.jpg</video:thumbnail_loc><video:title>Algorithms to Sample From Streams - Reservoir Sampling &amp; Variants by Jonathan Arfa</video:title><video:description>Slides available here: http://il.pycon.org/2016/static/sessions/jonathan-arfa.pdf</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/5df7f584-13d2-4b3a-a070-55c93c68a256</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/eiJW9E4RzrdHydwq6fwJ26</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/66217059-c4c9-4706-bb19-aa797c3fee12.jpg</video:thumbnail_loc><video:title>Decentralizing the cloud with Project Aleph - Moshe Malawach - PyCon Israel 2019</video:title><video:description>Decentralizing the cloud with Project Aleph (decentralized applications framework, aka "Look ma, no -centralized- cloud!") - Moshe Malawach - PyCon Israel 2019</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/6bc0e7cb-4a20-4d18-8def-e1c594306cd7</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/whyYxs2fanBNmChgXJEC9N</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/09ce1f6a-626f-44c4-9fc2-aa100b2fa6af.jpg</video:thumbnail_loc><video:title>Boosting simulation performance with Python - Eran Friedman - PyCon Israel 2019</video:title><video:description>Boosting simulation performance with Python - Eran Friedman - PyCon Israel 2019

https://github.com/eranfrie/pycon_israel_2019</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/f54261b0-b832-4737-a7e6-c74462a1d8be</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/vPTZWsyTbsWg7sxRbRJtQ7</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/bc83a04b-b03a-4df7-b2ff-9ae9298c11f5.jpg</video:thumbnail_loc><video:title>[heb] When the power of Where meeting the power of Share - Yehuda Horn - PyCon Israel 2019</video:title><video:description>When the power of Where meeting the power of Share - Yehuda Horn - PyCon Israel 2019

The talk is in hebrew.

https://www.slideshare.net/secret/pYDvPQAA99ub8o</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/f1890619-07ae-43aa-bb9a-a729c0fe8a52</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/kz9nrCp17fhAeRLppw1H7v</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/9a026ed1-1f41-43d0-bfa6-8b09db108e72.jpg</video:thumbnail_loc><video:title>Building text classifiers with Deep Learning frameworks - Inbal Horev - PyCon Israel 2019</video:title><video:description>Building text classifiers with state-of-the-art Deep Learning frameworks - Inbal Horev - PyCon Israel 2019

https://drive.google.com/file/d/1R1FoQR3JS3Vqz77JtOk7dSNX4dAp_rGT/view?usp=sharing</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/9e7e5642-8923-49c2-b1c5-9b45b9fc5e3d</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/sBuNh7Pph12xMjMtHtZqxY</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/38c1a8fc-9c83-46ad-b02b-f791e20a2c94.jpg</video:thumbnail_loc><video:title>Our DASK ETL Journey - Sephi Berry - PyCon Israel 2019</video:title><video:description>Our DASK ETL Journey - Sephi Berry - PyCon Israel 2019</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/d782626a-d8cd-4781-9c0f-2a9886cad616</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/4JgfqLFtQHsK9WUDe7XEM2</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/dc3165d4-9c39-43e8-8c7c-48d8fd44413b.jpg</video:thumbnail_loc><video:title>Understanding Python’s Debugging Internals - Liran Haimovitch - PyCon Israel 2019</video:title><video:description>Understanding Python’s Debugging Internals - Liran Haimovitch - PyCon Israel 2019
https://www.rookout.com/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/1e320d3b-a7ed-4c40-af09-11642dffdee3</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/bZQLKLt65n7cdpP9yXkdZc</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/cf9d54e9-86f4-4bb8-973e-9d5d84556ec9.jpg</video:thumbnail_loc><video:title>When Deep Learning meets Production - Nadav Goldin - PyCon Israel 2019</video:title><video:description>When Deep Learning meets Production - Nadav Goldin - PyCon Israel 2019

https://slides.com/nadavgoldin-1/when-deep-learning-meets-production-1#/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/590ed68c-1c3d-4307-ade5-9d1dd05e588d</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/vmCBEirrB5u7AJKH3KjCiA</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/b17e4410-8465-4558-999a-d2cde97781ac.jpg</video:thumbnail_loc><video:title>Data Classes in Python: Why They're Great - Tal Einat - PyCon Israel 2019</video:title><video:description>Data Classes in Python: Why They're Great + Examples Using attrs and dataclasses - Tal Einat - PyCon Israel 2019

https://taleinat.github.io/pycon-israel-2019-python-data-classes-talk/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/edba7613-58c4-46ef-b862-85957d956a8c</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/1HPERgiZrPzfa9nGUC48Gn</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/6b6a876a-723f-41b7-9ffc-44b66b5798ad.jpg</video:thumbnail_loc><video:title>How to effectively operationalize a Machine Learning model - Moran Haham - PyCon Israel 2019</video:title><video:description>A Case study: How to effectively operationalize a Machine Learning model - Moran Haham - PyCon Israel 2019</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/05d6df44-7718-4455-a5d0-fa50e4e146d9</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/hemvvQt5mdg4NHeqSdbmfj</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/62004ee9-3c0f-4d4a-9627-dc4c90699c35.jpg</video:thumbnail_loc><video:title>Building ORMs from scratch with advanced Python - Barak Itkin - PyCon Israel 2019</video:title><video:description>Building ORMs from scratch with advanced Python - Barak Itkin - PyCon Israel 2019

http://bit.ly/pycon-il-19-orms</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/836f86cf-e0f6-49d4-b040-503f8f575d1e</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/pgdkvgxsaBwiHyfpeLWQaa</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/e4ffb3c3-9968-448e-818a-cef5340f0411.jpg</video:thumbnail_loc><video:title>Extend Kubernetes to make you a coffee - Daniel Belenky &amp; Gal Ben Haim - PyCon Israel 2019</video:title><video:description>Extend Kubernetes to make you a coffee - Daniel Belenky &amp; Gal Ben Haim - PyCon Israel 2019</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/bc61f2bf-9feb-4246-a2aa-cac830d885e3</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/kHd8PCg3nVXZcGh79rnEXE</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/cbc7d90b-b9d7-4de7-a170-c0ac9cf0d2d3.jpg</video:thumbnail_loc><video:title>Parallel computing and Concurrency - Guy Doulberg - PyCon Israel 2019</video:title><video:description>Parallel computing and Concurrency - Guy Doulberg - PyCon Israel 2019</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/9f9e9b83-7a35-4f80-910c-0ac10862984c</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/3HXmFL3tUcqGZBZ7kkbdJD</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/2f66c285-2bfa-42a0-8923-2786e1c13221.jpg</video:thumbnail_loc><video:title>NLP on legal contracts - Uri Goren - PyCon Israel 2019</video:title><video:description>NLP on legal contracts - Uri Goren - PyCon Israel 2019

https://docs.google.com/presentation/d/1CvtqIp1O1hd4ISlXVkDBzW9J_oO-99zv-4HssX-doos/edit?usp=drivesdk</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/160de2fa-8cdd-417d-a63b-6842680998f9</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/tQjNxZgBucHD5kWYYKGRZQ</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/14179a54-aeac-497c-9bc0-f0ea2b6caf56.jpg</video:thumbnail_loc><video:title>Pandas for Fun and Profit: Using Pandas for Successful Investing. - Daniel Goldfarb - PyCon IL 2019</video:title><video:description>Pandas for Fun and Profit: Using Pandas for Successful Investing. - Daniel Goldfarb - PyCon Israel 2019</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/e1660844-e3c1-4969-a415-045f488d2fee</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/aKfFcjJRdKWCHGnhBegUYH</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/93fb805a-fae2-4186-9960-6bf671857ee5.jpg</video:thumbnail_loc><video:title>Opening session - PyCon Israel 2019</video:title><video:description>Opening session - PyCon Israel 2019</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/4eec4639-de8a-4bd7-9983-10dc7aa181b1</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/awfgg85DXpNvjMd6JqjLs5</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/10abcf14-762e-4d68-9871-676f18faf4f9.jpg</video:thumbnail_loc><video:title>PyPy - the hero we all deserve. - Amit Ripshtos - PyCon Israel 2019</video:title><video:description>PyPy - the hero we all deserve. - Amit Ripshtos - PyCon Israel 2019</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/4d1b59da-f77e-48ff-a9fc-c3942b7d56e8</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/vo3BrA3kxGZ4KGveV3GkGq</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/2b0d982d-dfd7-4ad7-b722-622f385097b7.jpg</video:thumbnail_loc><video:title>Standardizing Clinical Data with Python - Jacob Barhak - PyCon Israel 2019</video:title><video:description>Standardizing Clinical Data with Python - Jacob Barhak - PyCon Israel 2019

https://jacob-barhak.github.io/Presentation_PyConIsrael2019.html</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/edecfe42-4c08-409e-afac-b6844667e914</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/fV2ufn7jK2o7rT6HRZbFJ5</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/2e90ab51-1bc6-4fc6-b634-8a2a93699dad.jpg</video:thumbnail_loc><video:title>Hierarchical Temporal Memory in Python - Fred Rotbart - PyCon Israel 2019</video:title><video:description>Hierarchical Temporal Memory in Python - Fred Rotbart - PyCon Israel 2019

https://github.com/fcr/HTM_Talk_Pycon_Israel_2019</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/78c74707-dce0-4743-b5ea-1428bbd1c584</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/gMu9LZsyVgLcuRY8VsrWKR</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/b4815424-2717-4ddd-bb09-ae203bc0915a.jpg</video:thumbnail_loc><video:title>I hate security - Bluetooth distance detection story - Lior Mizrahi - PyCon Israel 2019</video:title><video:description>I hate security - Bluetooth distance detection story - Lior Mizrahi - PyCon Israel 2019

https://github.com/liormizr/linux_distance_locker</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/7fd2e5fe-123b-42ff-b582-2472d2b867ef</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/gvUviaBXoCBywF2vuiR3aC</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/ef4647cc-4cc4-4617-99f9-afb95011ac6c.jpg</video:thumbnail_loc><video:title>Disease Modeling with Scipy and PyMC - Dean Langsam - PyCon Israel 2019</video:title><video:description>Disease Modeling with Scipy and PyMC - Dean Langsam - PyCon Israel 2019</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/7da601b3-c1bf-4251-bf88-aa086242646e</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/ufq5dgiej1dXmPbNvF9Cf8</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/5163ce1f-8d2c-4e7a-9f94-769b666c24e1.jpg</video:thumbnail_loc><video:title>Beyond Word Embeddings The Future of Semantic Representation - Ari Bornstein - PyCon Israel 2019</video:title><video:description>Beyond Word Embeddings The Future of Semantic Representation - Ari Bornstein - PyCon Israel 2019

https://www.slideshare.net/AaronAriBornstein/pyconil-beyond-word-embeddings-slides</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/e4c3216a-a2ef-461a-a565-b1789a71d993</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/fEYaSzCCfP6NNbzHiqYJsf</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/497e2522-8702-49e4-928b-bbc39ded9350.jpg</video:thumbnail_loc><video:title>Social Network Analysis - From Graph Theory to Applications - Dima Goldenberg - PyCon Israel 2019</video:title><video:description>Social Network Analysis - From Graph Theory to Applications with Python - Dima Goldenberg - PyCon Israel 2019


Social network analysis is the study of social structures through the use of graph theory. In this talk I will present network theory and application of building and analyzing social networks for practical use-cases in Python with NetworkX.
_________________________________________________________________

Social network analysis is the process of investigating social structures through the use of networks and graph theory. It combines a variety of techniques for analyzing the structure of social networks as well as theories that aim at explaining the underlying dynamics and patterns observed in these structures. It is an inherently interdisciplinary field which originally emerged from the fields of social psychology, statistics and graph theory.

This talk will cover the theory of social network analysis, with a short introduction to graph theory and information spread. Then we will deep dive into Python code with NetworkX to get a better understanding of the network components, followed-up by constructing and implying social networks from real Pandas and textual datasets. Finally we will go over code examples of practical use-cases such as visualization with matplotlib, social-centrality analysis and influence maximization for information spread.

Code examples for the sessions can be found here: https://github.com/dimgold/pycon_social_networkx

_____________________________________________________

Dima Goldenberg

I was always excited about looking at patterns, especially in people interactions. This led me to focus on data science and social network research as a career and discover patterns in people behavior. I did my masters research about Influence Maximization in social networks at the Department of Engineering in Tel Aviv University. I love to teach and was teaching different data topics in the academia and outside. Today I am a Data Scientis...</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/76d0d214-2f12-4daa-8a94-66d317cbf07a</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/6gCKcCasY9Zhd18LTuZuNB</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/77a8d9c4-ca15-4fad-93a7-fcd21e1132cc.jpg</video:thumbnail_loc><video:title>Async/Awaiting Production - Ronnie Sheer - PyCon Israel 2019</video:title><video:description>Async/Awaiting Production - Ronnie Sheer - PyCon Israel 2019</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/2aac7ea1-f61a-48c2-84da-5f4f10136687</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/9yVfEhVp8Zx4BHdfp4EQqA</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/3aa19f91-c49a-48d8-8d59-7a065ad311c2.jpg</video:thumbnail_loc><video:title>"Scope of Variables in Python" - A full scoop of python scopes! - Yoav Glazner - PyCon Israel 2019</video:title><video:description>"Scope of Variables in Python" - A full scoop of python scopes! - Yoav Glazner - PyCon Israel 2019</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/4561ba64-cd31-48b3-9483-8501f240f752</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/8P5L1B9sMHqyysyep86kYn</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/189a708e-96fc-4945-924e-a3eba0b32529.jpg</video:thumbnail_loc><video:title>[heb] "Is it safe ?" - python code security tools - Yehuda Lavy - PyCon 2019</video:title><video:description>"Is it safe ?" - python code security tools - Yehuda Lavy - PyCon 2019

The talk is in hebrew.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/3f42dc4b-5fde-43e5-abd7-d8389cbfc149</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/pH2ppaUQBgKEDDNBwCtkc7</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/ff05e3e9-ed9f-4289-af04-3bd73c0c84c8.jpg</video:thumbnail_loc><video:title>Real world Graphene: lessons learned from building a GraphQL API - Marcin Gębala - PyCon Israel 2019</video:title><video:description>Real world Graphene: lessons learned from building a GraphQL API on top of a large Django project - Marcin Gębala - PyCon Israel 2019

Slides: https://speakerdeck.com/maarcingebala/real-world-graphene-pycon-israel-2019</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/bffc8c74-55e9-4430-9200-1d786cd0a228</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/wgi2y2SYfHYRUVoHS87wQe</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/769cc9b4-0314-43fc-b2a3-ed6bd78506e5.jpg</video:thumbnail_loc><video:title>Pipenv - The Python Companion You Wish You Always Had - Avi Aminov - PyCon Israel 2019</video:title><video:description>Pipenv - The Python Companion You Wish You Always Had - Avi Aminov - PyCon Israel 2019</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/f514cf39-219b-4554-802d-6e399faeff05</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/6TtLrCJj2SPgQz2jPG77EC</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/ad5ed193-efec-4eb1-a31b-cc99a8b60da3.jpg</video:thumbnail_loc><video:title>Root Cause Analysis with eBPF &amp; Python - Pavel Rogovoy - PyCon Israel 2019</video:title><video:description>Root Cause Analysis with eBPF &amp; Python - Pavel Rogovoy - PyCon Israel 2019

https://docs.google.com/presentation/d/1ppRyThQE44m0z1wfkYfbI4mB2c3ZjvbQ4f3PzUqyBKw/edit?usp=drivesdk</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/2fadbcb4-230b-438e-9a02-b57a16c24768</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/ic8ZMx4b2VmVxhcwsfW7Er</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/a73226ec-a50b-4340-92e3-076c024f5ded.jpg</video:thumbnail_loc><video:title>From 2 to 3 in 1 go - Yael Green - PyCon Israel 2019</video:title><video:description>From 2 to 3 in 1 go - Yael Green - PyCon Israel 2019</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/8b397771-e306-419d-8598-45dfc0d5ae1d</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/aJQLjpMBAUQRo8oQkAnzFB</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/c8b97bef-4acf-410e-9e3b-0b33febcc3b8.jpg</video:thumbnail_loc><video:title>Python 3.8 new stuff, assignment expressions - Eli Gur - PyCon Israel 2019</video:title><video:description>Python 3.8 new stuff, assignment expressions and why Guido quits as BDFL - Eli Gur - PyCon Israel 2019</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/4edd89c8-cc97-4b6b-ad76-f462fdad90e5</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/mwL9PyS6jQy73hcMavpNfH</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/d1d8365a-bf30-481d-80b2-f382137aaa34.jpg</video:thumbnail_loc><video:title>Medical ML, healthcare and model/feature interpretability - Dan Ofer - PyCon Israel 2019</video:title><video:description>Medical ML, healthcare and model/feature interpretability - Dan Ofer - PyCon Israel 2019</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/a6424bc5-5ce5-4c05-8df0-1ee45fabbf95</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/hRmKSWQoCQTCivTY1FGKr2</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/f1c8d1dc-0da1-40c9-b2d4-3b4e331b83aa.jpg</video:thumbnail_loc><video:title>[heb] Rust is the next Python FFI - Shmuel Amar - PyCon Israel 2019</video:title><video:description>Rust is the next Python FFI - Shmuel Amar - PyCon Israel 2019

The talk is in hebrew.

https://github.com/shmuelamar/rust-python-ffi</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/88767477-bbc7-4379-be7e-ede2196f62e7</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/9oq2X9bnsMZ4wwN2V6evfP</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/156fae2f-f508-4a32-b968-b64851b3aa0d.jpg</video:thumbnail_loc><video:title>PySnooper - Never use print for debugging again - Ram Rachum - PyCon Israel 2019</video:title><video:description>PySnooper - Never use print for debugging again - Ram Rachum - PyCon Israel 2019</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/43ea4891-a621-47ad-9b6c-1f59ce20c727</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/ezJAckegPaz25PypCTn7A7</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/fab8dc6f-e6fe-4d9e-9052-78a3c85a9771.jpg</video:thumbnail_loc><video:title>Model explainability - Idan Angel - PyCon Israel 2019</video:title><video:description>Model explainability - Idan Angel - PyCon Israel 2019</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/6dfc97ff-e26f-462a-83e7-49600c10134a</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/4xwsZA8mPcVMtVD1RDnQm6</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/2740d3c4-d7cf-45c9-838f-f808cd0b07e1.jpg</video:thumbnail_loc><video:title>Serverless orchestration of async serverless workers - Nikolay Grishchenko - PyCon Israel 2019</video:title><video:description>Serverless orchestration of async serverless workers in the cloud - Nikolay Grishchenko - PyCon Israel 2019

https://drive.google.com/open?id=1lGjOhRqfcMp36gpXOKYWByHST5dPxFMY</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/1cb23f70-e96a-4601-b6a5-b7017627cb05</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/dYkqPUTXhHJSeKJajAHA6r</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/28160528-4702-4c32-85de-edb1c1b59d1b.jpg</video:thumbnail_loc><video:title>Automation of feature engineering: pros and cons - Bitya Neuhof - PyCon Israel 2019</video:title><video:description>Automation of feature engineering: pros and cons - Bitya Neuhof - PyCon Israel 2019</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/690b49b9-dc2b-4037-bc2a-ebc102ae880b</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/ouAt2FUrESMKHsL6npCaPK</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/ef9888ed-ff95-42a2-aa1e-f65d4d555955.jpg</video:thumbnail_loc><video:title>Keynote - Python after Guido: The new governance model - Tal Einat - PyCon Israel 2019</video:title><video:description>Keynote - Python after Guido: The new governance model - Tal Einat - PyCon Israel 2019</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/b6271dd4-2ae1-4b9b-b7ad-01ae648b4685</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/bLnWM3tWEFCKt9Ty1mKfyQ</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/643fb910-b512-45d5-a81c-6f57108b74b1.jpg</video:thumbnail_loc><video:title>Fixtures and Test Doubles in Pytest - Gabor Szabo - PyCon Israel 2019</video:title><video:description>Fixtures and Test Doubles in Pytest - Gabor Szabo - PyCon Israel 2019

https://code-maven.com/slides/python-mocking/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/572da2de-c630-4c12-bb2b-8929e5734ae0</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/mVNQACYfoRCB2xHE9Cw6eY</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/16708b6c-6db8-494c-8889-f2f82a185770.jpg</video:thumbnail_loc><video:title>Making our Municipalities more Transparent using Python! - Adam Kariv - PyCon Israel 2019</video:title><video:description>Making our Municipalities more Transparent using Python! - Adam Kariv - PyCon Israel 2019</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/a97a0ed1-42f4-451e-80ad-780f2f6ce9ce</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/9C3cTBTSHJzDKPYxYt3UfA</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/b53cfde0-7e93-420c-b1d0-d598ba37b123.jpg</video:thumbnail_loc><video:title>Hacking Around Enumeration - Mark Geyzer - PyCon Israel 2019</video:title><video:description>Hacking Around Enumeration - Mark Geyzer - PyCon Israel 2019

https://notebooks.azure.com/volcano63/projects/Collection/html/Enumerator.ipynb</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/45d13e6e-de8c-4696-8c20-46d50c35b55e</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/t2jLPCvywvQXXCwjB9x8vH</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/2cbffe0d-1886-4056-ae4b-47915b3742b4.jpg</video:thumbnail_loc><video:title>Beautiful {Automation} System Tests using Pytest - Edward Haas - PyCon Israel 2019</video:title><video:description>Beautiful {Automation} System Tests using Pytest - Edward Haas - PyCon Israel 2019

https://ehaas.net/slides/decks/beautiful_tests/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/dad60e85-9846-4402-a051-aff803a9bc6f</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/cNVDifWKyuT4SZ8Ysp59WZ</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/95eea603-d088-4a33-9e40-6e6bd3bf8931.jpg</video:thumbnail_loc><video:title>AI based triage - predicting late and early mortality. - Talia Tron - PyCon Israel 2019</video:title><video:description>AI based triage - predicting late and early mortality after emergency department visit. - Talia Tron - PyCon IL 2019</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/5fa1cc21-cf46-4d3b-9bbe-a54348537565</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/3Vg4D5hwGhRav4kPUYiNaf</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/32f0943d-878d-489e-9d4a-6996c6114302.jpg</video:thumbnail_loc><video:title>Teaching Thousands Of CPUs How To Read - Roy Penn - PyCon Israel 2019</video:title><video:description>Teaching Thousands Of CPUs How To Read - Roy Penn, Moshe Hazoom &amp; Uri Tsemach - PyCon Israel 2019</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/17a1fad9-2d0a-46e6-a461-6aed06b40978</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/n9byzNCBNv6XBR8qMdRtuw</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/1762f162-e77a-4c4f-a16b-61b9c0caecec.jpg</video:thumbnail_loc><video:title>Logging Like a Pro - The Stuff They Don’t Tell You - David Bordeynik - PyCon Israel 2019</video:title><video:description>Logging Like a Pro - The Stuff They Don’t Tell You - David Bordeynik - PyCon Israel 2019
Slides: https://drive.google.com/file/d/1fPT_kgJNpoP4jHe4ms_ROAy4an5oflyP/view?usp=sharing</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/ab345ef6-288e-4e25-942d-c46749bde74a</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/kcZouWGFPTv7xS5aRvsSg7</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/fbe15521-3b00-4a24-bb5b-a18c85a987a7.jpg</video:thumbnail_loc><video:title>Data Pipelines - Comparing Airflow and Luigi - Orr Shilon &amp; Alex Levin - PyCon Israel 2019</video:title><video:description>Data Pipelines - Comparing Airflow and Luigi by people who have made mistakes in both - Orr Shilon &amp; Alex Levin - PyCon Israel 2019

https://github.com/orrshilon/pycon-israel-2019-airflow-luigi</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/9b8a2ebc-ceb1-4609-9d96-92f5b084c534</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/kv2wv8Co8812gE9gcZ459z</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/da2002ff-1ee5-43f5-a31f-4086415bf969.jpg</video:thumbnail_loc><video:title>Writing user space filesystems - Yuval Turgeman - PyCon Israel 2019</video:title><video:description>Writing user space filesystems - Yuval Turgeman - PyCon Israel 2019</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/9deb24ec-e625-4d89-aef8-06187e988d29</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/c7Dkyfe6azYcQKsAYxi2iX</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/df115dab-62f3-478c-8cc5-86f53f95e3f5.jpg</video:thumbnail_loc><video:title>Python Project Productionization - Yehuda Deutsch - PyCon Israel 2019</video:title><video:description>Python Project Productionization - Yehuda Deutsch - PyCon Israel 2019</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/5a01ff6b-323f-42f7-b0e6-5e1b633fea4d</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/2gZujPWBt6KrAkbu4xdy9g</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/0b57fd1d-4d50-4722-b080-dc4e2564cf11.jpg</video:thumbnail_loc><video:title>Numpy: what has changed and what is going to change? Matti Picus - PyCon Israel 2019</video:title><video:description>Numpy: what has changed and what is going to change?
Matti Picus - PyCon Israel 2019</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/0a54b942-47ee-46cf-af40-91439813a10f</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/r7ZDvHggreJscaVGYXwy8z</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/d0535998-b089-440e-a943-64427a0bc7fe.jpg</video:thumbnail_loc><video:title>[heb] Pylint - Python static code analysis - Gilad Shefer - PyCon Israel 2019</video:title><video:description>Pylint - Python static code analysis - Gilad Shefer - PyCon Israel 2019

The talk is in Hebrew.

https://docs.google.com/presentation/d/1KdJFQ-FFS0LZuoeNhBVGTAbuxTMxgd0QmCiDR3yJBuE/edit?usp=sharing</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/cb6e7487-f9bc-430b-8e37-0763cbaff5d7</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/oCYFh6ZEeUYDrcATuN9jZC</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/a515222a-4b3a-41c3-8fd6-0b9037f9d174.jpg</video:thumbnail_loc><video:title>[heb] Descriptors - Supercharge Your Dot - Miki Tebeka - PyCon Israel 2019</video:title><video:description>Descriptors - Supercharge Your Dot - Miki Tebeka - PyCon Israel 2019

The talk is in hebrew.

https://github.com/tebeka/talks/tree/master/pyconil-2019/descriptors</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/b752c13a-f33c-4b1e-bbc0-ac4e6c53adf6</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/oxqdjLejmfu9KPLvUnk1KW</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/82a28909-2dd7-4ca6-9f00-a304376926c1.jpg</video:thumbnail_loc><video:title>PyCon Israel 2019 event clip</video:title><video:description>PyCon Israel 2019 event clip</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/b68c0763-2cbe-4707-8a2a-ee4ccaab41fc</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/huwDgsEScv45TNp33wgxW2</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/2a9c4adb-133a-4cfb-a6eb-422b77a41c69.jpg</video:thumbnail_loc><video:title>PyCon Israel 2021 - Opening Session</video:title><video:description>PyCon Israel 2021 - Opening Session</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/858deda1-a6fe-4982-be0f-69a334d41111</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/1oWZs43bwNe3kkT4jvZuMM</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/5e21322f-e5db-42fc-8b7a-8921a08a7ff2.jpg</video:thumbnail_loc><video:title>Peter Kogan: Go Beyond Mock: on Mocks, Stubs and Fakes</video:title><video:description>Session language – English
Target audience – Developers, Testers/QA

Developers use the term "mocks" and "mocking" when referring to several different testing practices.

The talk will standardize the terminology of Mocks, Stubs, and Fakes: their capabilities, the differences between them, and when to use each one.

We'll start with defining Mocks, Stubs, and Fakes: their capabilities, the differences between them, and how to code them.

Next, I'll show an iterative code example where we mock the same code using the above three methods. Every time we mock the same code differently, we get to test different things.

The talk summary would be based on the code examples: covering every mock's strengths and weaknesses, when is it appropriate to use each type of testing method, and a general wrap-up.

If you want to test your code effectively, this talk is definitely for you!</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/03344085-ccc1-422a-a59a-ba95d89c6887</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/1zoMQHtT3RaTXb1tcT99V1</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/a9c2c420-e52f-4053-8d71-ee64968377c0.jpg</video:thumbnail_loc><video:title>Oren Matar: Beyond Time Complexity–NumPy, Pandas and vanilla python optimization tricks you must try</video:title><video:description>Session language – English
Target audience – Developers, Data Scientists, R&amp;D

Beyond basic algorithmic considerations when writing our code, you would be surprised how easy it is to get more than 100X increase in efficiency with less than 30 minutes of work without even improving the time complexity.

When operating on big arrays we often fall into old habits of code writing, be it using pandas, numpy or vanilla python. While these habits may optimize the speed at which we write code, they often fall short of the optimal code for run-time. Even saving milliseconds of run time per task can accumulate to staggering amounts. Sometimes despite having very similar syntax between functions and packages there is a huge difference in performance, since the internal workings of pandas, numpy and python varies, as each balances the overhead (or “init”) and marginal cost differently.
We will explore common and run-time costly pitfalls when using pandas and numpy and we will see when it is more efficient to use vanilla python compared to these packages.
I will introduce a profiling method and a timing method. Working with both together can help us detect the weakest points in our code, and quickly test different options for improving it. One of the main points of the talk is how to come up with many code variations and test them quickly to come up with the best solution.
I will present many often-neglected functions from these packages or native, and experiment to see when each is more efficient. E.g. using pandas index vs dict and itemgetter; np, pd or py isin methods; apply vs map; concatenating and appending data to arrays; and many more.
In addition, we will learn of some useful and surprising efficiency tricks and data-structures like sparse matrix, numpy array to replace a dict, clever ways of using memorization and more.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/04a996e6-ba90-4ead-a267-f2e08f773b32</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/aUbbtnDEZvmqaPPtCWpbNe</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/5ec3b558-ab60-41d9-8698-8fe72c088101.jpg</video:thumbnail_loc><video:title>Benjy Weinberger: Python monorepos: what, why and how</video:title><video:description>Session language – English 
Target audience – Developers, Data Scientists, R&amp;D, Managers

This talk will describe the monorepo codebase architecture, explain why you might want to use it for your Python code, and what kind of tooling you need to work effectively in it.

As organizations and repos grow, we have to choose how to manage codebases in a scalable way. We have two architectural alternatives:

\*Multirepo:\* split the codebase into increasing numbers of small repos, along team or project boundaries.
\*Monorepo:\* Maintain one large repository containing code for many projects and libraries, with multiple teams collaborating across it.
In this talk we'll discuss the pros and cons of monorepos for Python codebases, and the kinds of tooling and processes we can use to make working in a Python monorepo effective.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/502b32ad-fc59-4696-b849-bf1b83bb3299</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/aY2dQpVgWdSyeTS8MXj6Pb</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/e191f758-54b9-4baf-bb78-2d8174a08922.jpg</video:thumbnail_loc><video:title>Dean Langsam: Clippy for Python  Let's build a real time code companion by hooking over any function</video:title><video:description>Session language – English 
Target audience – Developers, DevOps, Data Scientists, R&amp;D


Python can do so much, including using python to change python behavior. In this talk, we will see how we can hook over any function in order to create an online “helper” in the style of Clippy for the old Office software. This can be useful for refe

This talk stems from the package I've built dovpanda. dovpanda is an overlay companion for working with pandas in an analysis environment - it hooks over any pandas method and suggests better ways code. We use sys.modules to replace the original function with a modified version while keeping track of the originals using contextmanagers. We then use inspect to understand what parameters were sent by the user so we can employ them to the companion's benefit. Using ast the companion can also understand information about runtime such as checking whether the function call was used in an assignment or part of a complex statement.
Python is so wonderful, as it lets you control Python itself. This really feels like superpowers. In this talk I hope to scratch the surface of a few examples for such superpowers.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/50b4a6d6-284e-497a-9e8c-4ea70e842c84</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/u3dPPBPW1AKe69oGHWPZFY</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/3f62a8bc-2b2d-4d60-b975-3a5050644158.jpg</video:thumbnail_loc><video:title>Drausin Wulsin: Reprogramming immunity with AI and single cell multiomics</video:title><video:description>Session language – English Target audience – Data Scientists, R&amp;D

Immunai has built one of the largest centralized immune single-cell data assets in the world and is using AI with it to expand the boundary of our understanding of core immune biology and how it translates to the clinical setting.

Our ability to interrogate and decipher the immune system has dramatically improved over the last 5 years with major advances in single-cell multiomic technology, both in the wet lab and in silico. Immunai has built one of the largest centralized immune single-cell data assets in the world and is using it to expand the boundary of our understanding of core immune biology and how it translates to the clinical setting. But this massive data asset offers a unique challenge in how to understand individual cell types, patients, diseases and treatments in the context of all the others. Immunai tackles this problem with cutting-edge artificial intelligence coupled tightly with our functional genomics platform, which together identify core biological mechanisms that enable us to develop the next generation of immune system therapeutics.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/e30f45fd-7305-4057-a87f-b9386c32326a</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/eXevXNSfyZrVeSjPyEuJkD</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/d860e389-f1cf-4bfc-8618-ddcd97775637.jpg</video:thumbnail_loc><video:title>Assaf Klein, Hila Weisman-Zohar: Enabling Super Fast DS Research using AutoML</video:title><video:description>Session language – Hebrew
Target audience – Developers, Data Scientists, R&amp;D, Managers

AutoML is a python driven tool we built in Outbrain Recommendations group. In this talk we'll share motivation for creating this tool, describe the general architecture and do a live short demo.

Recently Outbrain CTR prediction system was heavily reworked. In this talk, we will share our key enabler in this journey, a Python-based AutoML engine which allows data scientists to perform faster offline research iterations. This tool is a robust and highly parallel search engine built solely in Python. In this talk we'll share the motivation for building this tool, go through the general architecture and showcases some of its capabilities in a live demo.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/70fd0a31-ec6a-4c42-b4b2-d29f9acb7fdb</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/s3wqQ4fpe8meZzRJWhSbiy</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/eafbed85-9566-4a11-9dd5-a72284dbf4e7.jpg</video:thumbnail_loc><video:title>Ronnie Sheer: OWASP Top 10 in 20   Application Security for the average Pythonista</video:title><video:description>Session language – English 
Target audience – Developers, Testers/QA, DevOps, R&amp;D, Managers

This talk might give you what you need to secure your python application from OWASP top 10 vulnerabilities. We’ll look at examples, tools and quick tips for a more robust code base.

In this hands-on talk, Ronnie Sheer, Head of R&amp;D Hiverr(a Team8 startup) walks through real examples of OWASP top 10 Web Application Security Risks in Python applications. We will then look at small changes you may introduce to your codebase right away to make it more robust. Finally, you may start leveraging OWASP top ten to create a culture of secure coding. Securing Python applications can be an overwhelming task. Leveraging OWASP top ten is a great starting point.

Feel free to check out Ronnie's course on Secure Coding in Python:
https://www.linkedin.com/learning/secure-coding-in-python/developing-securely?lipi=urn%3Ali%3Apage%3Ad_flagship3_feed%3B1gWrlmxFQvO6I%2FYNFmmewQ%3D%3D</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/d2e7d83c-402b-4bab-b1b9-8130f24d1bf2</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/1qCzKpCcrvgsvb7n1NWQE7</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/0a61c791-2991-4220-8efb-77033611e026.jpg</video:thumbnail_loc><video:title>Jonathan Laserson: Automatic Curation of Test sets</video:title><video:description>Session language – Hebrew 
Target audience – Data Scientists, Other (please specify below) 
Other (target audience) – Analysts

Test sets are often designed to have a specific composition of cases, with constraints applied to each sub-population. Treating test-set curation as an optimization problem could save precious time and transition us towards a "data as code" paradigm.

Test set preparation is an essential part of any data science project. It is often the case that the test set is not just a random choice of samples, but rather a carefully designed population, with specific limits on the number of cases from each important sub-group. As the constraints get complicated, it often takes a while to get them all just-right.  In this talk I'll show how to treat the test-set curation as a constraint-optimization problem that can be automatically solved using linear programming. I will demonstrate an open-source python library, curation-magic, which elegantly does this for you, and argue that treating test-sets as an outcome of such optimization is a desired transition towards a "data as code" paradigm.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/03706515-664f-4bb1-9002-ee38974ecaf2</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/tBE2jUaT7yChrQFZyudvK3</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/ee2dd88e-b099-4221-9ee6-b287f2884b93.jpg</video:thumbnail_loc><video:title>Noy Nakash, Avi Naftalis: Novel approach collecting and analyzing data from PyTest w/ Elasticsearch</video:title><video:description>Session language – English 
Target audience – Developers, Testers/QA, Integrators, DevOps, Data Scientists, R&amp;D, Managers

CI/CD is critical for rapid software development, requiring advanced monitoring and logging infrastructure. We will present our PyTest integration with Elasticsearch, leading to significant debug reduction time and infra/product health improvements.

We will present our methods of integrating Python with the Elasticsearch database by using PyTest plugins and other advanced PyTest features. The Python + PyTest infrastructure allows us to gather useful data such as test coverage, infrastructure stability monitors, product health and debug information. We will go over the three different data levels that we are using: the CI/CD Infrastructure, test flow, and validation test coverage. In addition, we will share how this data enables us to achieve a faster, more stable CI/CD, leading to more efficient development and release cycles. Our system is based on Python PyTest and open source tools that can be run via cloud provider or local servers.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/dfa1354b-e795-4fe0-8b67-49c10e0a5a34</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/hArBnCmXnxHWqV2GYEDCNN</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/58e0b139-823e-44a5-bc33-c20c014d9a43.jpg</video:thumbnail_loc><video:title>Oren Matar: Opening the black box – an interpretable neural network architecture</video:title><video:description>Session language – English 
Target audience – Data Scientists

Neural networks don’t have to be black boxes, if you use creative designs and match the architecture to your specific needs, you can create a network as interpretable as linear regression, but without its linear constraints.

Many researchers use fully connected neural networks as a simple go-to model, without trying to match the architecture to the problem at hand. However, thanks to high-level open-source libraries such as pytorch, anyone can construct their own neural network architecture, to fit the requirements of a specific dataset. By creating a logical architecture, which models the generation process of our data, we achieve two goals:
1. Better accuracy on both train and test – since the model generalizes better.
2. Interpretability – we can assign coefficients to different parts of the model, in a similar way to linear regression models, while allowing great flexibility in the actual model.
Interpretability is important as it can help us understand the limitations and failings of our model, and engineer a better model, or collect more features, to improve on these areas.
We will examine a few examples of the limitations of simple fully connected neural networks, as well as other ML algorithms, and see how we can overcome these using architecture concepts anyone can implement in a few minutes using pytorch.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/86614a15-4b33-4082-94cc-1780e3d1b052</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/wQbqzrHweZLsecErEkiqy4</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/012caea8-8029-4f6f-b587-86e63ed4e398.jpg</video:thumbnail_loc><video:title>Haki Benita: Practical Advice for Using Mypy</video:title><video:description>Session language – Hebrew 
Target audience – Developers

In recent year Mypy gained wide spread adoption among Python developers. As it continues to improve and evolve, more and more useful features are being added.

In this talk I preset how to use the Python type system to make your code better and safer!

This talk is intended for both developers that are not familiar with Mypy, and to ones that are. There is something here for everyone!

In the talk I'm going to present the following:

\*\*Basic type annotations\*\*: syntax, installation and usage
\*\*Using types in practice\*\*: demonstrate how typing can be used to improve code using a real life example
\*\*How Mypy works\*\*: understand what type narrowing is, and use it to make Mypy perform  exhaustiveness checking for you!
If you want to make your code better and you don't know Mypy yet, don't miss out on this talk!</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/f9ac48dc-7d22-4128-9c8c-69b9b32b0d7b</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/9DGv44zdwkdCjxGbZEQNwa</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/677081cd-10c7-424f-b9ad-1229a266891d.jpg</video:thumbnail_loc><video:title>Naomi Kriger: String Comparison In Real Life</video:title><video:description>Session language – English 

Target audience – Developers, DevOps, Data Scientists, R&amp;D, Other (please specify below) 
Other (target audience) – Data Analysts

Text analysis in real life can often yield unsatisfactory results due to typos, alternate phrasing, abbreviations and more. In this talk, we'll cover practical and efficient string comparison methods, as well as tackle some commonly faced issues.

A common problem faced by data analysts, data scientists, and many developers who need to analyze and compare data, is that texts are often similar, but not quite identical to one another.
This can result from the existence of multiple ways to say the same thing, typos and abbreviations, common yet unindicative words (such as "the") and punctuation, that can all skew the results.

During this talk, I will walk you through several methods to compare inexact texts, using a few different libraries, cover the usages as well as advantages &amp; disadvantages of each method, and tackle some commonly faced issues.

By the end of the talk, you should have a good basis to start comparing texts efficiently and elegantly in your code.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/460c969d-9eb7-49f8-b996-f58da33e814d</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/mTqigHJSVsCrQ8CsiJhHua</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/521fe113-9170-4edc-a506-6dabffa563cf.jpg</video:thumbnail_loc><video:title>Nofar Betzalel: Prepare for the Unknown   Adjust Your Model to Label Distribution Shifts</video:title><video:description>Session language – English 
Target audience – Data Scientists

Label distribution shift is a significant ‘unknown' our models might encounter when facing the real world once they are deployed. In this talk I will provide practical approaches to assist our models to be more robust to such 'unknowns'.

If someone would have told me a year ago that we'd be wearing masks when walking outside and that my daughter's longest time off kindergarten won't be two weeks at August - I'd never believe it! But that's life - things change rapidly, and previously made assumptions might not remain valid.
Many of us, Data Scientists, find ourselves working hard to train a model, deploy it to live environment and then realize the real world does not behave as we expected it. Our model crashes upon a reality that is much different than what it is familiar with. The root cause for this gap is the unexpected changes that impact our domain's population.
In this talk I will focus on a specific type of 'unknown' change - a shift in the label's distribution. I will not only present how your model can be more agnostic to 'unknown' changes, but also provide practical approaches you can apply to your model.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/a924adf4-2320-4825-baf2-882f0d54bf65</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/24csNSDitoLQ45g5YRZu4b</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/10325860-f973-4fb7-bec1-bd98942d5417.jpg</video:thumbnail_loc><video:title>Yael Green: WebSockets and Flask for the real world</video:title><video:description>Session language – English
Target audience – Developers

Implementing a Flask realtime web application for production isn’t as easy as it seems.
Learn how to use Redis Pub/Sub, Ngnix, uWSGI, signaling, unix socket, mule process, socket.io and more to create a robust realtime app.

socket.io enables real-time, bidirectional, event-based communication between the browser and the server.
Ideally Pythonists running a Flask application would simply use the Flask-SocketIO library, yet Flask alone is not suitable for production and must be hosted by a real web server. Thus requiring additional development to enable the usage of socket.io.

Our Framework consists of a uWSGI server running Flask instances and other services behind a Nginx proxy. We will share a full working solution of a framework setup that supports Flask realtime web application in production.

The framework includes Redis Pub/Sub to publish events from any service, a mule service to listen to events, uWSGI signaling to notify all workers, socket.io on a Redis backend to allow lazy-apps, a new Nginx mapping and another http listener in the uWSGI server.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/088b6f0e-04a1-4691-aaae-1fcf9f0c2720</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/oo9ZozWTRhifyKMS9vkob4</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/c36a98ca-b306-4d56-8266-d02b7416ed45.jpg</video:thumbnail_loc><video:title>Lior Segev: How to Test Microservices</video:title><video:description>Session language – English
Target audience – Developers, Testers/QA, Integrators, R&amp;D

I'll present a tiered approach that allows testing microservices quickly and thoroughly. The tests use stateful mocks of other services, and thus allow concise tests as well as simulating outages, subtle timing problems and large datasets.

Microservices are fantastic, but a pain to test in complex interaction scenarios. Unit tests are quick and easy, but don’t cover interactions. System integration tests are a standard way to address complexity, but take a huge effort to maintain and a lot of resources to run. How can we get the best of both worlds?

In this talk, I’ll present a tiered approach that enables writing tests quickly without sacrificing coverage. The tests use stateful mocks of other services mediated by a verification layer. I’ll talk about how this approach allows testing of insidious failure modes, such as failures within dependencies and narrow race conditions, both of which are almost impossible to achieve in integration tests.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/b540f413-444a-4a77-bf79-38e1e0ccb827</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/e9wgWZ9npRKu9yrx78NyfH</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/13868cd9-7e2c-4146-8dda-251f19fb1287.jpg</video:thumbnail_loc><video:title>Hodaya Stern: Be a Pythonista   Coding and Life Lessons Learned from Python</video:title><video:description>Session language – Hebrew
Target audience – Developers, Testers/QA, Users, DevOps, Data Scientists, Other (please specify below)
Other (target audience) – All levels of python users who are not experienced specifically in Python

Programming requires a logical mindset, which can be used to introduce strategy into your daily life. Join me, as we review pythonic best practices, constructs and concepts and see how to take advantage of them both at and away from the keyboard.

Most people think of programming as a technological medium to accomplish a task. While this is definitely true, there is a lot more that you can get out of python than for loops and dictionaries. Thinking like a python developer enables you not only to code better, but also to incorporate programming best practices and strategies in your daily life. It also doesn't matter what type of application or script you are writing, by learning python concepts, constructs and best practices, you will be able to take full advantage of what the language has to offer.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/6a77690c-bb0a-471a-ae7f-c8a55afb2875</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/vZtyGXydbrjAgYGNDejpGN</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/2ddfeb3f-9f69-450a-ba4f-279759c20354.jpg</video:thumbnail_loc><video:title>Yehuda Levian: Cleaner SW architecture using python annotations</video:title><video:description>Session language – Hebrew
Target audience – Developers, Other (please specify below)
Other (target audience) – all kind of expert programmer.

While many developers struggle with the question, “should or shouldn’t I use python annotations?”. I would demonstrate how proper usage of python annotations guide the developers to refine the structure of the written code.

In the “The Clean Architecture” article, Uncle Bob explains the fundamentals principles of “clean” and fine coding. In this lecture, I would show how using python annotations helps the developer to follow those rules.
Python annotations are considered by many as redundant or nice to have, yet I will demonstrate how Python annotations, along with making the code more readable also enhances the chosen programming structure.
I will start the session with a brief introduction to what is considered, by uncle Bob, to be a “clean coding architecture” and continue with practical day to day examples.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/f2df6723-8e3c-4148-bd41-7ab4d0f5a1ba</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/1McSQi7rM2X6sXhzNi1nzF</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/6a7c7da4-cdfa-49c7-8a44-0823336bdcb1.jpg</video:thumbnail_loc><video:title>Uri Goren: Natural language grounding   the next frontier</video:title><video:description>Session language – English 
Target audience – Data Scientists, Managers

We all heard about huge transformers that cost millions of dollars to train, and achieve amazing results. But is there still room for the little guy, with a single GPU and a small budget to innovate in NLP ?
Well, have you heard about grounding ?

We all heard about huge transformers (e.g. gpt3, dale, etc) that cost millions of dollars to train, and achieve amazing results. But is there still room for the little guy, with a single GPU and a small budget to innovate in NLP ?

In this talk we would describe the natural language grounding technique, that takes world context into account and achieved impressing results.

We would demonstrate how instruction parsing could be done more efficiently with a grounded representation.
And we will will discuss the similarities with pragmatics (in linguistics).</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/064fc9eb-fdc9-4133-8792-fa46670b09a5</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/oZ1AYHp8VVUhcAyyAGeiTd</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/bbe9326e-29a6-438f-b616-c339f5a22eb9.jpg</video:thumbnail_loc><video:title>Stav Shemesh: What’s Everyone Talking About   Discovering Topics with Sentence BERT</video:title><video:description>Session language – English 
Target audience – Data Scientists, R&amp;D

Topic Modeling’s objective is to understand and extract the hidden topics from large volumes of text. Using a technique based on Sentence-BERT, we were able to perform the extraction of meaningful topics, and present some evaluation approaches.

Topic modeling is an information retrieval technique for discovering meaningful and interpretable topics in a collection of documents. It allows us to learn something about a set of documents that is too big to read.

In this talk we will cover how we leverage Sentence-BERT using the NLP Python framework sentence-transformers. It provides an easy method for extracting high quality sentence embeddings in a computationally efficient manner, which lays the basis for our topic modeling algorithm.

We will also be addressing the inherent difficulty of evaluating topic models by introducing measuring metrics and visualizations that aid the process of analyzing complex results.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/ba1ed12a-ff43-43be-85e8-ae21a15190c6</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/t6L8YPZHbL1GxLZZekwdob</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/3950f489-d379-4a4f-be6d-9261afd5cd1c.jpg</video:thumbnail_loc><video:title>Adam Kariv: Geographic Data   an Introductory Tale</video:title><video:description>Session language – English 
Target audience – Developers, Data Scientists


An introduction to Geographic Data, some of its basic concepts and common Python tools for working with it.

At some point in life there might come a time where you might need to work with geographic data.
Instead of waiting in dread for that day, it's best to be prepared!

In my talk I'll explain a bit about geo-data types, formats and concepts, and existing Python tools to easily work with it - all while working through a fun and quirky(?) sample case that we'll solve together.

Link to the presentation's notebook:
https://github.com/akariv/pyconil2021/blob/master/PyConIL2021.ipynb</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/db74a9d5-fbc5-486a-a257-59794151d176</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/4exCJ8xeM7dCdNpx7uNvni</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/7871b47c-2bcc-4912-a3cd-92cf9eea5197.jpg</video:thumbnail_loc><video:title>Hanan Shteingart: Causality in Python</video:title><video:description>Session language – English 
Target audience – Data Scientists, Managers 
Other (target audience) – business analytics

Most data scientists are focused on predictive (aka supervised) projects, yet the real growth is usually in the estimation of action effects and optimizations of action policies. To this end, I will present causal inference and related packages.

There are three layers of analytics: descriptive (BI), predictive (supervised modeling), and prescriptive - the latter, the less-known one, focus on answering the most important business questions. For example, "what was the effect of giving a discount" ( or "what should I do to create the desired effect" - In this talk, we will first discuss what frameworks are used to answer these questions, namely causal inference, and reinforcement learning. Then we will deep dive into CI and discuss in causality crash 101 courses why is it important. Last but not least we will present existing causal-inference open-source packages and their limitations.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/1a2f9463-f7f3-4810-991a-050fc65b6dd7</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/6yaX7CcDb9yTMJpTc12oBQ</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/8af0d938-dfba-4eba-a59c-d098791eace8.jpg</video:thumbnail_loc><video:title>David Melamed: Building a Secure Python Cloud Application from scratch</video:title><video:description>Session language – English
Target audience – Security Experts, Developers, DevOps, R&amp;D

When is it the right time to implement security when building an app? In this talk, you will learn how to build from scratch a secure Python application hosted in the cloud, the major attack vectors and tools you need to remediate to the main risks.

When do you think is the right moment to worry about the security of the application you develop in the cloud? The first time your customer requires it to buy your product, or should you just wait for the first security incident? I strongly believe that it is never too early to think and act towards securing your environment and your product, otherwise security becomes some unmanaged technical debt that just accumulates with every single line of code.

In this talk, you will learn how to build a secure Python application hosted in the cloud from scratch. You will discover what are the main common threats and attack vectors you need to fight, the tools you need to leverage to remediate to the most critical risks and how to continuously monitor the security of your application and environment.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/2cfba041-4b01-409b-8cdd-0f30022e697e</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/s94KntEsNTdfbsxxepXqhL</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/089c688a-f11c-47e8-80a5-09d7491c389f.jpg</video:thumbnail_loc><video:title>Yama Anin Aminof: Fun With Trees  Get to the Root of Song Classification</video:title><video:description>Session language – English 
Target audience – Data Scientists, R&amp;D

Join this session to hear about my journey with tree-based classifiers, while tackling the problem of classifying songs into different genres. Learn how XGBoost works and what makes it so popular.

Tree-based models are some of the most common machine learning models used today. It makes sense- the basic concept is easy to grasp and easy to work with.
In this talk, we will dive into the concepts behind the names Random Forest and XGBoost, and discuss the advantages and disadvantages in comparison to other machine learning models. On the music side, we will discover how to extract features from songs and how to use them to differentiate between genres.
This talk is intended for anyone with basic familiarity with machine learning that would like to deepen their understanding in the subjects of tree-based models, classification, and how to apply machine learning to songs.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/d3addd6e-17d1-462f-a2d3-9dc37ee8f094</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/kk2TV7uyxt9kFokbU2AaGf</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/9bce6d21-ec39-4f01-bb9c-89e6553fac25.jpg</video:thumbnail_loc><video:title>Gal Ben David: Leaving Celery in the Dust   How to truly scale in production</video:title><video:description>Session language – English
Target audience – Developers, DevOps, R&amp;D

When we first developed our system, we picked Celery due to its wide community adoption. When we started scaling our systems, we realized Celery was pulling us back from many different angles. We decided to replace Celery with our own technology.

Back in the days at Intsights, we architectured our platform based on a distributed task queue approach. Looking for an available library and devices to support our approach, we met Celery. According to Celery's documentation, Celery is a simple, flexible, and reliable distributed system to process vast amounts of messages while providing operations with the tools required to maintain such a system. It's a task queue with a focus on real-time processing while also supporting task scheduling.

For Intsights, Celery did not live to its promise. It did not scale and was highly bloated with metrics and communication overhead. Nonetheless, Celery did not introduce enough thread/process safety to handle problematic workloads that might fail, crash or get stuck on special occasions, such as a stuck GIL due to an infinite Regex.

At some point, we realized that our only option is to develop our own solution. We decided to stop chasing Celery bugs and be focused on what fits Intsights best. At first, we were inspired a lot by Celery's design. We implemented result backends, timeouts, and pipelines. We stuck to Celery's terminology to make the migration easier. Later we ditched most practices and introduced our own.

Today, we have a high performant, highly stable, and safe library that supports our use case in a perfect manner. Sergeant is meant to be very simple, very fast, very stable, and safe. Still, many features are missing or left out. We only support Mongo and Redis as backends. We do not guarantee consistency of task order and consumption. These compromises let us stay very simple to maintain and to focus on stability and performance. The library supp...</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/9c85ef1e-f072-4e32-88ef-e6e4f96d5842</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/2ssCaUamRtcUMt4BGWx499</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/ffeec1a5-5c0e-4005-a649-670918224c36.jpg</video:thumbnail_loc><video:title>Nathalie Hauser: Model Agnostic Interpretation Beyond Shap and Lime</video:title><video:description>Session language – English
Target audience – Data Scientists

I’ll discuss an interpretation framework that allows use of the features’ distribution to understand the direction of the feature’s impact. The concept is derived from ideas formulated in Pearl’s analysis of causality in his book “the book of why”.

The subject of interpretability becomes very important as models grow more and more complex but humans need to reason them. Since we don’t want to be blocked by the model’s algorithm (for example, if we want to bag several models), the community offers solutions that are based on alternatives analysis - local assessment, shuffling features, etc.

In this talk, I’ll offer a framework that allows use of the features’ distribution to understand the direction of the feature’s impact, both on the entire sample’s level and for specific observations. The inner workings of this method is highly intuitive and straightforward, and its concept is derived from ideas formulated in Judea Pearl’s analysis of causality (check out “the book of why” for more info).

I’ll present a specific use case of tabular data from Bluevine, and compare its performance to available solutions. I’ll also mention directions for applying a similar method to additional fields.

Nathalie Hauser,
Data Science Manager @Bluevine</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/0bcae252-d4d1-4e10-b244-429e7afad5bc</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/cdLenc6gmxrnLhRncXUSC5</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/2c9b9883-30ca-449c-84fc-fde3512cc3c6.jpg</video:thumbnail_loc><video:title>Adam Hopkins: Liberate your API: Building a task manager inside Sanic</video:title><video:description>Session language – English
Target audience – Developers

An inside look at some of the tools inside Sanic to help build a background task manager.

You are building an API when, inevitably, you realize that certain requests are super slow to respond. It dawns on you that you really need to push some work off to a background process. How should you do it?

We will explore some of the tools that exist inside the Sanic framework that will enable us to do just this. From the simple task, to complex multi-node cluster: we will look at different strategies to determine the most appropriate tool for the job. Think celery, except entirely within Sanic.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/5adcb55e-a492-43d1-ae67-cb5cedc0bf64</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/dEJyVmFMHuCf4cWrC3EQnA</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/923c1eff-9229-47ba-8948-91f3c746c800.jpg</video:thumbnail_loc><video:title>Nir Barazida: Set your EDA on Autopilot</video:title><video:description>Session language – English 
Target audience – Data Scientists

This session will focus on one of the hottest topics of the past two years in the data science ecosystem - Automated Exploratory Data Analysis.

Recently Andrew Ng held a conference where his main claim was that we should be more data-centric in our research. He based his doctrine on various studies and examples that showed significant improvement in model performance once the researchers modified the data.

"If 80% of our work is data preparation, then ensuring data quality is the important work of a machine learning team."  
Andrew Ng 

To provide the model with strong foundations, we must explore and process the data professionally and meticulously. It can be a very long and exhausting process. To help you get through this part successfully, the new 'Automated EDA' field has emerged.

In the lecture, we will explore the field of automation in ML and how it corresponds with the variability of the projects. We will examine what can be automated in EDA and explore the latest feature of two powerful open-source tools - Pandas Profiling and SweetViz.

The audience will receive a link for the sides and to a Colab notebook with examples for:

* Exporting EDA report using Pandas profiling and SweetViz.
* Exporting EDA report that compares two data sets.
* Exporting EDA report that compares two categories.
* FAQ</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/6696290f-142b-43a4-bfe6-8cd328aa4674</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/r1sxN8ngXq8kQbCyEKDamD</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/56c3bc0c-eddf-4357-ab12-edfb9b1442c8.jpg</video:thumbnail_loc><video:title>Ari Bornstein: Deep Learning, Minus the Boilerplate with PyTorch Lightning</video:title><video:description>Session language – English
Target audience – Developers, Data Scientists, R&amp;D

This talk introduces PyTorch Lightning, outline its core design philosophy, and provides inline examples of how this philosophy enables more reproducible and production-capable deep learning code.

PyTorch Lightning reduces the engineering boilerplate and resources required to implement state-of-the-art AI. Organizing PyTorch code with Lightning, enables seamless training on multiple-GPUs, TPUs, CPUs as well as the use of difficult to implement best practices such as model sharding, 16-bit precision and more, without any code changes. This talk introduces PyTorch Lightning, outline its core design philosophy, and provides inline examples of how this philosophy enables more reproducible and production-capable deep learning code based on work the following post https://opendatascience.com/pytorch-lightning-from-research-to-production-minus-the-boilerplate/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/ca84d3d0-e1c9-4b1f-8cd5-670cf2d6fa29</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/bXB4F37kty8gqGMnAAWxxR</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/19e6e44c-bc52-4f47-a3b2-de317f14a507.jpg</video:thumbnail_loc><video:title>Reuven Lerner: When is an exception not an exception? Using warnings in Python</video:title><video:description>Session language – English
Target audience – Developers, Testers/QA, Integrators

Python's warnings are exceptions — but they're also distinct from exceptions, and are both used and trapped differently. In this talk, I'll introduce warnings, how to raise, trap, and redirect them, and show you best practices for their use.

If your code encounters a big problem, then you probably want to raise an exception. But what should your code do if it finds a small problem, one that shouldn't be ignored, but that doesn't merit an exception? Python's answer to this question is warnings.

In this talk, I'll introduce Python's warnings, close cousins to exceptions but still distinct from them. We'll see how you can generate warnings, and what happens when you do. But then we'll dig deeper, looking at how you can filter and redirect warnings, telling Python which types of warnings you want to see, and which you want to hide. We'll also see how you can get truly fancy, turning some warnings into (potentially fatal) exceptions and handling certain types with custom callback functions.

After this talk, you'll be able to take advantage of Python's warning system, letting your users know when something is wrong without having to choose between "print" and a full-blown exception.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/58bee709-d3d9-4281-b0ee-cd0c3f768623</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/9bEWuTqDnZ1KHvYD89yyeV</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/a13cba1a-be72-451c-9e78-0f0b15b5cde0.jpg</video:thumbnail_loc><video:title>Asaf Sarid: Cutting the Right Corners: Handling High Cardinality by Understanding Your Data</video:title><video:description>Session language – English
Target audience – Developers, DevOps, Data Scientists, R&amp;D

Handling high cardinality with big data can be challenging. We improved our pipeline speed and stability by understanding which data matters more and creating a smart “Cardinality Protector” to reduce cardinality with minimal effect on the data.

As a marketing analytics platform, Singular handles and ingests billions of user events on a daily basis, along with all the marketing data pertaining to each event: Was an ad clicked? When and where? Which network served that ad? How much did the ad cost? And much more. The data is then aggregated so our customers can use it to make informed decisions in their daily marketing operations.

As our operations scaled, we have experienced cases where the sheer number of events, with the large number of columns saved per event, some of which have high cardinality, slowed down our data ingestion pipeline. It ate up CPU, memory and network resources to the point of affecting the user experience. The burden on the system was exacerbated by click spam: a type of fraud where automated tools simulate millions of ad clicks. Click spam increases the already high load on our pipeline.

Our challenge was to reduce the amount of data we ingest, improve our pipeline speed and stability and provide a better overall user experience. But we couldn't just remove excess rows as all rows are essential -- including ones that represent possibly-fraudulent clicks. Our customers want to measure click spam activity and find out where it originates. However, is it possible to retain the necessary information but still reduce the cardinality of some columns?

This was the starting point for what became the "Cardinality Protector." In-depth research into our data helped us prioritize all the columns and metrics by their importance to customers. We then created smart rules in order to cut out some of the most extreme cardinality with minimal effect on the data.

In t...</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/42468b5c-1d04-4782-98d4-972137a0e2c7</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/edMFq74vZJ5XwWkdH2aTue</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/b84fed29-a0f8-4f90-ad17-29f5c55c3e77.jpg</video:thumbnail_loc><video:title>Nikolay Grishchenko: Serverless Python</video:title><video:description>Session language – English
Target audience – Developers, Users, Integrators, R&amp;D, Managers

The time has come for almost every Python developer to build new applications following the serverless paradigm. This talk is 300 level describing the most important principles of serverless application architecture.

We shall learn the main benefits of micro-micro services as well as the main challenges when building this kind of applications. As a bonus: some ways to deal with these challenges and several common serverless architecture patterns.

Agenda
- Why Serverless? (15 min)
- Limits. Why they exist and how to fit them. (5 min)
- How to orchestrate. (5 min)

Speaker
Nikolay Grishchenko. 20+ years programming, 7+ years in Python, 5+ years with serverless applications.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/6b0fe0fd-0515-4d36-87d8-86af3b894429</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/9Q5CCaZcF9zGgd36vrovwD</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/d5c6eaae-897c-4e9e-9973-b5d58ef9e184.jpg</video:thumbnail_loc><video:title>Yair Beer: Python bottleneck optimization   progression from lists to cupy arrays</video:title><video:description>Session language – English
Target audience – Developers, Data Scientists, R&amp;D

In optimization problems speed is important, but unfortunately python isn't optimized to speed. In this talk I'll show how to use python and optimize bottleneck functions to be as fast as possible using different libraries and methods.

In this talk I'll present how to optimize the running time of a bottleneck function, progressing from using python lists to cupy's arrays. CuPy is a relatively new library that allows running calculations on the GPU using an API similar to NumPy.

I'll cover a few optimization techniques such as vectorized data structures, a-priori calculations and parallel operations.
I will also showcase how to time the function and simple profiling.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/477faa1a-8de4-4dc4-be05-1b2406c1ab65</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/b5dU8gMcV2uXgJuFLXYfG1</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/c122b5a1-c52a-46dc-9921-db33e4722f17.jpg</video:thumbnail_loc><video:title>Jacob Barhak, James Bednar: Using Python HoloViz Technologies to Create Interactive Presentations</video:title><video:description>Session language – English 
Target audience – Developers, Users, Data Scientists

The tutorial will introduce two interactive plots libraries: HoloViews, and panel and show how those can be used to create static html files with interactive graphics

The HoloViz project provides a set of Python libraries for high-level visualization of complex datasets. They are particularly useful for handling big data and multi-dimensional data that is common in machine-learning applications.
HoloViz technologies support multiple graphical engine backends and integrate seamlessly with flexible development and deployment environments like Jupyter notebooks and modern web browsers. The visualization outputs are interactive, with features such as widgets like sliders or selection boxes or hover tools to inspect data, while not requiring any JavaScript, HTML, CSS, or other web-technology expertise.
This tutorial will focus on two HoloViz libraries:

HoloViews: high level interface providing plots (heat maps, histograms, spikes, etc.) in many spatial and temporal combinations, with or without widgets for selecting along dimensions
Panel: simple application and dashboard creation from images, plots, Markdown, LaTeX, and other elements into one HTML page incorporating interactive tabs and widgets.

During the tutorial an interactive presentation will be constructed to show the attendees how to construct their own interactive poster / presentation.

The interactive presentation file can be accessed through this link:
https://jacob-barhak.github.io/Presentation_PyConIL2021_HoloViz.html</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/51924f90-3a5e-4cc4-a185-5da13669f578</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/aYgouLsQQn4on2fikYF4WD</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/71127170-e4ec-4fa4-bb75-563fb8398041.jpg</video:thumbnail_loc><video:title>Marina Shvartz: Testing stochastic AI models with hypothesis</video:title><video:description>Session language – English
Target audience – Developers, Data Scientists

In this talk, I will cover shortly the theory of property-based testing and then jump into use cases and examples to demonstrate the hypothesis library and how we used it to generate random examples of plausible edge cases of our AI model.

Over the years, testing has become one of the main focus areas in development teams, a good feature is a well tested one. In the field of AI this is many times a real struggle. Since eventually most advanced AI models are stochastic - we can’t manually define all their possible edge cases. This led us to use the hypothesis library which does a lot of that for you, while you can focus on defining the properties and specifications of your system.

In this talk, I will cover shortly the theory of property-based testing and then jump into use cases and examples to demonstrate how we used the hypothesis library to generate random examples of plausible edge cases of our AI model.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/50bd61d5-ab36-4d67-aaba-a929ae768685</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/1vEf6roDF5wy5y7iJCiNgB</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/562a4331-5a61-4bb2-a756-4d7c3a684bd5.jpg</video:thumbnail_loc><video:title>Ron Shilo, Pavel Rogovoy: Versioning 1 0 1</video:title><video:description>Session language – English 
Target audience – Developers, Testers/QA, Users, Integrators, DevOps, Data Scientists, R&amp;D

We introduce a very useful tool called "vmn" for auto increasing your application's version number in an agnostic way to language or architecture. You will learn how to use vmn for your application and how to integrate it to existing CI/CD procedures

Link:
https://github.com/final-israel/vmn

Problem statement:
Today there is no standard way for increasing application's version, retrieving it or going to a specific
version with the exact dependency it was once released with. These are the issues vmn tries to solve. In this talk we will include different real world use cases and will invite others to collaborate and get involved in the project's development.

Walk aways:
The attendees will learn how to stamp their current applications with vmn</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/0424232d-886c-4e32-bc30-c27f7792c069</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/4Q19w5jAyxTS5EdEhRjxLH</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/1e676baf-7e0b-4402-a2ad-fe0bc93c2f66.jpg</video:thumbnail_loc><video:title>Bat-El Ziony Sabati: Python’s Frontend, Not what you would think</video:title><video:description>Session language – Hebrew
Target audience – Developers

Most programmers consider Python as a scripting or a server side language totally unsuitable for UI . In Imubit we decided to use Jupyter Lab in order to combine Python's powerful server side abilities with a beautiful UI.

While Jupyter is widely used for big data or data science, we decided to use it to easily develop a streamlined work process for our engineers. With just a small amount of effort, we were able to create beautiful, easy to use Python user facing applications for non-technical users.
We will start by describing Jupyter Lab Extensions, then we will get a glimpse of some of Python’s frontend packages (Ipywidgets, panel, Ipyaggrid etc.), and learn how to use them and expand them with our own custom logic.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/1eff351b-9b95-4230-ad98-8f85f7c69bdd</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/kfmiegXppEZg3d4sx1nCeW</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/6ee5adff-4dc3-4d80-9104-e0d89986d070.jpg</video:thumbnail_loc><video:title>Roee Drucker: Lock &amp; roll   Advanced locks debugging with GDB</video:title><video:description>Session language – English
Target audience – Developers, Testers/QA, Security Experts

In this talk we'll use a real-life use case to learn how extending GDB with Python can help us to solve bugs, all while digging deep into the internals of Python locks and how they're implemented.

Debugging deadlocks is hard. Debugging deadlock in production is even harder.
This talk will demonstrate how Python’s state can be debugged in production using GDB and how can we easily add it to our debug toolkit. There's much we can do with extending GDB with Python to better understand the internals of the language, and even to customize it to our own debugging needs.
We'll learn about CPython's locks, how they affect us, and how to debug a multithreaded Python process in real-time using GDB.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/9bde8e4a-4a6f-4ea1-b668-e1e3e6f0c5e0</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/2Fvdposnk4nK9XRweBrfQN</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/794d2390-5ac1-48f3-8a77-5f59941f717e.jpg</video:thumbnail_loc><video:title>Gal Braun: Malware Representation Using Graphs</video:title><video:description>Session language – English
Target audience – Security Experts, Data Scientists

In the world of malware detection, we need to keep innovating all the time to catch the latest APTs. Let's see how can we do it with recent developments in graph analysis using neural networks

In the last decade, we suffer a new epidemic - Advanced Persistent Threats (APTs).
It seems like every other week a new kind of malware is born and the attack vectors are becoming more and more sophisticated. from pinpoint targeting of specific machines to massive infection of every machine it tackles on its way.
To be able to cope with a large amount of incidents happening every day in the “Everything is connected” age, assigning a human security researcher on every case is expensive and practically impossible.
Although sometimes considered as black magic - In recent years we can see the increasing usage of machine learning for malware detection and classification. The suggested solutions, inspired by various fields as Computer Vision and NLP, are implementing cutting edge solutions into the cybersecurity field.
In this talk, I’ll show how to use graphs to represent malware and how to use graph embeddings and GCN (Graph Convolutional Networks) to tackle such tasks as malware classification and detection, to help security researchers do their job in a faster and more efficient way.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/0d9d263c-b738-4b8a-9632-e65f21b53c3e</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/bVrLWkqdaz5NZRhERFBk4N</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/dedf91fc-5e6b-41d5-82e8-06ca221c96b8.jpg</video:thumbnail_loc><video:title>Noa Lubin: Harnessing Data to Improve Healthcare</video:title><video:description>Session language – English 
Target audience – Data Scientists

In this talk, you will learn how at Diagnostic Robotics we create insights from claims data, a form of administrative data at large scale, which provides a great opportunity for AI in healthcare. You will understand how we use medical code embeddings

In this talk, you will learn how at Diagnostic Robotics we create insights from claims data, a form of administrative data at large scale, which provides a great opportunity for AI in healthcare. You will understand how we use medical code embeddings and deep learning methods to build predictive proactive models that benefit the patients and reduce the cost of healthcare. We will also discuss the concept of causal machine learning, its use to emulate randomised controlled trials and see how it’s related to our models.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/5871b0d0-4328-4994-b415-eb516bb6e790</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/gQK1BTZwB2fX4tBpHs3ATu</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/494e5c2b-c9ce-4733-83df-ed894d8768e2.jpg</video:thumbnail_loc><video:title>Yaron Michl: mapping and analysis of geospatial big data using geemap and Google Earth Engine</video:title><video:description>Session language – English
Target audience – Developers, Users, Data Scientists, R&amp;D

Google Earth Engine (GEE) is a cloud computing platform with a multi-petabyte catalog of satellite imagery and geospatial datasets. It enables to analysis and visualizes changes on the Earth’s surface using python API,

Google Earth Engine (GEE) is a cloud computing platform with a multi-petabyte catalog of satellite imagery and geospatial datasets
With the new geemap Python package GEE users can easily manipulate, analyze, and visualize geospatial big data interactively in a Jupyter-based environment.

The topics will be covered in this lecture include:
(1) Brief introduction satellite imagery,
(2)introducing the Earth Engine Python API and the new geemap Python package.
(2) searching GEE data catalog .
(3) displaying GEE datasets.
(4) classifying images using machine learning algorithms.
(5) Finding the greenest place in Israel in terms amount of vegetation.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/80474981-2f83-483f-b5c7-0cbace496d42</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/675V2GSSW4CDr3oqGjaDtR</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/e636b4be-30c9-4e6c-83ec-084d94a50967.jpg</video:thumbnail_loc><video:title>Tal Franji: Genomic data   cost effective scaling in the cloud</video:title><video:description>Session language – English 
Target audience – Developers, DevOps, Data Scientists, R&amp;D

Genomic sequencing and processing data amounts to many terabytes of data. We'll present how single-cell processing pipe-line requires strong/eventual consistency trade-offs which are different from traditional big-data systems.

immunai runs a complex single-cell RNA sequencing pipe-line. The computational-biology and machine-learning tools eco-system revolves around R and Python. We use cost-effective cloud-storage for the large sequencing files while combining them with strongly consistent meta-data. R/python API users can retrieve the data indexed by any application defined set of labels/features. We will discuss the tradeoffs compared to other big-data platforms like Apache Spark, Elastic Search etc.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/29572f39-169e-4d93-aa34-e66093cd710b</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/5g4wqvuyV9TtXqMWf5T7hH</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/b6be7b44-456d-4f94-9e14-a58a7cf6efb4.jpg</video:thumbnail_loc><video:title>Chai Tadmor: FastAPI - The most modern Python3 web framework</video:title><video:description>Session language – English 
Target audience – Developers, Users, R&amp;D

FastAPI is a modern, high-performance, batteries-included Python web framework that's perfect for building RESTful APIs. It can handle both synchronous and asynchronous requests

With Python2 deprecated and the rise of Python3, a new world of features and projects have opened up. FastAPI is one of those projects. Heavily inspired by Flask, FastAPI has a lightweight microframework feel with support for Flask-like route decorators. This means that moving from Flask to FastAPI is easy. It takes advantage of Python type hints for parameter declaration which enables data validation (utilizing Pydantic - another great Python3 project) and OpenAPI/Swagger documentation. It's super fast. Since async is much more efficient than the traditional synchronous threading model, it can compete with Node and Go with regards to performance. In addition, it uses uvicorn - the async lightning-fast answer to gunicorn.

In this talk I will introduce you to FastAPI, why we at Insidepacket chose to use it as our web framework and how to migrate from Flask to FastAPI</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/227ee21d-1ea4-4a46-886b-82674bd40799</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/pNHJMVaQWWFGfyQ9i6fgDD</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/b8eaad09-80e3-4348-83f8-cad2c535081c.jpg</video:thumbnail_loc><video:title>Or Ben-Zeev: Python code in an object store, Go fast to production and don't break things</video:title><video:description>Session language – English
Target audience – Developers, Testers/QA, Users, Integrators, DevOps, R&amp;D, Managers

Loading python code from a remote location during runtime opens new world of opportunities (and challenges).

As we all know, python is a very versatile language. You can do a lot with python, from ‘scripting’ to ‘software development’, it can be interpreted and also compiled as most of us know .pyc files and some of us know .pyd files.

Another thing that can be done using python is ‘webImport’ or ‘http import’, it means importing a python module from the web. Using code that comes from a remote source can open us a new domain of possibilities, and a totally new domain of problems, risks and challenges.

In JPMorgan we have the Athena project, it has a huge python code base, probably the largest in the world. The athena ‘special’ python interpreter imports code from an object store and enables us to do many things:

Pros:
· A very fast way to update many services out there, as you just need to update the “public location”
· You do not have to create ‘large updates’ and push all the changes coming from different teams to production, if one developer is done, he can just push his own code to production without waiting for the ‘release time’. Even though the code base is large, updates are very fast
· Code could be updated after the artifact\container is ‘sealed’
· The code base\program can be very large, ignoring the size of the artifact
· Fixes and pushes to production can be very fast
· New tests can check the code computability of both the coming and the previous releases (for an instance, on git, if you store the tests in the same repo as the code, it will be very hard for you to write a test case, show that’s is failing on the released version, and prove that it passes on the fix you made)

Cons:
· Requires investment
· Loading modules can sometimes be slower than loading from disk
· Need to find a solution for code inconsistencies
· Code could be u...</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/c0c81fda-5332-40b3-b6e8-bbad0f8bbac3</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/t1MJB8K1ScsLCBBjaXtVtf</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/c99455da-0982-4f6c-9dfa-8b4e57ac3b68.jpg</video:thumbnail_loc><video:title>Reuven Lerner: Avoiding memory leaks with "weakref"</video:title><video:description>Session language – English
Target audience – Developers, Users

In Python, we normally don't worry about memory usage. But that doesn't mean memory leaks are impossible! In this talk, I'll introduce "weak references" -- how they work, when you would use them, and tricks to get the most out of them.

One of the great things about Python is that it includes garbage collection. You don't have to allocate or free memory; just let the system take care of things on its own! In theory, that means you can never experience memory leaks. But in practice, that's not quite true: There are definitely ways in which you can accidentally hold onto object references, resulting in a memory leak.

Fortunately, Python provides us with "weak references" in the standard library's "weakref" module. In this talk, I'll describe Python's garbage collector, and how we can end up with memory problems despite it. I'll then show you how the "weakref" module can help us -- both on its own, and with the data structures and functionality that the "weakref" module provides.

Even if you don't need weak references, knowing how they work can give you great insight into Python's internals, and how you can take advantage of them in your work.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/dac2edc3-089f-40c6-954f-cf2d7ee20ce8</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/rxjjE46YZMnf7MAjxUdk9p</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/7dbacfe5-b38b-4ec8-8ee4-86447364b3fd.jpg</video:thumbnail_loc><video:title>Noam Elfanbaum: Hello Airflow, Farewell Cronjobs</video:title><video:description>Session language – English
Target audience – Developers, Data Scientists, R&amp;D

At Bluevine we use Airflow to drive our all "offline" processing. In this talk, I'll present the challenges and gains we had at transitioning from a single server running Python scripts with cron to a full blown Airflow setup.

At Bluevine, we were looking to upgrade our backend processing infrastructure from a servers running Python scripts with Cron to a more scalable solution that allows for workflows (DAGs) and better observability of the application state. Airflow proved to be a valuable tool, though not without some sharp edges. Some of the points that I'll cover are:

- Supporting multiple Python versions
- Event driven DAGs
- Airflow Performance issues and how we circumvented them
- Building Airflow plugins to enhance observability
- Monitoring Airflow using Grafana
- CI for Airflow DAGs (super useful!)
- Patching Airflow scheduler</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/ced3d082-8ac4-4380-9eb4-43ba994b0993</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/tQ3zU54A59xfKskxMGiqRP</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/a2246384-dc17-4a9a-a3df-3d9a1df0fb3b.jpg</video:thumbnail_loc><video:title>Uri Yanover: War stories: when data doesn't easily fit in memory</video:title><video:description>Session language – English
Target audience – Developers, Data Scientists, R&amp;D

I plan to discuss three archetypical war-stories about fitting in memory. In each of them, I'll describe both the technical challenge and the human biases that needed to be overcome to arrive at sound solutions.

One aspect of handling big data is that typically a problem's dataset does not naively fit into RAM. Three episodes I'd like to discuss:
- Choosing a data-at-rest format for large dataset without reinventing the wheel.
- Choosing the right in-memory format for a sparse shortest-path matrix, when the dense version would be prohibitively big,
- How to chew thousands of larger than 1GB JSON files without swallowing them whole.

Administrative notes:

I strongly encourage you to turn on the subtitles.
I'll be available at the live chat during the session.
We will switch from the video to the Q&amp;A breakout room at 12:10
Feel free to follow up with me through uri AT immunai DOT com

I'll discuss the problems, their solutions and the mistakes I made along the way</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/e15c0999-994a-40fb-a598-277a58774c31</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/3ZdTeXH5w5yL6htosMxBAF</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/c7cb0cee-10c3-4337-9621-50e4ca924d76.jpg</video:thumbnail_loc><video:title>Gal Hochma: Short Text in the Wild</video:title><video:description>Session language – English
Target audience – Data Scientists

While most of our online lives revolve around short texts, there's very little information on how to apply NLP techniques on such texts. In this talk, I'll share the lessons we learned and the methodology we developed when dealing with short texts.

“Thanks for all the fish” ; “Happy bday grandma!” ; “Mercedes C-class Cabriolet” . Looks random, right? Well, maybe you know the old saying “one man’s trash is another woman’s treasure”. These texts, while very short, can be a virtual gold mine for many different business use-cases, some of which we tackle daily in our work. When we started working on unsupervised feature generation from very short texts, we started by looking into what’s already been done in the field, and to our surprise the answer was: not a lot. In this talk we’ll share some insights from our experience in dealing with short texts. We’ll start by defining what we mean by "short" in our unique case, why it’s interesting in various domains, where and why advanced out-of-the-box methods failed and finally, provide practical tips for handling short and unusual types of text.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/182f9ca7-154f-4746-a21c-a2de9d7463af</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/hPfA4uJjVHKwp2qafL9k4f</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/2041eab6-d9e0-4d2f-9bba-da1a27f790f4.jpg</video:thumbnail_loc><video:title>Alon Gal: Resumable persistent functions: build a chatbot the fun way</video:title><video:description>Session language – English 
Target audience – Developers, Academics

Source code for the examples is available on GitHub.

In K we had a simple task: build a chatbot. With a lot of logical paths. And loops. And external interrupts. In this talk I will present our fairly exotic solution, that looks like a resumable function, which is persisted across user requests.

I will be presenting the "dialogs framework", a library we built in-house for managing long-running persistent functions. These functions come back to life when they get a message from the user, magically resuming where they left off. I will go over the design process, the Python implementation details, and the current gaps and challenges.

The aim of this talk is to inspire similar projects, show off our framework, and reach out for community inspiration on our open challenges.

As motivation, here is the kind of code we are writing:

@dialog
def greet():
    name = run(prompt("Hi, I'm a bot. What's your name?"))
    location = run(prompt(f"{name} is a beautiful name! Where are you from?"))
    run(send(f"{location}? No kidding! I grew up there!"))

After each call to run, the function terminates and the user request is answered with the next message to display. The execution state is persisted into our database, allowing the follow-up answer to be handled by a different server in the future.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/882b2a5b-8e6e-4070-b89e-3a62a4788468</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/8EdDpx39dsgUo4MGLyncUz</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/02053aca-7b13-4701-a873-abe47773aedd.jpg</video:thumbnail_loc><video:title>Meir Vengrover: Python,  the golden bridge between algorithm and software development</video:title><video:description>Session language – English
Target audience – Developers, Data Scientists, R&amp;D, Managers

Software and algorithm teams have different needs, still, python can become a common language and satisfy the needs of both teams.
We will see how python as a common language boosts our development process.

Can algorithm and software teams talk the same language?
For many years in Applied Materials, the answer was – No! the teams have different needs...
While algorithm team preferred to develop their algorithms in MATLAB which has rich arsenal of scientific tools, software team preferred to write their code in C++ in order to gain code efficiency.
The code conversion between the teams was long and exhausting process.
In this lecture I will describe our decision to have python as a common language for both algorithm and software.
I will explain how python can fulfill the needs for both algorithm development and software standards of design and efficiency.
I will describe our joined development process in order to achieve algorithm and software goals through the language.
I will show you the boost this process gave us which will convince you to choose python as a common language in your company too!</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/3e0606ce-cfa9-448c-b2e4-6fbf95a014bd</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/8U1hsSAvefiRCiSZdU6AdJ</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/050558f6-ff54-46d0-91a9-fa27cde153f4.jpg</video:thumbnail_loc><video:title>Or Weis: Python RPC and PubSub over Websockets</video:title><video:description>Session language – English 
Target audience – Security Experts, Developers, DevOps, Data Scientists, R&amp;D, Managers

Modern distributed software doesn't stop at your VPC. Edge deployed software needs realtime communications, updates, and state sync. It needs RPC and PubSub over the web. Lets make it open-source.

In this talk we'll cover the need for over-the-web realtime RPC and PubSub, why we needed and created it for our OpenPolicyAgent realtime updates layer, along side:
- The challenges that the implementation faced
- Pro/Cons of realtime update channels
- Common use cases (updates, sync, event propagation, distributed computing, authorization, ...)
- Additional awesome Python open-source we used in this solution (FastApi, Tenacity, broadcaster, ...)
- How to use the open-source packages we shared.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/3ff2d253-a5ce-443a-9537-b12cc1604572</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/xfeB9XR9zAMsdHUQxJtKoW</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/84c5db01-512e-4fc9-8fa0-b39b66b16413.jpg</video:thumbnail_loc><video:title>Rachel Chocron: Application State Management</video:title><video:description>Session language – English
Target audience – Developers, R&amp;D

JupyterLab does not have state management as do other commonly used frontend frameworks. This is needed to create multi-page applications with connected forms and shared data. We solved this by developing a a custom solution, which we will present.

We implemented a multi-pages python application over JupyterLab in order to utilize Jupyter’s data visualization and UI capabilities. Our application requires the various pages to be aware of each other's data and get updates when it’s changed. We could not find a simple package for state management in python as other commonly used front-end frameworks have. Therefore, we implemented a simple state management package.

Our state has a dictionary interface, which enables the application pages to: * insert keys with any type of data, * register actions to change these keys * register to receive updates when a specific key is changed

We will show live code examples of how to use the state in python applications.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/fd0818a7-695d-4935-a02e-02962fefbe76</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/hmdmsP8cVtAzUPwKAnMEPZ</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/b4da5f94-3252-4e92-802b-a20a6a5ff686.jpg</video:thumbnail_loc><video:title>Eyal Trabelsi: Practical Optimisation for Pandas</video:title><video:description>Session language – English
Target audience – Data Scientists, Other (please specify below)
Other (target audience) – Software Engineer / Data Engineer / BI / Analyst

This talk will review some of the most common pitfalls that can cause otherwise perfectly good Pandas code to grind to be too slow for any time-sensitive applications, and walk through a set of tips and tricks to avoid them.

Writing performant pandas code is not an easy task, in this talk, I will explain how to find the bottlenecks and how to write proper code with computational efficiency, and memory optimization in mind.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/8464b4e6-7ec5-4197-b4f3-18f35f298b8f</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/v9mfz7Liwvgxn1BnzfkDae</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/616cd299-3f90-4408-baee-7a0566859fab.jpg</video:thumbnail_loc><video:title>Luka Androjna: Methods for Effective Online Testing in Python</video:title><video:description>Session language – English
Target audience – Developers, Data Scientists, R&amp;D

In online advertising, we run a lot of online tests to determine which approach boosts our engagement the most. We talk about different ways of online testing through the perspective of a new feature we developed that is based on continuous testing.

Testing different UI components, algorithms, optimization approaches in an effort to boost engagement is becoming more and more prominent in online applications. In this talk we will introduce a feature that is based on continuous online testing, Then we will go over online testing in general and some methods that we can use based on certain constraints of the domain. For instance having a limited time to decide which test group we want to use, to avoid having the test itself affecting the results. Sometimes we are also constrained by deadlines by which we have to conclude testing. In tests like those, we have to balance exploration and exploitation to maximize the test’s payout while still being certain in what we did. With that in mind will explore different methods of running online tests, namely split tests, epsilon-greedy multi-armed bandits, and Thompson sampling. We will go over their pros and cons, and applications. After a short demonstration written in python. We will conclude the talk with reasoning of why we chose the methods that we did.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/ec037399-6b49-48cc-a626-846bfff25283</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/heuywrc7amadxXBJ2mLYBu</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/1f1e43cb-0272-43bd-8814-f9c492245bf4.jpg</video:thumbnail_loc><video:title>Orr Shilon: A Feature Store   what is it good for</video:title><video:description>Session language – English 
Target audience – Developers, Data Scientists, R&amp;D

It’s good for feature reuse in machine learning, thereby increasing data science accuracy and velocity.

A feature store is a single interface to create, discover, and access features for model training and inference. A holistic feature store solution should be capable of:
* Ingestion - both from streams and batch jobs
* Serving - low latency single features for inference and high throughput bulk features for training
* Feature Engineering - transforming and aggregating
* Discovering - features and how to retrieve them

This session will attempt to demonstrate why a feature store is useful, review current open source solutions, and suggest how to build one.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/83747d20-0fa1-4b97-9dee-082d0cc58caa</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/c8DfQ6SNV8Qcf21cNWFsGB</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/4a3e8f97-cb0e-4d51-adaa-4387a828b055.jpg</video:thumbnail_loc><video:title>Noga Karni - Why Does “Don’t Stop Me Now” by Queen Make Us Happy? Feature Analysis</video:title><video:description>An enriching talk about music theory and analysis using python tools.

Have you ever noticed that, depending on your mood, not every song is suitable for you at a given time? And how about songs that change your mood while listening to them? For instance, Queen’s “Don’t Stop Me Now”, voted as the most feel-good song of all times, seems to make people pretty happy. If you wondered why this happens, this talk is for you!

We will walk through songs’ features that influence our mood based on the acoustic parameters, such as tempo and loudness. We will use signal processing tools written in Python to analyze it. We will also learn about compositional and lyrical features which help us decide if a song is “happy” or “sad” (or a mix of both).

After this talk, you will know some basic terms in signal processing and music. You then will understand, from the perspective of a signal processing engineer, what are the musical features which arouse your feelings.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/5a25b0f7-8ccd-4de3-8957-e21c57332cd3</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/7mepA2oxESi8jZnEahQiuP</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/847c7e76-5267-4e41-b864-4dc8b06df0c3.jpg</video:thumbnail_loc><video:title>Layla Abu Khalaf - What are we busy about?</video:title><video:description>A plan is what, a schedule is when .it takes both a plan and a schedule to get things done” - Peter Turla.

A plan is what, a schedule is when .it takes both a plan and a schedule to get things done” - Peter Turla. Aligning operational requirements with the needs of your employees is not an easy task. Managers that need to build a work schedule for their teams, need to consider many variables e.g. employees availability and personal preferences, operational needs of the organization, fairness and inclusion. The organization should both provide the service and run smoothly, and keep the employees engaged and satisfied. This challenge is scaled in the medical setting, where different professional staff members needs to attend different patients with their limitations.

In Antidote Health – a telehealth service, we created an automated process, based on Linear Programming methodology, implemented in Python pipeline.

The Project is based on preprocessing the data received from doctors about their availability times, and encoded via CP-SAT model,Pandas and Numpy libraries . Algorithm then runs and provides an optimization of shifts for each doctor given several constrains. The results are piped into the backend of our system, where the scheduling of the patient-doctor appointments is managed. The developed model assists and optimizes the end-to-end process of scheduling in a fast-paced dynamic environment .

By automating the scheduling process, you were able to deliver consistent results, experience fewer mistakes,reduce costs, maximize our doctors productivity , and boost overall doctors and patients satisfaction.

You will be inspired to develop similar solution for your scheduling needs. Remember - if you want to win in the marketplace you must first win in the workplace

Session language – English Target audience – Data Scientists Other (target audience) – Devops</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/3369f831-e4ed-4c92-8241-0bf96b795c0b</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/drGqvM2rTsnEwHCaWoMgHg</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/813da381-c0a0-42fc-adec-616ef199642f.jpg</video:thumbnail_loc><video:title>Bat El Ziony Sabati &amp; Mordechai Alter - Data Class Serialization The Right Way</video:title><video:description>Do you ever use data classes in your project? Need to store these data structures for later use?
In our talk, we will present how to do it in Python. We will focus on Pydantic and will show the correct way to do it for complex data structures.

Many of us write Python apps that handle data. As part of that, we often face the need of persisting this data as-is. This will enable us to use this data structure later.

In this session, we will present
1. How does Serialization work?
-- 1. The difficulties of Dynamic programming languages with serialized data
-- 2. A few different Python libraries that handle that (pickle, jsonpickle, pyyaml, marshmallow)
-- 3. How Pydantic takes the most precise approach
2. The problem and solution to Serializing subclasses
-- 1. The problem when deserializing the raw data
-- 2. A live session where we walk through increasingly better solutions to find the optimal one

After this session, you will have the understanding and tools to persist your complex data structures using Pydantic.

Session language – Hebrew Target audience – Developers</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/64c42b64-fcb3-43d5-844b-4ec05f513ddd</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/8weY92uXnvarW6gYsii5P4</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/0103c42a-7ac8-4f8a-baf5-15bb9cf16f66.jpg</video:thumbnail_loc><video:title>Dina Bavli - Life, Death, and Shopping</video:title><video:description>A step-by-step introduction to purchase prediction. Also applicable to survival analysis and churn prediction. Including implementation in PySpark.

When dealing with survival analysis, the model's success is predicting death correctly. But it can also predict an engine failure, abandonment, or even purchases.
In purchase prediction, survival analysis, or churn prediction, the data is usually labeled or artificially labeled by a set of rules- such as inactivity for 30 days equivalent to churn. But the data structure is different from classical machine learning, and the data handling and modeling are different accordingly.
In this lecture, we will cover the data structures and aggregations for such analysis focusing on time aggregations using pyspark and what NLP got to do with any of it.

Session language – English Target audience – Data Scientists Other (target audience) – In this lecture there is something for everyone, beginners wishing to learn what to learn, advanced that need a reminder and maybe introduction to a new topic, R&amp;D for new concepts, and in between.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/3ce8e449-7799-46a6-a672-d43606c424b1</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/dpnAdu5rAMRngf1iYwNaHs</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/ece585d2-95c7-4ac4-86a3-f369ee108918.jpg</video:thumbnail_loc><video:title>Liron Soffer - Web apps for data science using streamlit</video:title><video:description>Nobody cares about your algorithm, learn how to communicate model insights.

Data scientists can lose track of time working on their models, failing to consider anything other than loss and metrics. But, in reality, no one cares about one's specific model.
The ability to communicate the model’s functionality as well as other insights produced by the model are critical to the data science profession. However, this ability is often overlooked.
However, what if I told you that you could solve this problem and demonstrate your model's capabilities to the rest of the world with a simple Python script?

The talk will include a live demo that will demonstrate how, using a few lines of code, you could wrap a machine-learning model into a pure python web app so others can experiment with it. You will see how to incorporate interactive plotly graphs which gives the user an additional layer of understanding of the problem.

It is said that soft skills are hard currency. In our case, they are backed up with powerful technology. Whether you are a beginner or an experienced data scientist - this talk will level up your visual data communication, and grant you a new superpower!

Session language – Hebrew Target audience – Data Scientists</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/6471136d-7fa0-47fb-9f91-6fbaea485ff8</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/keytwXphSwKjJk9dLEcwxw</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/33873a41-596e-47e9-83a3-987f477252a5.jpg</video:thumbnail_loc><video:title>Avraham Raviv, Or Reginiano, Eliya Bronshtein - Formal Verification through Python – Why and How?</video:title><video:description>Formal verification (FV) can prove the correctness of algorithms and systems and so ensure safety. Since FV tools are not easy to use, we will show examples (from the RL domain) of how executing them via Python could be very useful and friendly-user.

Formal verification is a subfield in mathematics/computing that provides methods to specify [1] and formally prove the correctness [2] of algorithms and systems given an environment and described using variables, transition functions, etc.

The ability to check a code, whether it enters a state that is not safe using the information in the system is a great advantage. But unfortunately, the main model checkers (which are automatic tools implementing formal verification algorithms) are not very user-friendly. They require writing a text file, which can be very long for large-scale problems, and multiple steps to compile and run, also their UI isn’t always very accessible.

Utilizing model checkers such as NuSMV [3] can become easier by using python. By writing a code that generates the text file for us and activating the NuSMV as a subprocess, we can get the NuSMV results and by using python disassemble the answer and use it in our code accordingly.

Moreover, if we change the problem parameters or the scale of the problem changes between runs, we need to change the file for the NuSMV accordingly, which makes the transition between runs much more complicated. By using python we can make this process much easier and more modular, we can use the information on our code to write the file and also run it.

To demonstrate the idea, we will focus on reinforcement learning (which is a subfield of machine learning). We trained an agent to play frozen lake - a game in which the player needs to reach from one point to another on a board without falling into certain squares which are water holes. We use Q-learning [4] (which is a reinforcement learning algorithm) for the agent which is trained until the decisions table converge...</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/9bc2511a-3be8-4750-b852-8a534c0d2ef4</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/mzx3bYnCPzhs1EA1KSGwHL</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/93e1c018-983e-4ddb-bb1d-b9b2d932f53f.jpg</video:thumbnail_loc><video:title>Stav Shemesh - 🤖 Transformer-based NLP Pipelines with SpaCy v3</video:title><video:description>Transformer-based models have been producing superior results on various NLP tasks. In this talk, we’ll cover the new transformer-based NLP pipelines featured by SpaCy, and how to apply multi-task learning for improved efficiency and accuracy.

The transformer deep learning model adopts the mechanism of self-attention, and serves as a swiss army knife solution to many of the most common language tasks. Combining several language tasks together is commonly referred to as language processing pipeline, and was made popular across the NLP industry using SpaCy, a Python library for language understanding.
In this talk, we’ll cover the undoubtedly most exciting feature of SpaCy v3: the integration of transformer-based pipelines. We’ll learn how to quickly get started with pre-trained transformer models, how to create custom pipeline components, and how to perform multi-task learning and share a single transformer between multiple components. Altogether, we’ll explore the building of efficient NLP pipelines for real-world applications reaching state-of-the-art performance.

Session language – English Target audience – Data Scientists</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/a6a571ff-234c-4c3a-b9d1-7061a6b31bee</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/axqqyxuo7mk63a4MiApXCZ</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/37d52aa6-1239-40f4-8def-75cd97e012a4.jpg</video:thumbnail_loc><video:title>Inon Peled - Don’t Underestimate the Obvious: Murphy’s Law in Real-life Data Science</video:title><video:description>Murphy’s Law states that if anything can go wrong it will -- and this is particularly true in data science. Based on personal experience, I describe how to create an effective model despite data pitfalls, methodological hazards and hidden bugs.

“If anything can go wrong, it will”, states Murphy’s Law, and this holds particularly true in data science. Whereas the algorithms used in data science are mathematically flawless, the path to creating an effective model is often rife with obstacles, such as data deficiencies, methodological pitfalls, hidden bugs and human mistakes. In this talk, I offer lessons about common obstacles and how you can avoid them in your projects, as I have learnt from nearly a decade of data science work. Topics include: how data often violates our intuitive assumptions, and how Python tools can detect such violations. How to confidently build a model by starting from simple baselines and using synthetic data to your advantage. How to avoid common pitfalls – such as unintentional overfitting, train set contamination and inconsistent package versions – via defensive programming and code reviews. And how to guarantee long-term code correctness via Pytest.

Session language – English Target audience – Data Scientists</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/4d455b36-e24c-4525-9764-65667c5fe235</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/uj7b32gqtCPf16B8sPFDsk</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/8c7671f6-b13a-485a-a3a4-fc862dd2f1c9.jpg</video:thumbnail_loc><video:title>Michael Haberman - Getting Started with OpenTelemetry in Python</video:title><video:description>In this talk, you will learn about the concept and benefits of tracing by examining the open-source project OpenTelemetry. You will leave this session knowing how to set up OpenTelemetry to get better visibility and troubleshoot your system faster.

Tracing and observability are becoming very popular as distributed services are getting more complex. To better understand our architecture and to be able to troubleshoot production issues faster, we need to track how requests are populated throughout the system. By monitoring the interactions between the different components we can overcome some of the native complexity of distributed services. In this talk, you will learn about the concept and benefits of tracing by examining the open-source project OpenTelemetry in its Python version. You will leave this session knowing how to set up OpenTelemetry yourself and utilize open-source solutions and tracing data to get better visibility and troubleshoot your system faster.

Session language – Hebrew Target audience – Developers Other (target audience) – DevOps</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/e5471318-ac74-4643-ae93-973ff692b0b3</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/uEAPpJ2nMgBSE2k4tw2BTu</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/5a5a346a-ff9f-41c3-9a22-e4bc441800a2.jpg</video:thumbnail_loc><video:title>Dor Amram - How to Lift Your Tech Debt Curse with the Magic of the Open-Close Principle</video:title><video:description>Using Python's awesome features and important design principles for safe legacy code refactoring while maintaining a healthy production environment

Throughout the company life cycle many products change and evolve.
Your PM is demanding an urgent feature and you find yourself looking at a patchwork project composed of fixes on fixes, no testing and, "if it's working, don't touch it" comment written by someone who left the company a few years ago.

We all know the experience of inheriting a legacy system and with it the curse of tech debt.

In this talk I will share the insights I gained lifting many such curses, while maintaining a running production environment, using the magic of the Open-Close principle.
Giving you the right tools to plan and execute, your next refactoring challenge.

Session language – English Target audience – Developers</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/e8239a4c-10b3-441f-978c-3cc77054e8be</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/cqJpeY9MLaG8cf17V47bii</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/d76cb74d-2862-4d82-9236-30bbe126a267.jpg</video:thumbnail_loc><video:title>Naor David - Leveraging networkx in-memory graphs for securing your cloud infrastructure</video:title><video:description>Securing Infrastructure-as-code configurations is a key requirement in a cloud production system. We will cover how the networkx library is leveraged to represent cloud resources as a DAG, and how it enhances the misconfigurations scanning process.

We at Bridgecrew by Palo Alto Networks have published checkov, a Python open source tool which is the industry-standard for Infrastructure-as-code (aka: IaC) scanning, and is used by thousands of users and with an active community. Checkov scans for misconfigurations and reports the security implications and risks that such misconfiguration has induced. In this talk, I will show how we leveraged the networkx python library to empower checkov’s scanning capabilities.

IaC is the practice of codifying the provisioning and management of IT resources. As IaC frameworks have become more advanced, dependencies between IaC configurations were incorporated, just as physical IT resources are most likely to be dependent on each other.

Checkov utilizes the networkx graph library to build a DAG (directed acyclic graph) to enable blazing fast graph analysis queries relevant for the IaC security domain. It uses the graph to render configuration settings which stem from other configurations that are linked to it.
This allows the testing of more complex scenarios, in which a combination of dependent resources creates an unsecure misconfiguration, whereas scanning each resource independently would not unveil such misconfiguration.

After this lecture you’ll know what a DAG is, how to traverse it and the benefits of in-memory analysis over utilizing a persistent graph DB. You’ll also get to know the concept of IaC, and what benefits it brings to the development lifecycle, and why using checkov ensures your IaC remains continuously secure.

Session language – English Target audience – Other (please specify below) Other (target audience) – Cloud engineers, DevOps, Security experts</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/5c88818f-e8a2-422e-a023-b8f594df8313</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/hRHutRXFbjM4u66H8kCtv4</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/6cd3b459-3be1-4fb7-a765-73b639731671.jpg</video:thumbnail_loc><video:title>Miki Tebeka - JSON - The Fine Print</video:title><video:description>In this talk we'll discuss the finer points of working with JSON. We'll cover custom serialization, validation, and shine some lights at some darker corners.

Why does the following code prints False?

outgoing = (1, 2, 3) data = json.dumps(outgoing) incoming = json.loads(data) print(outgoing == incoming)

In this talk, we'll cover more advanced topics in JSON serialization. We'll look into serialization in general, look at some design decisions the Python JSON module does and look into custom serialization and streaming.

Session language – Hebrew Target audience – Developers</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/88833ba9-4fdb-4037-ad89-f3daf12a6c51</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/oUdKbd8SAWqbmBWqE89nVH</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/e53ec592-9e01-4874-8a49-2c6d7439094a.jpg</video:thumbnail_loc><video:title>Haki Benita - Overcoming Concurrency Issues in Web Applications</video:title><video:description>Concurrency in web applications is hard to identify and debug, and very easy to get wrong! In this talk I'm going to present common concurrency issues and suggest ways to identify and prevent them!

In this talk I'll present common issues, and different approaches for dealing with concurrency:

Why it is better to ask for forgiveness instead of permission when dealing with concurrency
What is the TOCTOU (time-of-check-time-of-use) problem, how it can happen and how to address it
How database locking can help with concurrency, and how to avoid it!
How and when to rely on database features to maintain correctness
Session language – Hebrew Target audience – Developers</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/b97394a1-27d1-41de-aa0c-78681dcf828f</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/jYMTMDpGFreL1hi8ErqYkH</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/f2598166-91b4-43f2-ab48-9d7ccc581238.jpg</video:thumbnail_loc><video:title>Anat Wax - Basic microcontroller programming with Python</video:title><video:description>Arduino microcontrollers can be used for numerous and versatile home-based functions. Want to learn what you can do and how to get started coding Arduino in Python? There’s a low cost of entry, and the possibilities are endless.

Python is not generally considered the best option for programming microcontrollers. It is big, slow, and not optimized for handling asynchronous events. So how can you enjoy the fantastic world of microcontrollers using Python? In this talk, I will share my journey and the transition I made moving from C to Python, using Arduino programming to improve my Pythonic skills.

There are so many possibilities latent in programming Arduino using Python. I will begin by explaining the basics of Arduino and Micro-Python and showing an Arduino project that I created and other open-source Python projects written for Arduino.

This talk aims to inspire Python developers from all levels to dive into the magical world of microcontrollers and get their hands dirty.

Are you curious about how you can enjoy the benefits of your Pythonic skills in the physical world? Would you like to learn how developing an Arduino project can help you improve your Pythonic skills? If you answered yes - this talk is for you! If you know Python – the microcontroller's world is open to you.

Session language – English Target audience – Developers</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/99b26df3-25a1-4b06-a970-d3332c714aa7</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/65yeMyrce4GKYqx4agxGVu</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/dabd6acc-123b-494d-815f-161697798bb4.jpg</video:thumbnail_loc><video:title>Yarin Asulin - Django URL Pattern Role Authorization System</video:title><video:description>Taking the Django traditional groups and permissions to the next level by adding layer and using an access endpoint pattern approach to provide scalability, flexibility and a wider control of authenticated user's access.

Django comes with a built-in permissions system with view, add, change, and delete permissions, as well as the ability to add other permissions as one might wish (even if with weird and uninformative names that no one will eventually use).
One question remains, though: is it the right approach when building a big Django application that contains a lot of different authorization groups?
This talk is more of a case study dedicated to the challenges (and solutions) we had at Bluevine around this exact question.
At Bluevine we faced many difficulties enforcing authorization with the traditional Django authorization system for several reasons. * incompatibilities and different users with different sets of permissions, due to lack of restrictions around the Django auth user model. * Inability to grant limited permissions to different models.

The above are just a few of these difficulties.
In this talk, we'll discuss the above and other difficulties, as well as our solutions.
Hint - we refreshed the Django permission mechanism by adding a role layer, changing permissions, and more.

Session language – Hebrew Target audience – Developers</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/2920891a-4061-46c5-a17f-95a9abaca766</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/doewnKiTUtENJfLrmdqC9N</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/0c8320aa-0978-4e5c-8de6-030a411fb986.jpg</video:thumbnail_loc><video:title>Michael Segal - Minimum Viable Security for Python Applications</video:title><video:description>Python remains a very popular programming and scripting language in the DevOps ecosystem for building CI/CD pipelines. In the same way we think about how we design and build our Python applications, we need to design, build and automate security.

The minimum viable security (MVS) approach, enables us to easily bake security into our config files, apps, and CI/CD processes with a few simple controls built for Python applications.

In this talk we will focus on five critical security controls that will be integrated as part of the CI/CD pipeline: Bandit for static application security (SAST), Gitleaks to detect hard-coded or insufficiently secured secrets, Python dependency checks (SCA), infrastructure as code (IaC) and ZAP for API and dynamic application security (DAST), in addition to custom controls to ensure proper enforcement of MFA via Github Security. These controls will provide a foundational framework for securing Python applications, from the first line of code, that will make it possible to continuously iterate and evolve our security maturity, for advanced layers of security that often comes with time, as well as increased experience.

Code examples will be showcased as part of this session.

Session language – English Target audience – Security Experts Other (target audience) – DevOps / DevSecOps</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/64485c73-a7bf-4800-8cdc-2250e59e504e</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/j9UCm9BX1je6uRcR2j8y9u</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/25763151-5e76-4179-be2b-47f8d53ba4fa.jpg</video:thumbnail_loc><video:title>Niv Sluzki - Pythonic DDD And How To Improve Your Life When Maintaining A Monolith</video:title><video:description>Startups choose python because it helps you to set up your application very quickly, but after a few months, it can get really messy. This is the story of how we in Databand managed to extract good backend guidelines with Python out of our monolith.

In this lecture, I'm going to talk about our experience in Databand.ai where we started with a quick-and-dirty web application architecture in order to quickly provide value to our customers.

Our application became larger and larger, and the business needs were significantly changed. A lot of new code and features were introduced, and we found ourselves chasing after our tails in order to detect problems in our app.
When we had enough, we started to conduct new backend guidelines and embraced a lot of DDD methodologies such as a bounded context, layering, unit of work, repository pattern, domain architecture, and so on.

I believe this tells the story of a lot of startups and there is a lot to learn from our experience - what went wrong, how to avoid it, and how to fix old problems.

Session language – Hebrew Target audience – Developers Other (target audience) – Team Leads</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/9302e0dd-b818-445b-9c7a-949afb9a4904</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/hztxruQJBQvRKUENftzE89</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/13b7837c-9745-494a-94d9-0b2972af6652.jpg</video:thumbnail_loc><video:title>Ron Alfia - Fine Grained Error Locations in Tracebacks</video:title><video:description>Python is dynamically typed. While awesome, even simple statements in a single line can cause series headaches. Running var['python']['3']['11']['a'] produced TypeError: 'NoneType' .. error. Impossible to debug from the Traceback, until 3.11..

A Python line can contains many operations e.g. in numpy -
result = (a + b) @ ( c + d)
If we will get an error, like broadcast error, the traceback will mention the Python line but won't be able to inform whether it originated from a + b or c + d.

Python is compiled to Bytecode (pyc files), which later interpretated to machine level. One Python line generates multiple bytecodes.

We will dive into Python's Bytecode, to understand how tracebacks work and why they were constrained to provide more information when bugs happen.

Those problems are solved in Python 3.11, released few weeks ago as alpha version. With it, the tracebacks now have markers that show exactly which variable caused the error. This feature reduce the use of debugging mode.

Session language – English Target audience – Developers</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/863ebc82-a939-4088-afb7-2ca074e3100e</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/3WUgk5yQzeqzGVVf8TMaGU</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/c27c81ff-9807-40d3-b565-50c03265dc00.jpg</video:thumbnail_loc><video:title>Aviad Hahami - Under the sea - Attacking vulnerable C creatures in Snakes-land</video:title><video:description>I'd like to share the findings from my research where I looked into python packages that wrap vulnerable C code and ship vulnerabilities to the unaware developers
Attackers aware of such libs may abuse these components without the developers knowing

The Python ecosystem has PyPI libraries that bundle C code, but if that code has vulnerabilities how would we ever find out? how can we fix them?
Until today, this was a common hidden problem and risk that we all accepted (mostly unknowingly). Today it changes. My talk will demonstrate the uncharted attack vector in open source software supply chain - unmanaged code pieces inside our dependencies.

You'll learn about the struggles of managing open source libraries and adopt takeaways from my research findings, where I looked into Python libraries that wrap vulnerable C code, and unknowingly shipped vulnerabilities to unaware and unsuspecting developers. The developers, on their end, may think that they're safe (no reported CVEs) but malicious actors with such knowledge can exploit these seemingly non-vulnerable libraries and compromise systems while flying completely under the radar.

Session language – English Target audience – Other (please specify below) Other (target audience) – Security experts, developers and basically everyone running "pip install"</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/17dca660-ca4b-44fc-8149-71672cde8720</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/x5T3YQNnTSB1dKXmc7Jf77</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/09062866-10bc-49ed-80eb-dd3a59afee91.jpg</video:thumbnail_loc><video:title>Michael Khaitov - Memoirs of a Python Object: Memory Management and Improving Performance</video:title><video:description>Python is known to be expensive in Memory and CPU. However, it does not mean you can't do anything about it.
In this talk, we'll learn about Python's memory management, and what you can do today to improve the performance of your Python program.

Python is a dynamically typed and garbage collected language. These traits naturally mean that Python can be less efficient in terms of its CPU performance and its memory utilization.
In this talk, we learn about how Python manages its memory, and what you can do about it to improve the performance of your Python program.
More specifically, we'll learn about:
- Variables vs Names - why Python is different than other programming languages
- How Python represents objects, and specifically - the PyObject struct
- Python's two methods of garbage collecting - Reference Counting and Tracing
- How you can improve the performance of your program
- Two case studies from Instagram (Facebook)

Session language – English Target audience – Developers</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/fbb9bc2d-909e-4c7c-b206-92d8935839aa</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/4k5JmcpLhvzD6ET96wSc6L</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/24edcf37-32a8-475f-9528-e8b695350eb7.jpg</video:thumbnail_loc><video:title>Hodaya Ankri - Identity providers, your app, and everything in-between</video:title><video:description>Signing in to Twitter using Google, or saving files from an app to the cloud are different applications of auth flows. This talk will show how it works and focus on integrating a flask app with identity providers by applying the relevant flow.

Most users prefer to sign in to apps via trusted identity platforms like Google, rather than managing a separate account per app.
As a backend developer, you would probably like to add such a login capability to your app, and more than that- let the user grant the app permission to use his data.
In this talk, you will hear about the standard authentication and authorization flows, and how we can integrate our flask app with identity providers - Starting from the basic terms and ending with the different auth flows. I will focus on matching the right flow for our app architecture and explain how the app gets the user's consent to access his data.
Although the integration code will be with a specific identity provider, the flow is generic for every standard identity platform.

Session language – English Target audience – Developers</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/1af57671-1b42-4f27-8e59-538b27b05f2a</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/ocMHydcXWQtVNArqqdvMZ9</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/d742f016-d2ba-4311-97c9-7961a07f109f.jpg</video:thumbnail_loc><video:title>Yonatan Goldschmidt - Optimizing Code Performance for Python Internals</video:title><video:description>The Python interpreter plays a critical role in controlling the performance of your code, using a vast variety of optimizations &amp; fast paths for common code patterns and idioms. This talk will walk you through how it can break or worsen performance.

The Python interpreter plays a critical role in controlling the performance of your code, using a vast variety of optimizations &amp; fast paths for common code patterns and idioms. This talk will be a fun interactive session presented through code examples that display an assortment of those optimizations and in which (unexpected) ways they can break, worsening the performance of your Python code; we'll follow by inspecting CPython interpreter's inherent behavior to understand the reason for the breakage. The output and results just might surprise even the most advanced Python coders.

This talk will (partly) be based on some code samples I have contributed to the excellent wtfpython (https://github.com/satwikkansal/wtfpython) focused on Python quirks in general, with a touch of performance. Through these snippets we will learn some performance dos and don'ts, by understanding CPython internals and features under the hood.

Session language – English Target audience – Developers Other (target audience) – Developers / Platform Engineers</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/b3ce67e0-4ecc-467f-9631-c0f103698d0e</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/jKKcUo8CbzHxQCxJsKYHk4</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/76d45e14-6998-4fcb-b35a-c7d54f7b9e83.jpg</video:thumbnail_loc><video:title>Nathan Shain - The Journey of Upgrading A Python Version: From a Debugger Perspective</video:title><video:description>What happens when you develop a Python debugger and the latest Python version breaks it? We’ll go through the process of debugging a Python debugger and the methods we used to solve it efficiently.

When a new Python version is released, the great opportunity to add new features to our software comes around. Yet, alongside those features, there’s always an API break which requires us to make undesired changes to our software. Often, the change can be as small and seemingly insignificant as a signature change or sometimes can be as big as shifting from Python 2 to 3.

In rare cases, due to this upgrade, your software would break. You'd then open your favorite debugger and begin debugging until you pinpoint the issue.

But what happens when you yourself develop a debugger… and need to debug your own debugger?

In this talk I will present what I learned from supporting the latest Python (3.10) when creating a debugger.
I’ll go through the background of the underlying debugging mechanism in Python, show a real-world example of what happens when an undocumented minor change in CPython interpreter breaks the debugger, and how to successfully find the solution. I’ll share some personal anecdotes of my own journey doing so and the tips and tricks I learned along the way.

Session language – English Target audience – Developers</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/97e01aaa-01e1-4e22-a3a7-4bf86daddfc5</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/iDrQFynj3q7grYuWsC6cPF</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/92ab021c-86c1-42a1-b087-d28240a6c4dc.jpg</video:thumbnail_loc><video:title>Yishai Zinkin - From PyPerf to py-spy - Everything You Need to Know About Python Profilers</video:title><video:description>With the increasing complexity of modern Python applications and the high cost of running them in the cloud––the need for profiling solutions rises. However, current solutions often times fall short.

With the increasing complexity of modern Python applications and the high cost of running them in the cloud the need for profiling solutions rises, but current solutions often times fall short, and are not equipped for the requirements of many common stacks and environments.

In this talk we will describe how contemporary Python profilers are implemented, discuss and demonstrate the advantages and disadvantages of different implementation approaches in different use cases. This talk will dive into modern profiling with flamegraphs - when and how to use them for the most accurate results, and introduce the Python profilers PyPerf &amp; py-spy and new implementation approaches including PyPerfMap - for a simpler ramp up, alongside more reliable data, that can work on any Linux machine.

Session language – English Target audience – DevOps Other (target audience) – Developers / Platform Engineers</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/8ee5ccff-68a9-437c-bb64-119c2e326c21</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/1ZPXNwYSnUkxrpe8exAg6v</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/745d1a5a-698f-4b27-b038-9a32f762b515.jpg</video:thumbnail_loc><video:title>David Baum - It's Critical: Concurrent programming as a sane programming model</video:title><video:description>We mostly hear about concurrency as a more performant replacement for threads or multi-processing.
But the hidden gem of concurrent programming is how sane concurrent code, and how easy it is to reason about shared state.

In this talk we'll be building a toy async-await framework of our own. Building this ourselves allows us to grok concurrency from the ground up, and understand its value when given to us as an existing framework

Session language – English Target audience – Developers</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/0812f3dc-ec4d-482c-a334-831bcb9576fb</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/4pYouMpo1v7hmrwyFND23z</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/fc38ca72-9101-463b-b7dd-ee7e50812ecb.jpg</video:thumbnail_loc><video:title>Adam Kariv - Building your own dystopic surveillance state with Python</video:title><video:description>Always wanted to have your own surveillance state but didn't know where to start?

In this talk we'll cover the first steps on doing face detection and recognition - in Python!

In this talk we'll go over on how to do face detection and recognition in Python and some simple applications of it (both for hobby projects and totalitarian regimes).

We'll use some handy Python libraries for processing images and finding out all faces that appear in them - find out who they are, how old they are in whether they're happy or not (the unhappy ones to be sent to re-education - out of scope for this talk).

Session language – English Target audience – Developers</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/1ba445df-e117-4866-9e40-7ba1eaf07dc1</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/mZPwZXiHP7Suaive65G8pP</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/12ede6c4-719d-4753-899c-295030d9da35.jpg</video:thumbnail_loc><video:title>PyCon 2022 - Python strategy panel</video:title><video:description>Sim Zacks moderates a discussion panel on Python strategy, with:
Michael Czeizler (Mobileye), 
Barak Peleg (AI21), 
Orit Wasserman (Red Hat), 
Lior Mizrahi (BlueVine), 
Oren Nissenbaum (Via), 
Miki Tebeka (353 Solutions) 
Tal Sayhonov (CYE)</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/aa097655-d383-4cc6-aeb8-c977fafcb4c1</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/vSbrm49nAAwrCf1RQgvNGk</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/1ab05037-bcc2-4e42-b24e-de62d4b8e117.jpg</video:thumbnail_loc><video:title>Maya Gershovitz Bar - The hidden costs of your favorite functions</video:title><video:description>Have you ever written a simple function, and added it to your pipeline only to discover it is WAY slower than it should be? In this talk, I will demonstrate how to sniff out functions that slow down your pipeline and be proactive about speeding up

Have you ever written a short and simple function, and added it to your pipeline only to discover it is WAY slower than it should be? Did you know some pandas functions are written in cython and work much faster than others? Python is not known to be the fastest language, but you can be proactive about speeding things up!

While Python is featureful and simple to write, it isn’t known as a fast language. Many of Python’s functions and one-liners have hidden complexity costs. Choosing the wrong ones can slow down your code and those costs definitely add up. For example - popping an item from the end of a list vs from the start of it, or using the “in” operator on a set vs a list. A few seconds running time difference in your local script could mean a few hours time difference on the production pipeline.

If you want to learn about what to look out for, how to overcome these pitfalls and make your code more efficient this is the talk for you.

Session language – English Target audience – Developers</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/f1daa444-48cb-4ee9-b2ea-d7619d0f8a53</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/1rfduAMHPZWh1acA8VvRX5</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/66b9322c-5018-4cb0-ba96-efabc3aeb11b.jpg</video:thumbnail_loc><video:title>Assaf Dayan - Building Lightning-Fast Apps With asyncio</video:title><video:description>asyncio, Python's concurrent I/O library, can power very-high-performance applications. Come and hear the story of how we were able to replace a legacy service cluster with a single asyncio-powered instance, and how you can do it too.

Modern services must handle vast amounts of traffic efficiently and in a scalable manner. One method of achieving high throughput while keeping things simple is by utilizing concurrent I/O.

The asyncio package is Python's offering for building high-performance, concurrent applications using non-blocking I/O. It is also known as an event loop or async/await (among other names), but in essence, it's a useful method for achieving high concurrency efficiently – one that differs from the principles of multithreading and offers unique benefits.

In this talk, I will share the story of why we designed an asyncio-based Python service, how its performance exceeded that of the Java service it replaced by an order-of-magnitude, and what learnings we gained from it. These learnings can help us design super-fast, highly concurrent services.

We will talk about:
- The principle behind asyncio's efficiency - its secret sauce.
- When asyncio shines, and when you might opt for a different approach.
- How to combine it with other paradigms to maximize your application's performance.

Session language – English Target audience – Developers</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/03865ad4-33cc-4859-a34b-2fbdf401a396</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/h79WbfvEzAbUmg1wffAmTr</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/79623a32-c6af-4f7e-997a-a086496d6c5b.jpg</video:thumbnail_loc><video:title>Reuven Lerner - What happens when you import a module?</video:title><video:description>We all "import" modules . But how does Python find and load modules, and making their definitions available? The answer is surprisingly complex. This talk walks you through the world of module importation, from load path, to finders and loaders.

Modules are a key feature of Python, allowing us to easily reuse our own code and take advantage of publicly available modules from PyPI. It's a rare program that doesn't include at least one "import" statement. But what actually happens when we import a module? How does Python find our file? How does it decide whether it should even try to find our module? And after it finds our module file, how does Python load it into memory, assigning to its attributes?

In this talk, I'll walk you through what happens when you "import" a module into Python. The mechanism is surprisingly complex, in no small part because it has to take so many possibilities into consideration. We'll talk about finders and loaders, and about the many ways in which you can customize the module-loading mechanism if you find a need to do so.

If you've ever imported a module, then this talk will pull back the curtain a bit, helping you to understand what's happening under the hood.

Session language – English Target audience – Developers</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/826e2fdf-70c7-4f5a-8023-1b4618e4c3e7</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/h9wRv6dGUZyNvTRA2dCa4v</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/c012111e-08d9-4bfe-8405-b99cfca88ea7.jpg</video:thumbnail_loc><video:title>Yael Green - Monorepo - One Repo To Rule Them All</video:title><video:description>Does your service architecture slow you down? Instead of enabling rapid and frequent deliveries? If you have found yourself in this situation, you will benefit from hearing about our journey towards an efficient repository structure.

In this session, we will share our journey towards a monorepo. We will discuss the many reasons we made this decision, and how it improved our development. Learning from our experience will help you choose the correct repository structure for your project and needs. We will get into details about the python specifics of a monorepo: what is a good python repository structure, how to utilize python relative imports, editable installation, and how to handle virtual environments. Getting practical, we will present our implementation of monorepo in Gitlab and how we transferred the repositories. We will dive into the technical details sharing commands and snippets.

At the end of this session, you will be able to choose the correct repository structure for your project and will have gained practical tools to implement a monorepo and conduct a safe transfer.

Session language – English Target audience – Developers</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/82c32ecf-37ca-466b-8316-68be42371b0f</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/nrr2kwzwR3noRUWEU1gLto</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/b29ed274-85d9-43c3-ab1d-162fe949accc.jpg</video:thumbnail_loc><video:title>Amit Ripshtos - No more sassy SaaS integrations</video:title><video:description>Applications today are giant meshes of services and interconnected APIs. However, there isn’t a standardized, systematic way to integrate them. In this talk, we'll cover the patterns of working with 3rd party integrations.

Applications today are giant meshes of services and interconnected APIs. We benefit from an ecosystem of rich SaaS and 3rd party integrations that are the de facto standard for many platforms and applications: Slack &amp; Jira for example. However, there isn’t a standardized, systematic way to integrate them.

In this talk, we'll cover the patterns and antipatterns of working with 3rd party integrations, and suggest how to wrap them into a very Pythonic framework that focuses on ease of use and great developer experience - using widely used frameworks such as Typer, Pydantic and methodologies like Dependency Injection, Snapshot testing &amp; JSONSchema.

At the end of the talk, the audience will understand the problem of many 3rd party integrations, how existing products solved that problem and how to develop an infrastructure that lets you develop these integrations faster.

Talk structure:
The problems with many integrations
Use-case: How Airbyte dealt with many integrations and created a community out of it
How to create a framework that let you integrate new SaaS easily using: * Pydantic * Typer * FastAPI * Decorators &amp; Dependency Injections
How to improve testing for integrations: * Snapshot testing using module patching

Session language – English Target audience – Developers</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/ad9ced57-128b-4fe5-9627-f433d3b9a7bc</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/j8JqXQ3UkEH2inWtPdv8P2</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/5ea1f389-bf78-4f14-997b-4627673e7752.jpg</video:thumbnail_loc><video:title>Gil Cohen &amp; Eyal Greenberg - Python common security mistakes in 2022</video:title><video:description>The Python eco-system and community made a lot of progress in terms of security and security awareness, but common OWASP top 10 mistakes still happen in the real world.

Python gives developers multiple tools and best practices to avoid common security issues and vulnerabilities. However, real life requirements, obstacles and deadlines can sometimes cause good developers to produce insecure code that is vulnerable to common OWASP top 10 attacks like Authorization Bypass, SQL Injection and Cross Site Scripting (XSS).

This presentation shows examples based on real-life vulnerabilities we encounter at CYE in our everyday penetration testing of our clients, with vulnerable code examples and mitigations.

Presentation outline:
Attack and threats - OWASP Top 10 * Parameter Tampering * SQL Injections * XSS\PXSS * Malicious File Upload

Mitigations * Parameterized Queries and ORM * Hardening: Authorizations + Views * Authorization and permission checks * Input Validation * Output HTML Encoding

Session language – English Target audience – Developers</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/92d8d9d6-4a9c-446e-babd-a4fc690b4d0b</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/1bSg6rc4iwcE6JvKDGmynf</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/c2c34f29-c7f9-45f5-a7b9-1fd9c4bf3fda.jpg</video:thumbnail_loc><video:title>Liron Faybish Ben Kimon - Detecting anomalous sequences using text processing methods</video:title><video:description>Hello wait you talk see to can’t my!
Sounds weird? Detecting abnormal sequences is a common problem.
Join my talk to see how this problem involves Bert, Word2vec &amp; Autoencoders (in python), and how you can apply it to information security problems

Dealing with sequences can be challenging as each item has its unique position in the sequence and there’s a correlation between all items and their positions. One of the most common issues when working with sequences is dealing with anomalous sequences, that doesn’t fit with the regular sequences’ structure. Those sequences make no sense, create noise in the data and interrupt the learning process.

The most common sequences are text sentences, and possible scenario for abnormal text sequences could be when trying to translate sound to text, and sometimes there’re some irrelevant noise that can translate to nonsense sequences, and if we want to build a model based on that data, we need to find a way to identify and clean this irrelevant and anomalous data.

Detecting anomalous sequences could be also related to non-text sequences, such as sequence of action or events. Those scenarios could be related to information security problems. For example, in many organizations there’re logs of actions that has been made on internal systems and detecting suspicious sequences of actions on the system could be a crucial in detecting attacks or misusage of the systems.

My proposed solution includes two phases.
In the first step, we need to model the items in the sequence and understand its structure and correlations. We need to train a word embedding algorithm for generating the vectors embedding out of the sequences, such as Bert or Word2vec.
The next step, after creating the sequence embedding, is detecting the anomalies. The algorithm we used for the anomaly detection phase is Autoencoder, where you can train the model on normal data and detect the abnormal events.

This pipeline has some challenges. For example, each sequence...</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/01846963-45e1-46d6-83c8-06327bf95850</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/nieE6zmAyCorMZP3N8xgAY</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/1a62e540-4f1a-4471-b385-c5f7b2a37cba.jpg</video:thumbnail_loc><video:title>Noa Marom - Python &amp; DAG architecture: Winning combination for dev of complex algo agile flows</video:title><video:description>Rapid development of complex algorithms requires an agile management. This talk will demonstrate how we leverage Python flexibility and DAGs power to enable a flexible algorithm development process with high quality and minimal risk at each stage.

Rapid development of complex and varied algorithms requires tight and agile management. This talk will demonstrate the power of DAGs (Direct Acyclic Graphs) to enable a flexible algorithm development process with high quality and minimal risk at each stage in a continuous delivery ecosystem. I will show how Python concepts and libraries are used in tandem with DAG architecture to manage independent, atomic algorithmic units with unique characteristics — and at the same time to easily create complex flows through flexible combinational integrations of algorithmic building blocks.
Python-based DAG is central in creating a strong yet open and simple infrastructure for our SW architecture, that supports incremental deliveries for the development of new high-quality algorithmic solutions according to changing requirements.
The semiconductor industry is a dynamic field experiencing rapid growth, requiring the continuous delivery of algorithmic solutions to diverse challenges. While these solutions are inherently complex, they need to be developed quickly and agilely.
Our DAG-based SW architecture is perfect for meeting these needs.
DAG enables us to develop and enrich our application in both new algorithm units — independent Python packages with their unique parameters, tests etc. — and new algorithmic flows, while improving reuse and throughput without interfering with parallel development.
Moreover, DAG provides the flexibility to update any existing algorithmic unit with new requirements, according to changing customer challenges. This is optimally done through the combination of DAG and Python, which inherently enables algorithmic building blocks to act as independent packages and yet remain accessible to debugging throu...</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/ac77f8e6-b195-479d-a0ec-12c594248f10</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/bGmADvqS6dP1jXSjeZNLDp</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/55e9dfe5-9927-4c12-95bc-bb430fcaaccd.jpg</video:thumbnail_loc><video:title>Boaz Wiesner &amp; Keren Meron - Supercharging Pipeline Efficiency with ML Performance Prediction</video:title><video:description>Running millions of tasks is difficult when dealing with high workload variance. We improved our pipeline efficiency by using ML models to classify task requirements and dynamically allocate the necessary system resources.

To process our customers' data, Singular's data pipeline fetches and enriches data from dozens of different data sources multiple times a day.

The pipeline consists of hundreds of thousands of daily tasks, each with a different processing time and resource requirements, depending on the customer's size and business needs. We deal with this scale by using Celery and Kubernetes as our tasks infrastructure. This lets us allocate dedicated workers and queues to each type of task based on its requirements.

Originally, our task requirements, required workers, and resources were all configured manually. As our customer base grew, we noticed that heavier and longer tasks were grabbing all the resources and causing unacceptable queues in our pipeline. Moreover, some of the heavier tasks required significantly more memory, leading to Out-Of-Memory kills and infrastructure issues.

If we could classify tasks by their heaviness and how long they were going to take, we could have segregated tasks in Celery based on their expected duration and memory requirements and thus minimized interruptions to the rest of the pipeline. However, the variance in the size and granularity of the fetched data made it impossible to classify if a task was about to take one minute or one hour.

Our challenge was: how do we categorize these tasks, accurately and automatically? To solve the issue we implemented a machine-learning model that could learn to predict the expected duration and memory usage of a given task. Using Celery’s advanced task routing capabilities, we could then dynamically configure different task queues based on the model's prediction.

This raised another challenge - how could we use the classified queues in the best way? We could have chosen to once aga...</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/569dd4ba-926a-4436-8d63-f18c24c56009</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/mpUBmM86F6JLPJ83PA9aaU</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/36ae5a02-ff73-4c28-be05-49afc1e05c8b.jpg</video:thumbnail_loc><video:title>Efrat Ravid - Cracking Wordle: Machine Learning based Strategies</video:title><video:description>Wordle is an online word game that has gone viral with millions of daily players world-wide. We will consider strategies based on information theory and reinforcement learning, allowing the creation of agents outperforming most human Wordle players.

Have you seen the posts on social media featuring yellow, green and gray boxes? Yes, that’s Wordle, a simple online word game that has gone viral with millions of daily players world-wide.

Though being a simple game, naive automatic solutions do not provide a winning strategy for the game. Following the success of machine learning solvers in games like chess and go, we will dive into Wordle and demonstrate how to program python agents that outperform most human players.

We will implement a strategy based on information theory and a strategy based on reinforcement learning. We will present a Wordle python package for evaluating our agents, which you can later use for evaluating and comparing your own agent.

Finally, we address the question all players are asking: What is the best starter word?

Session language – English Target audience – Data Scientists</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/a54d4d3f-0879-47ba-9d27-68a7af0d1442</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/iNsyPEVWtsfFpkJ2YLMBXW</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/81c7318a-a8b0-4d72-8440-e3d92d5a284b.jpg</video:thumbnail_loc><video:title>Yoel Zeldes &amp; Shuki Cohen - Zero to Hero: Few Shot Learning + Multi-armed Bandit</video:title><video:description>Join us to learn how to use large language models to solve NLP tasks. Via live coding, we'll demonstrate how to use Few Shot Learning together with Multi-armed Bandit, to tackle the boolean question answering task.

In the era of massive language models (LMs), solving NLP tasks can be as easy as specifying a product need to your engineering team: all you need to do is specify your need in a language the LM can understand. One of the main paradigms in nowadays massive LMs is called Few Shot Learning, where one can specify a set of examples from which the model has to understand the task. This approach can sometimes be as effective as finetuning.

But how do you choose the set of examples to show to the model? Randomly choose them? Try all possible combinations and choose the best one? We propose to formulate this task as a Multi-Armed Bandit problem: There are many possible sets of examples, and we’d like to explore and find the optimal in an efficient way.

In this session we’ll begin with an empty Jupyter Notebook and finish with a complete notebook that tackles the BoolQ task (boolean question answering). This live coding session will be paired with practical advices and insights you can apply to your next NLP task using the Few Shot Learning approach.

Session language – Hebrew Target audience – Data Scientists</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/9027f144-b0ba-4d77-a323-11941af7ffa0</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/sCaKsrLaySrUgAobE8xZtY</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/f59ddccc-0c01-40bc-906a-49aa1618bc70.jpg</video:thumbnail_loc><video:title>Dror Ivry - meet the best feature in python 3.10: match-case</video:title><video:description>```

1,1 == 1,1
1, True, 1
```
This bug led me into a rabbit hole of learning the internals of python's interpreter. This is a story of how python 3.10's structural pattern matching feature changed the way I write code completely

In this talk I'll go over the new structural pattern matching (also known as “match-case”) featured in python 3.10 and present real world examples on when and why it's extremely useful. In this talk, we will break the misconception that match-case is just another “switch-case” for python, and discover the it’s real power. those use cases include: * creating interactive CLIs * creating custom flake8 plugins * validating custom syntax

Session language – English Target audience – R&amp;D</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/d79a6399-9958-408e-8268-28ade9af34e2</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/u3YcNQLpJDQGtpJry3oXCJ</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/d2f6acda-379d-46ff-8053-305f2452763f.jpg</video:thumbnail_loc><video:title>Michael Sverdlin - Exploring the Cheese Shop - What's in the Python Package Index?</video:title><video:description>We pip install packages all day long, but did you consider where it is coming from?

Let's explore Pypi, the python package index. Topics we will cover:
1. What is Pypi?
2. How are packages uploaded and by who?
3. How to protect yourself from various attacks coming from Pypi?
4. Running your own Pypi repositories and mirroring python packages.

Session language – English Target audience – Developers</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/e32a01b7-7dda-4fe2-9143-b59406abe2de</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/7kGQ31t24tzvVrwqZvR6gi</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/66a14995-4bed-4b8e-bef7-32bd2589e8c8.jpg</video:thumbnail_loc><video:title>Assaf Klein &amp; Hila Weisman Zohar - Easily reduce Deep Computer Vision to shallow NLP</video:title><video:description>Being able to classify images is at the heart of many recommender systems. In this talk, we will share a simple trick to make the task of building an image classifier as easy as building a standard text classifier.

Building a task-specific image classification solution typically requires leveraging Computer Vision transfer learning techniques. It involves manipulating complex deep learning models, applying non trivial image preprocessing and using expensive hardware.
But what if you could leverage existing image meta-data annotations to classify our images?

In this talk we will share a simple trick to make the task of building an image classifier as easy as building a standard text classifier. This reduction simplifies preprocessing and training and it also dramatically reduces the required hardware &amp; computation time. This reduction is made possible by leveraging ready-made computer vision APIs provided by the public cloud vendors. These APIs extract semantic textual labels from images that in turn can be used to build simple, shallow NLP classifiers.

This simple reduction has helped us deliver fast &amp; cheap Python-based image classification models to production and is widely used in Outbrain products.

Session language – Hebrew Target audience – Data Scientists Other (target audience) – Product Managers, Data Analysts</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/33571ff6-4942-4159-bcfd-cad2f8ce4a43</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/r7m4YHENE9KoWnKcD9ijgr</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/e749bc65-995c-45be-9b1c-cfed47e22116.jpg</video:thumbnail_loc><video:title>Gabriel Manor Liechtman - Hidden Hacks in Linters for Better &amp; More Secure Code</video:title><video:description>Linters are a great tool that enable developers to create static analysis rules for their code base, and the most popular one in the Python ecosystem is Pylint - and this talk will walk through some of its advanced features

Linters are a great tool that enable developers to create static analysis rules for their code base, and the most popular one in the Python ecosystem is Pylint. While most programmers use pre-built sets of rules baked into their linter of choice, these can also be adapted to custom needs.

Today's linters are highly evolved and make it possible to avoid static code and even to run static analysis checks through the development and CI cycles, but they are even more powerful and few developers take advantage of their many advanced features. With Pylint it is quite easy to create custom rules that can for both general usage––such as library guidelines and even security SAST, through more customized usage like maintaining clarity around internal frameworks, and enforcing organizational guidelines.

Often times Python is chosen as the language of choice due to its suitability for specific tasks such data pipelines, and system engineering, while those who code in the language are not always familiar with the language's underlying fundamentals and patterns. With custom lint rules, you can proactively help your developers write better code in their native IDEs, protect IaC repos through custom lint enforcement on config files, and even have security tools leverage them for manual vulnerability checks. This talk will demonstrate how you can apply all of this to your Python code with Pylint.

Session language – Hebrew Target audience – Developers Other (target audience) – Security</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/cb574bfc-aef0-41c5-add8-f3f305227e8f</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/vwhbSXBgxRdivvHmajEHEU</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/da64619f-1d7f-409e-a9bd-5bc351c20ff3.jpg</video:thumbnail_loc><video:title>Ronnie Sheer - GPT-3 wrote the description for this talk... Scary or exciting?</video:title><video:description>This session might give you the tools to get started with Python and GPT-3.

GPT-3 is a powerful tool that can be used for a variety of natural language processing tasks. Python is a popular language for development, and Ronnie will show you how to use the two together to get the most out of GPT-3.

You'll learn how to set up your development environment, how to train and use GPT-3 models, and how to troubleshoot common issues. Ronnie will also share some tips and tricks for getting the most out of GPT-3.

At the end of the talk, you'll have a better understanding of how to develop with GPT-3 using Python, and you'll be able to apply what you've learned to your own projects.

Session language – English Target audience – Developers Other (target audience) – R&amp;D</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/ef134f67-e84b-4ded-9f27-37d36d3121c4</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/imeqC841HoMt5xQtmtxcfX</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/c651eca6-1452-4c29-99f0-2fcf1c88b1c9.jpg</video:thumbnail_loc><video:title>Ariel Lieberman - There is always another way: Sharpen your NumPy skills with the 8 Queens puzzle</video:title><video:description>A short walk through the challenge of finding the fastest NumPy algorithm/way for solving the 8 Queens puzzle. During this walkthrough I will explain the different solutions, the NumPy APIs I’ve been using and their underlying implementation.

NumPy is a powerful library. Understanding its underlying implementation and its APIs is key for achieving fast code.

The 8 Queens puzzle requires placing eight chess queens on an 8×8 chessboard so that no two queens threaten each other. Thus, a solution requires that no two queens share the same row, column, or diagonal. When solving the puzzle, it is possible to use shortcuts that reduce computational requirements. For example, by applying a simple rule that constrains each queen to a single column (or row). Generating permutations further reduces the possibilities to just 40,320 (that is, 8!), which then can be checked only for diagonal attacks.

The talk will explore 5 different ways to use NumPy to sum all the diagonals in a 2 dimensional array — from brute force, i.e. looping over all diagonals, to more advanced APIs (e.g. as_strides.)

During this walkthrough I will explain the different solutions, the NumPy APIs I’ve been using, their underlying implementation, and a few basic NumPy principles like array data structure, broadcasting, fancy indexing and more.

The optimal solution might surprise you.

We will learn that:

loops in NumPy are a performance enemy.
There are (almost) always multiple ways to solve a problem in NumPy — you may just need to expand your box of tricks.
Session language – English Target audience – Developers Other (target audience) – Algo Developers</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/8c7e817a-dad0-49a8-b484-b8ffae998bb7</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/kAesJr4gg2Vb6Ju4ZdGT51</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/6e520b38-768d-41fc-b0b0-4384b2092184.jpg</video:thumbnail_loc><video:title>Liran Haimovitch - Effective Protobuf: Everything You Wanted To Know, But Never Dared To Ask</video:title><video:description>Communicating and persisting data (and state!) is at the very core of software engineering. That’s where serialization comes in - but getting it right can be quite the challenge. Here's how to make it less so.

Communicating and persisting data (and state!) is at the very core of software engineering. That’s where serialization comes in: transforming a set of objects into a stream of bytes.

There are endless competing standards out there, roughly divided into textual and binary. For binary, Protobuf by Google is the undisputed ‘king of the hill’ and even spawned its own RPC library - gRPC.

Getting serialization right can be quite the challenge, especially when large data sets and big messages are involved. Two of the key challenges are:
The options are endless, but the long-term implications of your choices can be hard to predict.
Backwards compatibility is paramount, often making changes time-consuming and costly.

In this talk we are going to discuss the real-world techniques and optimizations learned building a high-performance production debugger. We’ll cover everything from the theory of serialization, through a quick introduction to Protobuf, all the way to the nitty-gritty details of how to squeeze every bit of performance under the most demanding conditions.

Session language – Hebrew Target audience – Developers</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/9ea537e1-b2e3-4660-981b-76055dfc0774</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/6BfuTG75sfK1GbY9tYwm6P</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/8d15c90e-9321-43e4-8e37-c11db363e113.jpg</video:thumbnail_loc><video:title>Lior Dagan Leib - Circuit Playground Bluefruit Board: Bringing Objects to Life (With Python Code)</video:title><video:description>What if you could take your Python coding skills and use it to affect the physical world around you? Circuit Playground boards allow you to do just that, and in this talk you’ll see how you can turn on the lights using the Python you already know.

As developers, we are used to limiting our creations only to the world displayed on screens. This is your opportunity to learn how to go beyond it.
In this talk I am going to introduce you to the basics of Adafruit’s Circuit Playground Bluefruit board. This round electronic circuit board can light up multicoloured LEDs, make sounds, detect touch, colour, temperature, sound, and motion (with no soldering or sewing required!). The board connects to your computer with a Micro USB cable, which allows you to save your Python code and run it instantly. During this talk we will explore together a few exciting sample projects along with their code.

Even if you never tinkered with hardware before, or just recently picked up Python, you’ll be able to run the existing sample code and create your own in no time.

Session language – English Target audience – Other (please specify below) Other (target audience) – Everyone who has some python coding skills and love learning new things</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/2d69a8f8-2af2-4418-b355-2a4a5de98c31</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/iqCfgEFjKVKb1NiimpP4S7</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/5138f02f-bd71-4ab3-8a54-1e52014bd261.jpg</video:thumbnail_loc><video:title>Shai Geva - Property Based Testing with Hypothesis: Stronger Tests, Less Work</video:title><video:description>Property based tests are a pragmatic way to write better tests with less work.

In this talk, we’ll introduce property based tests and show how they can help you in real-world use-cases.

Automated tests are great. But they’re not free - we all want tests that are good at protecting us from bugs - but to get that, we need to put a lot of work into them.

Property based testing is a technique that saves us a lot of this work. It uses the computer to generate hundreds, or even thousands of test cases - so we don’t have to.
This helps us find bugs sooner and more easily, and have more confidence in our code.

This session will point you in the right direction to start using property based tests in your work.

We will explore the technique through Python’s excellent Hypothesis framework and go over the fundamental concepts, basic usage and tooling.

We’ll also get a feeling for the power and variety of real-world use cases, by creating a test that explores a CRUD web application, finding bugs in edge cases we didn’t know.

We’ll finish with pointers and resources to help you get started.

Session language – English Target audience – Developers Other (target audience) – Also applies to test automation engineers - anyone who might write tests using code.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/8d1b8b8c-8ea3-47c9-9e7b-93717e3af7ce</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/ciEjxB9CShTLbAjapdqhXR</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/a53e868c-86a7-46d0-ba7a-1cb916aa5904.jpg</video:thumbnail_loc><video:title>Amit Raphael - python at scale – creating a High Definition Map of the world's road network</video:title><video:description>How we map continents at cm level accuracy from crowd sourced computer vision data using PySpark.
A tale of engineering challenges working with python at huge scale in production with a rapidly evolving development effort.

REM group in Mobileye is tasked with the challenge of creating and updating a high definition map at world scale with cm level accuracy of all road geometry and semantic elements to enable fully autonomous driving.

The map is constructed from crowd sourced anonymized data of millions of driving-assistance systems running computer vision processes in consumer vehicles.

This is the tale of the engineering challenges building a python based production solution running cutting edge algorithms efficiently on big data, while supporting a rapid pace development environment.

In this tale we will share how we addressed the need to:
- Build maps at huge scale in reasonable time and efficiency
- Enable 100+ developers to continuously evolve the technology at a fast pace, run their code on production loads, view and debug their results

We will discuss challenges of working with PySpark as our major computation engine, and some of the solutions we employed to adderess these challenges.

A peek into engineering in Mobileye REM group.

Session language – Hebrew Target audience – R&amp;D</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/5b8bc8e3-fd4e-4ff5-b9de-8243e6452407</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/fVPMhiK8C6kDEGX3fDiNUm</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/39c66359-1267-4125-8543-b3925fae6b2d.jpg</video:thumbnail_loc><video:title>Shachar Shemesh - Off road profiling - when the automated profilers just don't cut it.</video:title><video:description>When long running jobs are too long running jobs, profilers help us understand where it is that our code spends its time. I present a technique for manually guided profiling for cases the automatic tools cant' help.

Automatic profiling is great. You just run your code, as you normally do, and get a nice graph of where your CPU spends its time while you're waiting for a job to finish.

Except, sometimes the automatic tools can't help. Maybe something in your work load doesn't agree with them. Maybe they make your already long running job run so much longer that it's impractical to run it properly. Maybe you're only interested in profiling a small part of your code, and profiling the whole thing would create too much noise to be useful.

In this lecture I'll go over what I did when faced with such a problem. I'll detail the technique I used to determine where the time is spent. This is a manually guided profiling, i.e. the programmer decides which areas to measure.

We'll also handle the more complicated cases. In particular: * Short functions that get called a lot. * Preventing double accounting when one measured function calls another measured function. * How to present your data when you need to "sell" the need to fix a problem.

Last, but not least, I'll present an easy way for you to incorporate this technique into your own Python code.

Session language – English Target audience – Developers</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/78e3ce94-cf29-4e04-b5d6-4edb2ad3e50c</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/vfAq2jxZqiuKgvw44JPTkK</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/0b668000-a7db-411a-bb46-1dea01114c4f.jpg</video:thumbnail_loc><video:title>Daniel Weber- A Bug's Life</video:title><video:description>Have you ever faced the challenge of debugging a web application that runs differently in production than in your local environment?

In this talk, we'll explore the importance of gaining a deeper understanding of Gunicorn and NGINX, two critical components of the modern web stack, to become a better developer.
We'll dive into the power of greenlets, exploring how they offer a lightweight approach to concurrency management and we'll explore how all of this work together to handle HTTP requests, manage concurrency, and distribute workload across multiple worker processes.

We'll wrap up the talk by exploring some Python tips to help us write thread-aware code.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/ece2a475-4f8e-4e69-95fd-6a57586c223d</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/3hT6XAEdNf8cRAjfKrczjL</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/33aedc2c-1a85-4426-b7de-22abe4ec0c58.jpg</video:thumbnail_loc><video:title>Jonathan Daniel- Build Systems, Package Managers</video:title><video:description>The pyproject.toml file is the new standard for declaring Python projects, and it tells a story. Evidence for its significance is the tomllib built-in module introduced in Python 3.11. Many Python tools and linters adopted it as their primary configuration source. You should also use it - whether you publish a library, build an application or even write scripts/notebooks.

This talk will take us through the story of modern Python build systems and package managers. We'll learn where they come into play in the development life-cycle, their benefits, and their limitations.
Specifically, we will mention: Hatch, Poetry, PDM, Flit, and Rye.

We will cover dependency resolution and locking with .lock files and how to utilize them for reproducible environments and CI environment caches, facilitating development across large teams.

We will migrate together a Python project from the legacy setup.py file with many additional files into a single pyproject.toml with Poetry.

https://jond01.github.io/blog/pycon-il-23/</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/128dabba-c8b7-48d3-a2d2-4ecf8679f28c</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/7iX4BQeGanb42CBytopL73</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/bebf319f-1945-4dcd-a206-a3a42c2ebf14.jpg</video:thumbnail_loc><video:title>Gabriel L  Manor- Building Authorization With Python</video:title><video:description>Authorization is a critical part of any application due to users' greater privacy awareness and new privacy standards like GDPR. Therefore, developers today are required to build complex authorization logic. However, most developers lack the expertise to build authorization with Python correctly, and they rebuild authorization from scratch repeatedly.
This talk will provide best practices for building authorization with Python. To do so, he will show how to use existing tools in the ecosystem: OPA, OSO, OPAL, Zanzibar and others. Finally, he will provide recommendations about how to replace the pain of building authorization with implementing a simple and scalable solution.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/331868d1-5c71-46f0-bcbe-707b561965e6</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/7aSVjBa7tCjga3kcgQwV6s</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/fac0e920-2579-45b4-a86c-0d6295182af9.jpg</video:thumbnail_loc><video:title>Roy M Mezan- Brute force attack on Biometrical databases</video:title><video:description>Magic happens every time you take your phone out of your pocket. Somehow, just by looking at the screen, your phone recognizes you (and only you) and magically unlocks.

Have you ever stopped for a minute and thought to yourself - How does that even work? And maybe more importantly, how secure is it?

In this session, we're going to understand how facial recognition works under the hood. We'll dive into some potential security problems, and we'll show you how we were able to break into a biometric database built on the Dlib-python-library by applying a sophisticated brute-force attack. The results will surprise you.

Outline:
- Intro - The magic of Face ID [1 min]
- Under the hood - How Deep Learning Face ID works [4 min]
- Comparing faces - Exploring the Face-Space [3 min]
- Recap - Tying it all together [2 min]
- Exploitation - Weird behavior &amp; Possible weakness? [4 min]
- Shocking results! - [1 min]
- The Attack - Our attack on a Biometrical database [4 min]
- Summary [1 min]</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/31f7e7f2-210b-49c6-9210-dda8f9230600</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/fWfXFR8avy7H5Ht4qe4K2Y</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/0ec18fc8-4944-41e1-961e-9790b87661b9.jpg</video:thumbnail_loc><video:title>Sharon Rones Makmal- Automation Thinking</video:title><video:description>What is your first association when you hear “automation”? Is it QA automation? Business Process Automation? Data Analysis? If we explore it deeply, we can reveal many undiscovered layers- many uses of automation in many aspects of life.

Ever since my first position as an EDA Engineer - Electronics Design Automation Engineer – many years passed, I have been to many development positions, and I still find myself using these abilities I acquired, to improve my performance and excel in my tasks, both at work and my personal projects. Have you ever looked for a solution to ease your tasks in your personal or work life? Have you ever tried to think Automation? Can we really use it outside the defined world of automation jobs?

In this entry level lecture we will review together some real cases I dealt with and how I used Automation as a solution and improvement tool - automating repetitive commands, automating manual work, extracting information out of a big data and even writing a script that writes a reusable code. We will analyze the issues, review some code and discover the Power of Python in these tasks, and together we will train “automation thinking”.

Join me on the full fascinating tour of the automation mindset, and come out with a new and improved skill in your “bag of tricks”.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/78f35306-c3a6-4579-9659-e8fe5b792806</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/i2QpwXc3us6Y2Lzos8mXSN</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/72ff3d6a-c591-4380-86a5-0bcac2e79f34.jpg</video:thumbnail_loc><video:title>Shai Cohen- Date for two: Server, Client, and Datetime in a Multi-timezone environment</video:title><video:description>Any complex Django-based app will include many models that use the DateTime field, and the clients use those fields.

Assuming all our clients will always be in the same timezone is wrong for a globally used app.
Pythons DateTime and pytz packages can help you localize the information, but what is the “right localization”? And more importantly, how can we assume where to localize from?

When designing a flow that handles DateTime fields in server-client data exchange, timezone conversions are the main issue.

Another challenge is what can we assume about the DateTime data that comes from the client when they send a PUT request with a DateTime field? What should the response assume? What if the client sends a GET request without any additional data?

In this talk, we will address those issues by demonstrating a simple “Timed Assignment App” that can be used globally.
I’ll show the thought process that might go through your mind when designing the time features for this app, try different solutions using python packages, and finally suggest the “aviation method” for solving all the problems before they even happen.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/89ecee9d-c2cc-42cb-8fa5-3c524fa7c90e</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/th9p7Gph21wTYnQEoxPeW1</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/f0b78f3b-d3ef-432f-b93a-f01941d99382.jpg</video:thumbnail_loc><video:title>Yifat Makias Joshua- DB migration can be less scary - using alembic tool</video:title><video:description>Dealing with database migrations for developers can be pretty tricky.
Without a dedicated tool, this can be a frustrating task.

Python has frameworks that combine code and database management such as Django.
What if we prefer using a simpler framework for running our code, like Fast Api that does not contain a database management functionality?
Alembic tool is a great solution for that. Alembic tool helps us manage our database by creating and running migrations automatically.

This talk will go over the basics:
- Start working with alembic on a Fast Api project.
- The basic functionality that this tool provides and its' main features.
- What are the pros and cons of working with this tool?</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/dce7d1e6-a0ab-4e7d-a814-f52f10333b98</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/kMJT6P1SyYaKEGNwmQdgM2</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/14563bf9-b23b-4398-959f-1bd3502efb60.jpg</video:thumbnail_loc><video:title>Tom Ron- Do You Miss Me</video:title><video:description>Did the cat eat your CSV file? Did it eat only every third record?
Missing data is prevalent in real-world data and can be missing for various reasons.

In this talk, we will talk about the different patterns of missing data and what are the best practices for handling each. In addition, we will show how to visualize missing data as part of our data exploration phase to understand our data better.

As python is the leading programing language for data scientists and data analysts, we will use pandas, missingno, scikit-learn and other tools to demonstrate those ideas and explore the data.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/a04087d3-50e4-473e-a554-8f65d69d832f</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/s94VsLUd921K6kpvY8Ha4c</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/98dad6f0-fb58-4b8d-9150-f5e9a85febf0.jpg</video:thumbnail_loc><video:title>Shai Rubin- Fun With ASTs</video:title><video:description>The AST (Abstract Syntax Tree) module in Python can be used to analyze code, alert it, and even generate new code. We can use programming to change the AST representation of python, resulting in code that looks and behaves differently than the original.
This is a really cool thing to do.

In this talk we will explore the AST module capabilities, and its lack of capabilities.
We will learn the general structure of ASTmodule, its class hierarchy and its supported functions. Our focus will be on acquiring the skill to recreate the initial code through its AST representation. It seems that even though transforming python code into an AST is a simple task, the inverse process of transforming AST into code fails to replicate the original code.

We will see some examples of fun code-manipulations. First, we will show how to automatically add meaningful logs to your code. Second, we will experiment with code reordering and last, we will explore ideas to manipulate code for mutant testing purposes.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/d3adf8e1-2362-437a-9822-220e11929595</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/8CHiQiygfz4NRAKQKpbSyD</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/8a127781-f3e8-4ee4-aa76-2982f14b000b.jpg</video:thumbnail_loc><video:title>Pini Reisman- Faster code for global scale- Mobileye HD mapping the world</video:title><video:description>REM group in Mobileye is tasked with the challenge of creating and maintaining a high definition map at world scale with cm level accuracy of all road geometry and semantic elements to enable fully autonomous driving.

The map is constructed from crowd sourced anonymized data of millions of driving assistance systems running computer vision processes in consumer vehicles.

In this talk we will share stories from the trenches on how we optimized python workloads to run distributed big data processing.
We will discuss:
- how we approach these kinds of issues
- tools we use to identify and optimize algorithmic python code
- examples of how to write algorithmic code that runs 10x times faster leveraging a range of tools and technologies</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/3dd033f5-b559-47fb-a88d-d7dc3875f7cd</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/tisX81VCJ5dbNqRd2SYcZS</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/5b44d6aa-affb-4ca4-a82d-88b1c0724d2c.jpg</video:thumbnail_loc><video:title>Irit Katriel- Error Handling</video:title><video:description>Irit Katriel- Error Handling</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/dd16ff25-1d56-43df-818d-e81f792612a8</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/cw1qggV3ZdGFukBuaaai78</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/2a3fce39-bdd1-4469-986a-012ab91d6cd3.jpg</video:thumbnail_loc><video:title>Chayim Kirshen- Fixing a CVE In the Open: redis-py, chatgpt, and open source bug hunting</video:title><video:description>Ever experience a bug in a python library? What about a library that's downloaded nearly 30 million times a month? This talk focuses on a vulnerability - one that caused data leakage in some services.

Attend this talk this talk, to learn about the vulnerability that brought down the world's largest AI framework. Walk away with the tools to address these bugs in the future, learning how the library was debugged, and how the fix was tested. This talk will cover the technical detail behind how the fix was applied in the open, but also the process of working with security issues. Learn how to work with an Open Source community, while addressing a critical bug and keeping your cool.

Every line of code written is open-source, and in the public record, today.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/5d45189e-68fc-4c0f-8795-7cf5456d09df</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/xwxZNAULXNvmYELuJXvMMt</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/d38e957c-7dbf-4148-8da6-5433a0016714.jpg</video:thumbnail_loc><video:title>Josh Grossman , Michal Kamensky- Omniscient AppSec</video:title><video:description>The best software security solutions to your security requirements and challenges are specific to your use case, self-service and don't impede development velocity. This will often include creating custom, safe versions of functionality or not allowing the use of certain library functions which we know are dangerous. However, making sure that this guidance is constantly followed can be problematic.

Whilst standard automated tools such as bandit or pylint may help discover generic vulnerabilities such as insecure use of pickle or security errors/misconfigurations such insecure autoescape configuration, how can we verify that our custom solutions and guidance have been correctly implemented and more importantly, stay that way, without writing complicated custom rules for these tools?

In this talk we will discuss examples of custom solutions like this but more importantly, we will demonstrate how to continuously verify that the code remain in a secure state with these solutions implemented, on an ongoing basis. We will demonstrate using simple rule syntax provided by the free, open-source, Semgrep tool.

Some example scenarios we’ll discuss:

    Verifying we are not using a disallowed function in a 3rd party library.
    Checking for the presence of security sensitive decorators in all places with allowed exceptions, etc.
    Looking for a function that is called in an unsafe way.

You should leave with ideas for how you can have custom and specific security guidelines that match your situation and how you can use a simple rule syntax to verify them as well as solve other similar code analysis problems.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/ff4f5486-2b55-4fc1-a839-a66eeb6a55d9</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/dUwvNJVhpz1ruESQzPoehY</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/c87cf52a-1a2a-419a-8582-3083faca7aaa.jpg</video:thumbnail_loc><video:title>Omer Shacham , Oren Nissenbaum- Python Typing Implamentation</video:title><video:description>In this PyCon lecture, we'll explore Python typing implementation and why it's an important tool for any Python developer. We'll cover the basics of how to implement typing correctly, as well as some common mistakes to avoid. We'll also delve into some popular typing-related tools like mypy, dataclass, and pydantic. You'll come away with a solid understanding of Python typing and how to use these tools to improve your code quality and maintainability. Whether you're new to Python or an experienced developer, this lecture is a must-see for anyone looking to improve their coding skills.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/68832512-9d67-466b-88c9-5d92c7c988ac</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/eUp7kcFvyqyqPkGgLvnZns</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/6b76aab0-8caf-47ee-8753-357d16cf514c.jpg</video:thumbnail_loc><video:title>Aur Saraf- Things you can do in Python, but probably shouldn't</video:title><video:description>Have you ever used cffi to mutate an immutable str? Used fuckit('module') to import a module that tends to throw random fits of anger (and exceptions)? Used try: 1/0; except: import inspect to change a function's behavior based on who called it? Used an import hook to extend Python's syntax with your own syntactic constructs? Implemented a cache for your functions that parametrizes on the last modified time of the module they and their arguments are defined in and every module it depends on?

No? Good.

But someone had to check the grass isn't greener in hell, so you wouldn't be tempted to, right? And honestly, I've seen the last two running in production sorry i really gotta go ok thanks byeee dodges</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/7097b85b-50ae-4832-b0d3-a547464f2438</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/cdZPpw4mgmL75Hhw3UAu7A</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/e27bf6ad-c269-4c1e-b506-3ca30de7196f.jpg</video:thumbnail_loc><video:title>Boris Gorelik- The Secret Agents of Modeling: Why ABM Deserves Your Attention!</video:title><video:description>With recent advances in AI, novel methods like generative AI and large language models have captured significant attention. However, Agent-Based Modeling (ABM) offers unique advantages and versatility for various applications such as financial modeling, social interactions, and cybersecurity. In this talk, I aim to demonstrate the potential of ABM for fast experimentation and hypothesis testing by modeling the world through isolated, manageable components. By breaking down complex systems into simpler elements, ABM allows for easier exploration and understanding of the underlying dynamics. I will showcase various use cases and provide Python code snippets using the Mesa package to illustrate the practical implementation of ABM. Join me in discovering the untapped potential of Agent-Based Modeling and learn how to implement this powerful approach in your projects with the help of Python and the Mesa package. As an exciting bonus, I'll also demonstrate how to integrate GPT within ABM, because everyone wants a piece of GPT in their projects!</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/5ae514ea-3cbd-4523-916e-c98789cfe9be</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/dNa9x3n8f3VQw4ympkfB2s</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/aeb1ac42-fb0a-44f9-bf34-882d6ee1a51d.jpg</video:thumbnail_loc><video:title>Ran Bar Zik- Using 4$ microprocessor</video:title><video:description>ESP32 is a 4$ only microprocessor, it is a NON-Arduino microprocessor with built-in WiFi and Bluetooth, and you can work with it without electronic knowledge. Anyone with only expertise in Python can program and build a networking chip for monitoring your home network or a security infiltration tool that can hack WiFi networks or anything else – the sky is the limit! In this lecture, I will explain ESP32 and show a code and demo of the practical and fun projects you can build with it.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/679f83b4-bb5d-417e-bd8c-04d4dc7fc800</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/wFM3iuF6npMRhhknwLN2Yv</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/f21f15d7-91e1-4426-bb9e-97d4ddff7dc4.jpg</video:thumbnail_loc><video:title>Haki Benita- Taming Nondeterminism With Dependency Injection</video:title><video:description>There are many sources of nondeterminism in code such as randomness, IO, environment variables, databases and many more. Dependency injection is a pattern that provides a way to control nondeterminism in code and make tests easier to write.

In this talk I'll demonstrate how nondeterminism can pose challenges even in simple functions, and how to use dependency injection to address these problems!</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/f87fec6b-d9cc-4826-a821-3f36b13a4b61</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/4Fpkpm3CJM9KSNCrzGsa7U</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/308825f0-7a77-45f9-b68b-164820d4ce29.jpg</video:thumbnail_loc><video:title>Adam Hopkins- closing keynote</video:title><video:description>Adam Hopkins- closing keynote</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/1dcbcdad-1a2b-425f-b763-b7a86aa92844</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/pttPg77zov8hHhYG47gfXv</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/ba5399e4-6a3c-478a-aa59-626b52c839e1.jpg</video:thumbnail_loc><video:title>Galit Bary-Weisberg- Clean Code for Data Scientists</video:title><video:description>Python is a powerful and flexible language. However, its flexibility can sometimes lead to suboptimal code. For instance, consider this snippet taken from a real-world codebase: {v: [] for v in [a for b in p for a in b]}.
Many data scientists who use Python on a daily basis lack traditional software engineering education, resulting in code that may be difficult to maintain and debug.

Fortunately, best practices of clean code in software engineering have existed for many years and can help to avoid these problems before they occur. In this talk, we will review fundamental concepts from the influential book "Clean Code" by Robert C. Martin. The book was written in Java, but I assure you that I have enough examples of bad code also in Python :)
We will discuss when and how to incorporate these concepts into your daily work, providing practical examples of clean code dos and don'ts in Python.

If you're a team lead, software developer, or data scientist interested in producing better code and spending less time debugging, this talk is for you. Join me to learn how to level up your team's skills and write maintainable, efficient code that will save you valuable time.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/be186997-b236-4865-b504-14d594e62423</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/9gNmUo8LNAmtBc9ziP5S27</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/92bac65c-28de-4a98-97ff-bd506f7cf156.jpg</video:thumbnail_loc><video:title>Erez Waisbard- How to prepare your python code for the post-quantum era</video:title><video:description>The post-quantum era is upon us, and new cryptographic algorithms are now available. Python developers that use encryption, signatures, or other cryptographic operations in their code must update their Python code. There are already Python implementations, but they can be problematic to use as a drop-in.
In this session, We will learn about post-quantum cryptography algorithms and why we should use them.
We will also learn to combine the old and new algorithms securely, ensuring we maintain our classical assurance and certification while preparing for the quantum challenges.</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/42fdd620-fc38-4699-8148-d81efcf176b8</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/expQfkJqcxZtvxZQFZicDH</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/acd57d8c-6fe2-4d9f-9706-c544351247d7.jpg</video:thumbnail_loc><video:title>Sharone Zitzman: Don't Be a Hack / Dev Talks FTW</video:title><video:description>שרון זיצמן מסבירה לקהל איך לבנות הרצאה טכנית.

מתוך סדנת הכנה ל־CFP של כנס פייקון ישראל 2024</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/6da98bdd-818f-4176-ae5e-a4ff1e7c612f</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/w/3jH7GJCjKnQyMZoMozHFQU</loc><video:video><video:thumbnail_loc>https://tube.hamakor.org.il/static/thumbnails/64571ce6-4b2c-4972-9d7d-ad2b78bb12e3.jpg</video:thumbnail_loc><video:title>Shai Berger: What we want to see in PyCon</video:title><video:description>שי ברגר מסביר לקהל אילו הרצאות מחפש צוות התוכן של פייקון ישראל.

מתוך סדנת הכנה ל־CFP של כנס פייקון ישראל 2024</video:description><video:player_loc>https://tube.hamakor.org.il/videos/embed/12cf00e8-28ff-44bd-a542-e4844f5e6208</video:player_loc></video:video></url><url><loc>https://tube.hamakor.org.il/video-channels/root_channel</loc></url><url><loc>https://tube.hamakor.org.il/video-channels/uda_channel</loc></url><url><loc>https://tube.hamakor.org.il/video-channels/amit_channel</loc></url><url><loc>https://tube.hamakor.org.il/video-channels/tube_channel</loc></url><url><loc>https://tube.hamakor.org.il/video-channels/opensourceisrael</loc></url><url><loc>https://tube.hamakor.org.il/video-channels/pyconisrael</loc></url><url><loc>https://tube.hamakor.org.il/video-channels/augustpenguin</loc></url><url><loc>https://tube.hamakor.org.il/accounts/peertube</loc></url><url><loc>https://tube.hamakor.org.il/accounts/root</loc></url><url><loc>https://tube.hamakor.org.il/accounts/uda</loc></url><url><loc>https://tube.hamakor.org.il/accounts/amit</loc></url><url><loc>https://tube.hamakor.org.il/accounts/tube</loc></url></urlset>