From 84d8463aa1c5f98b652bb5fe0d6700f2f3bacda1 Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Sat, 7 Jun 2025 14:53:52 +0300
Subject: [PATCH 01/43] Added raw hebrew README file
---
README-he.md | 0
1 file changed, 0 insertions(+), 0 deletions(-)
create mode 100644 README-he.md
diff --git a/README-he.md b/README-he.md
new file mode 100644
index 00000000..e69de29b
From bc9ebefad654e43cb2d3cd27e8fcf10d5c6f9494 Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Sat, 7 Jun 2025 16:16:12 +0300
Subject: [PATCH 02/43] Translating - Motivation
---
README-he.md | 51 +++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 51 insertions(+)
diff --git a/README-he.md b/README-he.md
index e69de29b..a90430ec 100644
--- a/README-he.md
+++ b/README-he.md
@@ -0,0 +1,51 @@
+*[English](README.md) ∙ [日本語](README-ja.md) ∙ [简体中文](README-zh-Hans.md) ∙ [繁體中文](README-zh-TW.md) | [العَرَبِيَّة](https://github.com/donnemartin/system-design-primer/issues/170) ∙ [বাংলা](https://github.com/donnemartin/system-design-primer/issues/220) ∙ [Português do Brasil](https://github.com/donnemartin/system-design-primer/issues/40) ∙ [Deutsch](https://github.com/donnemartin/system-design-primer/issues/186) ∙ [ελληνικά](https://github.com/donnemartin/system-design-primer/issues/130) ∙ [עברית](https://github.com/donnemartin/system-design-primer/issues/272) ∙ [Italiano](https://github.com/donnemartin/system-design-primer/issues/104) ∙ [한국어](https://github.com/donnemartin/system-design-primer/issues/102) ∙ [فارسی](https://github.com/donnemartin/system-design-primer/issues/110) ∙ [Polski](https://github.com/donnemartin/system-design-primer/issues/68) ∙ [русский язык](https://github.com/donnemartin/system-design-primer/issues/87) ∙ [Español](https://github.com/donnemartin/system-design-primer/issues/136) ∙ [ภาษาไทย](https://github.com/donnemartin/system-design-primer/issues/187) ∙ [Türkçe](https://github.com/donnemartin/system-design-primer/issues/39) ∙ [tiếng Việt](https://github.com/donnemartin/system-design-primer/issues/127) ∙ [Français](https://github.com/donnemartin/system-design-primer/issues/250) | [Add Translation](https://github.com/donnemartin/system-design-primer/issues/28)*
+
+**עזרו [לתרגם](TRANSLATIONS.md) את המדריך!**
+
+# המדריך לתכנון מערכות (The System Design Primer)
+
+
+
+
+
+
+## מוטיבציה
+
+
+
+> ללמוד איך לתכנן מערכות ב-scale גדול.
+>
+> להתכונן לראיונות ארכיטקטורה.
+
+
+### ללמוד איך לתכנן מערכות ב-scale גדול
+
+ללמוד כיצד לתכנן מערכות סְקֵילָבִּילִיוּת יסייע לך להפוך למהנדס תוכנה טוב יותר.
+
+תכנון מערכות הוא נושא רחב. יש **כמות אדירה של משאבים ברחבי הרשת** על עקרונות של תכנון מערכות.
+
+ה-repo הזה הוא **אוסף מסודר** של משאבים שנועדו לעזור לך ללמוד איך לבנות מערכות ב-scale.
+
+### ללמוד מקהילת הקוד הפתוח
+
+מדובר בפרויקט קוד פתוח (open source) שמתעדכן באופן מתמשך.
+
+מוזמנים [לתרום!](#contributing)
+
+### להתכונן לראיונות ארכיטקטורה
+
+בנוסף לראיונות קידוד, ארכיטקטורה היא **רכיב נדרש** כחלק מתהליך **ראיונות טכניים** בהרבה חברות טכנולוגיות.
+
+**תוכל לתרגל שאלות ארכיטקטורה נפוצות** ואף **להשוות** את התוצאות שלך עם **פתרונות לדוגמה**: דיונים, קוד, ודיאגרמות.
+
+### נושאים נוספים להכנה לראיונות:
+
+
+
+
From e0a6ce9a815c3df97f10750b1d695f36bc1a145c Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Sat, 7 Jun 2025 20:22:53 +0300
Subject: [PATCH 03/43] Translating - Anki flashcards
---
README-he.md | 36 ++++++++++++++++++++++++++++++++++++
1 file changed, 36 insertions(+)
diff --git a/README-he.md b/README-he.md
index a90430ec..f8d4867f 100644
--- a/README-he.md
+++ b/README-he.md
@@ -49,3 +49,39 @@
+
+## כרטיסיות Anki
+
+
+
+
+
+
+
+
+החבילות המוכנות של כרטיסיות [Anki](https://apps.ankiweb.net/) משתמשות בשיטת **חזרתיות מבוססת מרווחים (Spaced Repetition)** כדי לעזור לך לזכור מושגים חשובים בתכנון מערכות.
+
+
+
+מומלצות לשימוש בדרכים.
+
+### משאב לראיונות קידוד: אתגרי קידוד אינטראקטיביים
+
+מחפש משאבים שיעזרו לך להתכונן [**לראיונות קידוד**](https://github.com/donnemartin/interactive-coding-challenges)?
+
+
+
+
+
+
+תעיף מבט על ה-repo המקביל [**Interactive Coding Challenges**](https://github.com/donnemartin/interactive-coding-challenges), שמכיל חבילת Anki נוספת:
+
+
+
+
From 2404f072ca71db8d5f264c4926f954715b378288 Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Sun, 8 Jun 2025 12:53:00 +0300
Subject: [PATCH 04/43] Translating - Contributing
---
README-he.md | 21 +++++++++++++++++++++
1 file changed, 21 insertions(+)
diff --git a/README-he.md b/README-he.md
index f8d4867f..09ed3e4f 100644
--- a/README-he.md
+++ b/README-he.md
@@ -85,3 +85,24 @@
+
+## תרומה למדריך
+
+
+
+> ללמוד מהקהילה.
+
+אל תהסס להגיש pull requests כדי לעזור:
+
+
+
+תכנים שעדיין דורשים ליטוש מסומנים בתור
תחת פיתוח.
+
+מומלץ לעיין ב
הנחיות לתרומה לפני התחלה.
+
+
From 56240af73ceb48e42dbccbf8d4c49379fe77b40c Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Sun, 8 Jun 2025 17:50:46 +0300
Subject: [PATCH 05/43] Translating - Index of system design topics
---
README-he.md | 152 +++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 152 insertions(+)
diff --git a/README-he.md b/README-he.md
index 09ed3e4f..bf5ca424 100644
--- a/README-he.md
+++ b/README-he.md
@@ -106,3 +106,155 @@
מומלץ לעיין בהנחיות לתרומה לפני התחלה.
+
+## אינדקס נושאים בתכנון מערכות
+
+
+
+> סיכומים של נושאים שונים בתכנון מערכות, כולל יתרונות וחסרונות. **כל החלטה כוללת פשרות (trade-offs)**.
+>
+> כל חלק מכיל קישורים להרחבה וללמידה מעמיקה יותר.
+
+
+
+
+
+
+
+
+
+
+
From 9e6f1f4a1445c5544a8a5b75fa154056d14c7e76 Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Sun, 8 Jun 2025 17:59:58 +0300
Subject: [PATCH 06/43] Trying to fix rtl in list
---
README-he.md | 34 +++++++++++++++++-----------------
1 file changed, 17 insertions(+), 17 deletions(-)
diff --git a/README-he.md b/README-he.md
index bf5ca424..d4fad973 100644
--- a/README-he.md
+++ b/README-he.md
@@ -134,8 +134,8 @@
@@ -206,19 +206,19 @@
מטמון (Cache)
@@ -232,10 +232,10 @@
תקשורת
אבטחה
From 3b761c568a519a51e1ae2e3b3d840b16d0a5c219 Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Sun, 8 Jun 2025 18:18:27 +0300
Subject: [PATCH 07/43] Translating - Study guide
---
README-he.md | 88 ++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 88 insertions(+)
diff --git a/README-he.md b/README-he.md
index d4fad973..880fcf7d 100644
--- a/README-he.md
+++ b/README-he.md
@@ -257,4 +257,92 @@
+## מדריך למידה
+
+
+> נושאים מוצעים ללימוד לפי לוח הזמנים לריאיון שלך (קצר, בינוני, ארוך)
+
+
+
+**ש: עבור הראיונות, האם אני אמור לדעת כל מה שכתוב כאן?**
+
+**ת: לא, אתה לא צריך לדעת הכול כדי להתכונן לריאיון**.
+
+מה שאתה תישאל עליו בריאיון תלוי בדברים כגון:
+
+
+ - כמה ניסיון יש לך
+ - מה הרקע הטכני שלך
+ - לאילו משרות אתה מתראיין
+ - באילו חברות אתה מתראיין
+ - מזל
+
+
+לרוב מצופה ממועמדים מנוסים יותר לדעת יותר על ארכיטקטורה ותכנון מערכות. ארכיטקטים או ראשי צוותים מצופים לדעת יותר מאשר עובדים בודדים. חברות טכנולוגיות מובילות לרוב יערכו ריאיון אחד או יותר של ארכיטקטורה.
+
+רצוי להתחיל רחב ולהעמיק במספר תחומים. זה עוזר לדעת קצת בנוגע למספר נושאי מפתח בתכנון מערכות. תתאים את המדריך לפי לוח הזמן שלך, הניסיון, המשרות שאתה מתראיין אליהן, והחברות שבהן אתה מתראיין.
+
+
+ - לוח זמנים קצר – התמקד ברוחב של נושאים בתכנון מערכות. תרגל פתרון של כמה שאלות ריאיון.
+ - לוח זמנים בינוני – התמקד ברוחב וקצת עומק של נושאים בתכנון מערכות. תרגל פתרון של הרבה שאלות ריאיון.
+ - לוח זמנים ארוך – התמקד ברוחב ויותר עומק של נושאים בתכנון מערכות. תרגל פתרון של רוב שאלות הריאיון.
+
+
+
+
+
+
From 030f375d8b580f509116a01ba7cf4de2eb5580bd Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Sun, 8 Jun 2025 18:21:17 +0300
Subject: [PATCH 08/43] Inserted index list into expandable details
---
README-he.md | 253 ++++++++++++++++++++++++++-------------------------
1 file changed, 128 insertions(+), 125 deletions(-)
diff --git a/README-he.md b/README-he.md
index 880fcf7d..c9b95ba0 100644
--- a/README-he.md
+++ b/README-he.md
@@ -120,140 +120,143 @@
-
+
From 7e803604e2ffc0926942420ef8c73d76339df391 Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Sun, 8 Jun 2025 18:31:28 +0300
Subject: [PATCH 09/43] Pictures are now a bit smaller
---
README-he.md | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/README-he.md b/README-he.md
index c9b95ba0..367f0b3f 100644
--- a/README-he.md
+++ b/README-he.md
@@ -5,7 +5,7 @@
# המדריך לתכנון מערכות (The System Design Primer)
-
+
@@ -55,7 +55,7 @@
-
+
@@ -74,7 +74,7 @@
מחפש משאבים שיעזרו לך להתכונן [**לראיונות קידוד**](https://github.com/donnemartin/interactive-coding-challenges)?
-
+
@@ -116,7 +116,7 @@
> כל חלק מכיל קישורים להרחבה וללמידה מעמיקה יותר.
-
+
From 3140221747c0019b8a9b4be1ad9f965057dac565 Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Sun, 8 Jun 2025 19:04:42 +0300
Subject: [PATCH 10/43] Translating - How to approach a system design interview
question
---
README-he.md | 86 +++++++++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 85 insertions(+), 1 deletion(-)
diff --git a/README-he.md b/README-he.md
index 367f0b3f..8aa4ab31 100644
--- a/README-he.md
+++ b/README-he.md
@@ -107,7 +107,7 @@
-## אינדקס נושאים בתכנון מערכות
+## אינדקס נושאים בארכיטקטורה
@@ -349,3 +349,87 @@
+
+## איך לגשת לשאלת ראיון ארכיטקטורה
+
+
+
+> איך לפתור שאלת ראיון ארכיטקטורה.
+
+ראיון ארכיטקטורה הוא **שיחה פתוחה**. מצופה ממך להוביל אותה.
+
+אתה יכול להיעזר בצעדים הבאים כדי להנחות את הדיון. כדי לחזק את ההבנה של התהליך, תעבור על [שאלות ריאיון בתכנון מערכות עם פתרונות](#system-design-interview-questions-with-solutions) אל מול הצעדים הבאים:
+
+### תאר מקרי שימוש, אילוצים והנחות עבודה
+
+אסוף דרישות והגדר את ה-scope של הבעיה.
+שאל שאלות כדי להבהיר את מקרי השימוש והאילוצים. דון בהנחות העבודה שאתה עושה.
+
+* מי הולך להשתמש במערכת?
+* איך הם הולכים להשתמש בה?
+* כמה משתמשים יהיו?
+* מה המערכת עושה?
+* מה הקלטים והפלטים של המערכת?
+* בכמה דאטא נצטרך לטפל?
+* כמה בקשות לשניה מחכות לנו?
+* מה היחס הצפוי בין קריאה לכתיבה?
+
+### שלב 2: כתוב תכנון במבט על (high level design)
+
+כתוב תכנון high level עם כל הרכיבים החשובים.
+
+* שרטט את הרכיבים החשובים והקשרים ביניהם
+* תצדיק את הרעיונות שלך
+
+### שלב 3: תכנן את הרכיבים המרכזיים
+
+צלול לפרטים של כל רכיב מרכזי. לדוגמה, אם התבקשת לתכנן [שירות קיצור כתובות url](solutions/system_design/pastebin/README.md), דון בנושאים הבאים:
+
+
+ - יצירה ואחסון hash של ה-url המלא
+
+ - דרכים כמו MD5 ו-Base62
+ - התנגשויות hash
+ - מסד נתונים SQL או NoSQL
+ - סכמת הנתונים
+
+
+ - המרה של כתובת מקוצרת לכתובת המלאה
+
+
+ - תכנון API ותכנון מונחה עצמים
+
+
+### שלב 4: תבצע scale לתכנון
+
+זהה וטפל בצווארי בקבוק, בהתאם לאילוצים. למשל, האם תזדקק לאחד מהפתרונות הבאים כדי להתמודד עם בעיות של סקילביליות?
+
+
+ - מאזן עומסים (Load balancer)
+ - סקיילינג אופקי (Horizontal scaling)
+ - שמירה במטמון (Caching)
+ - פיצול בסיס נתונים (Database sharding)
+
+
+דון בפתרונות אפשריים וה-trade-offs. הכול הוא trade-off. התמודד עם צווארי בקבוק בעזרת [עקרונות תכנון מערכת סקילבילית](#index-of-system-design-topics).
+
+### חישובים "על גב המעטפה" (מהירים)
+
+ייתכן שיבקשו ממך לבצע הערכות באופן ידני. ראה את [הנספח](#appendix) עבור המשאבים הבאים:
+
+* [Use back of the envelope calculations](http://highscalability.com/blog/2011/1/26/google-pro-tip-use-back-of-the-envelope-calculations-to-choo.html)
+* [Powers of two table](#powers-of-two-table)
+* [Latency numbers every programmer should know](#latency-numbers-every-programmer-should-know)
+
+### מקורות לקריאה נוספת
+
+עיין בקישורים הבאים כדי להבין טוב יותר למה לצפות:
+
+* [How to ace a systems design interview](https://www.palantir.com/2011/10/how-to-rock-a-systems-design-interview/)
+* [The system design interview](http://www.hiredintech.com/system-design)
+* [Intro to Architecture and Systems Design Interviews](https://www.youtube.com/watch?v=ZgdS0EUmn70)
+* [System design template](https://leetcode.com/discuss/career/229177/My-System-Design-Template)
+
+
From 2f8b50dbf6430afa16ecfb6dde7dbd6f821591aa Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Sun, 8 Jun 2025 19:10:29 +0300
Subject: [PATCH 11/43] Pictures now 75%
---
README-he.md | 14 ++++++++------
1 file changed, 8 insertions(+), 6 deletions(-)
diff --git a/README-he.md b/README-he.md
index 8aa4ab31..da245470 100644
--- a/README-he.md
+++ b/README-he.md
@@ -5,7 +5,7 @@
# המדריך לתכנון מערכות (The System Design Primer)
-
+
@@ -55,7 +55,7 @@
-
+
@@ -74,7 +74,7 @@
מחפש משאבים שיעזרו לך להתכונן [**לראיונות קידוד**](https://github.com/donnemartin/interactive-coding-challenges)?
-
+
@@ -116,7 +116,7 @@
> כל חלק מכיל קישורים להרחבה וללמידה מעמיקה יותר.
-
+
@@ -266,7 +266,10 @@
> נושאים מוצעים ללימוד לפי לוח הזמנים לריאיון שלך (קצר, בינוני, ארוך)
-
+
+
+
+
**ש: עבור הראיונות, האם אני אמור לדעת כל מה שכתוב כאן?**
@@ -292,7 +295,6 @@
לוח זמנים ארוך – התמקד ברוחב ויותר עומק של נושאים בתכנון מערכות. תרגל פתרון של רוב שאלות הריאיון.
-
From 29a4300f4219e6f8077bef5bb32b10d164fcd15b Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Sun, 8 Jun 2025 19:18:56 +0300
Subject: [PATCH 12/43] Translating - Added first interview question
---
README-he.md | 69 +++++++++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 68 insertions(+), 1 deletion(-)
diff --git a/README-he.md b/README-he.md
index da245470..e935b00c 100644
--- a/README-he.md
+++ b/README-he.md
@@ -352,7 +352,7 @@
-## איך לגשת לשאלת ראיון ארכיטקטורה
+## איך לגשת לשאלת ריאיון ארכיטקטורה
@@ -435,3 +435,70 @@
* [System design template](https://leetcode.com/discuss/career/229177/My-System-Design-Template)
+
+
+## שאלות ריאיון תכנון מערכות עם פתרונות
+
+
+
+> שאלות נפוצות בריאיון ארכיטקטורה עם הסברים פשוטים, קוד, ודיאגרמות.
+>
+> הפתרונות מפנים לתוכן שנמצא בתיקיית `solutions/`.
+
+
+
+
+ שאלה |
+ פתרון |
+
+
+
+
+ תכנן את Pastebin.com (או Bit.ly) |
+ פתרון |
+
+
+ תכנן את ציר הזמן והחיפוש של טוויטר (או הפיד והחיפוש של פייסבוק) |
+ פתרון |
+
+
+ תכנן סורק רשת (web crawler) |
+ פתרון |
+
+
+ תכנן את Mint.com |
+ פתרון |
+
+
+ תכנן את מבני הנתונים של רשת חברתית |
+ פתרון |
+
+
+ תכנן אחסון key-value למנוע חיפוש |
+ פתרון |
+
+
+ תכנן את מנגנון דירוג המכירות לפי קטגוריה של אמזון |
+ פתרון |
+
+
+ תכנן מערכת שיכולה לגדול למיליוני משתמשים על AWS |
+ פתרון |
+
+
+ הוסף שאלה לתכנון מערכת |
+ תרום |
+
+
+
+
+### תכנן את Pastebin.com (או Bit.ly)
+
+[צפה בתרגיל ובפתרון](solutions/system_design/pastebin/README.md)
+
+
+
+
+
+
+
From 19be8b4e86728ced24070d247dc1d95107851631 Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Sun, 8 Jun 2025 19:22:47 +0300
Subject: [PATCH 13/43] Translating - System design interview questions with
solutions
---
README-he.md | 97 +++++++++++++++++++++++++++++++++++++++++++++++++---
1 file changed, 92 insertions(+), 5 deletions(-)
diff --git a/README-he.md b/README-he.md
index e935b00c..4f85e351 100644
--- a/README-he.md
+++ b/README-he.md
@@ -462,7 +462,7 @@
פתרון |
- תכנן סורק רשת (web crawler) |
+ תכנן web crawler |
פתרון |
@@ -496,9 +496,96 @@
[צפה בתרגיל ובפתרון](solutions/system_design/pastebin/README.md)
-
-
-
-
+
+ הצג/הסתר דיאגרמה
+
+
+
+
+
+
+### תכנן את ציר הזמן והחיפוש של טוויטר (או הפיד והחיפוש של פייסבוק)
+
+[צפה בתרגיל ובפתרון](solutions/system_design/twitter/README.md)
+
+
+ הצג/הסתר דיאגרמה
+
+
+
+
+
+
+### תכנן web crawler
+
+[צפה בתרגיל ובפתרון](solutions/system_design/web_crawler/README.md)
+
+
+ הצג/הסתר דיאגרמה
+
+
+
+
+
+
+### תכנן את Mint.com
+
+[צפה בתרגיל ובפתרון](solutions/system_design/mint/README.md)
+
+
+ הצג/הסתר דיאגרמה
+
+
+
+
+
+
+### תכנן את מבני הנתונים של רשת חברתית
+
+[צפה בתרגיל ובפתרון](solutions/system_design/social_graph/README.md)
+
+
+ הצג/הסתר דיאגרמה
+
+
+
+
+
+
+### תכנן אחסון key-value למנוע חיפוש
+
+[צפה בתרגיל ובפתרון](solutions/system_design/query_cache/README.md)
+
+
+ הצג/הסתר דיאגרמה
+
+
+
+
+
+
+### תכנן את מנגנון דירוג המכירות לפי קטגוריה של אמזון
+
+[צפה בתרגיל ובפתרון](solutions/system_design/sales_rank/README.md)
+
+
+ הצג/הסתר דיאגרמה
+
+
+
+
+
+
+### תכנן מערכת שיכולה לגדול למיליוני משתמשים על AWS
+
+[צפה בתרגיל ובפתרון](solutions/system_design/scaling_aws/README.md)
+
+
+ הצג/הסתר דיאגרמה
+
+
+
+
+
From ab79c252698693f61f7d7ce283b7027b6b665e52 Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Sun, 8 Jun 2025 19:39:14 +0300
Subject: [PATCH 14/43] Pictures smaller
---
README-he.md | 16 ++++++++--------
1 file changed, 8 insertions(+), 8 deletions(-)
diff --git a/README-he.md b/README-he.md
index 4f85e351..aac18966 100644
--- a/README-he.md
+++ b/README-he.md
@@ -499,7 +499,7 @@
הצג/הסתר דיאגרמה
-
+
@@ -511,7 +511,7 @@
הצג/הסתר דיאגרמה
-
+
@@ -523,7 +523,7 @@
הצג/הסתר דיאגרמה
-
+
@@ -535,7 +535,7 @@
הצג/הסתר דיאגרמה
-
+
@@ -547,7 +547,7 @@
הצג/הסתר דיאגרמה
-
+
@@ -559,7 +559,7 @@
הצג/הסתר דיאגרמה
-
+
@@ -571,7 +571,7 @@
הצג/הסתר דיאגרמה
-
+
@@ -583,7 +583,7 @@
הצג/הסתר דיאגרמה
-
+
From 2442bc411cbe3adc871d09e84d5708649aba0888 Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Sun, 8 Jun 2025 19:47:35 +0300
Subject: [PATCH 15/43] Translating - Object-oriented design interview
questions with solutions
---
README-he.md | 63 +++++++++++++++++++++++++++++++++++++++++++++++++---
1 file changed, 60 insertions(+), 3 deletions(-)
diff --git a/README-he.md b/README-he.md
index aac18966..cb9c1d9b 100644
--- a/README-he.md
+++ b/README-he.md
@@ -441,7 +441,7 @@
-> שאלות נפוצות בריאיון ארכיטקטורה עם הסברים פשוטים, קוד, ודיאגרמות.
+> שאלות נפוצות בריאיון ארכיטקטורה עם הסברים לדוגמה, קוד, ודיאגרמות.
>
> הפתרונות מפנים לתוכן שנמצא בתיקיית `solutions/`.
@@ -454,7 +454,7 @@
- תכנן את Pastebin.com (או Bit.ly) |
+ תכנן את pastebin.com (או bit.ly) |
פתרון |
@@ -492,7 +492,7 @@
-### תכנן את Pastebin.com (או Bit.ly)
+### תכנן את pastebin.com (או bit.ly)
[צפה בתרגיל ובפתרון](solutions/system_design/pastebin/README.md)
@@ -589,3 +589,60 @@
+
+
+## שאלות ריאיון בתכנון מונחה עצמים עם פתרונות
+
+
+
+> שאלות נפוצות בתכנון מונחה עצמים עם הסברים לדוגמה, קוד, ודיאגרמות.
+>
+> הפתרונות מפנים לתוכן שנמצא בתיקיית `solutions/`.
+
+>**הערה: החלק הזה עדיין בפיתוח**
+
+
+
+
+
+ שאלה |
+ פתרון |
+
+
+
+
+ תכנן Hash Map |
+ פתרון |
+
+
+ תכנן מנגנון Cache בשיטת Least Recently Used |
+ פתרון |
+
+
+ תכנן מרכז שירות טלפוני (Call Center) |
+ פתרון |
+
+
+ תכנן חפיסת קלפים |
+ פתרון |
+
+
+ תכנן חניון |
+ פתרון |
+
+
+ תכנן שרת צ'אט |
+ פתרון |
+
+
+ תכנן מערך מעגלי |
+ תרום |
+
+
+ הוסף שאלה בעיצוב מונחה עצמים |
+ תרום |
+
+
+
+
+
From 7987c20d03c1b8cfa5be94aae07f119c38ed22e7 Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Sun, 8 Jun 2025 21:25:16 +0300
Subject: [PATCH 16/43] Translating - System design topics: start here
---
README-he.md | 71 +++++++++++++++++++++++++++++++++++++++++++---------
1 file changed, 59 insertions(+), 12 deletions(-)
diff --git a/README-he.md b/README-he.md
index cb9c1d9b..37067b2e 100644
--- a/README-he.md
+++ b/README-he.md
@@ -55,7 +55,7 @@
-
+
@@ -74,7 +74,7 @@
מחפש משאבים שיעזרו לך להתכונן [**לראיונות קידוד**](https://github.com/donnemartin/interactive-coding-challenges)?
-
+
@@ -367,21 +367,25 @@
אסוף דרישות והגדר את ה-scope של הבעיה.
שאל שאלות כדי להבהיר את מקרי השימוש והאילוצים. דון בהנחות העבודה שאתה עושה.
-* מי הולך להשתמש במערכת?
-* איך הם הולכים להשתמש בה?
-* כמה משתמשים יהיו?
-* מה המערכת עושה?
-* מה הקלטים והפלטים של המערכת?
-* בכמה דאטא נצטרך לטפל?
-* כמה בקשות לשניה מחכות לנו?
-* מה היחס הצפוי בין קריאה לכתיבה?
+
+ - מי הולך להשתמש במערכת?
+ - איך הם הולכים להשתמש בה?
+ - כמה משתמשים יהיו?
+ - מה המערכת עושה?
+ - מה הקלטים והפלטים של המערכת?
+ - בכמה דאטא נצטרך לטפל?
+ - כמה בקשות לשניה מחכות לנו?
+ - מה היחס הצפוי בין קריאה לכתיבה?
+
### שלב 2: כתוב תכנון במבט על (high level design)
כתוב תכנון high level עם כל הרכיבים החשובים.
-* שרטט את הרכיבים החשובים והקשרים ביניהם
-* תצדיק את הרעיונות שלך
+
+ - שרטט את הרכיבים החשובים והקשרים ביניהם
+ - תצדיק את הרעיונות שלך
+
### שלב 3: תכנן את הרכיבים המרכזיים
@@ -646,3 +650,46 @@
+
+## נושאים בתכנון מערכות: התחל כאן
+
+
+
+חדש בתחום תכנון מערכות?
+
+ראשית, תצטרך לקבל הבנה בסיסית של העקרונות הנפוצים, ללמוד מה הם, איך משתמשים בהם, מה היתרונות והחסרונות של כל אחד מהם.
+
+### שלב 1: צפה בהרצאה על סקילביליות
+
+[Scalability Lecture at Harvard](https://www.youtube.com/watch?v=-W9F__D3oY4)
+
+* Topics covered:
+ * Vertical scaling
+ * Horizontal scaling
+ * Caching
+ * Load balancing
+ * Database replication
+ * Database partitioning
+
+### שלב 2: קרא מאמר על סקילביליות
+
+[Scalability](https://web.archive.org/web/20221030091841/http://www.lecloud.net/tagged/scalability/chrono)
+
+* Topics covered:
+ * [Clones](https://web.archive.org/web/20220530193911/https://www.lecloud.net/post/7295452622/scalability-for-dummies-part-1-clones)
+ * [Databases](https://web.archive.org/web/20220602114024/https://www.lecloud.net/post/7994751381/scalability-for-dummies-part-2-database)
+ * [Caches](https://web.archive.org/web/20230126233752/https://www.lecloud.net/post/9246290032/scalability-for-dummies-part-3-cache)
+ * [Asynchronism](https://web.archive.org/web/20220926171507/https://www.lecloud.net/post/9699762917/scalability-for-dummies-part-4-asynchronism)
+
+### השלבים הבאים
+
+בהמשך, נסתכל על trade-offs ב-high level:
+
+* **Performance** vs **scalability**
+* **Latency** vs **throughput**
+* **Availability** vs **consistency**
+
+נזכור כי **הכול זה trade-off**.
+לאחר מכן נצלול לנושאים ספציפיים יותר כמו DNS, CDN ו-load balancers.
+
+
From 4abfe15cbda209924df338607293fbc12141d9dc Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Sun, 8 Jun 2025 21:54:55 +0300
Subject: [PATCH 17/43] Translating - Trade-offs
---
README-he.md | 77 ++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 77 insertions(+)
diff --git a/README-he.md b/README-he.md
index 37067b2e..9235db4f 100644
--- a/README-he.md
+++ b/README-he.md
@@ -693,3 +693,80 @@
לאחר מכן נצלול לנושאים ספציפיים יותר כמו DNS, CDN ו-load balancers.
+
+
+## ביצועים (performance) מול סקילביליות (scalability)
+
+
+
+שירות הוא **סקילבילי (scalable)** אם הוא משתפר **בביצועים (performance)** שלו באופן פרופורציונלי למשאבים שנוספו. באופן כללי, שיפור בביצועים פירושו היכולת לתת שירות ליותר יחידות עבודה, אך הוא יכול גם לבוא לידי ביטוי ביכולת להתמודד עם יחידות עבודה גדולות יותר, ככל שהדאטא גדל.
1
+
+דרך נוספת להסתכל על ביצועים מול סקילביליות
+
+
+ - אם יש לך בעיית ביצועים, המערכת איטית עבור משתמש בודד.
+ - אם יש לך בעיית סקילביליות, המערכת מהירה עבור משתמש בודד אך איטית בעומס כבד.
+
+
+### מקורות וקריאה נוספת
+
+* [A word on scalability](http://www.allthingsdistributed.com/2006/03/a_word_on_scalability.html)
+* [Scalability, availability, stability, patterns](http://www.slideshare.net/jboner/scalability-availability-stability-patterns/)
+
+
+
+## שיהוי (latency) מול תפוקה (throughput)
+
+
+
+**שיהוי** הוא הזמן שנדרש כדי לבצע פעולה כלשהי או להפיק תוצאה כלשהי
+
+**תפוקה** היא מספר הפעולות או התוצאות ליחידת זמן.
+
+באופן כללי, כדאי לשאוף **לתפוקה מקסימלית** עם **שיהוי סביר**.
+
+### חומרים וקריאה נוספת
+
+* [Understanding latency vs throughput](https://community.cadence.com/cadence_blogs_8/b/fv/posts/understanding-latency-vs-throughput)
+
+
+
+## זמינות (availability) מול עקביות (consistency)
+
+
+
+### משפט CAP
+
+
+
+
+ Source: CAP theorem revisited
+
+
+במערכות מחשוב מבוזרות, ניתן לתמוך רק בשניים מתוך שלושת התנאים הבאים:
+
+
+ - עקביות (Consistency) – כל קריאה מקבלת את הכתיבה העדכנית ביותר, או שגיאה.
+ - זמינות (Availability) - כל בקשה תקבל מענה, ללא הבטחה שהמידע שיחזור יהיה העדכני ביותר.
+ - יכולת חלוקה (Partition Tolerance) - המערכת ממשיכה לתפקד גם במקרים בהם נאבדות או מתעכבות מספר הודעות בין שרתי המערכת בגלל בעיות תקשורת.
+
+
+*ניתן לצאת מנקודת הנחה שרשתות לא אמינות - כך שנהיה חייבים לתמוך ב-״Partition tolerance״.
+לכן, נצטרך לבחור אחד משני האחרים - זמינות או עקביות.*
+
+#### בחירה ב-CP - עקביות ויכולת חלוקה
+
+המתנה לתשובה מהמערכת (אשר סובלת מ-network partition) עלולה להסתיים בשגיאת timeout. לכן, CP הוא בחירה טובה במידה ויש הצדקה עסקית לקריאות וכתיבות אטומיות.
+
+#### בחירה ב-AP - זמינות ויכולת חלוקה
+
+תשובות לבקשות מהמערכת מחזירות את הגרסה הזמינה ביותר של הנתונים הזמינים בשרת הרלוונטי, שאינה בהכרח האחרונה. כתיבה עשויה לקחת זמן מסוים עד שתסתיים, עד אשר התקשורת הבעייתית תיפתר.
+
+לכן, AP הוא בחירה טובה במידה ויש הצדקה עסקית לעבוד במצב של [eventual consistency](#eventual-consistency) או במידה והמערכת צריכה להמשיך לשרת למרות שגיאות בלתי-תלויות.
+
+### חומרים וקריאה נוספת
+
+* [CAP theorem revisited](http://robertgreiner.com/2014/08/cap-theorem-revisited/)
+* [A plain english introduction to CAP theorem](http://ksat.me/a-plain-english-introduction-to-cap-theorem)
+* [CAP FAQ](https://github.com/henryr/cap-faq)
+* [The CAP theorem](https://www.youtube.com/watch?v=k-Yaq8AHlFA)
From 649a69d5540b397ee3b1a5cde850311c3bf89d48 Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Sun, 8 Jun 2025 21:55:53 +0300
Subject: [PATCH 18/43] Updated size
---
README-he.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/README-he.md b/README-he.md
index 9235db4f..8f5d1369 100644
--- a/README-he.md
+++ b/README-he.md
@@ -738,7 +738,7 @@
### משפט CAP
-
+
Source: CAP theorem revisited
From e805e7b782e6d1484278bb1b4550cbd6e0d50080 Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Mon, 9 Jun 2025 20:54:44 +0300
Subject: [PATCH 19/43] Translating - Consistency and Availability Patterns
---
README-he.md | 140 ++++++++++++++++++++++++++++++++++++++++++++++++---
1 file changed, 133 insertions(+), 7 deletions(-)
diff --git a/README-he.md b/README-he.md
index 8f5d1369..5862cbbf 100644
--- a/README-he.md
+++ b/README-he.md
@@ -695,7 +695,7 @@
-## ביצועים (performance) מול סקילביליות (scalability)
+## ביצועים (Performance) מול סקילביליות (Scalability)
@@ -715,7 +715,7 @@
-## שיהוי (latency) מול תפוקה (throughput)
+## שיהוי (Latency) מול תפוקה (Throughput)
@@ -731,7 +731,7 @@
-## זמינות (availability) מול עקביות (consistency)
+## זמינות (Availability) מול עקביות (Consistency)
@@ -746,10 +746,10 @@
במערכות מחשוב מבוזרות, ניתן לתמוך רק בשניים מתוך שלושת התנאים הבאים:
- - עקביות (Consistency) – כל קריאה מקבלת את הכתיבה העדכנית ביותר, או שגיאה.
- - זמינות (Availability) - כל בקשה תקבל מענה, ללא הבטחה שהמידע שיחזור יהיה העדכני ביותר.
- - יכולת חלוקה (Partition Tolerance) - המערכת ממשיכה לתפקד גם במקרים בהם נאבדות או מתעכבות מספר הודעות בין שרתי המערכת בגלל בעיות תקשורת.
-
+
עקביות (Consistency) – כל קריאה מקבלת את הכתיבה העדכנית ביותר, או שגיאה.
+
זמינות (Availability) - כל בקשה תקבל מענה, ללא הבטחה שהמידע שיחזור יהיה העדכני ביותר.
+
יכולת חלוקה (Partition Tolerance) - המערכת ממשיכה לתפקד גם במקרים בהם נאבדות או מתעכבות מספר הודעות בין שרתי המערכת בגלל בעיות תקשורת.
+
*ניתן לצאת מנקודת הנחה שרשתות לא אמינות - כך שנהיה חייבים לתמוך ב-״Partition tolerance״.
לכן, נצטרך לבחור אחד משני האחרים - זמינות או עקביות.*
@@ -770,3 +770,129 @@
* [A plain english introduction to CAP theorem](http://ksat.me/a-plain-english-introduction-to-cap-theorem)
* [CAP FAQ](https://github.com/henryr/cap-faq)
* [The CAP theorem](https://www.youtube.com/watch?v=k-Yaq8AHlFA)
+
+
+
+
+## דפוסי עקביות (Consistency Patterns)
+
+
+
+כאשר קיימים מספר עותקים של אותם נתונים, עלינו להחליט כיצד לסנכרן ביניהם כדי שלקוחות יקבלו תצוגה עקבית של המידע.
+ניזכר בהגדרה של עקביות מתוך [משפט CAP](#cap-theorem): כל קריאה מקבלת את הכתיבה העדכנית ביותר או שגיאה.
+
+### עקביות חלשה (Weak Consistency)
+
+לאחר כתיבה, קריאות עשויות לראות או לא לראות את הערך החדש שנכתב. הגישה כאן היא של best effort - המאמץ הטוב ביותר.
+
+גישה זו נפוצה במערכות כמו memcached. עקביות חלשה מתאימה למקרים של מערכות זמן-אמת, כמו VoIP, שיחות וידאו, ומשחקים מרובי משתתפים.
+לדוגמה, אם אתה בשיחת טלפון ומאבד קליטה לכמה שניות, כשאתה חוזר אתה לא שומע מה שנאמר בזמן שלא הייתה קליטה.
+
+### עקביות לא מיידית (Eventual Consistency)
+
+לאחר כתיבה, הקריאות יראו בסופו של דבר את מה שנכתב (בדרך כלל תוך מספר מילישניות). הנתונים משוכפלים באופן אסינכרוני.
+
+גישה זו נפוצה במערכות כמו DNS ומייל. עקביות לא מיידית מתאימה למערכות ששומרות על זמינות גבוהה במיוחד.
+
+### עקביות חזקה (Strong Consistency)
+
+לאחר כתיבה, הקריאות יראו תמיד את הערך החדש שנכתב. השכפול מתבצע באופן סינכרוני.
+
+גישה זו נפוצה במערכות קבצים ובמסדי נתונים רלציוניים (RDBMS). עקביות חזקה מתאימה למערכות שדורשות טרנזקציות.
+
+### מקורות וקריאה נוספת
+
+- [Transactions across data centers](http://snarfed.org/transactions_across_datacenters_io.html)
+
+
+
+## דפוסי זמינות (Availability Patterns)
+
+
+
+קיימים שני דפוסים משלימים לתמיכה בזמינות גבוהה: **מעבר אוטומטי (fail-over)** ו-**שכפול (replication)**.
+
+### גיבוי בזמן כישלון (Fail-Over)
+
+#### אקטיבי-פסיבי (Active-Passive)
+
+במבנה אקטיבי-פסיבי, נשלחים heartbeat-ים בין השרת הפעיל לשרת הרזרבי (הפסיבי). אם ה-heartbeat נקטע, השרת הפסיבי לוקח את כתובת ה-IP של הפעיל וממשיך את השירות.
+
+משך זמן ההשבתה תלוי אם השרת הפסיבי פועל מראש במצב 'חם' (hot standby), או שיש להפעילו ממצב 'קר' (cold standby). רק השרת הפעיל מקבל תעבורה.
+
+סוג זה נקרא גם Master-Slave.
+
+#### אקטיבי-אקטיבי (Active-Active)
+
+במבנה אקטיבי-אקטיבי, שני השרתים מקבלים תעבורה ומחלקים ביניהם את העומס.
+
+אם השרתים חשופים פומבית, שרת ה-DNS צריך לדעת על כתובות ה-IP הציבוריות של שניהם. אם השרתים פנימיים, על לוגיקת האפליקציה להכיר את שניהם.
+
+סוג זה נקרא גם Master-Master.
+
+### חסרונות של מעבר אוטומטי
+
+
+ - מעבר אוטומטי מוסיף חומרה ועלות תפעולית.
+ - קיימת אפשרות לאובדן נתונים אם המערכת הפעילה קורסת לפני שהספיקה לשכפל את המידע למערכת הפסיבית.
+
+
+### שכפול (Replication)
+
+#### עבור Master-Slave/Master-Master
+
+נושא זה נדון בפירוט נוסף בחלק על [מסדי נתונים](#database):
+
+- [Master-slave replication](#master-slave-replication)
+- [Master-master replication](#master-master-replication)
+
+### זמינות במספרים
+
+נהוג למדוד זמינות לפי זמן פעילות (uptime) או חוסר פעילות (downtime)כאחוז מהזמן שבו השירות פועל. המדד הנפוץ הוא לפי מספר התשיעיות — לדוגמה: שירות עם זמינות של 99.99% מתואר כבעל ארבע תשיעיות.
+
+#### זמינות של 99.9% — שלוש תשיעיות
+
+| Duration | Acceptable downtime|
+|---------------------|--------------------|
+| Downtime per year | 8h 45min 57s |
+| Downtime per month | 43m 49.7s |
+| Downtime per week | 10m 4.8s |
+| Downtime per day | 1m 26.4s |
+
+#### זמינות של 99.99% — ארבע תשיעיות
+
+| Duration | Acceptable downtime|
+|---------------------|--------------------|
+| Downtime per year | 52min 35.7s |
+| Downtime per month | 4m 23s |
+| Downtime per week | 1m 5s |
+| Downtime per day | 8.6s |
+
+#### זמינות במקביל לעומת בטור
+
+אם שירות מורכב ממספר רכיבים שעלולים להיכשל, הזמינות הכוללת של השירות תלויה באופן שבו הם מסודרים - בטור או במקביל.
+
+###### בטור
+
+כאשר שני רכיבים עם זמינות קטנה מ-100% מסודרים בטור, הזמינות הכוללת יורדת:
+
+```
+Availability (Total) = Availability (Foo) * Availability (Bar)
+```
+
+אם גם `Foo` וגם `Bar` זמינים ברמה של 99.9%, הזמינות הכוללת שלהם בטור תהיה 99.8%.
+
+###### במקביל
+
+הזמינות הכוללת עולה כאשר שני רכיבים בעלי זמינות קטנה מ־100% פועלים במקביל:
+
+```
+Availability (Total) = 1 - (1 - Availability (Foo)) * (1 - Availability (Bar))
+```
+
+אם גם `Foo` וגם `Bar` זמינים ברמה של 99.9%, הזמינות הכוללת שלהם במקביל תהיה 99.9999%.
+
+
+
+
+
From 0d2c89e9cb2c28673a81657b9af2fd15b4f5e08a Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Mon, 9 Jun 2025 21:02:09 +0300
Subject: [PATCH 20/43] Updated links
---
README-he.md | 45 ++++++++++++++++++++++++---------------------
1 file changed, 24 insertions(+), 21 deletions(-)
diff --git a/README-he.md b/README-he.md
index 5862cbbf..9474f3be 100644
--- a/README-he.md
+++ b/README-he.md
@@ -123,37 +123,37 @@
אינדקס נושאים
- - נושאים בתכנון מערכות: התחל כאן
+
- נושאים בתכנון מערכות: התחל כאן
- - ביצועים (performance) מול סקילביליות (scalability)
- - שיהוי (latency) מול תפוקה (throughput)
- - זמינות (availability) מול עקביות (consistency)
+
- ביצועים (performance) מול סקילביליות (scalability)
+ - שיהוי (latency) מול תפוקה (throughput)
+ - זמינות (availability) מול עקביות (consistency)
- - דפוסי עקביות
+
- דפוסי עקביות
- - דפוסי זמינות
+
- דפוסי זמינות
- מערכת שמות דומיינים (DNS)
@@ -846,6 +846,8 @@
- [Master-slave replication](#master-slave-replication)
- [Master-master replication](#master-master-replication)
+
+
### זמינות במספרים
נהוג למדוד זמינות לפי זמן פעילות (uptime) או חוסר פעילות (downtime)כאחוז מהזמן שבו השירות פועל. המדד הנפוץ הוא לפי מספר התשיעיות — לדוגמה: שירות עם זמינות של 99.99% מתואר כבעל ארבע תשיעיות.
@@ -892,7 +894,8 @@ Availability (Total) = 1 - (1 - Availability (Foo)) * (1 - Availability (Bar))
אם גם `Foo` וגם `Bar` זמינים ברמה של 99.9%, הזמינות הכוללת שלהם במקביל תהיה 99.9999%.
+## מערכת שמות דומיינים (DNS)
+
+
+
-
-
-
From 4a70128f3c6b279b3538e3fddd3101f9f7967bbb Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Tue, 10 Jun 2025 18:42:09 +0300
Subject: [PATCH 21/43] Translating - DNS
---
README-he.md | 46 ++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 46 insertions(+)
diff --git a/README-he.md b/README-he.md
index 9474f3be..b2b5e890 100644
--- a/README-he.md
+++ b/README-he.md
@@ -898,4 +898,50 @@ Availability (Total) = 1 - (1 - Availability (Foo)) * (1 - Availability (Bar))
+
+
+
+ מקור: מצגת אבטחת DNS
+
+
+מערכת שמות דומיינים (DNS) ממירה שם דומיין כמו `www.example.com` לכתובת IP.
+
+ה-DNS בנוי בהיררכיה: כאשר ישנם כמה שרתי ניהול בשכבה העליונה. ה-router שלך או ספק האינטרנט (ISP) מספקים כתובות לשרת(י) DNS שיש לפנות אליהם בעת ביצוע חיפוש של כתובת.
+שרתי DNS בשכבה נמוכה יותר, מבצעים cache למיפויים, שעלולים להיות לא עדכניים (stale) אם הרשומה המעודכנת עוד לא עברה מהשרת בשכבה הגבוהה עד למטה (propagation delays).
+המיפוי של ה-DNS יכול להישמר על ידי הדפדפן או מערכת ההפעלה לפרק זמן מסוים, הנקבע על ידי [TTL – Time To Live](https://he.wikipedia.org/wiki/Time_to_live).
+
+
+ - NS record (Name Server) – מגדירה את שרתי DNS עבור הדומיין/תת-דומיין.
+ - MX record (Mail Exchange) – מגדירה את שרתי הדואר לקבלת הודעות.
+ - A record (Address) – ממפה שם לכתובת IP.
+ - CNAME (Canonical Name) – ממפה שם לשם אחר (למשל example.com →
www.example.com
) או לרשומת A
.
+
+
+שירותים מנוהלים כמו [CloudFlare](https://www.cloudflare.com/dns/) ו-[Route 53](https://aws.amazon.com/route53/) מספקים DNS מנוהל.
+חלקם מאפשרים ניתוב תעבורה בשיטות שונות:
+
+- [Weighted round robin](https://www.jscape.com/blog/load-balancing-algorithms)
+ - Prevent traffic from going to servers under maintenance
+ - Balance between varying cluster sizes
+ - A/B testing
+- [Latency-based](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-latency.html)
+- [Geolocation-based](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-geo.html)
+
+### חסרונות (DNS)
+
+
+ - פנייה לשרת DNS מוסיפה עיכוב קל, אם כי ברוב המקרים הוא מתמתן בזכות caching כפי שתואר קודם.
+ - ניהול שרתי DNS יכול להיות מורכב, ולרוב מנוהל על-ידי ממשלות, ISPs וחברות גדולות.
+ - שירותי DNS היו יעד לאחרונה ל-מתקפות DDoS, מה שמנע מגולשים להגיע לאתרים (למשל Twitter) בלי להכיר כתובות IP ידניות.
+
+
+### מקורות וקריאה נוספת
+
+- [DNS architecture](https://technet.microsoft.com/en-us/library/dd197427(v=ws.10).aspx)
+- [Wikipedia](https://en.wikipedia.org/wiki/Domain_Name_System)
+- [DNS articles](https://support.dnsimple.com/categories/dns/)
+
+
+
+
From 4c755070dcfbc8c9c8fde6f670affacdbab971c8 Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Tue, 10 Jun 2025 19:05:33 +0300
Subject: [PATCH 22/43] Translating - CDN
---
README-he.md | 51 +++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 51 insertions(+)
diff --git a/README-he.md b/README-he.md
index b2b5e890..805fa30f 100644
--- a/README-he.md
+++ b/README-he.md
@@ -943,5 +943,56 @@ Availability (Total) = 1 - (1 - Availability (Foo)) * (1 - Availability (Bar))
+## רשתות הפצת תוכן (CDN)
+
+
+
+
+
+
+ מקור: Why use a CDN
+
+
+רשת הפצת תוכן (CDN) היא רשת גלובלית ומבוזרת של שרתי proxy, אשר מנגישים תכנים ממיקומים הקרובים יותר למשתמש הקצה.
+בדרך כלל, קבצים סטטיים כמו HTML/CSS/JS, תמונות וסרטונים, מונגשים על ידי CDN, למרות שיש כאלו כמו CloudFront של Amazon התומכים גם בתכנים דינמיים.
+מיפוי ה-DNS שיתקבל ינחה את הלקוחות לאיזה שרת להתחבר.
+
+הגשת תוכן מ-CDN משפר ביצועים משמעותית בשני אופנים:
+
+
+ - המשתמש מקבל תוכן מ-data center הקרוב אליו פיזית.
+ - השרתים אינם צריכים לשרת בקשות שה-CDN מספק במקומם.
+
+
+### דחיפה (Push)
+
+ב-Push CDN התוכן נדחף אל ה-CDN בכל פעם שהוא משתנה בשרת המקור. האחריות על העלאת הקבצים וכתיבת ה-URLs המופנים ל-CDN היא שלך. אתה מגדיר את הזמן שבו פג תוקפו של תוכן מסוים, ומתי הוא מתעדכן.
+
+תוכן מועלה רק כאשר הוא חדש, או עבר שינוי, מה שמפחית תעבורה אבל ממקסם על האחסון. אתרים עם מעט תוכן או תעבורה, או עם תוכן שלא מתעדכן באופן תדיר עובדים טוב עם Push CDN. התוכן נמצא ב-CDN פעם אחת, במקום שישלפו אותו מחדש בתדירות קבועה.
+
+### משיכה (Pull)
+
+ב-Pull CDN התוכן נשלף מהשרת המקור רק כאשר משתמש מבקש אותו לראשונה. הקבצים נשארים בשרת שלך ו-URLs מפנים ל-CDN.
+הבקשה הראשונית איטית יותר עד שהקובץ נשמר ב-CDN.
+משך הזמן שבו ישאר ה-cache נקבע על-ידי [TTL – Time to Live](https://he.wikipedia.org/wiki/Time_to_live).
+
+ה-Pull CDN חוסך שטח אחסון על ה-CDN, אך עלול ליצור תעבורה מיותרת אם קבצים פגי-תוקף נשלפים שוב לפני ששונו בפועל.
+Pull CDN מתאים לאתרים עתירי תעבורה, שכן העומס מתפזר וה-CDN שומר רק קבצים שנדרשו לאחרונה.
+
+### חסרונות (CDN)
+
+
+ - עלויות CDN עשויות להיות משמעותיות בהתאם לנפח התעבורה, אך יש לשקול אותן מול העלויות שהיית משלם ללא CDN.
+ - תוכן עלול להיות מיושן (stale) אם עודכן לפני שפג תוקף ה-TTL.
+ - יש צורך לשנות את כתובות ה-URL של תוכן סטטי כך שיפנו אל ה-CDN.
+
+
+### מקורות וקריאה נוספת
+
+- [Globally distributed content delivery](https://figshare.com/articles/Globally_distributed_content_delivery/6605972)
+- [The differences between push and pull CDNs](http://www.travelblogadvice.com/technical/the-differences-between-push-and-pull-cdns/)
+- [Wikipedia](https://en.wikipedia.org/wiki/Content_delivery_network)
+
+
From 6e5fc77040bf270f09c5288297a32c1c77bb3e6f Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Tue, 10 Jun 2025 21:33:02 +0300
Subject: [PATCH 23/43] Translating - Load Balancer
---
README-he.md | 97 ++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 97 insertions(+)
diff --git a/README-he.md b/README-he.md
index 805fa30f..4ceced0d 100644
--- a/README-he.md
+++ b/README-he.md
@@ -995,4 +995,101 @@ Pull CDN מתאים לאתרים עתירי תעבורה, שכן העומס מת
+## מאזן עומסים (Load Balancer)
+
+
+
+
+
+ Source: Scalable system design patterns
+
+
+מאזן עומסים מבזר בקשות נכנסות מלקוח בין משאבי חישוב שונים כגון שרתי אפליקציה ומסדי נתונים. עבור כל בקשה, הוא מחזיר את התשובה ממשאב החישוב המתאים, אל הלקוח המתאים. מאזן עומסים יעיל ב:
+
+
+ - מניעת שליחת בקשות לשרתים לא יציבים (unhealthy)
+ - מניעת העמסת־יתר על משאבים
+ - סילוק נקודת כשל בודדת (SPOF)
+
+
+מאזן עומסים ניתן למימוש כחומרה (יקר) או כתוכנה כדוגמת HAProxy.
+
+יתרונות נוספים:
+
+
+ - SSL Termination – טכניקת אבטחה שבה מפענחים בקשות נכנסות לפני שהן מגיעות לשרת הקצה, ומצפינים את התשובות של השרת כך ששרתי ה-backend לא צריכים לבצע את הפעולות היקרות הללו.
+
+ - מוריד את הצורך להתקין תעודות X.509 על כל שרת.
+
+
+
+ - Session Persistence – יצירת עוגיות (cookies) וניתוב בקשות של לקוח מסוים לאותו מופע שהתנהל מולו, אם האפליקציה לא מנהלת סשנים בעצמה.
+
+
+
+כדי להגן מפני כישלונות נהוג להקים מספר מאזני עומסים, במצב
+[Active-Passive](#אקטיבי-פסיבי-active-passive) או [Active-Active](#אקטיבי-אקטיבי-active-active).
+
+מאזן עומסים יכול לנתב את התעבורה על פי מדדים שונים:
+
+- Random
+- Least loaded
+- Session/cookies
+- [Round robin or weighted round robin](https://www.g33kinfo.com/info/round-robin-vs-weighted-round-robin-lb)
+- [Layer 4](#layer-4-load-balancing)
+- [Layer 7](#layer-7-load-balancing)
+
+### איזון עומסים בשכבה 4
+
+מאזני עומסים בשכבה 4 בוחנים מידע בשכבת התעבורה ([transport layer](#communication)) כדי להחליט כיצד להפיץ בקשות.
+בדרך כלל, מדובר בכתובות ה-IP של המקור והיעד ובפורטים שבכותרת (header), ולא בתוכן הפקטה (packet).
+מאזני עומסים בשכבה 4 מעבירים את חבילות הרשת אל ומן השרת הנבחר (upstream server) תוך ביצוע
+[תרגום כתובות רשת (NAT)](https://www.nginx.com/resources/glossary/layer-4-load-balancing/).
+
+
+### איזון עומסים בשכבה 7
+
+מאזני עומסים בשכבה 7 בוחנים את [שכבת האפליקציה](#communication) כדי להחליט כיצד להפיץ בקשות. ההחלטה יכולה להתבסס על תוכן הכותרות (headers), גוף ההודעה, ועוגיות (cookies).
+
+מאזן עומסים בשכבה 7 מסיים (terminates) את תעבורת הרשת אל מול הלקוח, קורא את ההודעה, מקבל החלטת איזון-עומסים, ואז פותח חיבור לשרת שנבחר.
+למשל, מאזן כזה יכול לשלוח תעבורת וידאו לשרתים שמאחסנים קטעי וידאו, ובמקביל לנתב תעבורת חיוב משתמשים (billing) לשרתים מוקשחים אבטחתית.
+
+לעומת זאת, איזון עומסים בשכבה 4 דורש פחות זמן ומשאבי מחשוב מאשר שכבה 7, אם כי על חומרה מודרנית ההשפעה הביצועית עשויה להיות מזערית.
+
+### גדילה אופקית (Horizontal Scaling)
+
+מאזני עומסים מסייעים גם בגדילה אופקית (Horizontal Scaling), וכך משפרים ביצועים וזמינות.
+הרחבת המערכת באמצעות שרתים זולים חסכונית יותר ומביאה לרמת זמינות גבוהה לעומת **הגדלה אנכית (Vertical Scaling)** – חיזוק שרת יחיד בחומרה יקרה. בנוסף, קל יותר לגייס אנשי מקצוע המיומנים בעבודה עם שרתים סטנדרטיים מאשר כאלה המתמחים במערכות ארגוניות ייעודיות ויקרות.
+
+#### חסרונות: גדילה אופקית
+
+
+ - גדילה אופקית מוסיפה מורכבות וכוללת שכפול שרתים
+
+ - השרתים צריכים להיות stateless: אין לאחסן בהם מידע משתמש כגון סשנים או תמונות פרופיל
+ - ניתן לשמור סשנים באחסון נתונים מרכזי כגון מסד־נתונים (SQL או NoSQL) או מטמון פרסיסטנטי (Redis, Memcached)
+
+
+ - שרתים בהמשך השרשרת (downstream) למשל cache ו-DB צריכים להתמודד עם יותר חיבורים בו-זמנית ככל שמספר שרתי האפליקציה גדל
+
+
+### חסרונות: מאזן עומסים
+
+
+ - מאזן העומסים עצמו עלול להפוך לצוואר בקבוק בביצועים אם אין לו מספיק משאבים או אם הוא מוגדר בצורה לא נכונה.
+ - הוספת מאזן עומסים כדי להסיר נקודת כשל בודדת (SPOF) מוסיפה מורכבות למערכת.
+ - מאזן עומסים יחיד הוא SPOF, ועבודה עם מספר מאזני עומסים מגדילה עוד יותר את המורכבות.
+
+
+### מקורות וקריאה נוספת
+
+- [NGINX architecture](https://www.nginx.com/blog/inside-nginx-how-we-designed-for-performance-scale/)
+- [HAProxy architecture guide](http://www.haproxy.org/download/1.2/doc/architecture.txt)
+- [Scalability](https://web.archive.org/web/20220530193911/https://www.lecloud.net/post/7295452622/scalability-for-dummies-part-1-clones)
+- [Wikipedia](https://en.wikipedia.org/wiki/Load_balancing_(computing))
+- [Layer 4 load balancing](https://www.nginx.com/resources/glossary/layer-4-load-balancing/)
+- [Layer 7 load balancing](https://www.nginx.com/resources/glossary/layer-7-load-balancing/)
+- [ELB listener config](http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-listener-config.html)
+
+
From e5be7b7b8152a4c085fa71d9f4a3488203383aef Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Tue, 10 Jun 2025 21:35:46 +0300
Subject: [PATCH 24/43] Updates
---
README-he.md | 26 +++++++++++++-------------
1 file changed, 13 insertions(+), 13 deletions(-)
diff --git a/README-he.md b/README-he.md
index 4ceced0d..e435b85d 100644
--- a/README-he.md
+++ b/README-he.md
@@ -156,20 +156,20 @@
- זמינות במספרים
- מערכת שמות דומיינים (DNS)
- רשתות הפצת תוכן (CDN)
+ מערכת שמות דומיינים (DNS)
+ רשתות הפצת תוכן (CDN)
- מאזן עומסים (load balancer)
+ מאזן עומסים (load balancer)
פרוקסי 'הפוך' (Reverse Proxy)
@@ -899,7 +899,7 @@ Availability (Total) = 1 - (1 - Availability (Foo)) * (1 - Availability (Bar))
-
+
מקור: מצגת אבטחת DNS
@@ -948,7 +948,7 @@ Availability (Total) = 1 - (1 - Availability (Foo)) * (1 - Availability (Bar))
-
+
מקור: Why use a CDN
@@ -1000,7 +1000,7 @@ Pull CDN מתאים לאתרים עתירי תעבורה, שכן העומס מת
-
+
Source: Scalable system design patterns
From 40069a9bba14e675c98c0231ea053555ec36ca0e Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Wed, 11 Jun 2025 09:55:21 +0300
Subject: [PATCH 25/43] Translating - Reverse Proxy
---
README-he.md | 55 +++++++++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 54 insertions(+), 1 deletion(-)
diff --git a/README-he.md b/README-he.md
index e435b85d..e902c68c 100644
--- a/README-he.md
+++ b/README-he.md
@@ -172,7 +172,7 @@
גדילה אופקית (horizontal)
-
פרוקסי 'הפוך' (Reverse Proxy)
+ פרוקסי הפוך (Reverse Proxy)
@@ -1093,3 +1093,56 @@ Pull CDN מתאים לאתרים עתירי תעבורה, שכן העומס מת
- [ELB listener config](http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-listener-config.html)
+
+## פרוקסי הפוך (Reverse Proxy)
+
+
+
+פרוקסי הפוך הוא שרת אינטרנט המרכז שירותים פנימיים ומספק ממשק אחיד החוצה. בקשות שמגיעות מלקוחות מועברות לשרת ה-backend המסוגל לטפל בהן, ולאחר מכן הפרוקסי מחזיר ללקוח את תגובת השרת.
+
+יתרונות הכלולים בצורה זו:
+
+
+ - אבטחה מוגברת – הסתרת מידע על שרתי ה-backend, חסימת כתובות IP, הגבלת מספר חיבורים לכל לקוח
+ - גמישות וסקילביליות מוגברת – הלקוחות רואים רק את כתובת ה-IP של הפרוקסי, מה שמאפשר להגדיל/לשנות שרתים בלי להשפיע על הלקוחות
+ - SSL Termination – טכניקת אבטחה שבה מפענחים בקשות נכנסות לפני שהן מגיעות לשרת הקצה, ומצפינים את התשובות של השרת כך ששרתי ה-backend לא צריכים לבצע את הפעולות היקרות הללו.
+
+ - מוריד את הצורך להתקין תעודות X.509 על כל שרת.
+
+
+
+ - דחיסה – דחיסת תגובות השרת
+ - מטמון – החזרת תגובות עבור בקשות שמורות (cached)
+ - תוכן סטטי – הנגשת קבצים סטטיים ישירות
+
+ - HTML/CSS/JS
+ - תמונות
+ - סרטונים
+ - וכד׳
+
+
+
+
+### מאזן עומסים לעומת פרוקסי הפוך
+
+
+ - פריסת מאזן עומסים שימושית כשקיימים מספר שרתים. לרוב הוא מנתב תעבורה לקבוצת שרתים המבצעים אותה לוגיקה.
+ - פרוקסי הפוך מועיל גם כאשר יש רק שרת אינטרנט/אפליקציה אחד – ומעניק את כל היתרונות שפורטו לעיל.
+ - פתרונות כמו NGINX ו-HAProxy תומכים גם בפרוקסי הפוך בשכבה 7 וגם באיזון עומסים.
+
+
+### חסרונות: פרוקסי הפוך
+
+
+ - הכנסת פרוקסי הפוך מוסיפה מורכבות לארכיטקטורה.
+ - פרוקסי הפוך יחיד הוא SPOF. הגדרת כמה כאלו להפחתת סיכון (Fail-over) מוסיפה מורכבות נוספת.
+
+
+### מקורות וקריאה נוספת
+
+- [Reverse proxy vs load balancer](https://www.nginx.com/resources/glossary/reverse-proxy-vs-load-balancer/)
+- [NGINX architecture](https://www.nginx.com/blog/inside-nginx-how-we-designed-for-performance-scale/)
+- [HAProxy architecture guide](http://www.haproxy.org/download/1.2/doc/architecture.txt)
+- [Wikipedia](https://en.wikipedia.org/wiki/Reverse_proxy)
+
+
From a9e62485f00252c7e594c3ae1da378b4e9929ea4 Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Wed, 11 Jun 2025 09:56:06 +0300
Subject: [PATCH 26/43] Fixed rtl
---
README-he.md | 5 ++---
1 file changed, 2 insertions(+), 3 deletions(-)
diff --git a/README-he.md b/README-he.md
index e902c68c..3716c641 100644
--- a/README-he.md
+++ b/README-he.md
@@ -1114,11 +1114,10 @@ Pull CDN מתאים לאתרים עתירי תעבורה, שכן העומס מת
דחיסה – דחיסת תגובות השרת
מטמון – החזרת תגובות עבור בקשות שמורות (cached)
תוכן סטטי – הנגשת קבצים סטטיים ישירות
-
- - HTML/CSS/JS
+
+ - קבצי HTML/CSS/JS
- תמונות
- סרטונים
- - וכד׳
From a8529b508b712aba6f75f9f2475295d54a70a923 Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Wed, 11 Jun 2025 09:56:51 +0300
Subject: [PATCH 27/43] Smaller pics
---
README-he.md | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/README-he.md b/README-he.md
index 3716c641..73a0249d 100644
--- a/README-he.md
+++ b/README-he.md
@@ -899,7 +899,7 @@ Availability (Total) = 1 - (1 - Availability (Foo)) * (1 - Availability (Bar))
-
+
מקור: מצגת אבטחת DNS
@@ -948,7 +948,7 @@ Availability (Total) = 1 - (1 - Availability (Foo)) * (1 - Availability (Bar))
-
+
מקור: Why use a CDN
@@ -1000,7 +1000,7 @@ Pull CDN מתאים לאתרים עתירי תעבורה, שכן העומס מת
-
+
Source: Scalable system design patterns
From 8f17bb0f17922e1d4c09ec2762f6e7ab3e0c272b Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Sat, 14 Jun 2025 17:00:45 +0300
Subject: [PATCH 28/43] Translating - Application
---
README-he.md | 42 ++++++++++++++++++++++++++++++++++++++++++
1 file changed, 42 insertions(+)
diff --git a/README-he.md b/README-he.md
index 73a0249d..74db2ce1 100644
--- a/README-he.md
+++ b/README-he.md
@@ -1145,3 +1145,45 @@ Pull CDN מתאים לאתרים עתירי תעבורה, שכן העומס מת
- [Wikipedia](https://en.wikipedia.org/wiki/Reverse_proxy)
+
+
+## שכבת האפליקציה
+
+
+
+הפרדת שכבת הרשת משכבת האפליקציה (ידועה גם כשכבת ה-platform), מאפשרת לבצע scaling ולקנפג את שתי השכבות באופן בלתי תלוי. הוספת API חדש גוררת הוספתי שרתי אפליקציה, מבלי להוסיף בהכרח גם שרתי המטפלים בלוגיקת הרשת.
+
+עקרון האחריות היחידה (**single respoinsibility principle**) מעודד סרביסים עצמאיים וקטנים שעובדים יחד. צוותים קטנים המטפלים שירותים קטנים יכלוים להתכוונן בצורה מיטבית לגדילה מהירה.
+
+ Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוניות](#asynchronism).
+
+### מיקרו-סרביסים (Microservices)
+
+במונח [Microservices](https://he.wikipedia.org/wiki/מיקרו-שירותים) הכוונה למערך של שירותים קטנים, מודולריים, הניתנים לפריסה עצמאית. כל שירות רץ כתהליך נפרד ומתקשר באמצעות מנגנון פשוט ומוגדר היטב כדי להשיג יעד עסקי.
1
+
+לדוגמה, ב-Pinterest יכולים להיות המיקרו-סרביסים הבאים: פרופיל משתמש, עוקבים, פיד, חיפוש, העלאת תמונה וכו'.
+
+### גילוי סרביסים (Service Discovery)
+
+מערכות כמו [Consul](https://www.consul.io/docs/index.html), [Etcd](https://coreos.com/etcddocs/latest), ו-[Zookeeper](http://www.slideshare.net/sauravhaloi/introduction-to-apache-zookeeper) מסייעות לשירותים “למצוא” זה את זה על ידי ניהול ומעקב אחר שמות הסרביסים, כתובות IP, ופורטים.
+בדיקות דופק ([Health checks](https://www.consul.io/intro/getting-started/checks.html)) — מאמתות את תקינות השירות, לעיתים קרובות באמצעות endpoint HTTP.
+גם Consul וגם Etcd כוללים
+[אחסון key-value](#key-value-store) מובנה, השימושי לאחסון קונפיגורציה ונתונים משותפים.
+
+### חסרונות: שכבת האפליקציה
+
+
+ - הוספת שכבת אפליקציה עם סרביסים שהקשר ביניהם רופף (loosely coupled) דורשת גישה שונה בארכיטקטורה, תפעול ותהליכי פיתוח (לעומת מערכת מונוליטית).
+ - מיקרו-סרביסים עלולים להוסיף מורכבות מבחינת פריסות ותפעול.
+
+
+### מקורות וקריאה נוספת
+- [Intro to architecting systems for scale](http://lethain.com/introduction-to-architecting-systems-for-scale)
+- [Crack the system design interview](http://www.puncsky.com/blog/2016-02-13-crack-the-system-design-interview)
+- [Service oriented architecture](https://en.wikipedia.org/wiki/Service-oriented_architecture)
+- [Introduction to Zookeeper](http://www.slideshare.net/sauravhaloi/introduction-to-apache-zookeeper)
+- [Here's what you need to know about building microservices](https://cloudncode.wordpress.com/2016/07/22/msa-getting-started/)
+
+
+
+
From 9b073c6c4140bb184e34120382e1e0166fff8f0b Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Sat, 14 Jun 2025 21:08:27 +0300
Subject: [PATCH 29/43] Translating - DB/RDBMS
---
README-he.md | 227 +++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 227 insertions(+)
diff --git a/README-he.md b/README-he.md
index 74db2ce1..eb80fc14 100644
--- a/README-he.md
+++ b/README-he.md
@@ -1186,4 +1186,231 @@ Pull CDN מתאים לאתרים עתירי תעבורה, שכן העומס מת
+## מסדי נתונים (DB)
+
+
+
+
+
+ Source: Scaling up to your first 10 million users
+
+
+### מסדי נתונים רלציוניים (RDBMS)
+
+מסד נתונים רלציוני כמו SQL הוא אוסף פריטי מידע המאורגנים בטבלאות. **ACID** הוא סט מאפיינים של [טרנזקציות](https://he.wikipedia.org/wiki/טרנזקציה_(בסיס_נתונים)) במסדי נתונים רלציוניים:
+
+
+ - Atomicity – כל טרנזקציה מתבצעת בשלמותה או שלא מתבצעת כלל (all or nothing).
+ - Consistency – טרנזקציה מעבירה את ה-DB ממצב תקין אחד למצב תקין אחר.
+ - Isolation – הרצה במקביל של טרנזקציות שקולה להרצה סדרתית שלהן.
+ - Durability – לאחר שטרנזקציה הסתיימה, היא תישאר קבועה גם בקריסת מערכת.
+
+
+ישנן טכניקות רבות להגדלת (scaling) מסד נתונים רלציוני:
+
שכפול Master-Slave,
שכפול Master-Master,
פדרציה (Federation),
חלוקה (Sharding),
דה-נורמליזציה (Denormalization), ו-
SQL Tuning.
+
+---
+
+#### שכפול Master-Slave
+
+ה-master משרת קריאות וכתיבות (RW), ומשכפל את הכתיבות ל-slave אחד או יותר שמשרת רק קריאות (R). ה-slaves יכול לשכפל את הדאטא ל-slaves נוספים במבנה של מעין עץ.
+אם ה-master נופל, המערכת יכולה להמשיך לרוץ במצב read-only עד שאחד ה-slaves מקודם להיות master, או שמקצים master חדש.
+
+
+
+
+ Source: Scalability, availability, stability, patterns
+
+
+
+##### חסרונות: Master-Slave
+
+
+ - נדרשת לוגיקה לקידום slave ל-master.
+ - ראה חסרונות: replication – רלוונטי גם ל-Master-Slave וגם ל-Master-Master.
+
+
+---
+
+#### שכפול Master-Master
+
+שני ה-masters משרתים קריאה וכתיבה (RW) ומתאמים אחד עם השני את הכתיבות. אם אחד מהם נופל, המערכת יכולה להמשיך לתפקד במצב של קריאה וכתיבה.
+
+
+
+
+ Source: Scalability, availability, stability, patterns
+
+
+##### חסרונות: Master-Master
+
+
+ - נדרש מאזן עומסים או שינוי לוגיקת האפליקציה כדי להחליט לאן לכתוב.
+ - רוב מערכות ה-Master-Master מפרות עקרון של עקביות (לכן מפרות ACID) או סובלות מאיטיות כתיבה עקב הצורך לבצע סנכרון.
+ - ככל שמתרבים שרתים שמאפשרים כתיבה וה-latency גדל, יש צורך להכריע יותר מקרים של conflict.
+ - ראה חסרונות: replication.
+
+
+##### חסרונות: Replication (כללי)
+
+
+ - סכנת אובדן נתונים אם ה-master נופל לפני ששוכפל מידע חדש שנכתב.
+ - כל שינוי ב-master משתכפל לרפליקות, מה שגורם להן להיות עסוקות בשחזור הכתיבות, וזה מאט את הקריאות מהן.
+ - כל רפליקה נוספת מובילה ל-lag גדול יותר בקריאה עקב הצורך לשכפל את כל המידע לכל הרפליקות.
+ - בחלק מהמערכות, כתיבה ל-master יכולה להיות multi-threaded בעוד שברפליקות לרוב הכתיבה היא סנכרונית עם thread בודד.
+ - שכפול מוסיף עוד חומרה ומורכבות.
+
+
+##### מקורות וקריאה נוספת: Replication
+
+- [Scalability, availability, stability, patterns](http://www.slideshare.net/jboner/scalability-availability-stability-patterns/)
+- [Multi-master replication](https://en.wikipedia.org/wiki/Multi-master_replication)
+
+---
+
+#### פדרציה (Federation)
+
+
+
+
+ Source: Scaling up to your first 10 million users
+
+
+בפדרציה (או חלוקה פונקציונלית) מפצלת DB לפי הפונקציות שלו. לדוגמה, במקום DB מונוליטי בודד, ניתן לנהל 3 DBים נפרדים: **פורומים, משתמשים, ומוצרים**, מה שגורר פחות תעבורת קריאה וכתיבה לכל DB, ועקב כך פחות replication lag.
+מסדי נתונים קטנים יותר מאפשרים יותר דאטא שנכנס בזיכרון, שיכול להוביל ליותר cache hits מוצלחים. בלי master אחד מרכזי שאחראי לדאוג לכל הכתיבות באופן סדרתי, אפשר לכתוב במקביל ל-DB שונים עבור כל סוג של נתונים, ובכך להגדיל את ה-throughput.
+
+##### חסרונות: פדרציה
+
+
+ - לא יעיל אם הסכימה דורשת טבלאות עצומות.
+ - הלוגיקה באפליקציה צריכה להתעדכן כדי לדעת לאיזה DB לפנות.
+ - ביצוע פעולת JOIN משני DBים קשה יותר ודורש server link.
+ - דורשת הוספה של עוד חומרה ומורכבות.
+
+
+##### מקורות וקריאה נוספת: פדרציה
+
+- [Scaling up to your first 10 million users](https://www.youtube.com/watch?v=kKjm4ehYiMs)
+
+---
+
+#### חלוקה (Sharding)
+
+
+
+
+ Source: Scalability, availability, stability, patterns
+
+
+חלוקה מפזרת את הדאטא בין DBים שונים כך שכל DB מנהל חלק (subset) מסוים של הדאטא. נסתכל למשל על DB של משתמשים, ככל שכמות המשתמשים עולה, יותר חלקים (shards) מתווספים ל-cluster.
+
+בדומה ליתרונות של [פדרציה](), חלוקה גוררת פחות תעבורה של קריאות וכתיבות, פחות שכפול, ויותר cache hits. גודל ה-index גם קטן, מה שלרוב משפר את קצב ביצוע השאילתות.
+אם shard אחד נופל, כל שאר ה-shards עדיין פעילים, למרות שנרצה לבצע שכפול מסוים כדי להימנע מאיבוד מידע. כמו פדרציה, אין master מרכזי אחיד שכל הכתיבות עוברות דרכו, מה שמאפשר לכתוב במקביל ל-DBים שונים ולהגביר את ה-throughput.
+
+דרכים נפוצות לבצע sharding לטבלה של משתמשים הן באמצעות האות הראשונה של שם המשפחה, או המיקום הגיאוגרפי של המשתמש.
+
+##### חסרונות: Sharding
+
+
+ - הקוד צריך לדעת באיזה shard הנתונים נמצאים, דבר הגורר שאילתות SQL מורכבות.
+ - התפלגות נתונים עלולה להיות לא אחידה, קבוצה של power users על אותו ה-shard יכולה להביא לעומס מוגבר לאותו ה-shard ביחס לאחרים.
+ ביצוע rebalance גורר מורכבות נוספת. פונקציית sharding המבוססת על Consistent Hashing יכול להקטין את כמות הדאטא שמועבר בין shardים.
+
- ביצוע פעולת JOIN על מספר shardים מורכבת יותר.
+ - sharding מוסיף חומרה ומורכבות.
+
+
+###### מקורות וקריאה נוספת
+
+- [The coming of the shard](http://highscalability.com/blog/2009/8/6/an-unorthodox-approach-to-database-design-the-coming-of-the.html)
+- [Shard database architecture](https://en.wikipedia.org/wiki/Shard_(database_architecture))
+- [Consistent hashing](http://www.paperplanes.de/2011/12/9/the-magic-of-consistent-hashing.html)
+
+---
+
+#### דנורמליזציה (Denormalization)
+
+דנורמליזציה שואפת לשפר ביצועים של קריאות על חשבון חלק מהביצועים של הכתיבות. עותקים מיותרים (משוכפלים באופן מכוון, Redundant) של הדאטא נכתבים במספר טבלאות שונות כדי להימנע מביצוע JOINים יקרים. חלק מה-RDBMSים כמו [PostgreSQL](https://en.wikipedia.org/wiki/PostgreSQL) ו-Oracle תומכים ב-[materialized views](https://en.wikipedia.org/wiki/Materialized_view) אשר דואגים לשמירה של מידע מיותר ושמירת עותקים מיותרים עקביים.
+
+כאשר הדאטא מבוזר באמצעות טכניקות כמו [פדרציה]() או [חלוקה](), ניהול JOINים בין ריכוזי מידע שונים מגדיר את המורכבות. דנורמליזציה יכולה לייתר את הצורך לבצע JOINים מורכבים.
+
+ברוב המערכות, כמות הקריאות גדולה בהרבה מכמות הכתיבות, ביחס של 100:1 ואף 1000:1. קריה יכולה להוביל לביצוע JOIN מורכב ויקר, מה שעולה בביצוע פעולות דיסק זמן רב.
+
+##### חסרונות: דנורמליזציה
+
+
+ - הדאטא משוכפל.
+ - אף שדנורמליזציה משפרת קריאות, היא דורשת שכבת אילוצים (constraints) וחוקים מסוימים כדי לשמור על עקביות העותקים — מה שמסבך את תכנון ה-DB.
+ - במערכת עם עומס כתיבה כבד ייתכן שדנורמליזציה דווקא תפגע בביצועים.
+
+
+###### מקורות וקריאה נוספת
+
+- [Denormalization](https://en.wikipedia.org/wiki/Denormalization)
+
+---
+
+#### SQL Tuning
+
+SQL Tuning הוא תחום רחב, ונכתבו עליו לא מעט [ספרים](https://www.amazon.com/s/ref=nb_sb_noss_2?url=search-alias%3Daps&field-keywords=sql+tuning).
+חשוב לבצע **Benchmark** ו-**Profile** כדי לדמות עומסים ולגלות צווארי-בקבוק.
+
+
+ - Benchmark – סימולציית עומס כבד באמצעות כלים כמו ab.
+ - Profile – הפעלת כלים כגון Slow Query Log למעקב אחר בעיות ביצועים.
+
+
+התוצאות של השימוש בכלים אלו עשויה להוביל לאופטימיזציות הבאות:
+##### הידוק הסכימה (Tighten up the schema)
+
+
+ - MySQL כותב לדיסק בבלוקים עוקבים, לגישה מהירה.
+ - השתמש ב-
CHAR
במקום VARCHAR
לשדות קבועי-אורך
+
+ CHAR
מאפשר גישה אקראית מהירה; ב-VARCHAR
צריך לחפש את סוף-המחרוזת.
+
+
+ - השתמש ב-
TEXT
למקטעי טקסט גדולים (למשל פוסטים של בלוג); מאפשר גם חיפושים בוליאניים. השדה מאחסן מצביע על הדיסק שמטרתו לאתר את בלוק הטקסט.
+ - השתמש ב-
INT
למספרים עד 232 (≈ 4 מיליארד).
+ - השתמש ב-
DECIMAL
לערכים כספיים – כדי להימנע משגיאות Floating Point.
+ - הימנע מאחסון
BLOB
-ים גדולים; שמור רק את המיקום שלהם.
+ VARCHAR(255)
– המספר שמנצל בתים בצורה מיטבית בחלק מה-RDBMS-ים.
+ - הגדר
NOT NULL
כשאפשר כדי לשפר ביצועי חיפוש.
+
+
+##### השתמש באינדקסים טובים (Use good indices)
+
+
+ - עמודות הנשלפות באמצעות פקודות כמו
SELECT
, GROUP BY
, ORDER BY
, JOIN
יכולות להיות מהירות יותר עם אינדקסים.
+ - אינדקסים מיוצגים בדרך-כלל כ-B-Tree מאוזן: שומר על הדאטא ממוין, ומאפשר חיפוש/הוספה/מחיקה בזמן לוגריתמי.
+ - אינדקס שומר את הנתונים בזיכרון – אבל צורך יותר מקום.
+ - כתיבות עלולות להיות איטיות יותר כי צריך לעדכן גם את האינדקס.
+ - בעת טעינת נתונים גדולה ייתכן שיותר מהיר להשבית אינדקסים, לטעון את הנתונים ואז לבנות את האינדקסים מחדש.
+
+
+##### מניעת JOIN יקר
+
+
+
+##### חלוקה לטבלאות (Partitioning)
+
+
+ - חלוקה לטבלאות (Partitioning) מאפשרת לשמור את ה־hot spots (אזורים “חמים” בטבלה, כלומר רשומות שנקראות/נכתבות הכי הרבה) במחיצה קטנה שנשארת בזיכרון, ולכן שאילתות על הנתונים העדכניים רצות מהר יותר ומעמיסות פחות על הדיסק.
+
+
+##### כוונון Query Cache
+
+
+
+###### מקורות וקריאה נוספת
+
+- [Tips for optimizing MySQL queries](http://aiddroid.com/10-tips-optimizing-mysql-queries-dont-suck/)
+- [Is there a good reason i see VARCHAR(255) used so often?](http://stackoverflow.com/questions/1217466/is-there-a-good-reason-i-see-varchar255-used-so-often-as-opposed-to-another-l)
+- [How do null values affect performance?](http://stackoverflow.com/questions/1017239/how-do-null-values-affect-performance-in-a-database-search)
+- [Slow query log](http://dev.mysql.com/doc/refman/5.7/en/slow-query-log.html)
+
+
From 08f176413ddfc2e7bd0015a991668bc62c7a4eca Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Sun, 15 Jun 2025 09:57:27 +0300
Subject: [PATCH 30/43] Minor fixes
---
README-he.md | 17 +++++++----------
1 file changed, 7 insertions(+), 10 deletions(-)
diff --git a/README-he.md b/README-he.md
index eb80fc14..c4cf1a0a 100644
--- a/README-he.md
+++ b/README-he.md
@@ -1154,8 +1154,7 @@ Pull CDN מתאים לאתרים עתירי תעבורה, שכן העומס מת
הפרדת שכבת הרשת משכבת האפליקציה (ידועה גם כשכבת ה-platform), מאפשרת לבצע scaling ולקנפג את שתי השכבות באופן בלתי תלוי. הוספת API חדש גוררת הוספתי שרתי אפליקציה, מבלי להוסיף בהכרח גם שרתי המטפלים בלוגיקת הרשת.
עקרון האחריות היחידה (**single respoinsibility principle**) מעודד סרביסים עצמאיים וקטנים שעובדים יחד. צוותים קטנים המטפלים שירותים קטנים יכלוים להתכוונן בצורה מיטבית לגדילה מהירה.
-
- Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוניות](#asynchronism).
+Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוניות](#asynchronism).
### מיקרו-סרביסים (Microservices)
@@ -1218,7 +1217,7 @@ Pull CDN מתאים לאתרים עתירי תעבורה, שכן העומס מת
אם ה-master נופל, המערכת יכולה להמשיך לרוץ במצב read-only עד שאחד ה-slaves מקודם להיות master, או שמקצים master חדש.
-
+
Source: Scalability, availability, stability, patterns
@@ -1238,7 +1237,7 @@ Pull CDN מתאים לאתרים עתירי תעבורה, שכן העומס מת
שני ה-masters משרתים קריאה וכתיבה (RW) ומתאמים אחד עם השני את הכתיבות. אם אחד מהם נופל, המערכת יכולה להמשיך לתפקד במצב של קריאה וכתיבה.
-
+
Source: Scalability, availability, stability, patterns
@@ -1272,7 +1271,7 @@ Pull CDN מתאים לאתרים עתירי תעבורה, שכן העומס מת
#### פדרציה (Federation)
-
+
Source: Scaling up to your first 10 million users
@@ -1298,7 +1297,7 @@ Pull CDN מתאים לאתרים עתירי תעבורה, שכן העומס מת
#### חלוקה (Sharding)
-
+
Source: Scalability, availability, stability, patterns
@@ -1365,10 +1364,8 @@ SQL Tuning הוא תחום רחב, ונכתבו עליו לא מעט [ספרים
- MySQL כותב לדיסק בבלוקים עוקבים, לגישה מהירה.
- - השתמש ב-
CHAR
במקום VARCHAR
לשדות קבועי-אורך
-
- CHAR
מאפשר גישה אקראית מהירה; ב-VARCHAR
צריך לחפש את סוף-המחרוזת.
-
+ - השתמש ב-
CHAR
במקום VARCHAR
לשדות קבועי-אורך.
+ code>CHAR מאפשר גישה אקראית מהירה; ב-VARCHAR
צריך לחפש את סוף-המחרוזת.
- השתמש ב-
TEXT
למקטעי טקסט גדולים (למשל פוסטים של בלוג); מאפשר גם חיפושים בוליאניים. השדה מאחסן מצביע על הדיסק שמטרתו לאתר את בלוק הטקסט.
- השתמש ב-
INT
למספרים עד 232 (≈ 4 מיליארד).
From 8d6aadf15a74782069212711e63edd25272b1a83 Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Sun, 15 Jun 2025 11:14:35 +0300
Subject: [PATCH 31/43] Translating - finished DB
---
README-he.md | 169 ++++++++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 167 insertions(+), 2 deletions(-)
diff --git a/README-he.md b/README-he.md
index c4cf1a0a..d2add0ed 100644
--- a/README-he.md
+++ b/README-he.md
@@ -1351,7 +1351,7 @@ Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוני
#### SQL Tuning
-SQL Tuning הוא תחום רחב, ונכתבו עליו לא מעט [ספרים](https://www.amazon.com/s/ref=nb_sb_noss_2?url=search-alias%3Daps&field-keywords=sql+tuning).
+התחום של SQL Tuning הוא רחב, ונכתבו עליו לא מעט [ספרים](https://www.amazon.com/s/ref=nb_sb_noss_2?url=search-alias%3Daps&field-keywords=sql+tuning).
חשוב לבצע **Benchmark** ו-**Profile** כדי לדמות עומסים ולגלות צווארי-בקבוק.
@@ -1403,11 +1403,176 @@ SQL Tuning הוא תחום רחב, ונכתבו עליו לא מעט [ספרים
- במקרים מסוימים, query cache עלול לגרום לבעיות ביצועים.
-###### מקורות וקריאה נוספת
+##### מקורות וקריאה נוספת
- [Tips for optimizing MySQL queries](http://aiddroid.com/10-tips-optimizing-mysql-queries-dont-suck/)
- [Is there a good reason i see VARCHAR(255) used so often?](http://stackoverflow.com/questions/1217466/is-there-a-good-reason-i-see-varchar255-used-so-often-as-opposed-to-another-l)
- [How do null values affect performance?](http://stackoverflow.com/questions/1017239/how-do-null-values-affect-performance-in-a-database-search)
- [Slow query log](http://dev.mysql.com/doc/refman/5.7/en/slow-query-log.html)
+### NoSQL
+
+לעומת SQL קלאסי, NoSQL הוא אוסף של מבני נתונים הנשמרים בתור **Key-Value Store**, **Document Store**, **Wide Column Store** או **Graph Database**.
+הנתונים מנורמלים פחות, ופעולות JOIN מבוצעות לרוב בקוד האפליקציה עצמה.
+רוב האחסונים מסוג NoSQL אינם תומכים בטרנזקציות ACID מלאות ומספקים [עקביות לא מיידית](#eventual-consistency).
+
+מקובל לסמן את מאפייני NoSQL בראשי התיבות **BASE** (תווך שימוש ב[משפט CAP](#cap-theorem), תכונות BASE מתעדפות זמינות (A) על פני עקביות (C)):
+
+
+ - Basically Available – המערכת מבטיחה זמינות.
+ - Soft State – מצב המערכת עשוי להשתנות עם הזמן, גם ללא קלט.
+ - Eventual Consistency – המערכת תהפוך עקבית בסופו של דבר, בהנחה שלא מתקבל קלט נוסף בתקופה זו.
+
+
+מעבר לבחירה בין [SQL ל-NoSQL](#sql-or-nosql), חשוב להבין איזה סוג NoSQL מתאים ביותר לשימוש שלך. נדון בסוגים **Key-Value Stores**, **Document Stores**, **Wide Column Stores** ו-**Graph Databases**.
+
+---
+
+#### אחסון Key-Value
+> הפשטה: Hash Table
+
+אחסון Key-Value לרוב מאפשר קריאות וכתיבות ב-O(1) ומגובה באמצעות זיכרון או SSD. ניתן לשמור מפתחות ב[סדר לקסיקוגרפי](), מה שמאפשר שליפה יעילה של טווחי המפתחות.
+אחסון זה מאפשר תמיכה ב-metadadta עם ערכים.
+
+אחסון זה מספק ביצועים גבוהים ולרוב בשימוש עבור מודלי דאטא פשוטים או לדאטא שמשתנה במהירות, כמו שכבת cache in-memory. כיוון שסוגי אחסון זה מציעים סט מצומצם של פעולות, המורכבות נמצאת בשכבת האפלקציה אם נדרשות פעולות נוספות.
+
+אחסון זה הוא הבסיס למערכות מורכבות יותר כמו document store ובמקרים מסוימים גם graph db.
+
+##### מקורות וקריאה נוספת: אחסון Key-Value
+
+- [Key-value database](https://en.wikipedia.org/wiki/Key-value_database)
+- [Disadvantages of key-value stores](http://stackoverflow.com/questions/4056093/what-are-the-disadvantages-of-using-a-key-value-table-over-nullable-columns-or)
+- [Redis architecture](http://qnimate.com/overview-of-redis-architecture/)
+- [Memcached architecture](https://adayinthelifeof.nl/2011/02/06/memcache-internals/)
+
+---
+
+#### אחסון Document
+> הפשטה: אחסון Key-Value שבו הערך הוא מסמך
+
+אחסון Document מתרכז סביב מסמכים (XML, JSON, binary, etc.) כאשר מסמך שומר את כל המידע שקשור לאובייקט מסוים. אחסון זה מספק API או query language כדי לתשאל על בסיס המבנה הפנימי של המסמך עצמו. נשים לב, כי הרבה אחסונים מסוג Key-Value כוללים פיצ'רים כדי לעבוד עם ה-metadata של ה-value, מה שמטשטש את הגבול בין שני סוגי אחסון אלו.
+
+על בסיס המימוש הספציפי מאחורי הקלעים, מסמכים מאורגנים לפי אוספים, תגים, metadata או תיקיות. למרות שמסמכים יכולים להיות מאורגנים או מקובצים יחדיו, יכולים להיות להם שדות שונים לחלוטין אחד מהשני.
+
+
+אחסונים כמו [MongoDB](https://www.mongodb.com/mongodb-architecture) ו-[CouchDB](https://blog.couchdb.org/2016/08/01/couchdb-2-0-architecture/) מציעים שפה דמוית SQL על מנת לבצע שאילתות מורכבות.
+[DynamoDB](http://www.read.seas.harvard.edu/~kohler/class/cs239-w08/decandia07dynamo.pdf) תומך גם ב-Key-Value וגם במסמכים.
+
+אחסונים אלו מספקים גמישות גבוהה ולרוב בשימוש עבור דאטא שמשתנה בתדירות גבוהה.
+
+##### מקורות וקריאה נוספת: אחסון Document
+
+- [Document-oriented database](https://en.wikipedia.org/wiki/Document-oriented_database)
+- [MongoDB architecture](https://www.mongodb.com/mongodb-architecture)
+- [CouchDB architecture](https://blog.couchdb.org/2016/08/01/couchdb-2-0-architecture/)
+- [Elasticsearch architecture](https://www.elastic.co/blog/found-elasticsearch-from-the-bottom-up)
+
+---
+
+#### אחסון Wide Column
+
+
+
+
+ Source: SQL & NoSQL, a brief history
+
+
+> הפשטה: Map מקונן מסוג
+
+> ColumnFamily<RowKey, Columns<ColKey, Value, Timestamp>>
+
+אחסון Wide Column עובד עם יחידת דאטא בסיסית שהיא עמודה (זוג שם/ערך).
+עמודות מקובצות תחת column families (כמו טבלת SQL). Super column families הן אוסף של column families. אפשר לגשת לכל עמודה בנפרד עם row key, כאשר עמודות בעלות אותו row key יוצרות שורה.
+כל ערך מכיל timestamp עבור גרסאות ופתרון קונפליקטים.
+
+דוגמאות: Google הציגה את [Bigtable](http://www.read.seas.harvard.edu/~kohler/class/cs239-w08/chang06bigtable.pdf) כאחסון הראשון מסוג זה. זה השפיע על פרויקט הקוד הפתוח [HBase](https://www.edureka.co/blog/hbase-architecture/) (באקוסיסטם Hadoop) ו-[Cassandra](http://docs.datastax.com/en/cassandra/3.0/cassandra/architecture/archIntro.html) של Facebook.
+מערכות כמו Bigtable, HBase ו-Cassandra שומרות מפתחות בסדר **לקסיקוגרפי**, וכך מאפשרות שליפת טווחי מפתחות ביעילות.
+
+אחסונים אלו מציעים זמינות גבוהה, וסקילביליות גבוהה. לרוב משתמשים בהם לאחסון דאטאסטים מאוד גדולים.
+
+##### מקורות וקריאה נוספת: אחסון Wide Column
+
+- [SQL & NoSQL, a brief history](http://blog.grio.com/2015/11/sql-nosql-a-brief-history.html)
+- [Bigtable architecture](http://www.read.seas.harvard.edu/~kohler/class/cs239-w08/chang06bigtable.pdf)
+- [HBase architecture](https://www.edureka.co/blog/hbase-architecture/)
+- [Cassandra architecture](http://docs.datastax.com/en/cassandra/3.0/cassandra/architecture/archIntro.html)
+
+---
+
+#### אחסון Graph
+
+
+
+
+ Source: Graph database
+
+
+> הפשטה: גרף
+
+ב-DB גרפי כל **צומת** (Node) הוא רשומה, וכל **קשת** (Arc/Edge) היא קשר בין שני צמתים.
+ה-DB מותאם לייצוג קשרים מורכבים – עם הרבה מפתחות זרים (Foreign Keys) או יחסי Many-to-Many.
+
+אחסון זה מאפשר ביצועים גבוהים למודלים עם יחסים מורכבים, למשל כמו רשת חברתית. הטכנולוגיה הזו יחסית חדשה ופות נפוצה; ייתכן קושי למצוא כלי פיתוח ומשאבים. הרבה אחסונים מסוג זה נגישים רק באמצעות
+[REST APIs](#representational-state-transfer-rest).
+
+##### מקורות וקריאה נוספת: Graph
+
+- [Graph database](https://en.wikipedia.org/wiki/Graph_database)
+- [Neo4j](https://neo4j.com/)
+- [FlockDB](https://blog.twitter.com/2010/introducing-flockdb)
+
+#### מקורות וקריאה נוספת: NoSQL
+
+- [Explanation of base terminology](http://stackoverflow.com/questions/3342497/explanation-of-base-terminology)
+- [NoSQL databases a survey and decision guidance](https://medium.com/baqend-blog/nosql-databases-a-survey-and-decision-guidance-ea7823a822d#.wskogqenq)
+- [Scalability](https://web.archive.org/web/20220602114024/https://www.lecloud.net/post/7994751381/scalability-for-dummies-part-2-database)
+- [Introduction to NoSQL](https://www.youtube.com/watch?v=qI_g07C_Q5I)
+- [NoSQL patterns](http://horicky.blogspot.com/2009/11/nosql-patterns.html)
+
+### SQL or NoSQL
+
+
+
+
+ Source: Transitioning from RDBMS to NoSQL
+
+
+-סיבות לשימוש ב**SQL**:
+
+
+ - נתונים עם מבנה קבוע
+ - סכמה ברורה עם אילוצים וטיפוסים
+ - דאטא עם קשרי Foreign Key ו־Many-to-Many
+ - צורך בביצוע JOIN-ים מורכבים
+ - טרנזקציות (עקרונות ACID)
+ - תבניות ברורות לביצוע Scaling
+ - אקו־סיסטם ענק של כלים, קוד וקהילה
+ - חיפושים לפי אינדקס מהירים מאוד
+
+
+סיבות לשימוש ב-**NoSQL**:
+
+
+ - דאטא שהוא מובנה באופן חלקי
+ - סכמה דינמית או גמישה
+ - דאטא ללא relations
+ - אין צורך ב־JOIN־ים מורכבים
+ - אחסון TB או PB של דאטא
+ - פעולות רבות של כתיבה וקריאה בשנייה
+ - כמות גדולה של פעולות דיסק בשנייה
+
+
+דאטא לדוגמה שמתאים מאוד עבור **NoSQL**:
+
+- Rapid ingest of clickstream and log data
+- Leaderboard or scoring data
+- Temporary data, such as a shopping cart
+- Frequently accessed ('hot') tables
+- Metadata/lookup tables
+
+##### מקורות וקריאה נוספת: SQL or NoSQL
+
+- [Scaling up to your first 10 million users](https://www.youtube.com/watch?v=kKjm4ehYiMs)
+- [SQL vs NoSQL differences](https://www.sitepoint.com/sql-vs-nosql-differences/)
+
From 71ef65af5c1b41880b4423ded1240884d436b55b Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Sun, 15 Jun 2025 11:16:15 +0300
Subject: [PATCH 32/43] Minor fixes
---
README-he.md | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/README-he.md b/README-he.md
index d2add0ed..96b8a9e1 100644
--- a/README-he.md
+++ b/README-he.md
@@ -1472,7 +1472,7 @@ Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוני
#### אחסון Wide Column
-
+
Source: SQL & NoSQL, a brief history
@@ -1502,7 +1502,7 @@ Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוני
#### אחסון Graph
-
+
Source: Graph database
@@ -1532,7 +1532,7 @@ Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוני
### SQL or NoSQL
-
+
Source: Transitioning from RDBMS to NoSQL
From da82c9a4df80b40f7a29d5c8be1b1fca508faa99 Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Sun, 15 Jun 2025 11:46:08 +0300
Subject: [PATCH 33/43] Fixes
---
README-he.md | 74 +++++++++++++++++++++++++++++-----------------------
1 file changed, 41 insertions(+), 33 deletions(-)
diff --git a/README-he.md b/README-he.md
index 96b8a9e1..9beac113 100644
--- a/README-he.md
+++ b/README-he.md
@@ -130,29 +130,29 @@
השלבים הבאים
-
ביצועים (performance) מול סקילביליות (scalability)
-
שיהוי (latency) מול תפוקה (throughput)
-
זמינות (availability) מול עקביות (consistency)
+ ביצועים (Performance) מול סקילביליות (Scalability)
+
שיהוי (Latency) מול תפוקה (Throughput)
+
זמינות (Availability) מול עקביות (Consistency)
דפוסי עקביות
דפוסי זמינות
@@ -163,44 +163,44 @@
משיכה (Pull)
-
מאזן עומסים (load balancer)
+ מאזן עומסים (Load Balancer)
-
פרוקסי הפוך (Reverse Proxy)
+ פרוקסי הפוך (Reverse Proxy)
-
שכבת האפליקציה
+ שכבת האפליקציה
-
מסדי נתונים
+ מסדי נתונים
- - מסדי נתונים רלציוניים (RDBMS)
+
- מסדי נתונים רלציוניים (RDBMS)
- NoSQL
- SQL או NoSQL
@@ -748,17 +748,17 @@
- עקביות (Consistency) – כל קריאה מקבלת את הכתיבה העדכנית ביותר, או שגיאה.
- זמינות (Availability) - כל בקשה תקבל מענה, ללא הבטחה שהמידע שיחזור יהיה העדכני ביותר.
- - יכולת חלוקה (Partition Tolerance) - המערכת ממשיכה לתפקד גם במקרים בהם נאבדות או מתעכבות מספר הודעות בין שרתי המערכת בגלל בעיות תקשורת.
+ - עמידות לפיצול (Partition Tolerance) - המערכת ממשיכה לתפקד גם במקרים בהם נאבדות או מתעכבות מספר הודעות בין שרתי המערכת בגלל בעיות תקשורת.
*ניתן לצאת מנקודת הנחה שרשתות לא אמינות - כך שנהיה חייבים לתמוך ב-״Partition tolerance״.
לכן, נצטרך לבחור אחד משני האחרים - זמינות או עקביות.*
-#### בחירה ב-CP - עקביות ויכולת חלוקה
+#### בחירה ב-CP - עקביות ועמידות לפיצול
המתנה לתשובה מהמערכת (אשר סובלת מ-network partition) עלולה להסתיים בשגיאת timeout. לכן, CP הוא בחירה טובה במידה ויש הצדקה עסקית לקריאות וכתיבות אטומיות.
-#### בחירה ב-AP - זמינות ויכולת חלוקה
+#### בחירה ב-AP - זמינות ועמידות לפיצול
תשובות לבקשות מהמערכת מחזירות את הגרסה הזמינה ביותר של הנתונים הזמינים בשרת הרלוונטי, שאינה בהכרח האחרונה. כתיבה עשויה לקחת זמן מסוים עד שתסתיים, עד אשר התקשורת הבעייתית תיפתר.
@@ -1576,3 +1576,11 @@ Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוני
- [SQL vs NoSQL differences](https://www.sitepoint.com/sql-vs-nosql-differences/)
+
+
+
+## Cache
+
+
+
+
From 70ba8ef7195faa11b420accfd493c58cdec99c7b Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Sun, 15 Jun 2025 17:53:14 +0300
Subject: [PATCH 34/43] Translating - Cache
---
README-he.md | 79 +++++++++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 78 insertions(+), 1 deletion(-)
diff --git a/README-he.md b/README-he.md
index 9beac113..a101d449 100644
--- a/README-he.md
+++ b/README-he.md
@@ -1579,8 +1579,85 @@ Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוני
-## Cache
+## מטמון (Cache)
+
+
+
+ Source: Scalable system design patterns
+
+
+שמירת נתונים ב-cache משפרת את זמן טעינת הדפים, ומפחיתה את העומס על השרתים ועל ה-DBים.
+במודל זה, השרת מחפש האם הבקשה שהגיעה כבר נעשתה בעבר, ומנסה למצוא תוצאה מוכנה, כדי לחסוך את זמן העיבוד על אותה ההודעה מחדש.
+
+מסדי נתונים לרוב מרוויחים מהתפלגות אחידה של קריאות וכתיבה על פני החלוקות שלהם (partitions). פריטים שניגשים אליהם הרבה יכולים ליצור זינוק בקריאות וכתיבה לחלוקה מסוימת וליצור צווארי-בקבוק. כאשר שמים שכבת cache לפני ה-DB, פיקים קיצוניים בתעבורה נספגים בזיכרון המהיר של המטמון ולא מעמיסים על ה-DB.
+
+### מטמון בצד לקוח
+
+מטמון יכול להיות ממוקם בצד הלקוח (מערכת ההפעלה או הדפדפן), [צד השרת](#reverse-proxy-web-server), או בשכבה נפרדת.
+
+### מטמון CDN
+
+ניתן להסתכל על [CDN](#content-delivery-network) גם בתור שכבה של מטמון.
+
+### מטמון בשרת
+
+[פרוקסי הפוך](#reverse-proxy-web-server) ומנגנוני cache כמו [Varnish](https://www.varnish-cache.org/) יכולים להנגיש תוכן סטטי ודינמי ישירות. שרתי web יכולים גם לבצע cache לבקשות כדי להחזיר תשובות בלי צורך להגיע עד לשרתי האפליקציה.
+
+### מטמון במסד נתונים
+
+ה-DB לרוב כולל רמה מסוימת של caching באופן דיפולטי, אשר מאופטמת למקרה הכללי. ביצוע כיוונון להגדרות האלה עבור תבניות שימוש ספציפיות יכול להאיץ את הביצועים.
+
+
+### מטמון באפליקציה
+
+מטמון in-memory כמו Memcached ו-Redis מהווים אחסון key-value בין האפליקציה ובין ה-DB. כיוון שהדאטא מוחזק ב-RAM, זה הרבה יותר מהיר מ-DB טיפוסי שם הדאטא נשמר על הדיסק.
+ה-RAM יותר מוגבל מהדיסק, לכן אלגוריתמים של [cache invalidation](https://en.wikipedia.org/wiki/Cache_algorithms) כמו [least recently used (LRU)](https://en.wikipedia.org/wiki/Cache_replacement_policies#Least_recently_used_(LRU)) עוזרים "לזרוק" את הפריטים שלא נגעו בהן זמן רב (cold) ולהשאיר את הנתונים הרלוונטיים (hot).
+
+ל-Redis יש את הפיצ'רים הבאים:
+
+
+ - אופציה פרסיסטנטית
+ - מבני נתונים כמו sorted sets ו-lists
+
+
+יש הרבה רמות שניתן לבצע בהן cache, והן מתחלקות לשתי קטגוריות עיקריות: **database queries** ו-**objects**:
+
+- Row level
+- Query-level
+- Fully-formed serializable objects
+- Fully-rendered HTML
+
+באופן כללי, עדיף להימנע מביצוע caching לקבצים, דבר המקשה על cloning - שכפול, ועל auto-scaling - הוספה או הורדה של מכונות.
+
+### מטמון ברמת שאילתה
+
+בכל פעם שמבצעים שאילתה ל-DB, נעשה hash על השאילתה בתור key, ונאחסן את התוצאה שלה ל-cache. הגישה הזאת סובלת מבעיות של תוקף:
+
+
+
+ - קשה למחוק תוצאה שמורה של שאילתה מורכבת (באילו טבלאות הוא משתמש)
+ - שינוי קטן ב-DB מחייב מחיקה של כל השאילתות הרלוונטיות שנשמרו, התוצאות כבר לא מעודכנות
+
+
+### מטמון ברמת אובייקט
+
+במקום לשמור תוצאה של שאילתה, נחשוב על הנתונים כמו על "אובייקט" בקוד.
+האפליקציה שולפת את המידע מה-DB ומרכיבה ממנו מופע שמתאר אותו תוך שימוש ב-class כלשהו:
+
+
+
+ - יש להסיר את האובייקט מה-cache אם אחד מהשדות שלו השתנה
+ - מאפשר עיבוד אסינכרוני: תהליכים ברקע יכולים להרכיב אובייקטים על ידי הדבר האחרון שנמצא ב-cache
+
+
+הצעות לדברים שכדאי לבצע להם cache:
+
+* User sessions
+* Fully rendered web pages
+* Activity streams
+* User graph data
+
From 2bcc41cbb56162ab1374d7658c00a288b31bd16b Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Mon, 16 Jun 2025 21:55:55 +0300
Subject: [PATCH 35/43] Translating - finished cache
---
README-he.md | 148 +++++++++++++++++++++++++++++++++++++++++++++++++--
1 file changed, 143 insertions(+), 5 deletions(-)
diff --git a/README-he.md b/README-he.md
index a101d449..4c85cf9f 100644
--- a/README-he.md
+++ b/README-he.md
@@ -1647,7 +1647,6 @@ Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוני
במקום לשמור תוצאה של שאילתה, נחשוב על הנתונים כמו על "אובייקט" בקוד.
האפליקציה שולפת את המידע מה-DB ומרכיבה ממנו מופע שמתאר אותו תוך שימוש ב-class כלשהו:
-
- יש להסיר את האובייקט מה-cache אם אחד מהשדות שלו השתנה
- מאפשר עיבוד אסינכרוני: תהליכים ברקע יכולים להרכיב אובייקטים על ידי הדבר האחרון שנמצא ב-cache
@@ -1655,9 +1654,148 @@ Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוני
הצעות לדברים שכדאי לבצע להם cache:
-* User sessions
-* Fully rendered web pages
-* Activity streams
-* User graph data
+- User sessions
+- Fully rendered web pages
+- Activity streams
+- User graph data
+
+### מתי לעדכן את ה-cache?
+
+כיוון שאפשר לאחסן רק כמות מוגבלת של מידע ב-cache, יש לבחור באסטרטגיית עדכון ופינוי המקום ב-cache שמתאימה ביותר עבור המערכת.
+
+#### אסטרטגיית Cache-Aside
+
+
+
+
+ Source: From cache to in-memory data grid
+
+
+האפליקציה אחראית לבצע קריאה וכתיבה מול האחסון. ה-cache לא מדבר עם האחסון ישירות. האפליקציה עושה את הדברים הבאים:
+
+ - חיפוש הרשומה ב-cache, מה שמוביל ל-cache miss
+ - טוענים את הרשומה מהאחסון
+ - שומרים את התוצאה ב-cache
+ - מחזירים את הרשומה ללקוח
+
+
+```python
+def get_user(self, user_id):
+ user = cache.get("user.{0}", user_id)
+ if user is None:
+ user = db.query("SELECT * FROM users WHERE user_id = {0}", user_id)
+ if user is not None:
+ key = "user.{0}".format(user_id)
+ cache.set(key, json.dumps(user))
+ return user
+```
+למשל [Memcached](https://memcached.org/) יכול להיות בשימוש בקטע קוד מהסוג הזה, האפליקציה היא זו שקובעת מתי לקרוא ולכתוב ל-cache.
+אחרי שהפריט נכתב ל-cache, כל קריאה חוזרת אליו מהירה במיוחד. אסטרטגייה זו נקראת גם lazy loading. רק מידע שנעשתה אליו גישה נכנס ל-cache, מה שמונע שמירה של הרבה דאטא שאין בו שימוש.
+
+##### חסרונות: cache-aside
+
+
+ - כל cache miss עולה לנו ב-3 שלבים, מה שיכול לגרום לעיכוב משמעותי.
+ - הדאטא יכול להתיישן אם הוא מתעדכן ב-DB. הרשומה ב-RAM כבר לא רלוונטית. אפשר לקבוע TTL קצר או לעבור לאסטרטגיה של write-through.
+ - כאשר שרת ה-cache קורס, הוא מוחלף באחד חדש שעולה ריק מאפס, מה שגורם ל-latency גבוה.
+
+
+#### אסטרטגיית Write-Through
+
+
+
+
+ Source: Scalability, availability, stability, patterns
+
+
+האפליקציה מתייחסת אל ה-cache כאחסון המרכזי, מבצעת קריאות וכתיבות מולו, כאשר ה-cache אחרי לבצע את הקריאות והכתיבות מול ה-DB:
+
+
+ - האפליקציה מוסיפה או מעדכנת רשומה ב-cache
+ - ה-cache מסנכרן כל כתיבה ל-DB
+ - הפעולה חוזרת למשתמש
+
+
+Application code:
+
+```python
+set_user(12345, {"foo":"bar"})
+```
+
+Cache code:
+
+```python
+def set_user(user_id, values):
+ user = db.query("UPDATE Users WHERE id = {0}", user_id, values)
+ cache.set(user_id, user)
+```
+
+אסטרטגיה זו איטית יותר בשל ביצוע ה-write (שתי כתיבות במקום אחת), אבל קריאות שיקרו בהמשך של הדאטא שזה עתה נכתב יהיו מהירות. המשתמשים לרוב יותר סבלניים לגבי שיהוי כאשר מעדכנים את הדאטא לעומת קריאה שלו. הדאטא ב-cache תמיד עדכני.
+
+##### חסרונות: write through
+
+
+ - כאשר עולה node חדש של ה-cache הוא לא יכיר אף רשומה עד שהיא לא תתעדכן ב-DB, המערכת צריכה קודם לבצע עדכונים לאותם הערכים. שילוב של cache-aside עם write-through יכול לצמצם את הבעיה - אם אין ערך, האפליקציה טוענת מה-DB ושומרת ב-cache, ואז העדכון נכנס גם ל-cache וגם ל-DB.
+ - חלק גדול מהנתונים שנכתבים לעולם לא ייקראו, כל כתיבה נשמרת ל-cache ותופסת RAM יקר בלי שבהכרח יש בה שימוש. אפשר למנוע את בזבוז הזיכרון באמצעות TTL על ערכים שאינם נקראים. הערכים שעדיין "חמים" יתעדכנו מחדש ב-TTL בכל קריאה או כתיבה.
+
+
+#### אסטרטגיית Write-Behind/Back
+
+
+
+
+ Source: Scalability, availability, stability, patterns
+
+
+האפליקציה מבצעת את הפעולות הבאות:
+
+ - הוספה או עדכון של רשומה ב-cache.
+ - כתיבת הרשומה באופן אסינכרוני ל-DB, כך זמן הכתיבה שנתפס בעיני המשתמש קצר מאוד, מפני שהחלק האיטי (לדיסק) נעשה ברקע.
+
+
+##### חסרונות: write-behind
+
+
+ - יכול להיות אובדן מידע אם ה-cache נופל לפני שהכתיבה האסינכרונית ל-DB הסתיימה, ואז הרשומות נעלמו לנצח.
+ - יותר מורכב לממש write-behind מאז לממש את האסטרטגיות הקודמות כמו cache-aside או write-through.
+
+
+#### אסטרטגיית Refresh-Ahead
+
+
+
+
+ Source: From cache to in-memory data grid
+
+
+אפשר לקנפג את ה-cache כך שהוא ירענן כל פריט שניגשו אליו לאחרונה לפני שתפוג תקופת ה-TTL שלו (יבצע fetch מול ה-DB).
+
+אם המערכת יודעת לחזות בצורה טובה אילו פריטים יבוקשו שוב בקרוב, נקבל latency נמוך יותר משיטות read-through רגילות: המשתמש יקבל תשובה מ-cache שכבר עבר עדכון ברקע (ואין cache miss).
+
+##### חסרונות: refresh-ahead
+
+
+ - חיזוי לא מדויק של פריטים שיידרשו בעתיד יכול לגרום לרענון מיותר, ובזבוז של RAM וחיבורים ל-DB, מה שעלול לגרום לתוצאות איטיות יותר מאשר בלי לבצע refresh-ahead.
+
+
+### חסרונות: cache
+
+
+ - חייבים לשמר עקביות בין ה-cache ומקור המידע האמיתי (ה-DB) באמצעות cache invalidation, כללים הקובעים מתי מוחקים או מרעננים ערכים ב-cache.
+ - cache invalidation הוא אתגר לא פשוט, יש מורכבות נוספת להבנה מתי בדיוק ערך ב-cache הוא כבר לא עדכני.
+ - נדרשים לבצע שינויים בקוד ובתשתית להוספת רכיבים כמו Redis או Memcached.
+
+
+### מקורות וקריאה נוספת
+
+- [From cache to in-memory data grid](http://www.slideshare.net/tmatyashovsky/from-cache-to-in-memory-data-grid-introduction-to-hazelcast)
+- [Scalable system design patterns](http://horicky.blogspot.com/2010/10/scalable-system-design-patterns.html)
+- [Introduction to architecting systems for scale](http://lethain.com/introduction-to-architecting-systems-for-scale/)
+- [Scalability, availability, stability, patterns](http://www.slideshare.net/jboner/scalability-availability-stability-patterns/)
+- [Scalability](https://web.archive.org/web/20230126233752/https://www.lecloud.net/post/9246290032/scalability-for-dummies-part-3-cache)
+- [AWS ElastiCache strategies](http://docs.aws.amazon.com/AmazonElastiCache/latest/UserGuide/Strategies.html)
+- [Wikipedia](https://en.wikipedia.org/wiki/Cache_(computing))
+
+
From 154663f37069194833cf57bb93862f254cc10700 Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Mon, 16 Jun 2025 21:58:39 +0300
Subject: [PATCH 36/43] Width fixes
---
README-he.md | 13 ++++++-------
1 file changed, 6 insertions(+), 7 deletions(-)
diff --git a/README-he.md b/README-he.md
index 4c85cf9f..d59ba308 100644
--- a/README-he.md
+++ b/README-he.md
@@ -1472,7 +1472,7 @@ Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוני
#### אחסון Wide Column
-
+
Source: SQL & NoSQL, a brief history
@@ -1502,7 +1502,7 @@ Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוני
#### אחסון Graph
-
+
Source: Graph database
@@ -1666,7 +1666,7 @@ Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוני
#### אסטרטגיית Cache-Aside
-
+
Source: From cache to in-memory data grid
@@ -1703,7 +1703,7 @@ def get_user(self, user_id):
#### אסטרטגיית Write-Through
-
+
Source: Scalability, availability, stability, patterns
@@ -1742,7 +1742,7 @@ def set_user(user_id, values):
#### אסטרטגיית Write-Behind/Back
-
+
Source: Scalability, availability, stability, patterns
@@ -1763,7 +1763,7 @@ def set_user(user_id, values):
#### אסטרטגיית Refresh-Ahead
-
+
Source: From cache to in-memory data grid
@@ -1798,4 +1798,3 @@ def set_user(user_id, values):
-
From 2e5e5d38cf1b0461c813f7391885418345decfa4 Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Tue, 17 Jun 2025 19:16:04 +0300
Subject: [PATCH 37/43] Translating - Asynchronism
---
README-he.md | 59 ++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 59 insertions(+)
diff --git a/README-he.md b/README-he.md
index d59ba308..9fc94a00 100644
--- a/README-he.md
+++ b/README-he.md
@@ -1360,6 +1360,7 @@ Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוני
התוצאות של השימוש בכלים אלו עשויה להוביל לאופטימיזציות הבאות:
+
##### הידוק הסכימה (Tighten up the schema)
@@ -1798,3 +1799,61 @@ def set_user(user_id, values):
+
+## אסינכרוניות (Asynchronism)
+
+
+
+
+
+
+ Source: Intro to architecting systems for scale
+
+
+ביצוע פעולות באופן אסינכרוני עוזר לקצר זמני תגובה לבקשות עצמן. פעולות כבדות אינן מבוצעות ישירות אלא מתווספות לתור משימות, כאשר התשובה חוזר כמעט מיד. ברקע, המשימה מתבצעת מאוחר יותר.
+משימות שלוקחות זמן רב יכולות להתבצע מבעוד מועד, כמו aggregation תקופתי של דאטא. הנתונים כבר מוכנים מראש והשליפה תהיה מהירה.
+
+### תורי הודעות (Message Queues)
+
+תורי הודעות מקבלים, מחזיקים, ושולחים הודעות. אם פעולה איטית מידי לביצוע באופן סינכרוני, אפשר להשתמש בתור הודעות באופן הבא:
+
+
+ - האפליקציה מקבלת בקשת משתמש לביצוע פעולה כבדה, היא בונה הודעה ומכניסה אותה לתור. המשתמש מקבל תשובה על כך שהבקשה התקבלה והיא בתהליך.
+ - תהליך worker רץ ברקע ומאזין לתור, שולף את ההודעה ומתחיל לבצע את הפעולה. כשהוא מסיים, הוא מאשר לתור שההודעה טופלה בהצלחה, ומעדכן את האפליקציה.
+
+
+המשתמש לא נתקע (blocked) והעבודה מתבצעת ברקע. בזמן הזה, המשתמש יכול לבצע פעולות כדי לגרום לכך להיראות כאילו הפעולה בוצעה. למשל, אם מדובר על העלאה של ציוץ (tweet), הוא יכול להתרפסם מיידית ב-timeline של המשתמש, אבל יקח זמן עד שהוא באמת יישלח לכל העוקבים (ייתכן פער של כמה שניות).
+
+דוגמאות לסוגי תורים:
+
+- [Redis](https://redis.io/) is useful as a simple message broker but messages can be lost.
+
+- [RabbitMQ](https://www.rabbitmq.com/) is popular but requires you to adapt to the 'AMQP' protocol and manage your own nodes.
+
+- [Amazon SQS](https://aws.amazon.com/sqs/) is hosted but can have high latency and has the possibility of messages being delivered twice.
+
+### תורי משימות (Task Queues)
+
+תורי משימות מקבלים משימות לצד המידע הרלוונטי שלהן, מריצים אותן, ושולחים את התוצאות. הם יכולים לתמוך ב-scheduling, כלומר להריץ משימה כל זמן מסוים או בשעה קבועה. בנוסף, הם יכולים להריץ משימות כבדות מבחינה חישובית ברקע.
+
+- [Celery](https://docs.celeryproject.org/en/stable/) has support for scheduling and primarily has python support.
+
+### Back Pressure
+
+אם התור מתחיל לגדול באופן משמעותי מעבר לקצב שבו ה-workers מסוגלים לעבד, גודל התור יכול להיות מעבר למה שפנוי לנו בזיכרון, מה שיגרום ל-cache misses, יותר קריאות מהדיסק, וביצועים נמוכים יותר. [Back pressure](http://mechanical-sympathy.blogspot.com/2012/05/apply-back-pressure-when-overloaded.html) יכול לעזור באמצעות הגדלת גודל התור, מה ששומר על קצב הטיפול בבקשות לכאלו שכבר בתוך התור. אם התור מתמלא, השרת מפסיק לקבל עבודות חדשות ומחזיר ללקוח שגיאת HTTP 503 (עסוק). הלקוח יכול לנסות שוב לאחר זמן המתנה הולך וגדל כמו [exponential backoff](https://en.wikipedia.org/wiki/Exponential_backoff).
+
+### חסרונות: asynchronism
+
+
+ - במצבים שבהם מדובר בחישובים זולים במיוחד, או בתהליכים הדורשים עיבוד בזמן אמת, עדיף לעיתים לבצע את הפעולה באופן סינכרוני, משום שהוספת תור למערכת עלולה להוסיף עיכובים ומורכבות מיותרת.
+
+
+### מקורות וקריאה נוספת
+
+* [It's all a numbers game](https://www.youtube.com/watch?v=1KRYH75wgy4)
+* [Applying back pressure when overloaded](http://mechanical-sympathy.blogspot.com/2012/05/apply-back-pressure-when-overloaded.html)
+* [Little's law](https://en.wikipedia.org/wiki/Little%27s_law)
+* [What is the difference between a message queue and a task queue?](https://www.quora.com/What-is-the-difference-between-a-message-queue-and-a-task-queue-Why-would-a-task-queue-require-a-message-broker-like-RabbitMQ-Redis-Celery-or-IronMQ-to-function)
+
+
+
From a303acb99387937ea1e926556415911642ae3c9d Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Wed, 18 Jun 2025 13:24:03 +0300
Subject: [PATCH 38/43] Translating - Communication
---
README-he.md | 203 +++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 203 insertions(+)
diff --git a/README-he.md b/README-he.md
index 9fc94a00..e85e2f6b 100644
--- a/README-he.md
+++ b/README-he.md
@@ -1857,3 +1857,206 @@ def set_user(user_id, values):
+## תקשורת
+
+
+
+
+ Source: OSI 7 layer model
+
+
+
+
+### פרוטוקול HTTP
+
+פרוטוקול HTTP מאפשר ללקוח ולשרת אינטרנט להחליף מידע בפורמט מוגדר. הוא מבוסס על מבנה של request/response: הלקוח/הדפדפן שולח בקשה לתוכן או פעולה מסוימת, והשרת מחזיר תגובה הכוללת את הנתונים המבוקשים, לצד קוד סטטוס שמצהיר אם הבקשה הצליחה, נכשלה, או הופנתה למקום אחר.
+פרוטוקול זה הוא self-contained, כלומר כל המידע הנחוץ - הכותרות, סוג הבקשה, הנתונים - עובר כחבילה אחת. לכן החבילות האלה יכולות לעבור דרך router, load balancer בלי שהמתווכים יידרשו להבין את הלוגיקה. לאורך הדרך אותם גורמי ביניים יכולים להוסיף הצפנה, לדחוס נתונים, מבלי שהפרוטוקול עצמו ייפגע.
+
+בקשת HTTP טיפוסית מכילה verb (מתודה) ו-resource (נקודת קצה). דוגמאות:
+
+| Verb | Description | Idempotent* | Safe | Cacheable |
+|---|---|---|---|---|
+| GET | Reads a resource | Yes | Yes | Yes |
+| POST | Creates a resource or trigger a process that handles data | No | No | Yes if response contains freshness info |
+| PUT | Creates or replace a resource | Yes | No | No |
+| PATCH | Partially updates a resource | No | No | Yes if response contains freshness info |
+| DELETE | Deletes a resource | Yes | No | No |
+
+*ניתן לבצע מספר פעמים את אותה הבקשה ולקבל את אותה התוצאה כל פעם.
+
+פרוטוקול זה הוא בשכבת האפליקציה, והוא מסתמך על פרוטוקולים בשכבות נמוכות יותר כמו **TCP** ו-**UDP**.
+
+#### מקורות וקריאה נוספת
+
+* [What is HTTP?](https://www.nginx.com/resources/glossary/http/)
+* [Difference between HTTP and TCP](https://www.quora.com/What-is-the-difference-between-HTTP-protocol-and-TCP-protocol)
+* [Difference between PUT and PATCH](https://laracasts.com/discuss/channels/general-discussion/whats-the-differences-between-put-and-patch?page=1)
+
+### פרוטוקול TCP
+
+
+
+
+ Source: How to make a multiplayer game
+
+
+פרוטוקול זה הוא מבוסס מעל [IP network](https://en.wikipedia.org/wiki/Internet_Protocol). החיבור נבנה ונסגר באמצעות [handshake](https://en.wikipedia.org/wiki/Handshaking). כל הפקטות שנשלחות מובטחות להגיע ליעד בדיוק בסדר המקורי שבו הן נשלחו, ובאופן תקין (uncorrupted):
+
+- Sequence numbers and [checksum fields](https://en.wikipedia.org/wiki/Transmission_Control_Protocol#Checksum_computation) for each packet
+- [Acknowledgement](https://en.wikipedia.org/wiki/Acknowledgement_(data_networks)) packets and automatic retransmission
+
+אם השולח לא מקבל תשובה תקינה בתוך פרק זמן קצוב, הוא מניח שהמקטע אבד ומשדר אותו שוב. אם יש מספר timeouts כמה פעמים ברצף, אז החיבור נסגר. TCP מממש גם [flow control](https://en.wikipedia.org/wiki/Flow_control_(data)) וגם [congestion control](https://en.wikipedia.org/wiki/Network_congestion#Congestion_control) על מנת לפקח על קצב הנתונים. ההבטחות הללו מוסיפות תזמונים, חישובים, וחבילות בקרה, מה שעלול לגרום לעיכובים וליצור תעבורה פחות מהירה מאשר UDP.
+
+כדי לאפשר throughput מהיר, שרתים שומרים הרבה חיבורי TCP פתוחים, מה שמוביל לצריכת זיכרון גבוהה. הבעיה מחריפה כאשר אותו שרת מפעיל חיבורים נפרדים בין התהליכים שלו לבין שירותים פנימיים אחרים, כמו לדוגמה אל שרת [memcached](https://memcached.org/). ביצוע [Connection pooling](https://en.wikipedia.org/wiki/Connection_pool), שמירת אוסף חיבורים פתוחים המשותפים בין כל ה-threads, יכול לסייע ומצמצם את מספר החיבורים האמיתיים וחוסך זיכרון. בנוסף, ניתן לעבור ל-UDP היכן שניתן, שם אין שמירה של חיבור.
+
+ פרוטוקול TCP שימושי לאפליקציות שדורשות אמינות גבוהה, על פני מהירות וזמן תגובה מיידי. דוגמאות: שרתי HTTP, FTP, SMTP, SSH או MySQL בוחרים ב-TCP. שיקולים לבחירה בפרוטוקול זה על פני UDP:
+
+
+ - אנו זקוקים שכל הנתונים יגיעו בשלמותם, ללא אובדן מידע
+ - נרצה להתאים את קצב הנתונים ברשת באופן אוטומטי, בלי להציף את הקו
+
+
+
+### פרוטוקול UDP
+
+
+
+
+ Source: How to make a multiplayer game
+
+
+בפרוטוקול זה אין חיבור קבוע בין הלקוח לשרת. כל חבילה (Datagram) נשלחת בנפרד, ללא מעקב אחרי מה שכבר נשלח. החבילות יכולות להגיע ליעד בסדר שונה, או בכלל לא. אין תמיכה ב-congestion control. עם זאת, כיוון שאין את כל ההבטחות שכלולות ב-TCP, ה-overhead קטן מאוד ולכן UDP יעיל ומהיר יותר. האפליקציה צריכה להתמודד בעצמה עם איבוד חבילות וסדר החבילות.
+
+ב-UDP מתאפשר שידור (broadcast) - שליחת חבילה אחת לכל המכשירים של אותו ה-subnet. זה שימושי בשילוב עם [DHCP](https://en.wikipedia.org/wiki/Dynamic_Host_Configuration_Protocol) כיוון שבתחילת התהליך המחשב עדיין לא קיבל כתובת IP, ולכן אינו יודע למי לפנות ישירות. הוא משדר הודעה ברשת וכל שרת DHCP שומע את ההודעה, בוחר להשיב ומציע כתובת IP. ב-TCP זה לא היה עובד, כי שם אנו נדרשים לדעת כתובת יעד ספציפית.
+
+פרוטוקול זה הינו פחות אמין אבל עובד בצורה טובה במקרים של real time כמו VoIP, וידאו צ'אט, streaming, ומשחקים מרובי משתתפים. מתי הוא עדיף על TCP?
+
+
+ - אנו זקוקים ל-latency נמוך ביותר
+ - דאטא שמגיע באיחור גרוע יותר מאיבוד הדאטא
+ - נרצה לממש מנגנון תיקון שגיאות משלנו
+
+
+#### מקורות וקריאה נוספת: TCP and UDP
+
+- [Networking for game programming](http://gafferongames.com/networking-for-game-programmers/udp-vs-tcp/)
+- [Key differences between TCP and UDP protocols](http://www.cyberciti.biz/faq/key-differences-between-tcp-and-udp-protocols/)
+- [Difference between TCP and UDP](http://stackoverflow.com/questions/5970383/difference-between-tcp-and-udp)
+- [Transmission control protocol](https://en.wikipedia.org/wiki/Transmission_Control_Protocol)
+- [User datagram protocol](https://en.wikipedia.org/wiki/User_Datagram_Protocol)
+- [Scaling memcache at Facebook](http://www.cs.bu.edu/~jappavoo/jappavoo.github.com/451/papers/memcache-fb.pdf)
+
+
+
+
+### פרוטוקול RPC
+
+
+
+
+ Source: Crack the system design interview
+
+
+ב-RPC, לקוח גורם לריצה של פונקציה במרחב כתובות שונה, לרוב על שרת מרוחק, כאילו הייתה פונקציה מקומית בקוד שלו. הלקוח פשוט קורא לפונקציה, ומאחורי הקלעים ישנה ספריה אשר מטפלת באריזה (serialization) של הפרמטרים, שליחת הבקשה ב-TCP, קבלת התשובה ותרגומה לאובייקט.
+RPC הינו לרוב איטי יותר ופחות אמין מאשר קריאה מקומית, לכן חשוב לסמן קריאות כאלו כ-RPC כדי שמפתחים יבינו שהן עלולות להיכשל או להתעכב. תשתיות נפוצות כוללות את [Protobuf](https://developers.google.com/protocol-buffers/), [Thrift](https://thrift.apache.org/), [Avro](https://avro.apache.org/docs/current/).
+
+פרוטוקול זה מבוסס על בקשה-תגובה:
+
+
+ - תוכנית הלקוח - הקוד קורא לפונקציית ה-stub של ה-client. הפרמטרים נדחפים למחסנית כמו בקריאה לוקאלית רגילה לפונקציה (LPC).
+ - client stub - הספריה אורזת את מזהה הפונקציה ואת הארגומנטים ומקודדת אותם בפורמט שניתן להעביר לצד השני.
+ - תקשורת בצד הלקוח - מערכת ההפעלה שולחת את ההודעה אל השרת
+ - תקשורת בצד השרת - מערכת ההפעלה מקבלת את ההודעה ומעבירה אותה ל-server stub המתאים.
+ - server stub - מפענחת את המזהה ואת הארגומנטים, קוראת לפונקציה האמיתית בקוד השרת עם אותם הפרמטרים.
+ - השרת אורז את התוצאה ומחזיר אותה ללקוח על פי הצעדים הללו בסדר הפוך.
+
+
+קריאות RPC לדוגמה:
+
+```
+GET /someoperation?data=anId
+
+POST /anotheroperation
+{
+ "data":"anId";
+ "anotherdata": "another value"
+}
+```
+
+פרוטוקול מתמקד בהגדרת התנהגות של פונקציות כאילו הן חלק מהממשק המקומי של השפה. הקריאה עובדת מאחורי הקלעים לשרת אחר, אבל למפתח זה נראה כמו פונקציה רגילה. RPC מאפשר גם שליטה מוחלטת על הפונקציונליות והתקשורת, ומתאים לפיתוח מערכת פנימית. נרצה לבחור בספריה משלנו (SDK) כאשר:
+
+
+ - ישנה שפת יעד קבועה
+ - נרצה לשלוט באיך שניגשים ללוגיקה שלנו
+ - נרצה לשלוט בלוגיקה של טיפול בשגיאות
+ - ביצועים וחווית המשתמש בקצה היא שיקול מרכזי
+
+
+ממשקים שעוקבים אחרי פרוטוקול **REST** נוטים להיות יותר בשימוש עבור APIים פומביים.
+
+#### חסרונות: RPC
+
+
+ - תלות חזקה בין הלקוח לשרת
+ - צריך להגדיר API נפרד לכל פעולה חדשה
+ - קשה יותר לדבג RPC
+ - לא קל בהכרח לעשות שימוש בטכנולוגיות נוכחיות בלי התאמות נוספות. יש לוודא שהקריאות עוברות caching כמו שצריך על שרתים כמו Squid
+
+
+### ממשק REST
+
+בממשק REST הלקוח מבקש סט מסוים של משאבים המנוהלים על ידי השרת. השרת מספק ייצוג של המשאבים ופעולות שניתן לעשות עליהם. כל התקשורת היא
+stateless ו-cacheable. יש 4 תכונות של ממשק RESTful:
+
+
+ - זיהוי משאבים (URI ב-HTTP) - כל דבר שה-API חושף מקבל כתובת URL אחידה.
+ - הפעולה נקבעת לפי הפועל והכותרות - הפעלים השונים ב-HTTP בתוספת לכותרות ולגוף הבקשה מגדירים מה יקרה. עקרון זה מפריד בין ה-URI /orders/7 לבין הפעולה GET/PUT/PATCH.
+ - סטטוס שגיאות סטנדרטי - אין צורך להמציא קודי שגיאות, משתמשים בסטטוסים של HTTP כמו 404, 200 וכו'.
+ - HATEOAS - ממשק HTML עבור HTTP, התשובה עצמה כוללת קישורים לפעולות הבאות האפשריות.
+
+
+קריאות REST לדוגמה:
+```
+GET /someresources/anId
+
+PUT /someresources/anId
+{"anotherdata": "another value"}
+```
+
+הפרוטוקול מתמקד בחשיפת הנתונים בתור משאבים (בשונה מהפעלת פונקציות ב-RPC) באמצעות כתובת URL קבועה. הלקוח שולח בקשות HTTP סטנדרטיות והשרת מחזיר את התשובה המתאימה. זה מאפשר coupling נמוך בין הלקוח לשרת: הלקוח רק צריך לדעת אילו URI-ים קיימים ואילו פעלים מותר להפעיל (GET, POST), אין תלות בשפת התכנות של השרת או בספריות מיוחדות. REST מספק ממשק אחיד לייצוג הפעולות - [representation through headers](https://github.com/for-GET/know-your-http-well/blob/master/headers.md). כיוון שהוא stateless, קל לפרוס עותקים רבים שלו מאחורי load balancer ולבזר את העומסים.
+
+#### Disadvantage(s): REST
+
+
+ - כיוון ש-REST מתמקד שחשיפת נתונים בתור משאבים, אם הדאטא לא מסתדר באופן טבעי בהיררכיה הזאת, זה יכול פחות להתאים. למשל, להחזיר את כל הרשומות שהתעדכנו מהשעה האחרונה, עונה על סט מסוים של אירועים שלאו דווקא קל לבטא בתור path. עם REST, ניתן לשלב URI path, query parameters, ואולי גם להשתמש ב-request body.
+ - REST מתבסס לרוב על כמה פעולות ספציפיות (GET, POST, PUT, DELETE, PATCH) שלא תמיד מתאים בדיוק לשימוש המבוקש. פעולה כמו "העבר מסמכים שפג תוקפם לארכיון" אינה יושבת בצורה קלאסית על אחת הפקודות.
+ - כדי לשלוף משאב מורכב שכולל היררכייה מסועפת, יש לבצע מספר בקשות הולכות וחוזרות בין הלקוח לשרת. למשל, כדי לקבל פוסט עם תגובות מסוימות, הלקוח צריך לבצע כמה קריאות נפרדות (קודם לפוסט, ואז לתגובות). עבור אפליקציות mobile עם תנאי חיבוריות משתנים, כמות הבקשות הללו אינה רצויה.
+ - עם הזמן, שדות נוספים יכולים להתווסף לתגובה שחוזרת מה-API, ומשתמשים ישנים יכולים לקבל מידע שאינם זקוקים לו. הדבר מעמיס על גודל ה-payload ובכך על ה-latency.
+
+
+### השוואה בין קריאות RPC ובין REST
+| Operation | RPC | REST |
+|---|---|---|
+| Signup | **POST** /signup | **POST** /persons |
+| Resign | **POST** /resign
{
"personid": "1234"
} | **DELETE** /persons/1234 |
+| Read a person | **GET** /readPerson?personid=1234 | **GET** /persons/1234 |
+| Read a person’s items list | **GET** /readUsersItemsList?personid=1234 | **GET** /persons/1234/items |
+| Add an item to a person’s items | **POST** /addItemToUsersItemsList
{
"personid": "1234";
"itemid": "456"
} | **POST** /persons/1234/items
{
"itemid": "456"
} |
+| Update an item | **POST** /modifyItem
{
"itemid": "456";
"key": "value"
} | **PUT** /items/456
{
"key": "value"
} |
+| Delete an item | **POST** /removeItem
{
"itemid": "456"
} | **DELETE** /items/456 |
+
+
+ Source: Do you really know why you prefer REST over RPC
+
+
+#### מקורות וקריאה נוספת: REST and RPC
+
+- [Do you really know why you prefer REST over RPC](https://apihandyman.io/do-you-really-know-why-you-prefer-rest-over-rpc/)
+- [When are RPC-ish approaches more appropriate than REST?](http://programmers.stackexchange.com/a/181186)
+- [REST vs JSON-RPC](http://stackoverflow.com/questions/15056878/rest-vs-json-rpc)
+- [Debunking the myths of RPC and REST](https://web.archive.org/web/20170608193645/http://etherealbits.com/2012/12/debunking-the-myths-of-rpc-rest/)
+- [What are the drawbacks of using REST](https://www.quora.com/What-are-the-drawbacks-of-using-RESTful-APIs)
+- [Crack the system design interview](http://www.puncsky.com/blog/2016-02-13-crack-the-system-design-interview)
+- [Thrift](https://code.facebook.com/posts/1468950976659943/)
+- [Why REST for internal use and not RPC](http://arstechnica.com/civis/viewtopic.php?t=1190508)
+
From bba9ee3cde57ce7ffc3882136d3524bc5df20daa Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Wed, 18 Jun 2025 15:00:56 +0300
Subject: [PATCH 39/43] Translating - Security
---
README-he.md | 21 ++++++++++++++++++++-
1 file changed, 20 insertions(+), 1 deletion(-)
diff --git a/README-he.md b/README-he.md
index e85e2f6b..dd230fba 100644
--- a/README-he.md
+++ b/README-he.md
@@ -2025,7 +2025,7 @@ PUT /someresources/anId
הפרוטוקול מתמקד בחשיפת הנתונים בתור משאבים (בשונה מהפעלת פונקציות ב-RPC) באמצעות כתובת URL קבועה. הלקוח שולח בקשות HTTP סטנדרטיות והשרת מחזיר את התשובה המתאימה. זה מאפשר coupling נמוך בין הלקוח לשרת: הלקוח רק צריך לדעת אילו URI-ים קיימים ואילו פעלים מותר להפעיל (GET, POST), אין תלות בשפת התכנות של השרת או בספריות מיוחדות. REST מספק ממשק אחיד לייצוג הפעולות - [representation through headers](https://github.com/for-GET/know-your-http-well/blob/master/headers.md). כיוון שהוא stateless, קל לפרוס עותקים רבים שלו מאחורי load balancer ולבזר את העומסים.
-#### Disadvantage(s): REST
+#### חסרונות: REST
- כיוון ש-REST מתמקד שחשיפת נתונים בתור משאבים, אם הדאטא לא מסתדר באופן טבעי בהיררכיה הזאת, זה יכול פחות להתאים. למשל, להחזיר את כל הרשומות שהתעדכנו מהשעה האחרונה, עונה על סט מסוים של אירועים שלאו דווקא קל לבטא בתור path. עם REST, ניתן לשלב URI path, query parameters, ואולי גם להשתמש ב-request body.
@@ -2060,3 +2060,22 @@ PUT /someresources/anId
- [Thrift](https://code.facebook.com/posts/1468950976659943/)
- [Why REST for internal use and not RPC](http://arstechnica.com/civis/viewtopic.php?t=1190508)
+## אבטחת מידע
+
+הפרק הזה זקוק לעדכונים. מוזמנים [לעזור](#contributing)!
+
+אבטחת מידע היא תחום רחב ומורכב, אבל לרוב הראיונות (כל עוד אינך מומחה אבטחה) מספיק להכיר את העקרונות הבסיסיים:
+
+
+ - יש לדאוג שגם התקשורת (HTTPS/TLS) וגם הדאטא השמור על אחסון כלשהו יהיו מוצפנים.
+ - יש לנקות ולאמת כל קלט שמגיע מהדפדפן, ממשקי API חיצוניים או מקבצים כדי למנוע מתקפות כמו XSS או SQL injection.
+ - כשמרכיבים שאילתת SQL רצוי להשתמש במשתנים או ORM שמוסיף אותם אוטומטית, בלי לשרשר מחרוזות. כך המנוע לוקח את הפרמטרים כערכים ולא כחלק מהקוד.
+ - לפעול לפי עיקרון מינימום ההרשאות - least privilege. לכל תהליך, שירות, או משתמש יש להעניק רק את ההרשאות ההכרחיות לביצוע עבודתו ולא יותר.
+
+
+### מקורות וקריאה נוספת
+
+- [API security checklist](https://github.com/shieldfy/API-Security-Checklist)
+- [Security guide for developers](https://github.com/FallibleInc/security-guide-for-developers)
+- [OWASP top ten](https://www.owasp.org/index.php/OWASP_Top_Ten_Cheat_Sheet)
+
From ef5544f55ea7b94c44a1c59ceb50c975d69a2564 Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Wed, 18 Jun 2025 15:36:49 +0300
Subject: [PATCH 40/43] Translating - Final sections!
---
README-he.md | 273 ++++++++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 271 insertions(+), 2 deletions(-)
diff --git a/README-he.md b/README-he.md
index dd230fba..051d9c55 100644
--- a/README-he.md
+++ b/README-he.md
@@ -1857,7 +1857,7 @@ def set_user(user_id, values):
-## תקשורת
+## תקשורת (Communication)
@@ -2060,7 +2060,7 @@ PUT /someresources/anId
- [Thrift](https://code.facebook.com/posts/1468950976659943/)
- [Why REST for internal use and not RPC](http://arstechnica.com/civis/viewtopic.php?t=1190508)
-## אבטחת מידע
+## אבטחת מידע (Security)
הפרק הזה זקוק לעדכונים. מוזמנים [לעזור](#contributing)!
@@ -2079,3 +2079,272 @@ PUT /someresources/anId
- [Security guide for developers](https://github.com/FallibleInc/security-guide-for-developers)
- [OWASP top ten](https://www.owasp.org/index.php/OWASP_Top_Ten_Cheat_Sheet)
+
+## נספחים
+
+לפעמים תידרש לבצע חישובים מהירים (back-of-the-enveloppe) על מנת להעריך סדרי גודל. למשל, תצטרך אולי להעריך כמה זמן ייקח לייצר 100 thumbnails של תמונות מהדיסק, או כמה מקום בזיכרון מבנה נתונים כלשהו יצטרך. לשם כך יש את הטבלאות הבאות שיוכלו לעזור. טבלת החזקות של 2 עוזרת לנו לחשב גדלים של קבצים, הודעות וכו'. מספרי השיהוי נותנת לנו מושג כמה זמן בערך לוקחים תהליכים נפוצים.
+
+### טבלת חזקות של 2
+
+```
+Power Exact Value Approx Value Bytes
+---------------------------------------------------------------
+7 128
+8 256
+10 1024 1 thousand 1 KB
+16 65,536 64 KB
+20 1,048,576 1 million 1 MB
+30 1,073,741,824 1 billion 1 GB
+32 4,294,967,296 4 GB
+40 1,099,511,627,776 1 trillion 1 TB
+```
+
+#### מקורות וקריאה נוספת
+
+- [Powers of two](https://en.wikipedia.org/wiki/Power_of_two)
+
+### מספרי latency חשובים
+
+```
+Latency Comparison Numbers
+--------------------------
+L1 cache reference 0.5 ns
+Branch mispredict 5 ns
+L2 cache reference 7 ns 14x L1 cache
+Mutex lock/unlock 25 ns
+Main memory reference 100 ns 20x L2 cache, 200x L1 cache
+Compress 1K bytes with Zippy 10,000 ns 10 us
+Send 1 KB bytes over 1 Gbps network 10,000 ns 10 us
+Read 4 KB randomly from SSD* 150,000 ns 150 us ~1GB/sec SSD
+Read 1 MB sequentially from memory 250,000 ns 250 us
+Round trip within same datacenter 500,000 ns 500 us
+Read 1 MB sequentially from SSD* 1,000,000 ns 1,000 us 1 ms ~1GB/sec SSD, 4X memory
+HDD seek 10,000,000 ns 10,000 us 10 ms 20x datacenter roundtrip
+Read 1 MB sequentially from 1 Gbps 10,000,000 ns 10,000 us 10 ms 40x memory, 10X SSD
+Read 1 MB sequentially from HDD 30,000,000 ns 30,000 us 30 ms 120x memory, 30X SSD
+Send packet CA->Netherlands->CA 150,000,000 ns 150,000 us 150 ms
+
+Notes
+-----
+1 ns = 10^-9 seconds
+1 us = 10^-6 seconds = 1,000 ns
+1 ms = 10^-3 seconds = 1,000 us = 1,000,000 ns
+```
+
+מטריקות שימושיות בהתבסס על המספרים הללו:
+
+* Read sequentially from HDD at 30 MB/s
+* Read sequentially from 1 Gbps Ethernet at 100 MB/s
+* Read sequentially from SSD at 1 GB/s
+* Read sequentially from main memory at 4 GB/s
+* 6-7 world-wide round trips per second
+* 2,000 round trips per second within a data center
+
+#### Latency numbers visualized
+
+
+
+#### מקורות וקריאה נוספת
+
+- [Latency numbers every programmer should know - 1](https://gist.github.com/jboner/2841832)
+- [Latency numbers every programmer should know - 2](https://gist.github.com/hellerbarde/2843375)
+- [Designs, lessons, and advice from building large distributed systems](http://www.cs.cornell.edu/projects/ladis2009/talks/dean-keynote-ladis2009.pdf)
+- [Software Engineering Advice from Building Large-Scale Distributed Systems](https://static.googleusercontent.com/media/research.google.com/en//people/jeff/stanford-295-talk.pdf)
+
+### שאלות נוספות לראיונות
+
+> שאלות ריאיון נפוצות, עם קישורים למשאבים המסבירים כיצד לפתור כל אחת
+
+| Question | Reference(s) |
+|---|---|
+| Design a file sync service like Dropbox | [youtube.com](https://www.youtube.com/watch?v=PE4gwstWhmc) |
+| Design a search engine like Google | [queue.acm.org](http://queue.acm.org/detail.cfm?id=988407)
[stackexchange.com](http://programmers.stackexchange.com/questions/38324/interview-question-how-would-you-implement-google-search)
[ardendertat.com](http://www.ardendertat.com/2012/01/11/implementing-search-engines/)
[stanford.edu](http://infolab.stanford.edu/~backrub/google.html) |
+| Design a scalable web crawler like Google | [quora.com](https://www.quora.com/How-can-I-build-a-web-crawler-from-scratch) |
+| Design Google docs | [code.google.com](https://code.google.com/p/google-mobwrite/)
[neil.fraser.name](https://neil.fraser.name/writing/sync/) |
+| Design a key-value store like Redis | [slideshare.net](http://www.slideshare.net/dvirsky/introduction-to-redis) |
+| Design a cache system like Memcached | [slideshare.net](http://www.slideshare.net/oemebamo/introduction-to-memcached) |
+| Design a recommendation system like Amazon's | [hulu.com](https://web.archive.org/web/20170406065247/http://tech.hulu.com/blog/2011/09/19/recommendation-system.html)
[ijcai13.org](http://ijcai13.org/files/tutorial_slides/td3.pdf) |
+| Design a tinyurl system like Bitly | [n00tc0d3r.blogspot.com](http://n00tc0d3r.blogspot.com/) |
+| Design a chat app like WhatsApp | [highscalability.com](http://highscalability.com/blog/2014/2/26/the-whatsapp-architecture-facebook-bought-for-19-billion.html)
+| Design a picture sharing system like Instagram | [highscalability.com](http://highscalability.com/flickr-architecture)
[highscalability.com](http://highscalability.com/blog/2011/12/6/instagram-architecture-14-million-users-terabytes-of-photos.html) |
+| Design the Facebook news feed function | [quora.com](http://www.quora.com/What-are-best-practices-for-building-something-like-a-News-Feed)
[quora.com](http://www.quora.com/Activity-Streams/What-are-the-scaling-issues-to-keep-in-mind-while-developing-a-social-network-feed)
[slideshare.net](http://www.slideshare.net/danmckinley/etsy-activity-feeds-architecture) |
+| Design the Facebook timeline function | [facebook.com](https://www.facebook.com/note.php?note_id=10150468255628920)
[highscalability.com](http://highscalability.com/blog/2012/1/23/facebook-timeline-brought-to-you-by-the-power-of-denormaliza.html) |
+| Design the Facebook chat function | [erlang-factory.com](http://www.erlang-factory.com/upload/presentations/31/EugeneLetuchy-ErlangatFacebook.pdf)
[facebook.com](https://www.facebook.com/note.php?note_id=14218138919&id=9445547199&index=0) |
+| Design a graph search function like Facebook's | [facebook.com](https://www.facebook.com/notes/facebook-engineering/under-the-hood-building-out-the-infrastructure-for-graph-search/10151347573598920)
[facebook.com](https://www.facebook.com/notes/facebook-engineering/under-the-hood-indexing-and-ranking-in-graph-search/10151361720763920)
[facebook.com](https://www.facebook.com/notes/facebook-engineering/under-the-hood-the-natural-language-interface-of-graph-search/10151432733048920) |
+| Design a content delivery network like CloudFlare | [figshare.com](https://figshare.com/articles/Globally_distributed_content_delivery/6605972) |
+| Design a trending topic system like Twitter's | [michael-noll.com](http://www.michael-noll.com/blog/2013/01/18/implementing-real-time-trending-topics-in-storm/)
[snikolov .wordpress.com](http://snikolov.wordpress.com/2012/11/14/early-detection-of-twitter-trends/) |
+| Design a random ID generation system | [blog.twitter.com](https://blog.twitter.com/2010/announcing-snowflake)
[github.com](https://github.com/twitter/snowflake/) |
+| Return the top k requests during a time interval | [cs.ucsb.edu](https://www.cs.ucsb.edu/sites/default/files/documents/2005-23.pdf)
[wpi.edu](http://davis.wpi.edu/xmdv/docs/EDBT11-diyang.pdf) |
+| Design a system that serves data from multiple data centers | [highscalability.com](http://highscalability.com/blog/2009/8/24/how-google-serves-data-from-multiple-datacenters.html) |
+| Design an online multiplayer card game | [indieflashblog.com](https://web.archive.org/web/20180929181117/http://www.indieflashblog.com/how-to-create-an-asynchronous-multiplayer-game.html)
[buildnewgames.com](http://buildnewgames.com/real-time-multiplayer/) |
+| Design a garbage collection system | [stuffwithstuff.com](http://journal.stuffwithstuff.com/2013/12/08/babys-first-garbage-collector/)
[washington.edu](http://courses.cs.washington.edu/courses/csep521/07wi/prj/rick.pdf) |
+| Design an API rate limiter | [https://stripe.com/blog/](https://stripe.com/blog/rate-limiters) |
+| Design a Stock Exchange (like NASDAQ or Binance) | [Jane Street](https://youtu.be/b1e4t2k2KJY)
[Golang Implementation](https://around25.com/blog/building-a-trading-engine-for-a-crypto-exchange/)
[Go Implementation](http://bhomnick.net/building-a-simple-limit-order-in-go/) |
+| Add a system design question | [Contribute](#contributing) |
+
+### ארכיטקטורות מהעולם האמיתי
+
+> מאמרים על מערכות אמיתיות ואיך בנו את הארכיטקטורה שלהן
+
+
+
+
+ Source: Twitter timelines at scale
+
+
+**אין צורך לצלול לתוך כל הפרטים הטכניים הקטנים בכל מאמר, אלא:**
+
+
+ - לזהות עקרונות משותפים, טכנולוגיות נפוצות, ותבניות שחוזרות על עצמן
+ - ללמוד אילו בעיות נפתרות על ידי אילו רכיבים, איפה זה עובד ואיפה לא
+ - להבין את הלקחים שהופקו
+
+
+|Type | System | Reference(s) |
+|---|---|---|
+| Data processing | **MapReduce** - Distributed data processing from Google | [research.google.com](http://static.googleusercontent.com/media/research.google.com/zh-CN/us/archive/mapreduce-osdi04.pdf) |
+| Data processing | **Spark** - Distributed data processing from Databricks | [slideshare.net](http://www.slideshare.net/AGrishchenko/apache-spark-architecture) |
+| Data processing | **Storm** - Distributed data processing from Twitter | [slideshare.net](http://www.slideshare.net/previa/storm-16094009) |
+| | | |
+| Data store | **Bigtable** - Distributed column-oriented database from Google | [harvard.edu](http://www.read.seas.harvard.edu/~kohler/class/cs239-w08/chang06bigtable.pdf) |
+| Data store | **HBase** - Open source implementation of Bigtable | [slideshare.net](http://www.slideshare.net/alexbaranau/intro-to-hbase) |
+| Data store | **Cassandra** - Distributed column-oriented database from Facebook | [slideshare.net](http://www.slideshare.net/planetcassandra/cassandra-introduction-features-30103666)
+| Data store | **DynamoDB** - Document-oriented database from Amazon | [harvard.edu](http://www.read.seas.harvard.edu/~kohler/class/cs239-w08/decandia07dynamo.pdf) |
+| Data store | **MongoDB** - Document-oriented database | [slideshare.net](http://www.slideshare.net/mdirolf/introduction-to-mongodb) |
+| Data store | **Spanner** - Globally-distributed database from Google | [research.google.com](http://research.google.com/archive/spanner-osdi2012.pdf) |
+| Data store | **Memcached** - Distributed memory caching system | [slideshare.net](http://www.slideshare.net/oemebamo/introduction-to-memcached) |
+| Data store | **Redis** - Distributed memory caching system with persistence and value types | [slideshare.net](http://www.slideshare.net/dvirsky/introduction-to-redis) |
+| | | |
+| File system | **Google File System (GFS)** - Distributed file system | [research.google.com](http://static.googleusercontent.com/media/research.google.com/zh-CN/us/archive/gfs-sosp2003.pdf) |
+| File system | **Hadoop File System (HDFS)** - Open source implementation of GFS | [apache.org](http://hadoop.apache.org/docs/stable/hadoop-project-dist/hadoop-hdfs/HdfsDesign.html) |
+| | | |
+| Misc | **Chubby** - Lock service for loosely-coupled distributed systems from Google | [research.google.com](http://static.googleusercontent.com/external_content/untrusted_dlcp/research.google.com/en/us/archive/chubby-osdi06.pdf) |
+| Misc | **Dapper** - Distributed systems tracing infrastructure | [research.google.com](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/36356.pdf)
+| Misc | **Kafka** - Pub/sub message queue from LinkedIn | [slideshare.net](http://www.slideshare.net/mumrah/kafka-talk-tri-hug) |
+| Misc | **Zookeeper** - Centralized infrastructure and services enabling synchronization | [slideshare.net](http://www.slideshare.net/sauravhaloi/introduction-to-apache-zookeeper) |
+| | Add an architecture | [Contribute](#contributing) |
+
+### ארכיטקטורות של חברות
+
+| Company | Reference(s) |
+|---|---|
+| Amazon | [Amazon architecture](http://highscalability.com/amazon-architecture) |
+| Cinchcast | [Producing 1,500 hours of audio every day](http://highscalability.com/blog/2012/7/16/cinchcast-architecture-producing-1500-hours-of-audio-every-d.html) |
+| DataSift | [Realtime datamining At 120,000 tweets per second](http://highscalability.com/blog/2011/11/29/datasift-architecture-realtime-datamining-at-120000-tweets-p.html) |
+| Dropbox | [How we've scaled Dropbox](https://www.youtube.com/watch?v=PE4gwstWhmc) |
+| ESPN | [Operating At 100,000 duh nuh nuhs per second](http://highscalability.com/blog/2013/11/4/espns-architecture-at-scale-operating-at-100000-duh-nuh-nuhs.html) |
+| Google | [Google architecture](http://highscalability.com/google-architecture) |
+| Instagram | [14 million users, terabytes of photos](http://highscalability.com/blog/2011/12/6/instagram-architecture-14-million-users-terabytes-of-photos.html)
[What powers Instagram](http://instagram-engineering.tumblr.com/post/13649370142/what-powers-instagram-hundreds-of-instances) |
+| Justin.tv | [Justin.Tv's live video broadcasting architecture](http://highscalability.com/blog/2010/3/16/justintvs-live-video-broadcasting-architecture.html) |
+| Facebook | [Scaling memcached at Facebook](https://cs.uwaterloo.ca/~brecht/courses/854-Emerging-2014/readings/key-value/fb-memcached-nsdi-2013.pdf)
[TAO: Facebook’s distributed data store for the social graph](https://cs.uwaterloo.ca/~brecht/courses/854-Emerging-2014/readings/data-store/tao-facebook-distributed-datastore-atc-2013.pdf)
[Facebook’s photo storage](https://www.usenix.org/legacy/event/osdi10/tech/full_papers/Beaver.pdf)
[How Facebook Live Streams To 800,000 Simultaneous Viewers](http://highscalability.com/blog/2016/6/27/how-facebook-live-streams-to-800000-simultaneous-viewers.html) |
+| Flickr | [Flickr architecture](http://highscalability.com/flickr-architecture) |
+| Mailbox | [From 0 to one million users in 6 weeks](http://highscalability.com/blog/2013/6/18/scaling-mailbox-from-0-to-one-million-users-in-6-weeks-and-1.html) |
+| Netflix | [A 360 Degree View Of The Entire Netflix Stack](http://highscalability.com/blog/2015/11/9/a-360-degree-view-of-the-entire-netflix-stack.html)
[Netflix: What Happens When You Press Play?](http://highscalability.com/blog/2017/12/11/netflix-what-happens-when-you-press-play.html) |
+| Pinterest | [From 0 To 10s of billions of page views a month](http://highscalability.com/blog/2013/4/15/scaling-pinterest-from-0-to-10s-of-billions-of-page-views-a.html)
[18 million visitors, 10x growth, 12 employees](http://highscalability.com/blog/2012/5/21/pinterest-architecture-update-18-million-visitors-10x-growth.html) |
+| Playfish | [50 million monthly users and growing](http://highscalability.com/blog/2010/9/21/playfishs-social-gaming-architecture-50-million-monthly-user.html) |
+| PlentyOfFish | [PlentyOfFish architecture](http://highscalability.com/plentyoffish-architecture) |
+| Salesforce | [How they handle 1.3 billion transactions a day](http://highscalability.com/blog/2013/9/23/salesforce-architecture-how-they-handle-13-billion-transacti.html) |
+| Stack Overflow | [Stack Overflow architecture](http://highscalability.com/blog/2009/8/5/stack-overflow-architecture.html) |
+| TripAdvisor | [40M visitors, 200M dynamic page views, 30TB data](http://highscalability.com/blog/2011/6/27/tripadvisor-architecture-40m-visitors-200m-dynamic-page-view.html) |
+| Tumblr | [15 billion page views a month](http://highscalability.com/blog/2012/2/13/tumblr-architecture-15-billion-page-views-a-month-and-harder.html) |
+| Twitter | [Making Twitter 10000 percent faster](http://highscalability.com/scaling-twitter-making-twitter-10000-percent-faster)
[Storing 250 million tweets a day using MySQL](http://highscalability.com/blog/2011/12/19/how-twitter-stores-250-million-tweets-a-day-using-mysql.html)
[150M active users, 300K QPS, a 22 MB/S firehose](http://highscalability.com/blog/2013/7/8/the-architecture-twitter-uses-to-deal-with-150m-active-users.html)
[Timelines at scale](https://www.infoq.com/presentations/Twitter-Timeline-Scalability)
[Big and small data at Twitter](https://www.youtube.com/watch?v=5cKTP36HVgI)
[Operations at Twitter: scaling beyond 100 million users](https://www.youtube.com/watch?v=z8LU0Cj6BOU)
[How Twitter Handles 3,000 Images Per Second](http://highscalability.com/blog/2016/4/20/how-twitter-handles-3000-images-per-second.html) |
+| Uber | [How Uber scales their real-time market platform](http://highscalability.com/blog/2015/9/14/how-uber-scales-their-real-time-market-platform.html)
[Lessons Learned From Scaling Uber To 2000 Engineers, 1000 Services, And 8000 Git Repositories](http://highscalability.com/blog/2016/10/12/lessons-learned-from-scaling-uber-to-2000-engineers-1000-ser.html) |
+| WhatsApp | [The WhatsApp architecture Facebook bought for $19 billion](http://highscalability.com/blog/2014/2/26/the-whatsapp-architecture-facebook-bought-for-19-billion.html) |
+| YouTube | [YouTube scalability](https://www.youtube.com/watch?v=w5WVu624fY8)
[YouTube architecture](http://highscalability.com/youtube-architecture) |
+
+### בלוגים טכניים של חברות
+
+> ארכיטקטורות של חברות שאתה מתראיין אליהן.
+>
+> שאלות שישאלו אותך אולי יהיו מאותו הדומיין של המוצר ומהערכת.
+
+* [Airbnb Engineering](http://nerds.airbnb.com/)
+* [Atlassian Developers](https://developer.atlassian.com/blog/)
+* [AWS Blog](https://aws.amazon.com/blogs/aws/)
+* [Bitly Engineering Blog](http://word.bitly.com/)
+* [Box Blogs](https://blog.box.com/blog/category/engineering)
+* [Cloudera Developer Blog](http://blog.cloudera.com/)
+* [Dropbox Tech Blog](https://tech.dropbox.com/)
+* [Engineering at Quora](https://www.quora.com/q/quoraengineering)
+* [Ebay Tech Blog](http://www.ebaytechblog.com/)
+* [Evernote Tech Blog](https://blog.evernote.com/tech/)
+* [Etsy Code as Craft](http://codeascraft.com/)
+* [Facebook Engineering](https://www.facebook.com/Engineering)
+* [Flickr Code](http://code.flickr.net/)
+* [Foursquare Engineering Blog](http://engineering.foursquare.com/)
+* [GitHub Engineering Blog](https://github.blog/category/engineering)
+* [Google Research Blog](http://googleresearch.blogspot.com/)
+* [Groupon Engineering Blog](https://engineering.groupon.com/)
+* [Heroku Engineering Blog](https://engineering.heroku.com/)
+* [Hubspot Engineering Blog](http://product.hubspot.com/blog/topic/engineering)
+* [High Scalability](http://highscalability.com/)
+* [Instagram Engineering](http://instagram-engineering.tumblr.com/)
+* [Intel Software Blog](https://software.intel.com/en-us/blogs/)
+* [Jane Street Tech Blog](https://blogs.janestreet.com/category/ocaml/)
+* [LinkedIn Engineering](http://engineering.linkedin.com/blog)
+* [Microsoft Engineering](https://engineering.microsoft.com/)
+* [Microsoft Python Engineering](https://blogs.msdn.microsoft.com/pythonengineering/)
+* [Netflix Tech Blog](http://techblog.netflix.com/)
+* [Paypal Developer Blog](https://medium.com/paypal-engineering)
+* [Pinterest Engineering Blog](https://medium.com/@Pinterest_Engineering)
+* [Reddit Blog](http://www.redditblog.com/)
+* [Salesforce Engineering Blog](https://developer.salesforce.com/blogs/engineering/)
+* [Slack Engineering Blog](https://slack.engineering/)
+* [Spotify Labs](https://labs.spotify.com/)
+* [Stripe Engineering Blog](https://stripe.com/blog/engineering)
+* [Twilio Engineering Blog](http://www.twilio.com/engineering)
+* [Twitter Engineering](https://blog.twitter.com/engineering/)
+* [Uber Engineering Blog](http://eng.uber.com/)
+* [Yahoo Engineering Blog](http://yahooeng.tumblr.com/)
+* [Yelp Engineering Blog](http://engineeringblog.yelp.com/)
+* [Zynga Engineering Blog](https://www.zynga.com/blogs/engineering)
+
+#### מקורות וקריאה נוספת
+
+Looking to add a blog? To avoid duplicating work, consider adding your company blog to the following repo:
+
+* [kilimchoi/engineering-blogs](https://github.com/kilimchoi/engineering-blogs)
+
+
+
+
+## תחת פיתוח
+
+מעוניין להוסיף חלק או לעזור לסיים אחד שנמצא בעבודה? [תרום](#contributing)!
+
+- Distributed computing with MapReduce
+- Consistent hashing
+- Scatter gather
+- [Contribute](#contributing)
+
+## קרדיטים
+
+קרדיטים ומקורות נמצאים לכל אורך המדריך.
+תודות מיוחדות ל:
+
+- [Hired in tech](http://www.hiredintech.com/system-design/the-system-design-process/)
+- [Cracking the coding interview](https://www.amazon.com/dp/0984782850/)
+- [High scalability](http://highscalability.com/)
+- [checkcheckzz/system-design-interview](https://github.com/checkcheckzz/system-design-interview)
+- [shashank88/system_design](https://github.com/shashank88/system_design)
+- [mmcgrana/services-engineering](https://github.com/mmcgrana/services-engineering)
+- [System design cheat sheet](https://gist.github.com/vasanthk/485d1c25737e8e72759f)
+- [A distributed systems reading list](http://dancres.github.io/Pages/)
+- [Cracking the system design interview](http://www.puncsky.com/blog/2016-02-13-crack-the-system-design-interview)
+
+
+## יצירת קשר
+
+מוזמנים ליצור קשר ולדון על בעיות, שאלות, או הערות.
+פרטי הקשר שלי נמצאים בעמוד הבא - [GitHub page](https://github.com/donnemartin).
+
+## רישיון
+
+*I am providing code and resources in this repository to you under an open source license. Because this is my personal repository, the license you receive to my code and resources is from me and not my employer (Facebook).*
+
+ Copyright 2017 Donne Martin
+
+ Creative Commons Attribution 4.0 International License (CC BY 4.0)
+
+ http://creativecommons.org/licenses/by/4.0/
+
From f89bb32340882a5c63f8316fa32be831ad83ba49 Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Wed, 18 Jun 2025 16:44:48 +0300
Subject: [PATCH 41/43] Improvements
---
README-he.md | 14 +++++++-------
1 file changed, 7 insertions(+), 7 deletions(-)
diff --git a/README-he.md b/README-he.md
index 051d9c55..a633c5f0 100644
--- a/README-he.md
+++ b/README-he.md
@@ -1156,11 +1156,11 @@ Pull CDN מתאים לאתרים עתירי תעבורה, שכן העומס מת
עקרון האחריות היחידה (**single respoinsibility principle**) מעודד סרביסים עצמאיים וקטנים שעובדים יחד. צוותים קטנים המטפלים שירותים קטנים יכלוים להתכוונן בצורה מיטבית לגדילה מהירה.
Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוניות](#asynchronism).
-### מיקרו-סרביסים (Microservices)
+### מיקרוסרביסים (Microservices)
במונח [Microservices](https://he.wikipedia.org/wiki/מיקרו-שירותים) הכוונה למערך של שירותים קטנים, מודולריים, הניתנים לפריסה עצמאית. כל שירות רץ כתהליך נפרד ומתקשר באמצעות מנגנון פשוט ומוגדר היטב כדי להשיג יעד עסקי.1
-לדוגמה, ב-Pinterest יכולים להיות המיקרו-סרביסים הבאים: פרופיל משתמש, עוקבים, פיד, חיפוש, העלאת תמונה וכו'.
+לדוגמה, ב-Pinterest יכולים להיות המיקרוסרביסים הבאים: פרופיל משתמש, עוקבים, פיד, חיפוש, העלאת תמונה וכו'.
### גילוי סרביסים (Service Discovery)
@@ -1173,7 +1173,7 @@ Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוני
- הוספת שכבת אפליקציה עם סרביסים שהקשר ביניהם רופף (loosely coupled) דורשת גישה שונה בארכיטקטורה, תפעול ותהליכי פיתוח (לעומת מערכת מונוליטית).
- - מיקרו-סרביסים עלולים להוסיף מורכבות מבחינת פריסות ותפעול.
+ - מיקרוסרביסים עלולים להוסיף מורכבות מבחינת פריסות ותפעול.
### מקורות וקריאה נוספת
@@ -1349,7 +1349,7 @@ Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוני
---
-#### SQL Tuning
+#### אופטימיזציית SQL Tuning
התחום של SQL Tuning הוא רחב, ונכתבו עליו לא מעט [ספרים](https://www.amazon.com/s/ref=nb_sb_noss_2?url=search-alias%3Daps&field-keywords=sql+tuning).
חשוב לבצע **Benchmark** ו-**Profile** כדי לדמות עומסים ולגלות צווארי-בקבוק.
@@ -1411,7 +1411,7 @@ Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוני
- [How do null values affect performance?](http://stackoverflow.com/questions/1017239/how-do-null-values-affect-performance-in-a-database-search)
- [Slow query log](http://dev.mysql.com/doc/refman/5.7/en/slow-query-log.html)
-### NoSQL
+### מסדי נתונים NoSQL
לעומת SQL קלאסי, NoSQL הוא אוסף של מבני נתונים הנשמרים בתור **Key-Value Store**, **Document Store**, **Wide Column Store** או **Graph Database**.
הנתונים מנורמלים פחות, ופעולות JOIN מבוצעות לרוב בקוד האפליקציה עצמה.
@@ -1530,7 +1530,7 @@ Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוני
- [Introduction to NoSQL](https://www.youtube.com/watch?v=qI_g07C_Q5I)
- [NoSQL patterns](http://horicky.blogspot.com/2009/11/nosql-patterns.html)
-### SQL or NoSQL
+### השוואה: SQL or NoSQL
@@ -1538,7 +1538,7 @@ Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוני
Source: Transitioning from RDBMS to NoSQL
--סיבות לשימוש ב**SQL**:
+סיבות לשימוש ב-**SQL**:
- נתונים עם מבנה קבוע
From 1ab48acf78f85287e23bcd8dbdec90fd6fa95447 Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Wed, 18 Jun 2025 16:55:07 +0300
Subject: [PATCH 42/43] Updated index
---
README-he.md | 144 +++++++++++++++++++++++++--------------------------
1 file changed, 72 insertions(+), 72 deletions(-)
diff --git a/README-he.md b/README-he.md
index a633c5f0..09628256 100644
--- a/README-he.md
+++ b/README-he.md
@@ -30,7 +30,7 @@
מדובר בפרויקט קוד פתוח (open source) שמתעדכן באופן מתמשך.
-מוזמנים [לתרום!](#contributing)
+מוזמנים [לתרום!](#תרומה-למדריך)
### להתכונן לראיונות ארכיטקטורה
@@ -41,11 +41,11 @@
### נושאים נוספים להכנה לראיונות:
@@ -101,7 +101,7 @@
- תרגום לשפות נוספות
-תכנים שעדיין דורשים ליטוש מסומנים בתור תחת פיתוח.
+תכנים שעדיין דורשים ליטוש מסומנים בתור תחת פיתוח.
מומלץ לעיין בהנחיות לתרומה לפני התחלה.
@@ -136,20 +136,20 @@
- דפוסי עקביות
+ דפוסי עקביות (Consistency Patterns)
- דפוסי זמינות
+ דפוסי זמינות (Availability Patterns)
מאזן עומסים (Load Balancer)
פרוקסי הפוך (Reverse Proxy)
@@ -179,11 +179,11 @@
שכבת האפליקציה
- מסדי נתונים
+ מסדי נתונים (DB)
- מטמון (Cache)
+ מטמון (Cache)
- אסינכרוניות (asynchronism)
+ אסינכרוניות (Asynchronism)
- תקשורת
+ תקשורת (Communication)
- אבטחה
- נספחים
+ אבטחת מידע (Security)
+ נספחים
- תחת פיתוח
- קרדיטים
- פרטי קשר
- רישיון
+ תחת פיתוח
+ קרדיטים
+ פרטי קשר
+ רישיון
@@ -441,7 +442,7 @@
-## שאלות ריאיון תכנון מערכות עם פתרונות
+## שאלות ריאיון ארכיטקטורה עם פתרונות
@@ -491,7 +492,8 @@
הוסף שאלה לתכנון מערכת |
- תרום |
+ תרום |
@@ -605,7 +607,6 @@
>**הערה: החלק הזה עדיין בפיתוח**
-
@@ -640,11 +641,13 @@
תכנן מערך מעגלי |
- תרום |
+ תרום |
הוסף שאלה בעיצוב מונחה עצמים |
- תרום |
+ תרום |
@@ -1838,7 +1841,7 @@ def set_user(user_id, values):
- [Celery](https://docs.celeryproject.org/en/stable/) has support for scheduling and primarily has python support.
-### Back Pressure
+### לחץ נגדי (Back Pressure)
אם התור מתחיל לגדול באופן משמעותי מעבר לקצב שבו ה-workers מסוגלים לעבד, גודל התור יכול להיות מעבר למה שפנוי לנו בזיכרון, מה שיגרום ל-cache misses, יותר קריאות מהדיסק, וביצועים נמוכים יותר. [Back pressure](http://mechanical-sympathy.blogspot.com/2012/05/apply-back-pressure-when-overloaded.html) יכול לעזור באמצעות הגדלת גודל התור, מה ששומר על קצב הטיפול בבקשות לכאלו שכבר בתוך התור. אם התור מתמלא, השרת מפסיק לקבל עבודות חדשות ומחזיר ללקוח שגיאת HTTP 503 (עסוק). הלקוח יכול לנסות שוב לאחר זמן המתנה הולך וגדל כמו [exponential backoff](https://en.wikipedia.org/wiki/Exponential_backoff).
@@ -2062,7 +2065,7 @@ PUT /someresources/anId
## אבטחת מידע (Security)
-הפרק הזה זקוק לעדכונים. מוזמנים [לעזור](#contributing)!
+הפרק הזה זקוק לעדכונים. מוזמנים [לעזור](#תרומה-למדריך)!
אבטחת מידע היא תחום רחב ומורכב, אבל לרוב הראיונות (כל עוד אינך מומחה אבטחה) מספיק להכיר את העקרונות הבסיסיים:
@@ -2180,7 +2183,7 @@ Notes
| Design a garbage collection system | [stuffwithstuff.com](http://journal.stuffwithstuff.com/2013/12/08/babys-first-garbage-collector/)
[washington.edu](http://courses.cs.washington.edu/courses/csep521/07wi/prj/rick.pdf) |
| Design an API rate limiter | [https://stripe.com/blog/](https://stripe.com/blog/rate-limiters) |
| Design a Stock Exchange (like NASDAQ or Binance) | [Jane Street](https://youtu.be/b1e4t2k2KJY)
[Golang Implementation](https://around25.com/blog/building-a-trading-engine-for-a-crypto-exchange/)
[Go Implementation](http://bhomnick.net/building-a-simple-limit-order-in-go/) |
-| Add a system design question | [Contribute](#contributing) |
+| Add a system design question | [Contribute](#תרומה-למדריך) |
### ארכיטקטורות מהעולם האמיתי
@@ -2222,7 +2225,7 @@ Notes
| Misc | **Dapper** - Distributed systems tracing infrastructure | [research.google.com](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/36356.pdf)
| Misc | **Kafka** - Pub/sub message queue from LinkedIn | [slideshare.net](http://www.slideshare.net/mumrah/kafka-talk-tri-hug) |
| Misc | **Zookeeper** - Centralized infrastructure and services enabling synchronization | [slideshare.net](http://www.slideshare.net/sauravhaloi/introduction-to-apache-zookeeper) |
-| | Add an architecture | [Contribute](#contributing) |
+| | Add an architecture | [Contribute](#תרומה-למדריך) |
### ארכיטקטורות של חברות
@@ -2305,17 +2308,14 @@ Looking to add a blog? To avoid duplicating work, consider adding your company
* [kilimchoi/engineering-blogs](https://github.com/kilimchoi/engineering-blogs)
-
-
-
## תחת פיתוח
-מעוניין להוסיף חלק או לעזור לסיים אחד שנמצא בעבודה? [תרום](#contributing)!
+מעוניין להוסיף חלק או לעזור לסיים אחד שנמצא בעבודה? [תרום](#תרומה-למדריך)!
- Distributed computing with MapReduce
- Consistent hashing
- Scatter gather
-- [Contribute](#contributing)
+- [Contribute](#תרומה-למדריך)
## קרדיטים
From a260e09497d4aac7c292329ab810bdb4f76cac21 Mon Sep 17 00:00:00 2001
From: Roy Mayan <>
Date: Wed, 18 Jun 2025 20:59:18 +0300
Subject: [PATCH 43/43] Updated more links
---
README-he.md | 87 ++++++++++++++++++++++++++--------------------------
1 file changed, 43 insertions(+), 44 deletions(-)
diff --git a/README-he.md b/README-he.md
index 09628256..ab9c2527 100644
--- a/README-he.md
+++ b/README-he.md
@@ -116,7 +116,7 @@
> כל חלק מכיל קישורים להרחבה וללמידה מעמיקה יותר.
-
+
@@ -268,7 +268,7 @@
> נושאים מוצעים ללימוד לפי לוח הזמנים לריאיון שלך (קצר, בינוני, ארוך)
-
+
@@ -307,43 +307,43 @@
- קרא את הנושאים בתכנון מערכות כדי לקבל הבנה כללית של איך מערכות עובדות |
+ קרא את אינדקס נושאים בארכיטקטורה כדי לקבל הבנה כללית של איך מערכות עובדות |
:+1: |
:+1: |
:+1: |
- קרא כמה מאמרים מתוך בלוגים של חברות שאתה מתראיין אליהן |
+ קרא כמה מאמרים מתוך בלוגים טכניים של חברות שאתה מתראיין אליהן |
:+1: |
:+1: |
:+1: |
- קרא על כמה ארכיטקטורות מהעולם האמיתי |
+ קרא על כמה ארכיטקטורות מהעולם האמיתי |
:+1: |
:+1: |
:+1: |
- חזור על איך לגשת לשאלת ריאיון בתכנון מערכות |
+ חזור על איך לגשת לשאלת ריאיון ארכיטקטורה |
:+1: |
:+1: |
:+1: |
- תרגל שאלות ריאיון בתכנון מערכות עם פתרונות |
+ תרגל שאלות ריאיון ארכיטקטורה עם פתרונות |
כמה |
הרבה |
רוב |
- תרגל שאלות ריאיון בתכנון מונחה עצמים עם פתרונות |
+ תרגל שאלות ריאיון בתכנון מונחה עצמים עם פתרונות |
כמה |
הרבה |
רוב |
- חזור על שאלות ריאיון נוספות בתכנון מערכות |
+ חזור על שאלות ריאיון נוספות |
כמה |
הרבה |
רוב |
@@ -361,7 +361,7 @@
ראיון ארכיטקטורה הוא **שיחה פתוחה**. מצופה ממך להוביל אותה.
-אתה יכול להיעזר בצעדים הבאים כדי להנחות את הדיון. כדי לחזק את ההבנה של התהליך, תעבור על [שאלות ריאיון בתכנון מערכות עם פתרונות](#system-design-interview-questions-with-solutions) אל מול הצעדים הבאים:
+אתה יכול להיעזר בצעדים הבאים כדי להנחות את הדיון. כדי לחזק את ההבנה של התהליך, תעבור על [שאלות ריאיון ארכיטקטורה עם פתרונות](#שאלות-ריאיון-ארכיטקטורה-עם-פתרונות) אל מול הצעדים הבאים:
### תאר מקרי שימוש, אילוצים והנחות עבודה
@@ -420,24 +420,24 @@
פיצול בסיס נתונים (Database sharding)
-דון בפתרונות אפשריים וה-trade-offs. הכול הוא trade-off. התמודד עם צווארי בקבוק בעזרת [עקרונות תכנון מערכת סקילבילית](#index-of-system-design-topics).
+דון בפתרונות אפשריים וה-trade-offs. הכול הוא trade-off. התמודד עם צווארי בקבוק בעזרת [עקרונות תכנון מערכת סקילבילית](#אינדקס-נושאים-בארכיטקטורה).
-### חישובים "על גב המעטפה" (מהירים)
+### חישובי מספרים (back-of-the-enveloppe)
-ייתכן שיבקשו ממך לבצע הערכות באופן ידני. ראה את [הנספח](#appendix) עבור המשאבים הבאים:
+ייתכן שיבקשו ממך לבצע הערכות באופן ידני. ראה את [הנספחים](#נספחים) עבור המשאבים הבאים:
-* [Use back of the envelope calculations](http://highscalability.com/blog/2011/1/26/google-pro-tip-use-back-of-the-envelope-calculations-to-choo.html)
-* [Powers of two table](#powers-of-two-table)
-* [Latency numbers every programmer should know](#latency-numbers-every-programmer-should-know)
+- [Use back of the envelope calculations](http://highscalability.com/blog/2011/1/26/google-pro-tip-use-back-of-the-envelope-calculations-to-choo.html)
+- [Powers of two table](#powers-of-two-table)
+- [Latency numbers every programmer should know](#latency-numbers-every-programmer-should-know)
### מקורות לקריאה נוספת
עיין בקישורים הבאים כדי להבין טוב יותר למה לצפות:
-* [How to ace a systems design interview](https://www.palantir.com/2011/10/how-to-rock-a-systems-design-interview/)
-* [The system design interview](http://www.hiredintech.com/system-design)
-* [Intro to Architecture and Systems Design Interviews](https://www.youtube.com/watch?v=ZgdS0EUmn70)
-* [System design template](https://leetcode.com/discuss/career/229177/My-System-Design-Template)
+- [How to ace a systems design interview](https://www.palantir.com/2011/10/how-to-rock-a-systems-design-interview/)
+- [The system design interview](http://www.hiredintech.com/system-design)
+- [Intro to Architecture and Systems Design Interviews](https://www.youtube.com/watch?v=ZgdS0EUmn70)
+- [System design template](https://leetcode.com/discuss/career/229177/My-System-Design-Template)
@@ -765,7 +765,7 @@
תשובות לבקשות מהמערכת מחזירות את הגרסה הזמינה ביותר של הנתונים הזמינים בשרת הרלוונטי, שאינה בהכרח האחרונה. כתיבה עשויה לקחת זמן מסוים עד שתסתיים, עד אשר התקשורת הבעייתית תיפתר.
-לכן, AP הוא בחירה טובה במידה ויש הצדקה עסקית לעבוד במצב של [eventual consistency](#eventual-consistency) או במידה והמערכת צריכה להמשיך לשרת למרות שגיאות בלתי-תלויות.
+לכן, AP הוא בחירה טובה במידה ויש הצדקה עסקית לעבוד במצב של [eventual consistency](#עקביות-לא-מיידית-eventual-consistency) או במידה והמערכת צריכה להמשיך לשרת למרות שגיאות בלתי-תלויות.
### חומרים וקריאה נוספת
@@ -782,7 +782,7 @@
כאשר קיימים מספר עותקים של אותם נתונים, עלינו להחליט כיצד לסנכרן ביניהם כדי שלקוחות יקבלו תצוגה עקבית של המידע.
-ניזכר בהגדרה של עקביות מתוך [משפט CAP](#cap-theorem): כל קריאה מקבלת את הכתיבה העדכנית ביותר או שגיאה.
+ניזכר בהגדרה של עקביות מתוך [משפט CAP](#משפט-cap): כל קריאה מקבלת את הכתיבה העדכנית ביותר או שגיאה.
### עקביות חלשה (Weak Consistency)
@@ -844,10 +844,10 @@
#### עבור Master-Slave/Master-Master
-נושא זה נדון בפירוט נוסף בחלק על [מסדי נתונים](#database):
+נושא זה נדון בפירוט נוסף בחלק על [מסדי נתונים](#מסדי-נתונים-db):
-- [Master-slave replication](#master-slave-replication)
-- [Master-master replication](#master-master-replication)
+- [Master-slave replication](#שכפול-master-slave)
+- [Master-master replication](#שכפול-master-master)
@@ -1031,8 +1031,7 @@ Pull CDN מתאים לאתרים עתירי תעבורה, שכן העומס מת
-כדי להגן מפני כישלונות נהוג להקים מספר מאזני עומסים, במצב
-[Active-Passive](#אקטיבי-פסיבי-active-passive) או [Active-Active](#אקטיבי-אקטיבי-active-active).
+כדי להגן מפני כישלונות נהוג להקים מספר מאזני עומסים, במצב [Active-Passive](#אקטיבי-פסיבי-active-passive) או [Active-Active](#אקטיבי-אקטיבי-active-active).
מאזן עומסים יכול לנתב את התעבורה על פי מדדים שונים:
@@ -1045,7 +1044,7 @@ Pull CDN מתאים לאתרים עתירי תעבורה, שכן העומס מת
### איזון עומסים בשכבה 4
-מאזני עומסים בשכבה 4 בוחנים מידע בשכבת התעבורה ([transport layer](#communication)) כדי להחליט כיצד להפיץ בקשות.
+מאזני עומסים בשכבה 4 בוחנים מידע בשכבת התעבורה ([transport layer](#תקשורת-communication)) כדי להחליט כיצד להפיץ בקשות.
בדרך כלל, מדובר בכתובות ה-IP של המקור והיעד ובפורטים שבכותרת (header), ולא בתוכן הפקטה (packet).
מאזני עומסים בשכבה 4 מעבירים את חבילות הרשת אל ומן השרת הנבחר (upstream server) תוך ביצוע
[תרגום כתובות רשת (NAT)](https://www.nginx.com/resources/glossary/layer-4-load-balancing/).
@@ -1053,7 +1052,7 @@ Pull CDN מתאים לאתרים עתירי תעבורה, שכן העומס מת
### איזון עומסים בשכבה 7
-מאזני עומסים בשכבה 7 בוחנים את [שכבת האפליקציה](#communication) כדי להחליט כיצד להפיץ בקשות. ההחלטה יכולה להתבסס על תוכן הכותרות (headers), גוף ההודעה, ועוגיות (cookies).
+מאזני עומסים בשכבה 7 בוחנים את [שכבת האפליקציה](#תקשורת-communication) כדי להחליט כיצד להפיץ בקשות. ההחלטה יכולה להתבסס על תוכן הכותרות (headers), גוף ההודעה, ועוגיות (cookies).
מאזן עומסים בשכבה 7 מסיים (terminates) את תעבורת הרשת אל מול הלקוח, קורא את ההודעה, מקבל החלטת איזון-עומסים, ואז פותח חיבור לשרת שנבחר.
למשל, מאזן כזה יכול לשלוח תעבורת וידאו לשרתים שמאחסנים קטעי וידאו, ובמקביל לנתב תעבורת חיוב משתמשים (billing) לשרתים מוקשחים אבטחתית.
@@ -1071,7 +1070,7 @@ Pull CDN מתאים לאתרים עתירי תעבורה, שכן העומס מת
גדילה אופקית מוסיפה מורכבות וכוללת שכפול שרתים
- השרתים צריכים להיות stateless: אין לאחסן בהם מידע משתמש כגון סשנים או תמונות פרופיל
- - ניתן לשמור סשנים באחסון נתונים מרכזי כגון מסד־נתונים (SQL או NoSQL) או מטמון פרסיסטנטי (Redis, Memcached)
+ - ניתן לשמור סשנים באחסון נתונים מרכזי כגון מסד־נתונים (SQL או NoSQL) או מטמון פרסיסטנטי (Redis, Memcached)
שרתים בהמשך השרשרת (downstream) למשל cache ו-DB צריכים להתמודד עם יותר חיבורים בו-זמנית ככל שמספר שרתי האפליקציה גדל
@@ -1157,7 +1156,7 @@ Pull CDN מתאים לאתרים עתירי תעבורה, שכן העומס מת
הפרדת שכבת הרשת משכבת האפליקציה (ידועה גם כשכבת ה-platform), מאפשרת לבצע scaling ולקנפג את שתי השכבות באופן בלתי תלוי. הוספת API חדש גוררת הוספתי שרתי אפליקציה, מבלי להוסיף בהכרח גם שרתי המטפלים בלוגיקת הרשת.
עקרון האחריות היחידה (**single respoinsibility principle**) מעודד סרביסים עצמאיים וקטנים שעובדים יחד. צוותים קטנים המטפלים שירותים קטנים יכלוים להתכוונן בצורה מיטבית לגדילה מהירה.
-Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוניות](#asynchronism).
+Workers בשכבת האפליקציה מסייעים גם [לאסינכרוניות](#אסינכרוניות-asynchronism).
### מיקרוסרביסים (Microservices)
@@ -1170,7 +1169,7 @@ Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוני
מערכות כמו [Consul](https://www.consul.io/docs/index.html), [Etcd](https://coreos.com/etcddocs/latest), ו-[Zookeeper](http://www.slideshare.net/sauravhaloi/introduction-to-apache-zookeeper) מסייעות לשירותים “למצוא” זה את זה על ידי ניהול ומעקב אחר שמות הסרביסים, כתובות IP, ופורטים.
בדיקות דופק ([Health checks](https://www.consul.io/intro/getting-started/checks.html)) — מאמתות את תקינות השירות, לעיתים קרובות באמצעות endpoint HTTP.
גם Consul וגם Etcd כוללים
-[אחסון key-value](#key-value-store) מובנה, השימושי לאחסון קונפיגורציה ונתונים משותפים.
+[אחסון key-value](#אחסון-key-value) מובנה, השימושי לאחסון קונפיגורציה ונתונים משותפים.
### חסרונות: שכבת האפליקציה
@@ -1230,7 +1229,7 @@ Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוני
---
@@ -1251,7 +1250,7 @@ Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוני
נדרש מאזן עומסים או שינוי לוגיקת האפליקציה כדי להחליט לאן לכתוב.
רוב מערכות ה-Master-Master מפרות עקרון של עקביות (לכן מפרות ACID) או סובלות מאיטיות כתיבה עקב הצורך לבצע סנכרון.
ככל שמתרבים שרתים שמאפשרים כתיבה וה-latency גדל, יש צורך להכריע יותר מקרים של conflict.
- ראה חסרונות: replication.
+ ראה חסרונות: replication.
##### חסרונות: Replication (כללי)
@@ -1307,7 +1306,7 @@ Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוני
חלוקה מפזרת את הדאטא בין DBים שונים כך שכל DB מנהל חלק (subset) מסוים של הדאטא. נסתכל למשל על DB של משתמשים, ככל שכמות המשתמשים עולה, יותר חלקים (shards) מתווספים ל-cluster.
-בדומה ליתרונות של [פדרציה](), חלוקה גוררת פחות תעבורה של קריאות וכתיבות, פחות שכפול, ויותר cache hits. גודל ה-index גם קטן, מה שלרוב משפר את קצב ביצוע השאילתות.
+בדומה ליתרונות של [פדרציה](#פדרציה-federation), חלוקה גוררת פחות תעבורה של קריאות וכתיבות, פחות שכפול, ויותר cache hits. גודל ה-index גם קטן, מה שלרוב משפר את קצב ביצוע השאילתות.
אם shard אחד נופל, כל שאר ה-shards עדיין פעילים, למרות שנרצה לבצע שכפול מסוים כדי להימנע מאיבוד מידע. כמו פדרציה, אין master מרכזי אחיד שכל הכתיבות עוברות דרכו, מה שמאפשר לכתוב במקביל ל-DBים שונים ולהגביר את ה-throughput.
דרכים נפוצות לבצע sharding לטבלה של משתמשים הן באמצעות האות הראשונה של שם המשפחה, או המיקום הגיאוגרפי של המשתמש.
@@ -1392,7 +1391,7 @@ Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוני
##### מניעת JOIN יקר
##### חלוקה לטבלאות (Partitioning)
@@ -1418,9 +1417,9 @@ Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוני
לעומת SQL קלאסי, NoSQL הוא אוסף של מבני נתונים הנשמרים בתור **Key-Value Store**, **Document Store**, **Wide Column Store** או **Graph Database**.
הנתונים מנורמלים פחות, ופעולות JOIN מבוצעות לרוב בקוד האפליקציה עצמה.
-רוב האחסונים מסוג NoSQL אינם תומכים בטרנזקציות ACID מלאות ומספקים [עקביות לא מיידית](#eventual-consistency).
+רוב האחסונים מסוג NoSQL אינם תומכים בטרנזקציות ACID מלאות ומספקים [עקביות לא מיידית](#עקביות-לא-מיידית-eventual-consistency).
-מקובל לסמן את מאפייני NoSQL בראשי התיבות **BASE** (תווך שימוש ב[משפט CAP](#cap-theorem), תכונות BASE מתעדפות זמינות (A) על פני עקביות (C)):
+מקובל לסמן את מאפייני NoSQL בראשי התיבות **BASE** (תווך שימוש ב[משפט CAP](#משפט-cap), תכונות BASE מתעדפות זמינות (A) על פני עקביות (C)):
- Basically Available – המערכת מבטיחה זמינות.
@@ -1428,14 +1427,14 @@ Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוני
- Eventual Consistency – המערכת תהפוך עקבית בסופו של דבר, בהנחה שלא מתקבל קלט נוסף בתקופה זו.
-מעבר לבחירה בין [SQL ל-NoSQL](#sql-or-nosql), חשוב להבין איזה סוג NoSQL מתאים ביותר לשימוש שלך. נדון בסוגים **Key-Value Stores**, **Document Stores**, **Wide Column Stores** ו-**Graph Databases**.
+מעבר לבחירה בין [SQL ל-NoSQL](#השוואה-sql-or-nosql), חשוב להבין איזה סוג NoSQL מתאים ביותר לשימוש שלך. נדון בסוגים **Key-Value Stores**, **Document Stores**, **Wide Column Stores** ו-**Graph Databases**.
---
#### אחסון Key-Value
> הפשטה: Hash Table
-אחסון Key-Value לרוב מאפשר קריאות וכתיבות ב-O(1) ומגובה באמצעות זיכרון או SSD. ניתן לשמור מפתחות ב[סדר לקסיקוגרפי](), מה שמאפשר שליפה יעילה של טווחי המפתחות.
+אחסון Key-Value לרוב מאפשר קריאות וכתיבות ב-O(1) ומגובה באמצעות זיכרון או SSD. ניתן לשמור מפתחות ב[סדר לקסיקוגרפי](https://he.wikipedia.org/wiki/%D7%99%D7%97%D7%A1_%D7%A1%D7%93%D7%A8_%D7%9E%D7%99%D7%9C%D7%95%D7%A0%D7%99), מה שמאפשר שליפה יעילה של טווחי המפתחות.
אחסון זה מאפשר תמיכה ב-metadadta עם ערכים.
אחסון זה מספק ביצועים גבוהים ולרוב בשימוש עבור מודלי דאטא פשוטים או לדאטא שמשתנה במהירות, כמו שכבת cache in-memory. כיוון שסוגי אחסון זה מציעים סט מצומצם של פעולות, המורכבות נמצאת בשכבת האפלקציה אם נדרשות פעולות נוספות.
@@ -1517,7 +1516,7 @@ Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוני
ה-DB מותאם לייצוג קשרים מורכבים – עם הרבה מפתחות זרים (Foreign Keys) או יחסי Many-to-Many.
אחסון זה מאפשר ביצועים גבוהים למודלים עם יחסים מורכבים, למשל כמו רשת חברתית. הטכנולוגיה הזו יחסית חדשה ופות נפוצה; ייתכן קושי למצוא כלי פיתוח ומשאבים. הרבה אחסונים מסוג זה נגישים רק באמצעות
-[REST APIs](#representational-state-transfer-rest).
+[REST APIs](#ממשק-rest).
##### מקורות וקריאה נוספת: Graph
@@ -1600,15 +1599,15 @@ Workers בשכבת האפליקציה מסייעים גם [לא-סינכרוני
### מטמון בצד לקוח
-מטמון יכול להיות ממוקם בצד הלקוח (מערכת ההפעלה או הדפדפן), [צד השרת](#reverse-proxy-web-server), או בשכבה נפרדת.
+מטמון יכול להיות ממוקם בצד הלקוח (מערכת ההפעלה או הדפדפן), [צד השרת](#פרוקסי-הפוך-reverse-proxy), או בשכבה נפרדת.
### מטמון CDN
-ניתן להסתכל על [CDN](#content-delivery-network) גם בתור שכבה של מטמון.
+ניתן להסתכל על [CDN](#רשתות-הפצת-תוכן-cdn) גם בתור שכבה של מטמון.
### מטמון בשרת
-[פרוקסי הפוך](#reverse-proxy-web-server) ומנגנוני cache כמו [Varnish](https://www.varnish-cache.org/) יכולים להנגיש תוכן סטטי ודינמי ישירות. שרתי web יכולים גם לבצע cache לבקשות כדי להחזיר תשובות בלי צורך להגיע עד לשרתי האפליקציה.
+[פרוקסי הפוך](#פרוקסי-הפוך-reverse-proxy) ומנגנוני cache כמו [Varnish](https://www.varnish-cache.org/) יכולים להנגיש תוכן סטטי ודינמי ישירות. שרתי web יכולים גם לבצע cache לבקשות כדי להחזיר תשובות בלי צורך להגיע עד לשרתי האפליקציה.
### מטמון במסד נתונים