כל הפוסטים

⏱️ 2 דקות שפות תכנות #C++

Data Center, AI Server, GPU Cluster - שלושה מושגים שכל מי שמתעסק בבינה מלאכותית חייב להבין

⏱️ 2 דקות 📚 חומרת AI & תשתיות - חלק 6 תשתיות #מרכז נתונים #שרת AI

Data Centers - הבית של כל הבינה המלאכותית

⏱️ 2 דקות 📚 חומרת AI & תשתיות - חלק 1 תשתיות #מרכזי נתונים #תשתיות AI

De Facto Standard - כשהתנהגות מוזרה הופכת לחוק טבע

⏱️ 3 דקות ארכיטקטורה מערכתית #De Facto Standard

Deploy הוא אירוע מסוכן

⏱️ 2 דקות 📚 כשהמערכת כבר רצה - חלק 4 ארכיטקטורה מערכתית #Deploy

Design for Failure - כשתקלה אינה הפתעה

⏱️ 2 דקות ארכיטקטורה מערכתית #Design for Failure #Resilience

Divided Resources - איך מחלקים משאבים בין מודלים או תהליכים

⏱️ 2 דקות 📚 אופטימיזציה של חומרת הסקה - חלק 7 למידת מכונה חומרה #חלוקת משאבים #אופטימיזציה #הסקה

DSP VS DLA

⏱️ 2 דקות חומרה #DSP #DLA

Escalation הוא כלי, לא כישלון

⏱️ 2 דקות 📚 הנדסה בלי נקודת התחלה - חלק 2 ארכיטקטורה מערכתית #Escalation

Ethernet - איך הרשת שמחברת את המחשבים שלך קשורה גם לאימון ול-Inference?

⏱️ 2 דקות תקשורת #Ethernet #רשתות

Event, Topic ו-Key: שלושת המושגים שלא כדאי לערבב

⏱️ 2 דקות 📚 מערכות Event-Driven - חלק 6 ארכיטקטורה מערכתית #Event-Driven #Topic

FAB, Bring-Up ו-Post-Silicon - איך השבב הופך לחי?

⏱️ 4 דקות 📚 מסע לעולם עיצוב השבבים - חלק 13 עיצוב שבבים #FAB #Post-Silicon

Firmware, Driver ו-Runtime - שלוש שכבות שמפעילות את הבינה שלך

⏱️ 2 דקות חומרה #Firmware #Driver

Good Enough Engineering

⏱️ 2 דקות 📚 כשהמערכת כבר רצה - חלק 9 ארכיטקטורה מערכתית #Good Enough Engineering

GPU Cluster - איך מלמדים מאות כרטיסים לעבוד כמו מוח אחד

⏱️ 2 דקות 📚 חומרת AI & תשתיות - חלק 5 תשתיות #אשכול GPU #מרכזי נתונים

Graceful Degradation - איך מערכת מתנהגת כשהכול כבר לא עובד כמו שצריך

⏱️ 2 דקות ארכיטקטורה מערכתית #Graceful Degradation #Resilience

Gradual rollout: למה "בהדרגה" לא תמיד בטוח

⏱️ 3 דקות 📚 כשהמערכת כבר רצה - חלק 5 ארכיטקטורה מערכתית #Rollout

gRPC - איך מערכות ה-AI “מדברות” זו עם זו

⏱️ 2 דקות תקשורת #gRPC #Protobuf

Hardware-aware Software - למה קוד "נכון" לוגית יכול להיות כישלון ביצועי

⏱️ 3 דקות ארכיטקטורה מערכתית #Hardware-aware #Performance

Hot Path vs Cold Path - הפרדה בין זרמים חמים לקרים

⏱️ 2 דקות ארכיטקטורה מערכתית #Hot Path #System Design

HTTP - למה הוא נראה פשוט, אבל רחוק מלהיות כזה

⏱️ 2 דקות 📚 איך מחשבים מדברים - חלק 10 תקשורת #HTTP

Idempotency - לתכנן כאילו הכול יישלח פעמיים

⏱️ 3 דקות 📚 כשהתקשורת נשברת - חלק 8 תקשורת #Idempotency

Idle - למה Idle הוא לא מצב ניטרלי, אלא סימן שדורש פירוש

⏱️ 2 דקות ארכיטקטורה מערכתית #Idle #Capacity

Incident response הוא תרבות, לא פרוצדורה

⏱️ 2 דקות 📚 כשהמערכת כבר רצה - חלק 8 ארכיטקטורה מערכתית #Incident Response

Inference Optimization - לגרום למודלים לעבוד מהר יותר, לא רק טוב יותר

⏱️ 2 דקות 📚 מסע אל עולם ההסקה - חלק 5 אופטימיזציית הסקה #Quantization #Batching

Inference Pipeline - מאחורי הקלעים של ריצת המודל

⏱️ 2 דקות למידת מכונה #Inference #MLOps

Inference כזרימה, לא כבקשה - למה מודלי שפה לא "עובדים" אלא מתנהלים

⏱️ 4 דקות אופטימיזציית הסקה #Streaming #Inference

InternViT - השלב הבא אחרי ViT

⏱️ 3 דקות ראייה ממוחשבת #InternViT #מודלים

Jitter - למה Latency של הרשת הוא לא הבעיה, אלא חוסר הוודאות שלה

⏱️ 2 דקות ארכיטקטורה מערכתית #Jitter #Latency #Networking

KPI: כשמדידה מפסיקה להיות כלי - והופכת למלכודת

⏱️ 2 דקות ארכיטקטורה מערכתית #KPI #מדידה

Latency כבעיה ארגונית, לא טכנית

⏱️ 4 דקות 📚 כשהמערכת כבר רצה - חלק 2 ארכיטקטורה מערכתית #Latency

Latency, Bandwidth ו-Throughput - ולמה כולם מתבלבלים ביניהם

⏱️ 2 דקות 📚 איך מחשבים מדברים - חלק 8 תקשורת #Latency #Throughput

Load אינו אויב - Spikes כן

⏱️ 2 דקות 📚 כשהתקשורת נשברת - חלק 4 תקשורת #Load #Burstiness

MLOps - איך מודל טוב באמת מגיע לפרודקשן

⏱️ 2 דקות פרודקשן #MLOps #ניטור

MTTR - למה Time-to-Recover חשוב יותר מ-Time-to-Fail

⏱️ 2 דקות ארכיטקטורה מערכתית #MTTR #Reliability

MVP - Minimum Viable Product: מה זה באמת, ולמה כל כך קל לטעות בהגדרה

⏱️ 2 דקות Business Strategy #MVP

NVIDIA - איך חברת כרטיסי מסך הפכה למלכת ה-AI

⏱️ 2 דקות 📚 חומרת AI & תשתיות - חלק 2 חומרה #NVIDIA #GPU

ONNX - איך מודלים סוף סוף מדברים באותה שפה

⏱️ 2 דקות AI Frameworks #ONNX #תאימות

Ordering - למה סדר הוא מותרות יקרות

⏱️ 3 דקות 📚 כשהתקשורת נשברת - חלק 7 תקשורת #Ordering

Over-engineering ו-Under-engineering: שני צדדים של אותה טעות

⏱️ 3 דקות 📚 כשהמערכת כבר רצה - חלק 10 ארכיטקטורה מערכתית #Over-Engineering

Ownership כחרב פיפיות

⏱️ 2 דקות 📚 הנדסה בקנה מידה אנושי - חלק 3 ארכיטקטורה מערכתית #Ownership

Parallelism - איך מריצים מודלים במקביל?

⏱️ 2 דקות אופטימיזציית הסקה #חישוב מקבילי

Polling מול Event: מי שואל ומי מודיע

⏱️ 2 דקות 📚 מערכות Event-Driven - חלק 2 ארכיטקטורה מערכתית #Event-Driven #Polling

Production הוא נקודת האמת של המערכת

⏱️ 2 דקות 📚 כשהמערכת כבר רצה - חלק 1 ארכיטקטורה מערכתית #פרודקשן

Provisioning - הכנת הקרקע לפני שמריצים מודלים

⏱️ 2 דקות תהליך הסקה #Provisioning #משאבים

PyTorch - מה ההבדל בין פעולות View על טנזורים לבין פעולות אחרות?

⏱️ 2 דקות Pytorch #Python #Tensors

PyTorch - מה זה בעצם @torch.inference_mode()?

⏱️ 2 דקות Pytorch #Python #Inference

Quantization - איך "מכווצים" מודלים בלי לפגוע בתוצאות

⏱️ 2 דקות אופטימיזציית הסקה #Quantization #Inference

Queue אינו פתרון - הוא התחייבות

⏱️ 3 דקות 📚 כשהתקשורת נשברת - חלק 6 תקשורת #Queues #Latency

Rate Limit לעומת Quota: שני גבולות שנראים דומים - אבל פותרים בעיות שונות

⏱️ 2 דקות ארכיטקטורה מערכתית #Rate Limiting #Quota

RDMA - למה לוותר על המעבד כדי להרוויח מהירות?

⏱️ 2 דקות תקשורת #RDMA #רשתות

RDMA - שתי דרכים להגיע לאותו יעד: InfiniBand ו-RoCE

⏱️ 2 דקות תקשורת #InfiniBand #RoCE

RDMA ו-SmartNICs - כשכרטיס הרשת נהיה חכם

⏱️ 2 דקות תקשורת #SmartNIC #RDMA

Refactoring בלי לעצור את העולם

⏱️ 2 דקות 📚 הנדסה בלי נקודת התחלה - חלק 4 ארכיטקטורה מערכתית #Refactoring

Resource Optimization - איך כל הגורמים משפיעים בפועל על Latency ו-TPS

⏱️ 2 דקות 📚 אופטימיזציה של חומרת הסקה - חלק 8 למידת מכונה חומרה #אופטימיזציה #NUMA #הסקה

Retries - מנגנון התאוששות או מכפיל נזק

⏱️ 3 דקות 📚 כשהתקשורת נשברת - חלק 3 תקשורת #Retries #Exponential Backoff

RPC, Messaging, Streaming - שלוש פילוסופיות תקשורת

⏱️ 3 דקות 📚 כשהתקשורת נשברת - חלק 10 תקשורת #RPC #Messaging

RTL למתחילים - מה זה Verilog/VHDL?

⏱️ 3 דקות 📚 מסע לעולם עיצוב השבבים - חלק 5 עיצוב שבבים #RTL #Verilog

SDK vs Library vs Framework - מה ההבדל?

⏱️ 2 דקות כלי פיתוח #SDK #Framework

Serialization: המחיר של העברת מידע

⏱️ 2 דקות 📚 מערכות Event-Driven - חלק 5 ארכיטקטורה מערכתית #Event-Driven #Serialization

Serving - איך מודל מתחיל “לדבר עם העולם”

⏱️ 2 דקות תהליך הסקה #Serving #Batching

Simulation, FPGA, Emulation - איך בודקים את השבב לפני הייצור?

⏱️ 4 דקות 📚 מסע לעולם עיצוב השבבים - חלק 11 עיצוב שבבים #Simulation #FPGA

SLA: מה זה בעצם - ולמה ההגדרה עצמה כבר מגבילה

⏱️ 2 דקות ארכיטקטורה מערכתית #SLA #Reliability

SLO: היעד הפנימי שמגדיר איך המערכת אמורה להתנהג

⏱️ 2 דקות ארכיטקטורה מערכתית #SLO #Reliability

Stateless זה לא שאין State - זה איפה הוא נמצא

⏱️ 3 דקות 📚 כשהתקשורת נשברת - חלק 11 תקשורת #State #Stateless

TCP לעומת UDP - אמינות או מהירות

⏱️ 2 דקות 📚 איך מחשבים מדברים - חלק 6 תקשורת #TCP #UDP

The Cost of Simplicity - למה פשטות אמיתית יקרה יותר ממורכבות

⏱️ 2 דקות ארכיטקטורה מערכתית #פשטות #מורכבות

Thread Affinity - איך מצמידים תהליכים לליבות בצורה חכמה

⏱️ 2 דקות 📚 אופטימיזציה של חומרת הסקה - חלק 6 למידת מכונה חומרה #הצמדת תהליכים #אופטימיזציה #הסקה

Throttling: ההאטה שמצילה מערכת מקריסה

⏱️ 2 דקות ארכיטקטורה מערכתית #Throttling #Reliability

Timeouts - ההחלטה הקשה ביותר בתקשורת

⏱️ 3 דקות 📚 כשהתקשורת נשברת - חלק 2 תקשורת #Timeouts

Trade-off - למה החלטה הנדסית טובה תמיד כואבת קצת

⏱️ 2 דקות ארכיטקטורה מערכתית #Trade-off

TTM - למה Time To Market הוא חלק קריטי בהנדסת Inference ופתרונות AI?

⏱️ 3 דקות Business Strategy #TTM

vLLM - איך גורמים למודלים לדבר מהר, בלי לבזבז זיכרון

⏱️ 2 דקות vLLM #מנוע הסקה #Serving

Workaround - כשהמערכת לא מוכנה, אבל המציאות לא מחכה

⏱️ 2 דקות ארכיטקטורה מערכתית #Workaround

Yocto: למה לבנות מערכת ולא רק "להתקין לינוקס"

⏱️ 2 דקות כלי פיתוח #Yocto #Embedded

אופטימום (Optimum) - מה זה בכלל אומר?

⏱️ 2 דקות למידת מכונה #אופטימיזציה #Optimum

איך בונים סביבת Benchmarking עם Docker (כולל GPU)

⏱️ 2 דקות 📚 Docker למדידת ביצועים - חלק 3 תשתיות #Docker #ביצועים

איך מבטיחים סדר הודעות ב-RUD PDC? הסבר למתחילים (כולל דוגמה מוחשית)

⏱️ 2 דקות 📚 סדרת UET - חלק 3 תקשורת #UET #RUD PDC

איך מגדילים תפוקה בלי להאט את המערכת? (Batching, Stream Scheduling ו-Offload)

⏱️ 2 דקות אופטימיזציית הסקה #ביצועים #Throughput

איך מודדים מהירות של מודל בינה מלאכותית?

⏱️ 1 דקות מדדי ביצועים #Throughput #Latency

איך משלבים Docker ב-CI/CD להרצת Inference Benchmarking אוטומטי

⏱️ 2 דקות 📚 Docker למדידת ביצועים - חלק 5 תשתיות #Docker #CI/CD

איך עובד Inference בפועל?

⏱️ 2 דקות 📚 מסע אל עולם ההסקה - חלק 2 תהליך הסקה #אופטימיזציה

איך קונטיינרים תורמים לביצועים ולמדידה מדויקת ב-Inference Benchmarking

⏱️ 2 דקות 📚 Docker למדידת ביצועים - חלק 4 תשתיות #Docker #ביצועים

איך רעיון קטן של "קיצור דרך" הפך את ResNet למהפכה

⏱️ 2 דקות 📚 סדרת ResNet - חלק 2 ראייה ממוחשבת #ResNet #Skip Connection

איך רעיונות של ResNet הופיעו שוב במודלים רבים אחרים?

⏱️ 1 דקות 📚 סדרת ResNet - חלק 6 ראייה ממוחשבת #ResNet #ארכיטקטורה

איך שרתים מדברים זה עם זה - ומה ההבדל בין Ethernet, InfiniBand ו-RoCE?

⏱️ 2 דקות תקשורת #InfiniBand #RoCE

אין תמונה מלאה, ועדיין צריך להחליט

⏱️ 2 דקות 📚 הנדסה בלי נקודת התחלה - חלק 1 ארכיטקטורה מערכתית #קבלת החלטות #אי-ודאות

בדיקות רגרסיה - ולמה הן ההגנה החשובה ביותר נגד הידרדרות במערכת?

⏱️ 3 דקות כלי פיתוח #Testing #Regression

גרף דינמי או גרף סטטי - איך המודל שלך חושב?

⏱️ 2 דקות גרפים #גרף דינמי

הארגון הוא חלק מהמערכת (גם אם לא כתבת עליו שורה)

⏱️ 3 דקות 📚 הנדסה בקנה מידה אנושי - חלק 1 ארכיטקטורה מערכתית #ארגונים

האתגרים ב-Scaling - ולמה לפעמים “יותר” זה דווקא פחות?

⏱️ 3 דקות אופטימיזציית חומרה #סקיילינג

הבעיה ש-Tensor Parallelism פותר

⏱️ 2 דקות אופטימיזציית הסקה #חישוב מקבילי #Tensor Parallelism

הוספת Backend ל-PyTorch - למה זה חשוב ואיך זה עובד?

⏱️ 3 דקות Pytorch #Python #AI Frameworks

הנדסה בוגרת היא בחירת סיכונים

⏱️ 2 דקות 📚 הנדסה בלי נקודת התחלה - חלק 10 ארכיטקטורה מערכתית #בגרות הנדסית #ניהול סיכונים

הנדסה היא מערכת חברתית

⏱️ 2 דקות 📚 הנדסה בקנה מידה אנושי - חלק 10 ארכיטקטורה מערכתית #תרבות הנדסית #ארגונים

הנהגה שמאפשרת טעויות, לא מונעת אותן

⏱️ 3 דקות 📚 הנדסה בקנה מידה אנושי - חלק 6 ארכיטקטורה מערכתית #הנהגה #תרבות הנדסית

הנחת היסוד המסוכנת - הרשת אמינה "ברוב הזמן"

⏱️ 2 דקות 📚 כשהתקשורת נשברת - חלק 1 תקשורת #אי-ודאות

הקשר בין Yocto ל-Inference: למה סביבת הריצה חשובה כמו המודל

⏱️ 2 דקות כלי פיתוח #Yocto #Embedded

התמונה השלמה - איך כל חלקי התקשורת מתחברים למערכת אחת חיה

⏱️ 3 דקות 📚 איך מחשבים מדברים - חלק 13 תקשורת #חשיבה מערכתית #פרוטוקולים

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

⏱️ 3 דקות ארכיטקטורה מערכתית #Latency #Throughput #System Design

חומרה מול תוכנה - ההבדלים הבסיסיים שכל מי שמגיע מעולם הקוד צריך להבין

⏱️ 3 דקות 📚 מסע לעולם עיצוב השבבים - חלק 3 עיצוב שבבים #חומרה #תוכנה

חלוקת ליבות - איך לנהל נכון את כוח העיבוד שלך

⏱️ 2 דקות 📚 אופטימיזציה של חומרת הסקה - חלק 5 חומרה #ניהול ליבות #אופטימיזציה

כשאין זמן לאלגנטיות

⏱️ 2 דקות 📚 הנדסה בלי נקודת התחלה - חלק 3 ארכיטקטורה מערכתית #חוב טכני

כשהתקשורת נשברת - הנדסה תחת עומס, כשל ואי-ודאות

⏱️ 2 דקות 📚 כשהתקשורת נשברת - חלק 0 תקשורת #עומס #אי-ודאות

כשל כמידע, לא כאסון - איך מערכות לומדות דרך שבירה

⏱️ 2 דקות ארכיטקטורה מערכתית #Failure #Observability

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

⏱️ 2 דקות ארכיטקטורה מערכתית #Resilience #Isolation

כשמדדים משקרים

⏱️ 2 דקות 📚 כשהמערכת כבר רצה - חלק 3 ארכיטקטורה מערכתית #Metrics #Observability

כשמערכת משקפת מבנה ארגוני

⏱️ 4 דקות 📚 כשהמערכת כבר רצה - חלק 7 ארכיטקטורה מערכתית #ארגונים

כשצוותים נעים בקצבים שונים

⏱️ 2 דקות 📚 הנדסה בלי נקודת התחלה - חלק 7 ארכיטקטורה מערכתית #צוותים

לא מעמיסים על מערכת קרה

⏱️ 2 דקות ארכיטקטורה מערכתית #Cold Start #System Design

לבחור מה לא לשפר

⏱️ 2 דקות 📚 הנדסה בלי נקודת התחלה - חלק 5 ארכיטקטורה מערכתית #צוואר בקבוק

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

⏱️ 2 דקות ארכיטקטורה מערכתית #Observability #Logs

למה "יישור קו" הוא מושג מסוכן

⏱️ 3 דקות 📚 הנדסה בקנה מידה אנושי - חלק 5 ארכיטקטורה מערכתית #יישור קו

למה "מודל גדול יותר" הוא לעיתים קיצור דרך מוטעה

⏱️ 2 דקות Profiling #צוואר בקבוק #אופטימיזציית הסקה

למה "רק נוסיף Cache" הוא דגל אדום

⏱️ 2 דקות ארכיטקטורה מערכתית #Cache #System Design

למה "שרת" אינו מחשב אלא תפקיד שמחליף צורה

⏱️ 2 דקות התשתית שאף אחד לא מסביר #שרת #תפקיד #תשתית

למה Approximations מצילות מערכות

⏱️ 2 דקות ארכיטקטורה מערכתית #Approximation #System Design

למה Inference הוא בעיית מערכות, לא בעיית ML

⏱️ 2 דקות אופטימיזציית הסקה #Systems #Inference

למה Inference הוא המקום שבו אוטומציה נשברת

⏱️ 2 דקות אופטימיזציית הסקה #Inference #Automation

למה Inference הוא המקום שבו זמן הופך לחומר

⏱️ 2 דקות אופטימיזציית הסקה #Inference #Latency

למה Inference הוא המקום שבו מודולריות נכשלת

⏱️ 2 דקות אופטימיזציית הסקה #Inference #מודולריות

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

⏱️ 3 דקות אופטימיזציית הסקה #Inference #Scheduling

למה Inference הוא מערכת עם זיכרון קצר

⏱️ 2 דקות אופטימיזציית הסקה #Inference #System Design

למה Inference הוא מערכת של פשרות, לא של אופטימיזציה

⏱️ 2 דקות אופטימיזציית הסקה #Inference #Trade-off

למה Inference טוב "מבזבז" משאבים בכוונה

⏱️ 2 דקות אופטימיזציית הסקה #Inference #יציבות

למה Inference טוב לא מנסה להיות גנרי

⏱️ 2 דקות אופטימיזציית הסקה #Inference #System Design

למה Inference טוב לא מנסה להיות חכם

⏱️ 2 דקות אופטימיזציית הסקה #Inference #יציבות

למה Inference טוב לא מנסה לנצח את הזמן

⏱️ 2 דקות אופטימיזציית הסקה #Inference #Latency

למה Inference טוב מתוכנן גם לאנשים שטועים

⏱️ 2 דקות אופטימיזציית הסקה #Inference #Resilience

למה Inference טוב מתוכנן סביב קצב טבעי

⏱️ 3 דקות אופטימיזציית הסקה #Inference #Throughput

למה Inference טוב מתייחס ל-Silence כאל אות

⏱️ 2 דקות אופטימיזציית הסקה #Inference #Observability

למה Inference טוב מתנהג אותו דבר גם כשאף אחד לא מסתכל

⏱️ 2 דקות אופטימיזציית הסקה #Inference #אמינות

למה Inference יציב דורש החלטות לא הפיכות

⏱️ 2 דקות אופטימיזציית הסקה #Inference #System Design

למה Inference לא אוהב הפתעות - גם טובות

⏱️ 2 דקות אופטימיזציית הסקה #Inference #Latency

למה Inference לא אוהב מצבי ביניים

⏱️ 2 דקות אופטימיזציית הסקה #Inference #יציבות

למה Inference לא אוהב שיפורים הדרגתיים

⏱️ 2 דקות אופטימיזציית הסקה #Inference #Latency

למה Inference לא סובל אמביוולנטיות

⏱️ 2 דקות אופטימיזציית הסקה #Inference #קבלת החלטות

למה ResNet משמשת כ-Backbone במודלים כמו YOLO, DETR ומערכות סגמנטציה?

⏱️ 1 דקות 📚 סדרת ResNet - חלק 5 ראייה ממוחשבת #ResNet #Backbone

למה Resource Lifecycle חשוב יותר מאלגוריתם

⏱️ 2 דקות ארכיטקטורה מערכתית #Resource Management #Reliability

למה Verification הוא חלק מביצועים

⏱️ 2 דקות Profiling #Testing #אופטימיזציית הסקה

למה אי-ודאות קטנה היא אויב של סקייל

⏱️ 2 דקות ארכיטקטורה מערכתית #Scale #Tail Latency

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

⏱️ 3 דקות 📚 הנדסה בקנה מידה אנושי - חלק 7 ארכיטקטורה מערכתית #למידה ארגונית #Postmortem

למה בכלל צריך להבין חומרה כשעוסקים באופטימיזציות Inference?

⏱️ 2 דקות 📚 אופטימיזציה של חומרת הסקה - חלק 1 חומרה #אופטימיזציה #הסקה

למה המודל שלך “מרגיש איטי”?

⏱️ 2 דקות Profiling #מדידת ביצועים #צוואר בקבוק

למה המודל שלך לא מספיק? - Scaling ב-AI

⏱️ 2 דקות אופטימיזציית חומרה #סקיילינג #הסקה

למה המודל שלך לא רץ מהר כמו שציפית? Bottlenecks באינפרנס

⏱️ 2 דקות 📚 מסע אל עולם ההסקה - חלק 4 אתגרי הסקה #צווארי בקבוק #אופטימיזציה

למה הפרמטר הכי חשוב הוא זה שאין לך גישה אליו

⏱️ 2 דקות ארכיטקטורה מערכתית #System Design #Resilience

למה התנהגות בין Warm ל-Cold היא מקור להפתעות מסוכנות

⏱️ 2 דקות ארכיטקטורה מערכתית #Cold Start #System Design

למה זיכרון מגביל ביצועים בגלל זמן גישה, לא בגלל גודל

⏱️ 2 דקות ארכיטקטורה מערכתית #Memory #Latency

למה חייבת להיות הפרדה בין Test Code לקוד Production במערכות ML?

⏱️ 3 דקות כלי פיתוח #Testing #MLOps

למה כולם מדברים על Python כשמדברים על Machine Learning?

⏱️ 2 דקות שפות תכנות #Python

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

⏱️ 2 דקות ארכיטקטורה מערכתית #Observability #Benchmark

למה מערכות גדולות נופלות לאט

⏱️ 2 דקות ארכיטקטורה מערכתית #Degradation #Reliability

למה מערכות נופלות דווקא כשהן מצליחות

⏱️ 2 דקות ארכיטקטורה מערכתית #Scalability #Reliability

למה מערכת טובה "מדברת בשקט"

⏱️ 2 דקות ארכיטקטורה מערכתית #Observability #Alerting

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

⏱️ 2 דקות ארכיטקטורה מערכתית #Rate Limiting #System Design

למה מערכת טובה נראית "משעממת" בגרפים

⏱️ 2 דקות ארכיטקטורה מערכתית #Observability #Metrics

למה מערכת שלא נכשלת לעולם היא מסוכנת

⏱️ 2 דקות ארכיטקטורה מערכתית #Failure #Observability

למה מערכת שעובדת ב-99% מהזמן היא מערכת גרועה

⏱️ 2 דקות ארכיטקטורה מערכתית #Reliability #Availability

למה פרוטוקולים מתפתחים - ולעולם לא מוחלפים לגמרי

⏱️ 2 דקות 📚 איך מחשבים מדברים - חלק 11 תקשורת #פרוטוקולים #Backward Compatibility

למה צווארי בקבוק נודדים - ולא נשארים במקום אחד

⏱️ 2 דקות ארכיטקטורה מערכתית #Bottleneck #System Design

למה צריך שכבות בתקשורת - ולמה "פתרון אחד להכול" נכשל

⏱️ 2 דקות 📚 איך מחשבים מדברים - חלק 3 תקשורת #שכבות תקשורת

למה קוד נקי יכול להסתיר מערכת לא ברורה

⏱️ 2 דקות ארכיטקטורה מערכתית #Code Quality #System Behavior

למה רוב בעיות הביצועים הן בעיות תזמון

⏱️ 2 דקות ארכיטקטורה מערכתית #Scheduling #Performance

למה רוב האופטימיזציות לא ניתנות להוכחה

⏱️ 2 דקות ארכיטקטורה מערכתית #Optimization #System Design

למה רוב מערכות ה-Inference לא מנצלות את החומרה שלהן

⏱️ 2 דקות אופטימיזציית הסקה #Utilization #Inference

למה רשתות עמוקות התחילו "להישבר" - ומה הייתה הבעיה ש-ResNet באה לפתור?

⏱️ 3 דקות 📚 סדרת ResNet - חלק 1 ראייה ממוחשבת #ResNet #רשתות עמוקות

למה תורים הם הלב הסמוי של תקשורת

⏱️ 2 דקות 📚 איך מחשבים מדברים - חלק 9 תקשורת #Queues #Latency

מאחורי הקלעים של Benchmark - מה באמת נמדד כשמודדים Inference

⏱️ 2 דקות חומרה #Firmware #Benchmark

מאחורי הקלעים של המודל שלך - מה זה גרף חישובי?

⏱️ 1 דקות גרפים #Computation Graph #Inference

מה בעצם למדנו על הנדסה בקנה מידה אנושי

⏱️ 3 דקות 📚 הנדסה בקנה מידה אנושי - חלק 11 ארכיטקטורה מערכתית #תרבות הנדסית #ארגונים

מה ההבדל בין OpenAI Completion Format ל-OpenAI Chat Format?

⏱️ 3 דקות AI Frameworks #OpenAI #LLM

מה ההבדל בין מערכת מבוזרת למערכת מקבילית?

⏱️ 3 דקות פרודקשן #מערכת מבוזרת #חישוב מקבילי

מה הם מספרי רפרנס - ולמה הם קריטיים כשמבצעים בנצ'מרקינג למודלים?

⏱️ 4 דקות מדידת הסקה #Benchmark #Reference Numbers

מה זה Broker - ולמה הוא אף פעם לא "רק צינור"

⏱️ 3 דקות 📚 מערכות Event-Driven - חלק 3 ארכיטקטורה מערכתית #Event-Driven #Broker

מה זה Cache ולמה הוא משנה הכל?

⏱️ 1 דקות 📚 אופטימיזציה של חומרת הסקה - חלק 4 חומרה #זיכרון מטמון #אופטימיזציה

מה זה Connection - ולמה חיבור הוא מצב לוגי, לא כבל

⏱️ 2 דקות 📚 איך מחשבים מדברים - חלק 7 תקשורת #Connection

מה זה Docker ולמה כולם משתמשים בו?

⏱️ 2 דקות 📚 Docker למדידת ביצועים - חלק 1 תשתיות #Docker #קונטיינרים

מה זה Event (ומה זה לא)

⏱️ 2 דקות 📚 מערכות Event-Driven - חלק 1 ארכיטקטורה מערכתית #Event-Driven #Events

מה זה FPS - ולמה מדד זה כל כך חשוב במודלי vision?

⏱️ 2 דקות ראייה ממוחשבת #FPS #ביצועים

מה זה Happy Path - ולמה הוא מסוכן כשמתכננים רק אותו

⏱️ 2 דקות ארכיטקטורה מערכתית #Happy Path #Design for Failure

מה זה HBM - ולמה הוא משנה את כללי המשחק בביצועי AI?

⏱️ 3 דקות חומרה #HBM #זיכרון

מה זה heuristics - ולמה מערכות אוהבות ושונאות אותן בו-זמנית

⏱️ 2 דקות כלי פיתוח #Heuristics #System Design

מה זה Hop

⏱️ 1 דקות 📚 מערכות Event-Driven - חלק 4 ארכיטקטורה מערכתית #Event-Driven #Hop

מה זה Kernel Fusion - ואיך הוא מאיץ את המודל שלך בלי לשנות אותו

⏱️ 2 דקות אופטימיזציית הסקה #קרנל

מה זה llm-d - הספרייה/הפרויקט הפתוח לפריסה בקנה מידה של מודלים גדולים

⏱️ 2 דקות vLLM #Serving #Kubernetes

מה זה NCHW - ולמה כולם מדברים על זה כשמדובר בטנזורים של רשתות נוירונים?

⏱️ 2 דקות ראייה ממוחשבת #NCHW #Pytorch

מה זה NUMA ולמה זה חשוב באופטימיזציות Inference?

⏱️ 2 דקות 📚 אופטימיזציה של חומרת הסקה - חלק 2 חומרה #NUMA #הסקה

מה זה Packet - ולמה לא שולחים מידע כיחידה אחת

⏱️ 2 דקות 📚 איך מחשבים מדברים - חלק 5 תקשורת #Packet

מה זה Place & Route - ואיך ממצבים את השערים על השבב ומחברים ביניהם?

⏱️ 3 דקות 📚 מסע לעולם עיצוב השבבים - חלק 9 עיצוב שבבים #Place & Route #Backend

מה זה Routing - ולמה הוא משפיע יותר ממה שנדמה

⏱️ 2 דקות ארכיטקטורה מערכתית #Routing #Load Balancing

מה זה Semiconductors ולמה הם הבסיס של כל טכנולוגיה מודרנית?

⏱️ 2 דקות חומרה #Semiconductors #שבבים

מה זה STA - Static Timing Analysis - ואיך מוודאים שהשבב יעבוד בתדר הנכון?

⏱️ 4 דקות 📚 מסע לעולם עיצוב השבבים - חלק 10 עיצוב שבבים #STA #Timing

מה זה Steady State - ולמה מערכות נופלות כשמתכננים רק אליו

⏱️ 2 דקות ארכיטקטורה מערכתית #Steady State #System Design

מה זה Tapeout - והאם באמת שולחים קלטת לייצור?

⏱️ 3 דקות 📚 מסע לעולם עיצוב השבבים - חלק 12 עיצוב שבבים #Tapeout #Production

מה זה Verification - ולמה 70% מפיתוח שבבים הוא בדיקות?

⏱️ 3 דקות 📚 מסע לעולם עיצוב השבבים - חלק 7 עיצוב שבבים #Verification #בדיקות

מה זה בעצם AI Deployment - ואיך זה שונה מ"להריץ מודל"?

⏱️ 2 דקות פרודקשן #Deployment #Serving

מה זה בעצם Attention Mask - ולמה הוא חשוב?

⏱️ 2 דקות AI Frameworks #Attention Mask #Tokenizer

מה זה בעצם BUS - ולמה כל רכיב במחשב תלוי בו?

⏱️ 3 דקות חומרה #Bus #ארכיטקטורת מחשב

מה זה בעצם Data Drift - ואיך הוא משפיע על Inference?

⏱️ 2 דקות פרודקשן #Data Drift #MLOps

מה זה בעצם DDR - ולמה זה חשוב כל כך?

⏱️ 3 דקות חומרה #DDR #זיכרון

מה זה בעצם DLA - ולמה מאיץ ייעודי משנה את כללי המשחק?

⏱️ 2 דקות חומרה #DLA #מאיץ

מה זה בעצם Docker, Image ו-Container?

⏱️ 2 דקות 📚 Docker למדידת ביצועים - חלק 2 תשתיות #Docker #קונטיינרים

מה זה בעצם DSP - ולמה זה חשוב גם בעולמות של AI?

⏱️ 2 דקות חומרה #DSP #אופטימיזציית הסקה

מה זה בעצם Firmware - ולמה זה משנה לביצועי AI

⏱️ 2 דקות חומרה #Firmware #אופטימיזציית הסקה

מה זה בעצם HPC - ולמה עולם המחשוב המודרני לא יכול בלעדיו?

⏱️ 3 דקות חומרה #HPC #חישוב מקבילי

מה זה בעצם ImageNet - ולמה הוא היה נקודת מפנה בעולם הראייה הממוחשבת?

⏱️ 3 דקות ראייה ממוחשבת #ImageNet #Datasets

מה זה בעצם Inference Benchmarking - ולמה זה כל כך חשוב?

⏱️ 2 דקות מדידת הסקה #ביצועים #Throughput #Latency

מה זה בעצם Knob

⏱️ 2 דקות ארכיטקטורה מערכתית #Knob #System Design

מה זה בעצם MLPerf - ולמה הוא הפך ל"מדד האמת" של ביצועי AI?

⏱️ 3 דקות מדידת הסקה #ביצועים #Benchmark

מה זה בעצם Negative Testing - ולמה מערכות טובות נבנות דווקא מהשגיאות?

⏱️ 2 דקות כלי פיתוח #Testing #Negative Testing

מה זה בעצם NIC - ולמה הוא קריטי בעולמות של Inference?

⏱️ 2 דקות חומרה #NIC #תקשורת

מה זה בעצם NMS - ולמה YOLO לא יכול לעבוד בלעדיו?

⏱️ 2 דקות ראייה ממוחשבת #NMS #YOLO

מה זה בעצם Offload - ולמה כולם מדברים על זה באופטימיזציה?

⏱️ 2 דקות אופטימיזציית הסקה #Offload #ביצועים

מה זה בעצם PCI Express - ולמה הוא קריטי במערכות חישוב מתקדמות?

⏱️ 2 דקות תקשורת #PCIe #חומרה

מה זה בעצם Pillow - ולמה כמעט כל קוד שעובד עם תמונות משתמש בה?

⏱️ 2 דקות ראייה ממוחשבת #Pillow #Python

מה זה בעצם Pipeline של מודל?

⏱️ 2 דקות למידת מכונה #Model Pipeline #MLOps

מה זה בעצם RUD PDC - ולמה מערכות תקשורת משתמשות בו?

⏱️ 3 דקות 📚 סדרת UET - חלק 1 תקשורת #RUD PDC #UET

מה זה בעצם SDK - ולמה כמעט כל מערכת תוכנה מודרנית בנויה עליו?

⏱️ 3 דקות כלי פיתוח #SDK

מה זה בעצם Smoke Test - ולמה הוא השלב הראשון בכל מערכת תוכנה?

⏱️ 2 דקות כלי פיתוח #Testing #Smoke Test

מה זה בעצם SMOTE - ולמה משתמשים בו כשרוצים לאזן נתונים?

⏱️ 3 דקות למידת מכונה #SMOTE #Preprocessing

מה זה בעצם Switch - ולמה הוא כל כך מרכזי בעולם התקשורת?

⏱️ 2 דקות תקשורת #Switch #רשתות

מה זה בעצם Technical Debt?

⏱️ 2 דקות ארכיטקטורה מערכתית #Technical Debt

מה זה בעצם UET, ולמה מערכות תקשורת לא יכולות לעבוד בלעדיו?

⏱️ 2 דקות 📚 סדרת UET - חלק 2 תקשורת #UET #RUD PDC

מה זה בעצם ViT - ולמה הוא שינוי תפיסתי בעולם הראייה הממוחשבת?

⏱️ 3 דקות ראייה ממוחשבת #טרנספורמר #ViT

מה זה בעצם VLSI - ולמה כל שבב מודרני מתחיל ממנו?

⏱️ 2 דקות חומרה #VLSI #שבבים

מה זה בעצם YOLO - ולמה הוא הפך לסטנדרט בזיהוי אובייקטים בזמן אמת?

⏱️ 2 דקות ראייה ממוחשבת #YOLO #זיהוי אובייקטים

מה זה בעצם אקו-סיסטם בעולם הטכנולוגיה וה-AI?

⏱️ 2 דקות 📚 חומרת AI & תשתיות - חלק 7 תשתיות #אקו-סיסטם #מסגרות עבודה

מה זה בעצם מאיץ (Accelerator)?

⏱️ 2 דקות 📚 חומרת AI & תשתיות - חלק 4 חומרה #מאיץ #GPU

מה זה בעצם מנוע Inference - ולמה הוא כל כך חשוב?

⏱️ 2 דקות 📚 מסע אל עולם ההסקה - חלק 6 אופטימיזציית הסקה #מנועים #vLLM

מה זה בעצם סקייל (Scale)?

⏱️ 2 דקות ארכיטקטורה מערכתית #Scale #System Design

מה זה לוח מעגל (PCB) ולמה הוא הבסיס של כל מחשב?

⏱️ 2 דקות חומרה #PCB #Motherboard

מה זה ליבות (Cores) ו-Threads?

⏱️ 1 דקות 📚 אופטימיזציה של חומרת הסקה - חלק 3 חומרה #ליבות #תהליכונים

מה זה מחשב ברשת - ולמה כתובת אינה מיקום

⏱️ 2 דקות 📚 איך מחשבים מדברים - חלק 4 תקשורת #כתובות רשת

מה זה סיליקון ואיך הוא קשור לשבבים, לתוכנה - ולעמק הסיליקון?

⏱️ 2 דקות חומרה #Silicon #שבבים

מה זה שבב? ההסבר הפשוט ביותר להתחלה בעולם החומרה

⏱️ 2 דקות 📚 מסע לעולם עיצוב השבבים - חלק 1 עיצוב שבבים #שבבים #חומרה

מה למדנו - מפת הדרך של הסדרה כולה

⏱️ 4 דקות 📚 כשהתקשורת נשברת - חלק 14 תקשורת #תרבות הנדסית #אי-ודאות

מה מסתתר מאחורי נוסחת ה-Quantization?

⏱️ 3 דקות אופטימיזציית הסקה #Quantization #Inference

מה קורה מאחורי הקלעים כשהמודל עונה לך? (Prefill, Decoding ו-KV Cache)

⏱️ 2 דקות 📚 מסע אל עולם ההסקה - חלק 3 הסקה #Prefill #Decode #KV Cache

מהו “ארגז חול” ולמה הוא חיוני ל-AI?

⏱️ 3 דקות כלי פיתוח #סביבות בדיקה

מהו Bottleneck Block, ולמה הוא מאפשר ל-ResNet50 להיות גם עמוקה וגם קלה

⏱️ 2 דקות 📚 סדרת ResNet - חלק 3 ראייה ממוחשבת #ResNet #Bottleneck Block

מהו DFT - ולמה שבב חייב להיות "ניתן לבדיקה" כבר משלב התכנון?

⏱️ 3 דקות 📚 מסע לעולם עיצוב השבבים עיצוב שבבים #DFT #Verification

מהו Frontend בעולם השבבים?

⏱️ 3 דקות 📚 מסע לעולם עיצוב השבבים - חלק 4 עיצוב שבבים #Frontend #תכנון לוגי

מהו Inference ולמה הוא קורה אחרי Training?

⏱️ 2 דקות 📚 מסע אל עולם ההסקה - חלק 1 הסקה #אימון מודלים

מהו Kernel?

⏱️ 2 דקות האצת חומרה #קרנל #חישוב מקבילי

מהו Thread Pool - ולמה הוא קיים בכלל

⏱️ 2 דקות ארכיטקטורה מערכתית #Thread Pool #Concurrency

מהו פרוטוקול - ולמה חופש מוחלט יוצר כאוס

⏱️ 2 דקות 📚 איך מחשבים מדברים - חלק 2 תקשורת #פרוטוקולים

מהי Synthesis - וכיצד RTL הופך לשערים אמיתיים בשבב?

⏱️ 3 דקות 📚 מסע לעולם עיצוב השבבים - חלק 8 עיצוב שבבים #Synthesis #Backend

מהי ארכיטקטורת שבב - ולמה היא השלב שבו מחליטים מה השבב באמת יהיה?

⏱️ 3 דקות 📚 מסע לעולם עיצוב השבבים - חלק 6 עיצוב שבבים #ארכיטקטורה #תכנון מערכת

מהי בכלל תקשורת - ולמה חיבור פיזי לא מספיק

⏱️ 2 דקות 📚 איך מחשבים מדברים - חלק 1 תקשורת #יסודות תקשורת

מהי מערכת מבוזרת - ולמה כמעט כל מערכת מודרנית היא כזו?

⏱️ 3 דקות פרודקשן #מערכת מבוזרת #ארכיטקטורה

מהי מערכת על שבב (SoC) - ולמה שבב אחד יכול להכיל עולם שלם בתוכו?

⏱️ 3 דקות 📚 מסע לעולם עיצוב השבבים - חלק 2 עיצוב שבבים #SoC #ארכיטקטורה

מהי רגרסיה - ולמה זה מושג קריטי בבדיקות תוכנה ובנצ'מרקינג?

⏱️ 2 דקות כלי פיתוח #Testing #Regression

מהנדסים בוגרים לא מחפשים שליטה

⏱️ 2 דקות 📚 כשהמערכת כבר רצה - חלק 11 ארכיטקטורה מערכתית #בגרות הנדסית

מהנדסים שמובילים בלי סמכות

⏱️ 3 דקות 📚 הנדסה בלי נקודת התחלה - חלק 6 ארכיטקטורה מערכתית #הובלה #Alignment

מנועי DMA - איך הנתונים זזים בלי להעמיס על המעבד

⏱️ 2 דקות חומרה #DMA #אופטימיזציית הסקה

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

⏱️ 2 דקות 📚 כשהתקשורת נשברת - חלק 13 תקשורת #תרבות הנדסית #אי-ודאות

מערכת שלא מתבגרת לבד

⏱️ 2 דקות 📚 הנדסה בלי נקודת התחלה - חלק 8 ארכיטקטורה מערכתית #בגרות הנדסית

מצאתם צוואר בקבוק? הנה מה עושים עכשיו

⏱️ 2 דקות Profiling #צווארי בקבוק #אופטימיזציית הסקה

משפחת ResNet: מה ההבדל בין ResNet18, 34, 50, 101 - ומתי בוחרים כל אחת?

⏱️ 2 דקות 📚 סדרת ResNet - חלק 4 ראייה ממוחשבת #ResNet #ResNet50

מתי Knob הוא ברכה - ומתי הוא סימן אזהרה

⏱️ 2 דקות ארכיטקטורה מערכתית #Knob #System Design

מתי לארגון אין יותר capacity לשיפור

⏱️ 2 דקות 📚 הנדסה בקנה מידה אנושי - חלק 8 ארכיטקטורה מערכתית #Capacity

מתי לעזוב מערכת

⏱️ 3 דקות 📚 הנדסה בלי נקודת התחלה - חלק 9 ארכיטקטורה מערכתית #בגרות הנדסית

מתי צריך לשבור מבנה ארגוני

⏱️ 3 דקות 📚 הנדסה בקנה מידה אנושי - חלק 9 ארכיטקטורה מערכתית #מבנה ארגוני

סיכום הסדרה: המסע המלא מרעיון לשבב - כל השלבים במבט אחד

⏱️ 5 דקות 📚 מסע לעולם עיצוב השבבים - חלק 14 עיצוב שבבים #סיכום #סקירה

סיכום הסדרה: מ-NUMA ועד Throughput - איך אופטימיזציה הופכת חומרה לביצועים

⏱️ 2 דקות 📚 אופטימיזציה של חומרת הסקה - חלק 9 למידת מכונה חומרה #אופטימיזציה #NUMA #הצמדת תהליכים #ניהול משאבים

סינכרוניות ואסינכרוניות: שתי דרכים שונות לגרום למערכת לעבוד

⏱️ 2 דקות ארכיטקטורה מערכתית #Async #System Design

צוואר בקבוק גלוי מול צוואר בקבוק סמוי - ומה הופך את הסמוי למסוכן יותר

⏱️ 2 דקות ארכיטקטורה מערכתית #Bottleneck #Observability

רוחב פס בזיכרון ובשבבים - למה זה קריטי לביצועי מערכות AI

⏱️ 2 דקות חומרה #Bandwidth #זיכרון

תהליכים שנולדו לסקייל, אבל הורגים תגובתיות

⏱️ 2 דקות 📚 הנדסה בקנה מידה אנושי - חלק 4 ארכיטקטורה מערכתית #תהליכים #סקייל

תמריצים חזקים יותר מארכיטקטורה

⏱️ 2 דקות 📚 הנדסה בקנה מידה אנושי - חלק 2 ארכיטקטורה מערכתית #תמריצים

תקשורת כמשקפת תרבות הנדסית

⏱️ 3 דקות 📚 כשהתקשורת נשברת - חלק 12 תקשורת #תרבות הנדסית

תקשורת כראי לחשיבה מערכתית

⏱️ 2 דקות 📚 איך מחשבים מדברים - חלק 12 תקשורת #חשיבה מערכתית