diff --git a/_includes/footer.html b/_includes/footer.html
index cbf61d0..e0c038c 100644
--- a/_includes/footer.html
+++ b/_includes/footer.html
@@ -16,7 +16,7 @@ <h5 class="white-text">Links</h5>
   </div>
   <div class="footer-copyright blue-grey darken-4">
     <div class="container">
-    © 2016 The content of this blog is licensed under the Creative Commons Attribution 3.0 License, the code samples under the MIT License, and the pictures under Fair use.
+    © 2016 The content is licensed under the Creative Commons Attribution 3.0 License, code samples under the MIT License, and pictures under Fair use.
     </div>
   </div>
 </footer>
diff --git a/_includes/nav.html b/_includes/nav.html
index 4b6001b..eb95beb 100644
--- a/_includes/nav.html
+++ b/_includes/nav.html
@@ -1,56 +1,3 @@
-<!-- <nav class="button-collapse blue-grey darken-3">
-  <div class="nav-wrapper">
-    <a class="brand-logo" href="{{ site.baseurl }}/">
-      <img src="" alt="{{ site.title }}" />
-    </a>
-    <a href="#" data-activates="mobile-demo" class="button-collapse"><i class="material-icons">menu</i></a>
-    <ul class="right hide-on-med-and-down">
-      <li><a href="http://nirgn.com">About</a></li>
-      {% for my_page in site.pages %}
-        {% if my_page.title %}
-          {% if my_page.url == page.url %}
-            <li class="active"><a href="{{ my_page.url | prepend: site.baseurl }}">{{ my_page.title }}</a></li>
-          {% else  %}
-            <li><a href="{{ my_page.url | prepend: site.baseurl }}">{{ my_page.title }}</a></li>
-          {% endif %}
-        {% endif %}
-      {% endfor %}
-    </ul>
-    <ul id="mobile-demo" class="side-nav blue-grey darken-3">
-      <li><a href="http://nirgn.com">About</a></li>
-      {% for my_page in site.pages %}
-        {% if my_page.title %}
-          {% if my_page.url == page.url %}
-            <li class="active"><a href="{{ my_page.url | prepend: site.baseurl }}">{{ my_page.title }}</a></li>
-          {% else  %}
-            <li><a href="{{ my_page.url | prepend: site.baseurl }}">{{ my_page.title }}</a></li>
-          {% endif %}
-        {% endif %}
-      {% endfor %}
-    </ul>
-  </div>
-</nav> -->
-
-<!-- <nav class="hide-on-med-and-down blue-grey darken-3">
-  <div class="nav-wrapper">
-    <a class="brand-logo" href="{{ site.baseurl }}/">
-      <img src="" alt="{{ site.title }}" />
-    </a>
-    <ul class="right">
-      <li><a href="http://nirgn.com" target="_blank">About</a></li>
-      {% for my_page in site.pages %}
-        {% if my_page.title %}
-          {% if my_page.url == page.url %}
-            <li class="active"><a href="{{ my_page.url | prepend: site.baseurl }}">{{ my_page.title }}</a></li>
-          {% else  %}
-            <li><a href="{{ my_page.url | prepend: site.baseurl }}">{{ my_page.title }}</a></li>
-          {% endif %}
-        {% endif %}
-      {% endfor %}
-    </ul>
-  </div>
-</nav> -->
-
 <nav>
   <div class="nav-wrapper blue-grey darken-3">
     <a href="{{ site.baseurl }}/" class="brand-logo">
diff --git a/_layouts/page.html b/_layouts/page.html
index ce233ad..a12d29a 100644
--- a/_layouts/page.html
+++ b/_layouts/page.html
@@ -1,7 +1,7 @@
 ---
 layout: default
 ---
-<article class="post">
+<article class="post col s12 card-panel">
 
   <header class="post-header">
     <h1 class="post-title">{{ page.title }}</h1>
diff --git a/_layouts/post.html b/_layouts/post.html
index be9e08b..e437b85 100644
--- a/_layouts/post.html
+++ b/_layouts/post.html
@@ -5,6 +5,12 @@
   <div class="parallax"><img src="/assets/img/posts/{{ page.base-images-url }}/{{ page.hero-image }}"></div>
 </div>
 <article class="row" itemscope itemtype="http://schema.org/BlogPosting">
+
+  <!-- Include LaTeX support if the post needs it -->
+  {% if page.latex == true %}
+    <script src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML" type="text/javascript"></script>
+  {% endif %}
+
   <div class="col s12 card-panel">
     <!-- Title and Date -->
     <header class="post-header">
diff --git a/_posts/2015-02-01-arduino-9.md b/_posts/2015-02-01-arduino-9.md
index ab0c8a0..e68fc94 100644
--- a/_posts/2015-02-01-arduino-9.md
+++ b/_posts/2015-02-01-arduino-9.md
@@ -4,48 +4,6 @@ author: nirgn
 layout: post
 categories:
   - Arduino
-tags:
-  - 5V
-  - Arduino
-  - Battery
-  - Breadboard
-  - Code
-  - const
-  - Diode
-  - Drain
-  - Gate
-  - GND
-  - int
-  - LED
-  - Motor
-  - Ohm
-  - Source
-  - Switch
-  - Transistor
-  - ארדואינו
-  - דיודה
-  - הסבר
-  - זרם
-  - חוט מגשר
-  - חשמל
-  - טרנזיסטור
-  - לד
-  - לוח מטריצה
-  - מאמר
-  - מגנטי
-  - מדריך
-  - מוט
-  - מינוס
-  - מנוע
-  - מתג
-  - מתח
-  - נורה
-  - סוללה
-  - פין
-  - פלוס
-  - פרויקט
-  - קוד
-  - שדה
 ---
 [<img class="alignleft wp-image-1281" src="http://www.lifelongstudent.net/wp-content/uploads/2014/03/Main_Arduino.png" alt="Main Arduino" width="350" height="207" />](http://www.lifelongstudent.net/wp-content/uploads/2014/03/Main_Arduino.png)בפרויקט הזה, נחבר מנוע אל הארדואינו שיפעל על פי הוראה מאיתנו (ע"י לחיצה על המתג). בנוסף להכרת רכיב המנוע, נכיר את הדיודה והטרנזיסטור.
 
@@ -116,4 +74,4 @@ void loop(){
 
 אז הפרויקט הזה היה קצר וקטן, אך חשוב בגלל הרכיבים והטכניקות החדשות שלמדנו. הפרויקט התמקד בהפעלת מנוע חשמלי, וכדי להפעילו השתמשנו בטרנזיסטור (על מנת לשלוט בפעולה של המנוע ולא להפעילו באופן רציף), ודיודה על מנת להגן על הרכיבים במעגל החשמלי שלנו.
 
-* אולי תהיתם למה משתמשים באותן השמות לרגליים של נורות ה LED והדיודות, וזה כי נורות LED הן דיודות. ישנם סוגים רבים של דיודות, אבל כולם חולקים תכונה אחת: הם מאפשרי לזרם לזרום מהאנודה לקתודה, אך לא להפך.
\ No newline at end of file
+* אולי תהיתם למה משתמשים באותן השמות לרגליים של נורות ה LED והדיודות, וזה כי נורות LED הן דיודות. ישנם סוגים רבים של דיודות, אבל כולם חולקים תכונה אחת: הם מאפשרי לזרם לזרום מהאנודה לקתודה, אך לא להפך.
diff --git a/_posts/2015-02-15-arduino-10.md b/_posts/2015-02-15-arduino-10.md
index 056da62..8d93228 100644
--- a/_posts/2015-02-15-arduino-10.md
+++ b/_posts/2015-02-15-arduino-10.md
@@ -4,51 +4,6 @@ author: nirgn
 layout: post
 categories:
   - Arduino
-tags:
-  - 5V
-  - 9V
-  - analog
-  - Arduino
-  - Battery
-  - Breadbord
-  - Code
-  - const
-  - DC
-  - Digital
-  - GND
-  - H Bridge
-  - HIGH
-  - IC
-  - LOW
-  - Motor
-  - read
-  - Switch
-  - write
-  - ארדואינו
-  - גשר
-  - הסבר
-  - זרם
-  - טרנזיסטור
-  - לוח מטריצה
-  - מאמר
-  - מדריך
-  - מנוע
-  - מעגל
-  - משולב
-  - משתנים
-  - מתג
-  - מתח
-  - נגד
-  - סוללה
-  - סיכות
-  - פוטנציומטר
-  - פונקציות
-  - פינים
-  - פלט
-  - קבוע
-  - קוד
-  - קלט
-  - תנאי
 ---
 [<img class="alignleft wp-image-1281" src="http://www.lifelongstudent.net/wp-content/uploads/2014/03/Main_Arduino.png" alt="Main Arduino" width="350" height="207" />](http://www.lifelongstudent.net/wp-content/uploads/2014/03/Main_Arduino.png)בפרויקט הזה, נמשיך לשחק עם המנוע שחיברנו לארדואינו בפוסט הקודם, אך הפעם נחבר 2 מתגים, הראשון יכבה וידליק את המנוע, והשני יהפוך את כיוון הפעולה שלו. ולבסוף נוסיף פוטנציומטר כדי לשלוט על המהירות בה המנוע מסתובב.
 
@@ -181,4 +136,4 @@ void loop(){
 
 הפרויקט הזה היה ארוך ומורכב יותר. המשכנו לדבר על המנוע ושילבנו פונקציות קודמות שלמדנו ורכיבים שונים (מתגים ופוטנציומטר). בנוסף, למדנו על H-bridge &#8211; גשר, והבנו מהם מעגלים משולבים. אני מקווה שהצלחתם להפעיל את הפרויקט, ובמידה ואתם צריכים עזרה או שיש לכם איזשהי שאלה אשמח לעזור בתגובות.
 
-אם אתם רוצים להפוך את הפרויקט לשימושי יותר, חשבו על כך שהפעולה העיקרית שאתם עושים היא החלפת הכיוון של סיבוב המנוע מצד ימין לצד שמאל ולהפך, איזה דברים דורשים פעולה כזאת? ניתן לחשוב על שבשבת, על מנעול (סיבוב לצד אחד נועל וסיבוב לצד שני פותח), מאורר (כיוון המאורר), או אפילו רכב על שלט (אם נחבר גלגל שיניים למנוע בצורה אורכית, סיבוב ימינה / שמאלה יניע את הגלגלים קדימה / אחורה).
\ No newline at end of file
+אם אתם רוצים להפוך את הפרויקט לשימושי יותר, חשבו על כך שהפעולה העיקרית שאתם עושים היא החלפת הכיוון של סיבוב המנוע מצד ימין לצד שמאל ולהפך, איזה דברים דורשים פעולה כזאת? ניתן לחשוב על שבשבת, על מנעול (סיבוב לצד אחד נועל וסיבוב לצד שני פותח), מאורר (כיוון המאורר), או אפילו רכב על שלט (אם נחבר גלגל שיניים למנוע בצורה אורכית, סיבוב ימינה / שמאלה יניע את הגלגלים קדימה / אחורה).
diff --git a/_posts/2015-03-01-arduino-11.md b/_posts/2015-03-01-arduino-11.md
index cc31f3a..41c0adc 100644
--- a/_posts/2015-03-01-arduino-11.md
+++ b/_posts/2015-03-01-arduino-11.md
@@ -4,39 +4,6 @@ author: nirgn
 layout: post
 categories:
   - Arduino
-tags:
-  - Arduino
-  - Breadboard
-  - Code
-  - cursor
-  - D4-D7
-  - EN
-  - include
-  - LCD
-  - LED
-  - liquidCrystal
-  - loop
-  - Pin
-  - R/W
-  - RS
-  - setup
-  - Switch
-  - Vcc
-  - Vss
-  - ארדואינו
-  - ייבוא
-  - לוח מטריצה
-  - מסך
-  - מצביע
-  - מתח
-  - סמן
-  - ספרייה
-  - פין
-  - פרמטר
-  - קוד
-  - רנדומלי
-  - תווים
-  - תקשורת
 ---
 [<img class="alignleft wp-image-1281" src="http://www.lifelongstudent.net/wp-content/uploads/2014/03/Main_Arduino.png" alt="Main Arduino" width="350" height="207" />](http://www.lifelongstudent.net/wp-content/uploads/2014/03/Main_Arduino.png)בפרויקט הזה, נבנה את הצעצוע הקלאסי <a href="http://en.wikipedia.org/wiki/Magic_8-Ball" target="_blank">magic 8-ball</a>. אך נבנה אותו בצורה אחרת, ועם פחות אפשרויות (8 במקום 20, בשביל הקטנת קטע הקוד) נשתמש בפעם הראשונה במסך LCD כדי להציג את הטקסט, ומתג הטייה על מנת לבדוק האם ניערנו את הכדור (כדי לשאול שאלה).
 
@@ -118,7 +85,7 @@ void loop(){
             lcd.setCursor(0, 0);
             lcd.print("The ball says:");
             lcd.setCursor(0, 1);
-            
+
             swtich(reply){
                 case 0: lcd.print("Yes");
                     break;
@@ -148,4 +115,4 @@ void loop(){
 
 הפרויקט הזה לא היה מורכב מידי אך היה חשוב, שכן חזרנו קצת על שימוש במתג ההטייה ובפוטנציומטר, בייבוא ספריות (עשינו את זה גם בפרויקט הסרוו). למדנו על רכיב חדש ושימושי מאוד בחיינו &#8211; מסך LCD, והשתמשנו בפקודה חדשה בשם switch.
 
-* שימו לב לגבי כל החוטים המגשרים שעוברים בפרויקט, אם נתקלתם בבעיות כלשהן, סביר להניח שהן נובעות מחיבור לא נכון של החוטים (בהתחשב בכמות הגבוהה שיש בפרויקט הנל) &#8211; אז שימו לב.
\ No newline at end of file
+* שימו לב לגבי כל החוטים המגשרים שעוברים בפרויקט, אם נתקלתם בבעיות כלשהן, סביר להניח שהן נובעות מחיבור לא נכון של החוטים (בהתחשב בכמות הגבוהה שיש בפרויקט הנל) &#8211; אז שימו לב.
diff --git a/_posts/2015-03-15-binary-tree.md b/_posts/2015-03-15-binary-tree.md
index 40a7f0c..f82ed96 100644
--- a/_posts/2015-03-15-binary-tree.md
+++ b/_posts/2015-03-15-binary-tree.md
@@ -4,41 +4,6 @@ author: nirgn
 layout: post
 categories:
   - Data_Structures
-tags:
-  - Binary Tree
-  - Data structure
-  - NIL
-  - Tree
-  - Tree Delete
-  - Tree Insert
-  - Tree Maximum
-  - Tree Minimum
-  - Tree Search
-  - Tree Successor
-  - אדום שחור
-  - בינרי
-  - בנים
-  - גרפים
-  - הכנסה
-  - מאוזן
-  - מבנה נתונים
-  - מחזיר
-  - מחיקה
-  - מינימום
-  - מלא
-  - מנוון
-  - מפתח
-  - מצביע
-  - מקסימום
-  - סריקה
-  - עוקב
-  - עץ
-  - עץ בינארי
-  - פעולות בסיסיות
-  - צומת
-  - קודם
-  - שאילתות
-  - שורש
 ---
 [<img class="alignleft wp-image-1045" src="http://www.lifelongstudent.net/wp-content/uploads/2013/04/DataStructures.png" alt="Dataֹׁ Structures" width="350" height="227" srcset="http://www.lifelongstudent.net/wp-content/uploads/2013/04/DataStructures.png 400w, http://www.lifelongstudent.net/wp-content/uploads/2013/04/DataStructures-300x194.png 300w" sizes="(max-width: 350px) 100vw, 350px" />](http://www.lifelongstudent.net/wp-content/uploads/2013/04/DataStructures.png)עץ בינארי הוא מבנה נתונים מופשט, הבנוי / מאורגן בצורת עץ, כשלכל קודקוד יש לכל היותר שני בנים (המתייחסים אליהם כ'בן ימיני' ו'בן שמאלי') ולכל קודקוד (פרט לראשון, הנקרא שורש) יש אב יחיד. העץ הינו מכוון ז"א שישנו כיוון אחד (במקרה שלנו נראה כמו מלמעלה למטה, כאילו אנו יורדים במורד העץ), וזה מתבטא בכך שכל צומת שומר אך ורק את הבנים שלו ולא את האב.
 
@@ -225,4 +190,4 @@ return y</pre>
 
 אז הצגנו את תכונותיהם הבסיסיות של עצי חיפוש בינאריים, ולאחר מכן ראינו כיצד סורקים עץ חיפוש בינארי כדי להדפיס את ערכיו בסדר ממוין, כיצד מחפשים ערך בעץ חיפוש בינארי, כיצד מוצאים את איבר המינימום או המקסימום, כיצד מוצאים את האיבר העוקב לאיבר נתון (ובאופן סימטרי את האיבר הקודם לאיבר נתון), וכיצד מכניסים איבר לעץ חיפוש בינארי או מוחקים ממנו איבר.
 
-היתרון בעצי חיפוש בינאריים הוא האפשרות לחפש איבר מסוים או למיין את האיברים בזמן מהיר יחסית (לדוגמה ביחס למערך או רשימה מקושרת). הפעולות הבסיסיות שתיארנו יתבצעו במהירות אם עץ החיפוש הוא נמוך, אך אם הוא גבוה, הביצועים לא יהיו טובים יותר מאשר מימוש באמצעות רשימה מקושרת. לכן בפוסט הבא נדבר על עצי חיפוש מאוזנים, או AVL.
\ No newline at end of file
+היתרון בעצי חיפוש בינאריים הוא האפשרות לחפש איבר מסוים או למיין את האיברים בזמן מהיר יחסית (לדוגמה ביחס למערך או רשימה מקושרת). הפעולות הבסיסיות שתיארנו יתבצעו במהירות אם עץ החיפוש הוא נמוך, אך אם הוא גבוה, הביצועים לא יהיו טובים יותר מאשר מימוש באמצעות רשימה מקושרת. לכן בפוסט הבא נדבר על עצי חיפוש מאוזנים, או AVL.
diff --git a/_posts/2015-04-05-avl.md b/_posts/2015-04-05-avl.md
index 8867cf8..908080b 100644
--- a/_posts/2015-04-05-avl.md
+++ b/_posts/2015-04-05-avl.md
@@ -4,39 +4,6 @@ author: nirgn
 layout: post
 categories:
   - Data_Structures
-tags:
-  - AVL
-  - Binary
-  - Code
-  - Data
-  - Delete
-  - Insert
-  - Keys
-  - Pseudo
-  - rotation
-  - Strucutre
-  - Tree
-  - איזון
-  - בינארי
-  - בן
-  - גובה
-  - גורם
-  - הכנסה
-  - הסבר
-  - חיפוש
-  - מאמר
-  - מחיקה
-  - מפתחות
-  - סבא
-  - סדר
-  - עץ
-  - פסאודו
-  - צאצא
-  - צומת
-  - קוד
-  - רוטציה
-  - שורש
-  - שילתא
 ---
 [<img class="alignleft wp-image-1045" src="http://www.lifelongstudent.net/wp-content/uploads/2013/04/DataStructures.png" alt="Dataֹׁ Structures" width="350" height="227" srcset="http://www.lifelongstudent.net/wp-content/uploads/2013/04/DataStructures.png 400w, http://www.lifelongstudent.net/wp-content/uploads/2013/04/DataStructures-300x194.png 300w" sizes="(max-width: 350px) 100vw, 350px" />](http://www.lifelongstudent.net/wp-content/uploads/2013/04/DataStructures.png)בפוסט הקודם במבני נתונים (על עצים בינארים בכלל ועץ חיפוש בינארי בפרט) ראינו שאפשר לממש כל אחת מהפעולות הבסיסיות בזמן (O(h כאשר h הוא גבוה העץ. מהירות זאת יכולה להיות נמוכה אם העץ נמוך, אך כמו שאמרנו, אם העץ גבוה אפשר שהביצועים לא יהיו טובים יותר מאשר במימוש באמצעות רשימה מקושרת. על מנת לפתור את הבעיה הזאת קיימת גרסה אחרת של עץ חיפוש בינארי הנקראת עץ AVL. ההבדל בין הגרסאות הוא שעץ AVL הוא עץ מאוזן.
 
@@ -191,4 +158,4 @@ p[x] &lt;- y</pre>
 
 בפוסט זה למדנו על נגזרת של עצי חיפוש בינארים הנקראת עצי חיפוש בינארים מאוזנים. הבנו כיצד מבצעים פעולת הכנסה (4 אפשרויות שונות) ומחיקה (3 אפשרויות שונות) לעצים כאלו תוך שמירה על האיזון שלהם (איזון גבוה העץ). על מנת לשמור על איזון העץ למדנו כיצד לבצע רוטציה על העץ (לשנות את סדר המפתחות התוכי של העץ). 
 
-עצי חיפוש בינארי **מאוזנים** מאפשרים לנו לבצע את פעולות המילון (הכנסה ומחיקה) בזמן (O(lgn (מה שאינו מובטח אם משתמשים בעצי חיפוש בינארי רגילים). לכן השימוש בעצי AVL כ"קופסה שחורה" יכול להועיל כאשר אנו מתכננים מבני נתונים שתומכים או בפעולות המילון או בפעולות פשוטות ושימושיות אחרות שנגזרות מהן.
\ No newline at end of file
+עצי חיפוש בינארי **מאוזנים** מאפשרים לנו לבצע את פעולות המילון (הכנסה ומחיקה) בזמן (O(lgn (מה שאינו מובטח אם משתמשים בעצי חיפוש בינארי רגילים). לכן השימוש בעצי AVL כ"קופסה שחורה" יכול להועיל כאשר אנו מתכננים מבני נתונים שתומכים או בפעולות המילון או בפעולות פשוטות ושימושיות אחרות שנגזרות מהן.
diff --git a/_posts/2015-04-19-12-d4.md b/_posts/2015-04-19-12-d4.md
index f769743..b566002 100644
--- a/_posts/2015-04-19-12-d4.md
+++ b/_posts/2015-04-19-12-d4.md
@@ -4,63 +4,6 @@ author: nirgn
 layout: post
 categories:
   - Arduino
-tags:
-  - 5V
-  - A0
-  - Arduino
-  - boolean
-  - Breadboard
-  - Button
-  - Code
-  - const
-  - dealy
-  - digitalWrite
-  - 'false'
-  - for
-  - GND
-  - int
-  - LED
-  - loop
-  - Piezo
-  - Pin
-  - pinMode
-  - print
-  - Serial
-  - Servo
-  - setup
-  - 'true'
-  - אדמה
-  - אנודה
-  - אנלוגי
-  - ארדואינו
-  - דיגיטלי
-  - הסבר
-  - זרם
-  - חוט מגשר
-  - לד
-  - לוח מטריצה
-  - לולאה
-  - מאמר
-  - מדריך
-  - מטען החשמלי
-  - מנוע
-  - מתג
-  - מתח
-  - נגד
-  - נורה
-  - נעילה
-  - ספרייה
-  - סרוו
-  - ערך
-  - פונקציה
-  - פיאזו
-  - פין
-  - פרויקט
-  - קבוע
-  - קבל
-  - קוד
-  - קתודה
-  - תזוזה
 ---
 [<img class="alignleft wp-image-1281" src="http://www.lifelongstudent.net/wp-content/uploads/2014/03/Main_Arduino.png" alt="Main Arduino" width="350" height="207" />](http://www.lifelongstudent.net/wp-content/uploads/2014/03/Main_Arduino.png)בפרויקט הזה, נבנה מנגנון נעילה. אפשר לבנות את המעגל כשלעצמו, אך הרבה יותר כיף אם הוא באמת עושה משהו, לכן אם יש לכם קופסת קרטון, עץ או משהו דומה, חתכו אותה והשתמשו במנוע הסרוו על מנת לפתוח ולסגור אותה.
 
@@ -123,10 +66,10 @@ tags:
 אם הקופסא נעולה:
 
   * נקרא את הערך מרכיב ה piezo ונאחסן אותו במשתנה KnockVal.
-  * כדי להכיל רק נקישות "חוקיות", נבדוק (עם משפט <a href="http://arduino.cc/en/Reference/If" target="_blank">if</a>) האם מס' הנקישות קטן מ-3 (הרי המקסימום הוא 3), והאם knockVal גדול מ-0 (האם התקבל ערך כלשהו). 
+  * כדי להכיל רק נקישות "חוקיות", נבדוק (עם משפט <a href="http://arduino.cc/en/Reference/If" target="_blank">if</a>) האם מס' הנקישות קטן מ-3 (הרי המקסימום הוא 3), והאם knockVal גדול מ-0 (האם התקבל ערך כלשהו).
       * כדי לבדוק האם הנקישה עצמה חוקית נבדוק אותה ע"י העברת הנקישה לפונ' אחרת בשם <span style="color: #ff0000;">checkForKnock</span> שכרגע היא לא כתובה (נכתוב אותה בסוף התוכנית), ונבדוק האם התוצאה שתוחזר מהפונ' הזאת שווה ל true, אם כן נעלה את מס' הנקישות ב-1 (במקום לכתוב numberOfKnocks שווה לעצמו ועוד 1, ניתן בקיצור לכתוב <span style="color: #ff0000;">++numberOfKnocks</span>).
   * ונרצה להדפיס את מס' הנקישות שנותרו {לא רק אם הנקישה הייתה חוקית, אלא כל פעם. לכן נכתוב זאת מחוץ ל if של הפונ' checkForKnock, ז"א בתוך ה if הנוכחי (נדפיס את מס' הנקישות שנותרו [3 פחות מס' הנקישות שהוקשו עד כה, וטקסט)]}, וסיימנו גם עם ה if של מס' הנקישות קטן מ-3, לכן נסגור גם אותו עם סוגריים מסולסלים.
-  * אך מה עם מס' הנקישות גדול מ-3? אז בכלל לא ניכנס לכל הבדיקה שעשינו עד כה, לכן נישאר ב <a href="http://arduino.cc/en/Reference/If" target="_blank">if</a> של 'הקופסא נעולה' (לא סגרנו אותו עדיין), ונכתוב <a href="http://arduino.cc/en/Reference/If" target="_blank">if</a> נוסף, בו נבדוק האם מס' הנקישות גדול מ-3, אם כן: 
+  * אך מה עם מס' הנקישות גדול מ-3? אז בכלל לא ניכנס לכל הבדיקה שעשינו עד כה, לכן נישאר ב <a href="http://arduino.cc/en/Reference/If" target="_blank">if</a> של 'הקופסא נעולה' (לא סגרנו אותו עדיין), ונכתוב <a href="http://arduino.cc/en/Reference/If" target="_blank">if</a> נוסף, בו נבדוק האם מס' הנקישות גדול מ-3, אם כן:
       * נפתח את הקופסא (locked=false).
       * נסובב את מנוע הסרוו ל-0 מעלות.
       * נבצע דיילי (כדי לתת למנוע זמן לבצע את הסיבוב).
@@ -229,4 +172,4 @@ boolean checkForKnock(int value){
 
 הפרויקט סוגר ופותח את הקופסא ע"י המתג, ופותח את הקופסא ע"י הנקישות. כתבתי את הפתיחה של הקופסה גם ע"י המתג רק לבקרה. בשביל לשחק עם הפרויקט, הורידו את השורות ששולטות על פתיחת הקופסא עם המתג, כך שהמתג ינעל רק את הקופסא, והנקישות יפתחו אותה.
 
-* שימו לב שנגד בעל ערך קטן יותר שיתחבר לרכיב ה Piezo יהיה רגיש יותר לתנודות &#8211; אז אם תצטרכו חברו נגד שמתנגד פחות.
\ No newline at end of file
+* שימו לב שנגד בעל ערך קטן יותר שיתחבר לרכיב ה Piezo יהיה רגיש יותר לתנודות &#8211; אז אם תצטרכו חברו נגד שמתנגד פחות.
diff --git a/_posts/2015-05-03-13-aa-led.md b/_posts/2015-05-03-13-aa-led.md
index 9505756..46379cb 100644
--- a/_posts/2015-05-03-13-aa-led.md
+++ b/_posts/2015-05-03-13-aa-led.md
@@ -4,47 +4,6 @@ author: nirgn
 layout: post
 categories:
   - Arduino
-tags:
-  - Ardunio
-  - Breadboard
-  - Capacitive
-  - Code
-  - int
-  - LED
-  - Libraries
-  - long
-  - loop
-  - Pin
-  - Sensor
-  - setup
-  - sketchbook
-  - void
-  - אוהם
-  - ארדואינו
-  - בנאי
-  - דגימה
-  - הסבר
-  - חיבור
-  - חיישן
-  - לוח מטריצה
-  - לקמפל
-  - מאמר
-  - מגע
-  - מדריך
-  - מופע
-  - מחלקה
-  - מחשב
-  - מעגל
-  - משתנה
-  - נגד
-  - נורה
-  - ספריות
-  - ספרייה
-  - פין
-  - קוד
-  - קימפול
-  - קריאה
-  - תיקייה
 ---
 [<img class="alignleft wp-image-1281" src="http://www.lifelongstudent.net/wp-content/uploads/2014/03/Main_Arduino.png" alt="Main Arduino" width="350" height="207" />](http://www.lifelongstudent.net/wp-content/uploads/2014/03/Main_Arduino.png)בפרויקט הזה נבנה נבנה מנורת LED שתידלק כשנגע בחומר מוליך כלשהו. כמו בפרויקט ה Servo נשתמש בספרייה חיצונית, אך הפעם לא אחת המובנת ב IDE של ה Arduino, אלא בספרייה שבן אדם פרטי כתב, בחור בשם פול בדג'ר, ושמה CapacitiveSensor.
 
@@ -117,4 +76,4 @@ void loop(){
 
 הפרויקט הזה היה קטן יחסית, בלי הרבה חיבורים או הרבה קוד, אך התמקדנו בדבר חדש והוא התקנה של ספריות חיצוניות. הדבר חשוב במיוחד מכיוון שאנו לא רוצים לבנות הכל בעצמנו ואם מישהו בנה כבר ספרייה כלשהי שאנו יכולים להשתמש בה לצרכינו, אין לנו כל סיבה להמציא את הגלגל מחדש. בנוסף, שימו לב שבפרויקט הזה השתמשנו בקצה השני של החוט המגשר על מנת לסגור מעגל (ניתן גם לגעת בו, וגופנו יסגור את המעגל), כל שעשינו זה לשדר אות, לסגור את המעגל ולקרוא אותו בפין הנוסף על מנת לראות האם הוא נסגר או לא (אם אנחנו מקבלים את האות ששלחנו או לא).
 
-במידה ונתקלתם בבעיה כלשהי בעת קימפול הספרייה, להלן המדריך המלאה מאתר Arduino להתקנה של ספריות: <a href="http://arduino.cc/en/Guide/Libraries" target="_blank">http://arduino.cc/en/Guide/Libraries</a>. בנוסף, שימו לב שכשאתם מחלצים את התיקייה מתוך ה zip היא מכילה תקייה ובתוכה ישנה כבר תיקייה בשם <span style="color: #ff0000;">libraries</span>, כנסו אליה וחלצו את 2 הפרויקטים משם אל תוך תקיית ה <span style="color: #ff0000;">libraries</span> הקיימת שלכם (שלא יהיה לכם מצב של תקייה בתוך תיקייה בתוך תקייה ורק אז הפרויקטים).
\ No newline at end of file
+במידה ונתקלתם בבעיה כלשהי בעת קימפול הספרייה, להלן המדריך המלאה מאתר Arduino להתקנה של ספריות: <a href="http://arduino.cc/en/Guide/Libraries" target="_blank">http://arduino.cc/en/Guide/Libraries</a>. בנוסף, שימו לב שכשאתם מחלצים את התיקייה מתוך ה zip היא מכילה תקייה ובתוכה ישנה כבר תיקייה בשם <span style="color: #ff0000;">libraries</span>, כנסו אליה וחלצו את 2 הפרויקטים משם אל תוך תקיית ה <span style="color: #ff0000;">libraries</span> הקיימת שלכם (שלא יהיה לכם מצב של תקייה בתוך תיקייה בתוך תקייה ורק אז הפרויקטים).
diff --git a/_posts/2015-05-17-arduino-14.md b/_posts/2015-05-17-arduino-14.md
index 61225ce..689ccb2 100644
--- a/_posts/2015-05-17-arduino-14.md
+++ b/_posts/2015-05-17-arduino-14.md
@@ -4,52 +4,6 @@ author: nirgn
 layout: post
 categories:
   - Arduino
-tags:
-  - ADC
-  - Arduino
-  - Array
-  - begin
-  - bit
-  - buffer
-  - bytes
-  - draw
-  - if
-  - Image
-  - loop
-  - new
-  - Png
-  - Port
-  - Processing
-  - Serial
-  - setup
-  - Sketch
-  - USB
-  - write
-  - אובייקט
-  - ארדואינו
-  - ביט
-  - ביטים
-  - בתים
-  - חיבור
-  - טורי
-  - טורית
-  - יישום
-  - מאמר
-  - מדריך
-  - מערך
-  - נתונים
-  - סיריאלי
-  - ערך
-  - ערכים
-  - פונקציה
-  - פוקציה
-  - פורט
-  - פקודה
-  - פרמטר
-  - צבע
-  - רשימה
-  - תמונה
-  - תקשורת
 ---
 [<img class="alignleft wp-image-1281" src="http://www.lifelongstudent.net/wp-content/uploads/2014/03/Main_Arduino.png" alt="Main Arduino" width="350" height="207" />](http://www.lifelongstudent.net/wp-content/uploads/2014/03/Main_Arduino.png)בפרויקט הזה, נשתמש ב Arduino על מנת לשלוט על תוכנית במחשב שלנו (באמצעות תקשורת טורית). המעגל האלקטרוני יהיה פשוט מאוד הפעם, וכך גם הקוד של ה Arduino, נתמקד נטו בשליטה על התוכנית מחשב האחרת, באמצעות ה Arduino.
 
@@ -145,4 +99,4 @@ void draw(){
 
 ## <span style="text-decoration: underline;"><strong>לסיכום</strong></span>
 
-בפרויקט הזה התמקדנו בלמידת תוכנית חדשה בשם Processing, השפה דומה לזו שנו משתמשים ב Sketch (ה IDE של Arduino), אך מספיק שונה בשביל שנצטרך לדבר עליה ולהתנסות קצת. הפן הפיזי בפרויקט הזה היה קטן, כמו גם תכנות ה Arduino. אך התמקדנו בעיקר בתקשורת שבין התוכנות על מנת להשפיע בעזרת ה Arduino על תוכנית חדשה ושונה לגמרי שמבצעת דברים אחרים, במקרה הזה במחשב שלנו, אך את המידע ניתן להעביר גם על גבי האינטרנט ולהשפיע על תוכנית הנמצאת במחשב / בשרת מרוחק. וודאו שאתם מבינים כיצד בנינו וכתבנו את הפרויקט מכיוון שהוא מהווה קפיצת מדרגה משמועתית ובסיס לפרויקטים עתידים. כעת, נפתח בפנינו עולם חדש של אפשרויות לתקשר עם המכשירים שסביבנו ולשלוט בהם.
\ No newline at end of file
+בפרויקט הזה התמקדנו בלמידת תוכנית חדשה בשם Processing, השפה דומה לזו שנו משתמשים ב Sketch (ה IDE של Arduino), אך מספיק שונה בשביל שנצטרך לדבר עליה ולהתנסות קצת. הפן הפיזי בפרויקט הזה היה קטן, כמו גם תכנות ה Arduino. אך התמקדנו בעיקר בתקשורת שבין התוכנות על מנת להשפיע בעזרת ה Arduino על תוכנית חדשה ושונה לגמרי שמבצעת דברים אחרים, במקרה הזה במחשב שלנו, אך את המידע ניתן להעביר גם על גבי האינטרנט ולהשפיע על תוכנית הנמצאת במחשב / בשרת מרוחק. וודאו שאתם מבינים כיצד בנינו וכתבנו את הפרויקט מכיוון שהוא מהווה קפיצת מדרגה משמועתית ובסיס לפרויקטים עתידים. כעת, נפתח בפנינו עולם חדש של אפשרויות לתקשר עם המכשירים שסביבנו ולשלוט בהם.
diff --git a/_posts/2015-06-14-bfs.md b/_posts/2015-06-14-bfs.md
index 1d05c8a..53a9374 100644
--- a/_posts/2015-06-14-bfs.md
+++ b/_posts/2015-06-14-bfs.md
@@ -4,28 +4,6 @@ author: nirgn
 layout: post
 categories:
   - Algorithms
-tags:
-  - Algorithm
-  - Algorithms
-  - Array
-  - BFS
-  - Binary
-  - Code
-  - Pseudo
-  - Queue
-  - Tree
-  - אלגוריתם
-  - אלגוריתמים
-  - בינארי
-  - זמן
-  - מערך
-  - מקום
-  - סיבוכיות
-  - עץ
-  - פסאודו
-  - קוד
-  - ריצה
-  - תור
 ---
 [<img class="alignleft wp-image-1172" src="http://www.lifelongstudent.net/wp-content/uploads/2014/12/The_Friendship_Algorithm.png" alt="The Friendship Algorithm" width="300" height="209" />](http://www.lifelongstudent.net/wp-content/uploads/2014/12/The_Friendship_Algorithm.png)BFS (ראשי תיבות של Breadth First Search) &#8211; חיפוש לרוחב, הוא אלגוריתם המשתמש במבנה נתונים תור (Queue) על מנת לעבור ולהדפיס את הצמתים של עץ בינארי בצורה רוחבית (על פי הייצוג בעץ).
 
@@ -77,7 +55,7 @@ while (notEmpty (q)) do
           </li>
         </ul>
       </li>
-      
+
       <li>
         שורה 8: נבדוק האם הבן הימני של t שונה מ NIL, במקרה שלנו הוא c, ולכן ניכנס ל If: <ul>
           <li>
@@ -85,7 +63,7 @@ while (notEmpty (q)) do
           </li>
         </ul>
       </li>
-      
+
       <li>
         כעת התור, q, נראה: [b, c].
       </li>
@@ -105,7 +83,7 @@ while (notEmpty (q)) do
           </li>
         </ul>
       </li>
-      
+
       <li>
         שורה 8: נבדוק האם הבן הימני של t שונה מ NIL. והוא שווה ל e, לכן ניכנס ל If: <ul>
           <li>
@@ -113,7 +91,7 @@ while (notEmpty (q)) do
           </li>
         </ul>
       </li>
-      
+
       <li>
         כעת התור q, נראה: [c, d, e].
       </li>
@@ -133,7 +111,7 @@ while (notEmpty (q)) do
           </li>
         </ul>
       </li>
-      
+
       <li>
         שורה 8: נבדוק האם הבן הימני של t שונה מ NIL, הוא g, לכן ניכנס ל If: <ul>
           <li>
@@ -141,7 +119,7 @@ while (notEmpty (q)) do
           </li>
         </ul>
       </li>
-      
+
       <li>
         כעת התור, q, נראה: [d, e, f, g].
       </li>
@@ -179,7 +157,7 @@ while (notEmpty (q)) do
           </li>
         </ul>
       </li>
-      
+
       <li>
         שורה 8: נבדוק האם הבן הימני של t שונה מ NIL, הוא לא שונה, ולכן לא ניכנס ל If.
       </li>
@@ -247,4 +225,4 @@ while (notEmpty (q)) do
 &nbsp;
 
 **סיבוכיות זמן ריצה: (O(n**.  
-**סיבוכיות מקום: (O(1**.
\ No newline at end of file
+**סיבוכיות מקום: (O(1**.
diff --git a/_posts/2015-07-12-why-is-so-hard-to-be-a-new-developer.md b/_posts/2015-07-12-why-is-so-hard-to-be-a-new-developer.md
index fb60e64..3ab4268 100644
--- a/_posts/2015-07-12-why-is-so-hard-to-be-a-new-developer.md
+++ b/_posts/2015-07-12-why-is-so-hard-to-be-a-new-developer.md
@@ -7,26 +7,8 @@ base-images-url: 'new-developers'
 hero-image: 'hero_image.jpg'
 categories:
   - Stuff
-tags:
-  - אוניברסיטה
-  - אתגר
-  - "ג'וניור"
-  - לימודים
-  - מהנדסים
-  - מחשבים
-  - מכללה
-  - מסלול
-  - מפתח
-  - מקצוע
-  - מתחיל
-  - סטודנטים
-  - פרקטיקה
-  - ציונים
-  - תאוריה
-  - תואר
-  - תחום
 ---
-אתחיל בלהסביר שהפוסט הנל בא כתוצאה מקריאת הכתבה "<a href="http://www.itworld.com/article/2945674/careers/computer-science-students-are-in-demand-and-they-know-it.html" target="_blank">Computer science students are in demand and they know it</a>" של ITWORLD. הפוסט מציין כי ישנו ביקוש הולך וגובר לבוגרי מדעי המחשב ותחומים דומים, והבוגרים מודעים לכך. ושללכת ללמוד מדעי המחשב זהו צעד חכם, במיוחד בהתחשב במחקרים המראים ביקוש הולך וגובר.
+אתחיל בלהסביר שהפוסט הנל בא כתוצאה מקריאת הכתבה "[Computer science students are in demand and they know it](http://www.itworld.com/article/2945674/careers/computer-science-students-are-in-demand-and-they-know-it.html)" של ITWORLD. הפוסט מציין כי ישנו ביקוש הולך וגובר לבוגרי מדעי המחשב ותחומים דומים, והבוגרים מודעים לכך. ושללכת ללמוד מדעי המחשב זהו צעד חכם, במיוחד בהתחשב במחקרים המראים ביקוש הולך וגובר.
 
 <!--more-->
 
diff --git a/_posts/2015-08-09-pen-testing-introduction.md b/_posts/2015-08-09-pen-testing-introduction.md
index 8a00539..cbd05f9 100644
--- a/_posts/2015-08-09-pen-testing-introduction.md
+++ b/_posts/2015-08-09-pen-testing-introduction.md
@@ -7,61 +7,6 @@ base-images-url: 'pen-testing-part-1'
 hero-image: 'hero_image.jpg'
 categories:
   - Pen_Testing
-tags:
-  - DDoS
-  - Footprining
-  - Freenet
-  - Hacking
-  - Hidden Wiki
-  - I2P
-  - Information
-  - Internet
-  - Kali
-  - Key Logger
-  - Linux
-  - nodes
-  - Penetration Testing
-  - Phishing
-  - Proxy
-  - RAT
-  - Reverse
-  - root
-  - Rootkit
-  - Server
-  - Shell
-  - SQL Injection
-  - SSL
-  - Terminal
-  - TLS
-  - Tor
-  - Virtual Box
-  - Virus
-  - VPN
-  - VPS
-  - אינטרנט
-  - אנונימיות
-  - אפלה
-  - בדיקות חדירה
-  - דפדפן
-  - האקינג
-  - ווירוס
-  - ווירטואלי
-  - כלים
-  - לינוקס
-  - מאמר
-  - מדריך
-  - מידע
-  - סיסמה
-  - פישינג
-  - פרוקסי
-  - פרטית
-  - פריצה
-  - צמתים
-  - קלי
-  - רוט
-  - רשת
-  - שרת
-  - תקיפה
 ---
 לא ממזמן חזרתי לנושא שעניין אותי עוד מהתקופה שלי בתור נער מתבגר &#8211; בדיקות חדירה (Pen Testing ראשי תיבות של Penetration Testing). באיזשהו שלב (לא זכור לי אפילו למה) פניתי לתחומים אחרים הקשורים למחשבים (בעיקר פיתוח), אך העניין האינסופי בתחום נשאר, ולאחרונה חזרתי להתעניין בנושא. סדרת הפוסטים הקרובה תיהיה יומן מסע של תהליך הלמידה שלי את העולם הענק הנקרא בדיקות חדירה. כמו תמיד אבצע disclaimer: אינני מתיימר לדעת הכל, וכל מה שאכתוב כאן הוא מלמידה אישית שלי דרך ספרים ואתרים שונים. אינני אחראי על השימוש שתבצעו בידע שיכתב בפוסטים אלו, ו**אני נגד שימוש לרעה בידע שתצברו כאן** (יש מספיק עבודות בהם תוכלו ליישם את הידע שלכם, כך שממש אין צורך לעבור על החוק).
 
@@ -76,37 +21,37 @@ tags:
 
 <!--more-->
 
-## <span style="text-decoration: underline;"><strong>1. הכנות</strong></span>
+#### 1. הכנות
 
 מכיוון שאני רק מתחיל לחקור את העולם הזה ועדיין אין ברשותי את הידע לאן ללכת או מה לעשות, התחלתי בלהוריד ולהתקין הפצת לינוקס המגיעה עם מספר כלים לביצוע בדיקות חדירה (penetration testing) הנקראת Kali Linux (שמעתי עליה מראש, ואפשר גם <a href="https://en.wikipedia.org/wiki/Kali_Linux" target="_blank">לקרוא עליה ב wikipedia</a>).
 
 &nbsp;
 
-## <span style="text-decoration: underline;"><strong>2. מונחים בסיסיים</strong></span>
+#### 2. מונחים בסיסיים
 
 בזמן שהפצת Kali יורדת (3.1GB), הלכתי ל Google והתחלתי לקרוא על המושגים השונים ששמעתי במשך השנים:
 
-  * **Footprinting &#8211;** זהו שם המייצג את תהליך איסוף המידע. מידע זה יכול להיות ווירטואלי כמו כתובת IP של השרת, או פיזי כמו לזהות עובדים באותה החברה או תדפיסים שנזרקו לפח וכד'.
-  * **DDoS &#8211;** (ראשי תיבות של Distributed Denial-of Service או בעברית התקפת מניעת שירות) היא התקפה המשביתה מערכת ע"י יצירת עומס חריג על משאביה (עד שאינה יכולה לשרת אף משתמש אחר). בדר"כ התקפה כזאת דורשת משאבים נוספים ולכן ההכנה שלה יכולה להיות מורכבת (במידה ואתם עושים זאת לבד ולא קונים את המשאבים, ודורשת השתלטות על מספר רב של מחשבים נוספים), אך ביצוע קל יחסית ולכן נחשבת לילדותית. לדוגמה אם אני זוכר נכון, לשרת <a href="https://en.wikipedia.org/wiki/Apache_HTTP_Server" target="_blank">Apache</a> יש מגבלה (כברירת מחדל) של 10,00 בקשות, ואם אתם יכולים לשלוח 10,000 בקשות לשניה בעיקרון סתמתם את השרת, והוא לא ישרת אף חיבור אחר.
-  * **RAT &#8211;** (ראשי תיבות של  Remote Administration Tools) הוא מושג המתאר כלים המאפשרים למישהו לשלוט באופן במלא במכשירכם, מרוחק. הטריק עם הכלים האלו הוא לגרום להם להיות FUD (ראשי תיבות של Fully UnDetectable).
-  * **RootKit &#8211;** הוא כינוי לכלי המתקינים על מערכת ההפעלה, המסוגל להסתיר תהליכים הרצים ברקע מהמערכת עצמה (לדוג' כדי שהמשתמש לא יראה את התהליך רץ ב Task Manager). בה בעת, כמו כלי RAT, כלי זה מאפשר גישה מלאה למכשירכם.
-  * **Phishing &#8211;** הוא ניסיון גניבת מידע ע"י התחזות. ז"א כשמישהו משתמש בפיתיון כלשהו כדי להוליך אתכם שולל, ואתם "בולעים" אותו. לדוג' שליחת מייל עם לינק להורדת איזשהו קובץ, או שליחת לינק לאתר שנראה כמו האתר המקורי אך בפועל זה אתר שאתם הקמתם (וזאת על מנת לגנוב את שם המשתמש והסיסמה שלכם), וכד'.
-  * **SQL Injections &#8211;** זהו מקרה פרטי של קבוצת פרצות אבטחה הנגרמות עקב היכולת ל"הזריק קוד" לשירות (מדובר על היכולת ליצור קוד בזמן ריצה, כאשר תוכן הקוד אינו נוצר על ידי המתכנת ואינו נבדק על ידו). במקרה הזה מדובר על שליחת שאילתות SQL לבקשות HTTP (בדרך כלל דרך שדה קלט כלשהו), כאשר המבנה / תבנית של השאליתה אינו מסודר כמו שצריך בשרת הדבר מאפשר חשיפה של נתונים ממסד הנתונים.
-  * **VPN &#8211;** (ראשי תיבות של Virtual Private Network או בעברית רשת פרטית ווירטואלית), היא שיטה להעברת מידע פרטי על גבי רשת ציבורית. ארגונים רבים בעולם משתמשים בשיטה זו על מנת לחבר עובדים באופן מרוחק לרשת הארגונית שלהם. ומשתמשים רבים מבצעים שימוש בחברות המאפשרות להתחבר לרשת שלהם (בתמורה לסכום כספי כלשהו) על מנת שישמשו חוצץ אל מול התקשורת החיצונית (ז"א כדי שהמיקום שלך לא יוודע, אתה מתחבר ל VPN של אותה חברה וגולש דרכם כשהם מנתבים אלייך, דרך הרשת הפנימית שלהם, את המידע שמגיע אליהם מבחוץ (לאחר שעבר הצפנה). כך שמי ששלח את המידע אינו יודע שבפועל זאת הייתה הבקשה שלך). היישומים המפורסמים ביותר של רשתות VPN הם <a href="https://openvpn.net/" target="_blank">OpenVPN</a> ו <a href="https://en.wikipedia.org/wiki/IPsec" target="_blank">IPsec</a>.
-  * **[<img class="alignleft wp-image-2200" src="http://www.lifelongstudent.net/wp-content/uploads/2015/07/ProxyConcept.png" alt="Proxy Concept" width="250" height="188" srcset="http://www.lifelongstudent.net/wp-content/uploads/2015/07/ProxyConcept.png 400w, http://www.lifelongstudent.net/wp-content/uploads/2015/07/ProxyConcept-150x113.png 150w, http://www.lifelongstudent.net/wp-content/uploads/2015/07/ProxyConcept-300x225.png 300w" sizes="(max-width: 250px) 100vw, 250px" />](http://www.lifelongstudent.net/wp-content/uploads/2015/07/ProxyConcept.png)Proxy &#8211;** בדומה ל VPN, שרת פרוקסי מספק גישה למשאבים חיצוניים ברשת, ז"א שדרכו עוברים כל הבקשות (הנתונים נשלחים אליו והוא שולח אותם אל היעד, היעד מחזיר אליו את התשובה והוא שולח אותה אליכם). משמאל ניתן לראות תמונה המתארת (באופן מושפט למדי) את תהליך התקשורת מול השרת פרוקסי. השרת משמש כנקודת הפרדה בין רשת המחשבים הפנימית של הארגון ובין הרשת החיצונית, ומאפשר ניתוח של המידע לפני כניסתו לרשת הפנימית. Proxy נחשבת לשיטה פחות אמינה בכל הקשור לשמירה על פרטיות (אינני יודע עדיין למה, אך זה מה שעולה מהחפירה הקטנה שלי באינטרנט, ולכן ראיתי שלרוב מבצעים שרשור Proxy). 
-  * **Tor &#8211;** (ראשי תיבות של The Onion Router) זוהי תוכנת קוד פתוח הנועדה לאפשר גלישה אנונימית באינטרנט. התוכנה מנתבת את החבילות (Packets) דרך מחשבים אחרים המחוברים לרשת Tor עם התוכנה, עד שהחבילה יוצאת דרך אחד הצמתים (Nodes). כאשר החבילה מתחילה את דרכה, שכבת האפליקציה מוצפנת (ז"א המידע המקורי כולל כתובת ה IP של היעד מוצפן) כמה פעמים, והחבילה נשלחת "לטיול ווירטואלי" בין הצמתים (שנבחרו באופן אקראי) עד שיוצאת באחד מהם. כל אחד מהצמתים מפענח את השכבה הבאה המכילה את המידע לאן לשלוח את הבקשה הלאה, ושולח אותה מבלי לחשוף את כתובת המקור (ממנה הבקשה נשלחה). וכך גם מפחית את הסיכוי לחשיפה (גם אם מקור אחד יחשוף את היעד שלו, הבקשה עוברת דרך כמה צמתים עד שיוצאת, ובהסתמך על זה שאחד יקיים את ההסכם ולא יחשוף את המידע, הבקשה תיהיה אנונימית). יש לציין כי כבר הוכח בעבר שמפעלי הצמתים כן יכולים לנתח ולחשוף את המידע שעובר מהצומת האחרונה אל היעד במידה והתקשורת אינה משתמשת בפרוטקול <a href="https://en.wikipedia.org/wiki/Transport_Layer_Security" target="_blank">SSL (או TLS)</a>, דבר המאפשר לדלות מידע על מי המקור של הבקשה. ואף כי ישנם אתרים שחוסמים גישה דרך צמתי Tor ידועים (לדוג' לא ניתן לערוך ערכים בוויקיפדיה דרך Tor).
-  * **VPS &#8211;** (ראשי תיבות של Virtual Private Server) הוא מכונה ווירטואלית הנמכרת כשירות (ז"א חברה שבבעלותה מחשב גדול מחלקת אותו ומשכירה לך מפרט שלך עליו אתה יכול לעשות מה שאתה רוצה). מפתחים רבים משתמשים במכונות אלה בשביל להתקין סביבת פיתוח מרוחקת (או לפתח או לבצע בדיקות כנגד סביבה ספציפית). משתמשים בשירותים אלה גם כדי לאחסון שירותים שלא צריכים שרתים פיזיים אך גם שירותי אחסון כבר אינם מספיקים להם.
-  * **Key Loggers &#8211;** המונח מתאר כלים המאפשרים לחלץ מידע (הקשות מקלדת) ממקור כלשהו. ז"א להקליט את הקשות המקלדת במחשב כלשהו ושלוח אותם לאימייל ספציפי או לשרת FTP בשביל ניתוח והוצאת מידע בעל ערך. היום כלים אלה יכולים לעשות יותר מאשר להקליט הקשות מקלדת, כמו לנתר אחר תיקייה ספציפית, לקחת תמונות מסך, וכד'.
-  * **Terminal &#8211;** (או System Console) היא מעטפת גרפית ל Shell שהוא כלי שורת פקודה, המעבד את בקשות המשתמש, ואומר למערכת ההפעלה מה לעשות בהתאם. לכלים המבוססים על ה Terminal יש יתרונות רבים, בינהם פחות תלויות בספריות חיצוניות (בדר"כ ספריות GUI), קלים יותר מבחינת משקל בדיסק ומבחינת תקשורת באינטרנט (לשלוח שורת טקסט באינטרנט יהיה מהיר יותר משלוח צילום מסך, לדוג'), ועוד.
-  * **Firewall &#8211;** במקרה הזה אני מדבר על מערכת לניטור וחסימת תקשורת לא רצויה (לרשת המקומית או למחשב ספציפי), ולא Computer Firewall שהוא מחשב ייעודי המנתר את התקשורת. 
-  * **Virus &#8211;** היא תוכנה המסוגלת לבצע שכפול עצמי, ולרוב גם מסוגלת לבצע פעולות נוספות כגון מחיקת מידע, הצגת הודעה מעצבנת וכד'.
-  * **Reverse Shells &#8211;** הוא סוג של Shell בו המכונה המדובקת פותחת חיבור ומתקשרת חזרה עם המכונה התוקפת.
+* **Footprinting &#8211;** זהו שם המייצג את תהליך איסוף המידע. מידע זה יכול להיות ווירטואלי כמו כתובת IP של השרת, או פיזי כמו לזהות עובדים באותה החברה או תדפיסים שנזרקו לפח וכד'.
+* **DDoS &#8211;** (ראשי תיבות של Distributed Denial-of Service או בעברית התקפת מניעת שירות) היא התקפה המשביתה מערכת ע"י יצירת עומס חריג על משאביה (עד שאינה יכולה לשרת אף משתמש אחר). בדר"כ התקפה כזאת דורשת משאבים נוספים ולכן ההכנה שלה יכולה להיות מורכבת (במידה ואתם עושים זאת לבד ולא קונים את המשאבים, ודורשת השתלטות על מספר רב של מחשבים נוספים), אך ביצוע קל יחסית ולכן נחשבת לילדותית. לדוגמה אם אני זוכר נכון, לשרת <a href="https://en.wikipedia.org/wiki/Apache_HTTP_Server" target="_blank">Apache</a> יש מגבלה (כברירת מחדל) של 10,00 בקשות, ואם אתם יכולים לשלוח 10,000 בקשות לשניה בעיקרון סתמתם את השרת, והוא לא ישרת אף חיבור אחר.
+* **RAT &#8211;** (ראשי תיבות של  Remote Administration Tools) הוא מושג המתאר כלים המאפשרים למישהו לשלוט באופן במלא במכשירכם, מרוחק. הטריק עם הכלים האלו הוא לגרום להם להיות FUD (ראשי תיבות של Fully UnDetectable).
+* **RootKit &#8211;** הוא כינוי לכלי המתקינים על מערכת ההפעלה, המסוגל להסתיר תהליכים הרצים ברקע מהמערכת עצמה (לדוג' כדי שהמשתמש לא יראה את התהליך רץ ב Task Manager). בה בעת, כמו כלי RAT, כלי זה מאפשר גישה מלאה למכשירכם.
+* **Phishing &#8211;** הוא ניסיון גניבת מידע ע"י התחזות. ז"א כשמישהו משתמש בפיתיון כלשהו כדי להוליך אתכם שולל, ואתם "בולעים" אותו. לדוג' שליחת מייל עם לינק להורדת איזשהו קובץ, או שליחת לינק לאתר שנראה כמו האתר המקורי אך בפועל זה אתר שאתם הקמתם (וזאת על מנת לגנוב את שם המשתמש והסיסמה שלכם), וכד'.
+* **SQL Injections &#8211;** זהו מקרה פרטי של קבוצת פרצות אבטחה הנגרמות עקב היכולת ל"הזריק קוד" לשירות (מדובר על היכולת ליצור קוד בזמן ריצה, כאשר תוכן הקוד אינו נוצר על ידי המתכנת ואינו נבדק על ידו). במקרה הזה מדובר על שליחת שאילתות SQL לבקשות HTTP (בדרך כלל דרך שדה קלט כלשהו), כאשר המבנה / תבנית של השאליתה אינו מסודר כמו שצריך בשרת הדבר מאפשר חשיפה של נתונים ממסד הנתונים.
+* **VPN &#8211;** (ראשי תיבות של Virtual Private Network או בעברית רשת פרטית ווירטואלית), היא שיטה להעברת מידע פרטי על גבי רשת ציבורית. ארגונים רבים בעולם משתמשים בשיטה זו על מנת לחבר עובדים באופן מרוחק לרשת הארגונית שלהם. ומשתמשים רבים מבצעים שימוש בחברות המאפשרות להתחבר לרשת שלהם (בתמורה לסכום כספי כלשהו) על מנת שישמשו חוצץ אל מול התקשורת החיצונית (ז"א כדי שהמיקום שלך לא יוודע, אתה מתחבר ל VPN של אותה חברה וגולש דרכם כשהם מנתבים אלייך, דרך הרשת הפנימית שלהם, את המידע שמגיע אליהם מבחוץ (לאחר שעבר הצפנה). כך שמי ששלח את המידע אינו יודע שבפועל זאת הייתה הבקשה שלך). היישומים המפורסמים ביותר של רשתות VPN הם <a href="https://openvpn.net/" target="_blank">OpenVPN</a> ו <a href="https://en.wikipedia.org/wiki/IPsec" target="_blank">IPsec</a>.
+* **[<img class="alignleft wp-image-2200" src="http://www.lifelongstudent.net/wp-content/uploads/2015/07/ProxyConcept.png" alt="Proxy Concept" width="250" height="188" srcset="http://www.lifelongstudent.net/wp-content/uploads/2015/07/ProxyConcept.png 400w, http://www.lifelongstudent.net/wp-content/uploads/2015/07/ProxyConcept-150x113.png 150w, http://www.lifelongstudent.net/wp-content/uploads/2015/07/ProxyConcept-300x225.png 300w" sizes="(max-width: 250px) 100vw, 250px" />](http://www.lifelongstudent.net/wp-content/uploads/2015/07/ProxyConcept.png)Proxy &#8211;** בדומה ל VPN, שרת פרוקסי מספק גישה למשאבים חיצוניים ברשת, ז"א שדרכו עוברים כל הבקשות (הנתונים נשלחים אליו והוא שולח אותם אל היעד, היעד מחזיר אליו את התשובה והוא שולח אותה אליכם). משמאל ניתן לראות תמונה המתארת (באופן מושפט למדי) את תהליך התקשורת מול השרת פרוקסי. השרת משמש כנקודת הפרדה בין רשת המחשבים הפנימית של הארגון ובין הרשת החיצונית, ומאפשר ניתוח של המידע לפני כניסתו לרשת הפנימית. Proxy נחשבת לשיטה פחות אמינה בכל הקשור לשמירה על פרטיות (אינני יודע עדיין למה, אך זה מה שעולה מהחפירה הקטנה שלי באינטרנט, ולכן ראיתי שלרוב מבצעים שרשור Proxy). 
+* **Tor &#8211;** (ראשי תיבות של The Onion Router) זוהי תוכנת קוד פתוח הנועדה לאפשר גלישה אנונימית באינטרנט. התוכנה מנתבת את החבילות (Packets) דרך מחשבים אחרים המחוברים לרשת Tor עם התוכנה, עד שהחבילה יוצאת דרך אחד הצמתים (Nodes). כאשר החבילה מתחילה את דרכה, שכבת האפליקציה מוצפנת (ז"א המידע המקורי כולל כתובת ה IP של היעד מוצפן) כמה פעמים, והחבילה נשלחת "לטיול ווירטואלי" בין הצמתים (שנבחרו באופן אקראי) עד שיוצאת באחד מהם. כל אחד מהצמתים מפענח את השכבה הבאה המכילה את המידע לאן לשלוח את הבקשה הלאה, ושולח אותה מבלי לחשוף את כתובת המקור (ממנה הבקשה נשלחה). וכך גם מפחית את הסיכוי לחשיפה (גם אם מקור אחד יחשוף את היעד שלו, הבקשה עוברת דרך כמה צמתים עד שיוצאת, ובהסתמך על זה שאחד יקיים את ההסכם ולא יחשוף את המידע, הבקשה תיהיה אנונימית). יש לציין כי כבר הוכח בעבר שמפעלי הצמתים כן יכולים לנתח ולחשוף את המידע שעובר מהצומת האחרונה אל היעד במידה והתקשורת אינה משתמשת בפרוטקול <a href="https://en.wikipedia.org/wiki/Transport_Layer_Security" target="_blank">SSL (או TLS)</a>, דבר המאפשר לדלות מידע על מי המקור של הבקשה. ואף כי ישנם אתרים שחוסמים גישה דרך צמתי Tor ידועים (לדוג' לא ניתן לערוך ערכים בוויקיפדיה דרך Tor).
+* **VPS &#8211;** (ראשי תיבות של Virtual Private Server) הוא מכונה ווירטואלית הנמכרת כשירות (ז"א חברה שבבעלותה מחשב גדול מחלקת אותו ומשכירה לך מפרט שלך עליו אתה יכול לעשות מה שאתה רוצה). מפתחים רבים משתמשים במכונות אלה בשביל להתקין סביבת פיתוח מרוחקת (או לפתח או לבצע בדיקות כנגד סביבה ספציפית). משתמשים בשירותים אלה גם כדי לאחסון שירותים שלא צריכים שרתים פיזיים אך גם שירותי אחסון כבר אינם מספיקים להם.
+* **Key Loggers &#8211;** המונח מתאר כלים המאפשרים לחלץ מידע (הקשות מקלדת) ממקור כלשהו. ז"א להקליט את הקשות המקלדת במחשב כלשהו ושלוח אותם לאימייל ספציפי או לשרת FTP בשביל ניתוח והוצאת מידע בעל ערך. היום כלים אלה יכולים לעשות יותר מאשר להקליט הקשות מקלדת, כמו לנתר אחר תיקייה ספציפית, לקחת תמונות מסך, וכד'.
+* **Terminal &#8211;** (או System Console) היא מעטפת גרפית ל Shell שהוא כלי שורת פקודה, המעבד את בקשות המשתמש, ואומר למערכת ההפעלה מה לעשות בהתאם. לכלים המבוססים על ה Terminal יש יתרונות רבים, בינהם פחות תלויות בספריות חיצוניות (בדר"כ ספריות GUI), קלים יותר מבחינת משקל בדיסק ומבחינת תקשורת באינטרנט (לשלוח שורת טקסט באינטרנט יהיה מהיר יותר משלוח צילום מסך, לדוג'), ועוד.
+* **Firewall &#8211;** במקרה הזה אני מדבר על מערכת לניטור וחסימת תקשורת לא רצויה (לרשת המקומית או למחשב ספציפי), ולא Computer Firewall שהוא מחשב ייעודי המנתר את התקשורת. 
+* **Virus &#8211;** היא תוכנה המסוגלת לבצע שכפול עצמי, ולרוב גם מסוגלת לבצע פעולות נוספות כגון מחיקת מידע, הצגת הודעה מעצבנת וכד'.
+* **Reverse Shells &#8211;** הוא סוג של Shell בו המכונה המדובקת פותחת חיבור ומתקשרת חזרה עם המכונה התוקפת.
 
 כמובן שאין זאת רשימה מלאה או מייצגת, רק הפירוש שלי למושגים השונים שראיתי בכל מיני מקומות, כדי שאתחיל להבין מה אני קורא.
 
 &nbsp;
 
-## <u>3. סביבת עבודה</u>
+#### 3. סביבת עבודה
 
 נתחיל בהתקנת Kali על <a href="https://www.virtualbox.org/" target="_blank">Virtual Box</a>. מכיוון שההתקנה זו דומה לכל התקנת מכונה ווירטואלית רגילה אני לא אעבור על כל התהליך, אך אציין כי כשאתם יוצרים מכונה ווירטואלית חדשה ה Type שלה כמובן צריך להיות Linux וב Version בחרו Debian (דביאן) (מכיוון שהיא מבוססת עליה) 64bit. הזיכרון המומלץ הוא 2GB, והאחסון המומלץ הוא 20GB.
 
@@ -135,7 +80,7 @@ tags:
 
 &nbsp;
 
-## <u>4. אנונימיות</u>
+#### 4. אנונימיות
 
 יש כמה דרכים לנסות לשמור על אנונימיות ברשת. בראש ובראשונה, Proxy בה אנו מנתבים את התקשורת שלנו דרך כמה צמתים אחרים. שיטה זאת יכולה להיות מסוכנת כי איננו יודעים דבר אודות השרת בו החבילות שלנו (Packets) עוברות. שיטה אחרת היא להשתמש ב VPN ולהצפין את המידע העובר בינינו ובין ספק ה VPN. והשיטה בה נעסוק כרגע היא דרך Tor, המנתבת את הגלישה דרך צמתים שונים כאשר כל צומת מוסיף שכבת (המצפינה את החבילה ומוסיפה מידע נחוץ כגון להחזיר אליו את החבילה) עד שלבסוף החבילה יוצאת מאחד הצמתים אל רשת האינטרנט.
 
@@ -149,6 +94,6 @@ tags:
 
 &nbsp;
 
-## <span style="text-decoration: underline;"><strong>סיכום</strong></span>
+#### סיכום
 
 הפוסט הזה היה יותר הקדמה ויישור קו עם עצמי מאשר למידה של משהו חדש. הכנו את הסביבה בה נבלה את רוב זמננו, פירשנו והבנו מושגים ששמענו בחצי אוזן (או נזכרנו והבהרנו מושגים אותם שמענו בעבר), למדנו (או חזרנו) על מספר פקודות Bash בסיסיות אותם נצטרך לעבודה היום &#8211; יומית במערכת Linux, ולבסוף נכנסו קצת לאתרים שלא נגישים בדרכים רגילות והבנו כיצד Tor עובד ושומר (או מנסה) על האנונימיות שלנו. בפוסט הבא נמשיך לדבר בהרחבה על נושא האנונמיות ונתחיל לדבר על איסוף מידע חיצוני, ולמה לבצע את זה בכלל.
diff --git a/_posts/2015-11-01-operating-system-part-1.md b/_posts/2015-11-01-operating-system-part-1.md
index 549f264..84adb7f 100644
--- a/_posts/2015-11-01-operating-system-part-1.md
+++ b/_posts/2015-11-01-operating-system-part-1.md
@@ -7,56 +7,6 @@ base-images-url: 'operating-system-part-1'
 hero-image: 'hero_image.svg'
 categories:
   - Operating Systems
-tags:
-  - Apps
-  - c programming language
-  - Code
-  - deadlock
-  - debugging
-  - embedded
-  - executable
-  - Files
-  - Hardware
-  - INPUT
-  - Kernel
-  - machine
-  - mainframe
-  - management
-  - memory
-  - operating system
-  - OS
-  - OUTPUT
-  - process
-  - Shell
-  - system call
-  - אפליקציה
-  - גרעין
-  - הפעלה
-  - זיכרון
-  - חומרה
-  - יישום
-  - מבוזר
-  - מכונה
-  - ממשק
-  - מעבד פקודות
-  - מערכות
-  - מערכות הפעלה
-  - מערכת
-  - מערכת הפעלה
-  - מצב מיוחס
-  - מצב קיפאון
-  - משאבים
-  - ניהול
-  - ניהול זיכרון
-  - סנכרון
-  - פלט
-  - קבצים
-  - קלט
-  - קריאות מערכת
-  - שפת C
-  - שרתים
-  - תהליך
-  - תכנית ריצה
 ---
 פוסט זה הוא הראשון בסדרת פוסטים על מערכות הפעלה, ומהווה הקדמה ויישור קו תיאורטי של הנושא. אציין מראש כי הפוסטים בסדרה יהיו כבדים (בעלי מלל רב) וטכניים. הפוסטים נועדו למי שולמד מערכות הפעלה כחלק מתואר במדעי המחשב ו/או למי שמעוניין ללמוד לבד ו/או לאנשים שרק רוצים להיזכר (בראש כל פוסט יהיה תוכן עניינים). 
 
@@ -71,9 +21,12 @@ tags:
 
 &nbsp;
 
-## <span style="text-decoration: underline;"><strong>1. מהי מערכת הפעלה</strong></span>
+#### 1. מהי מערכת הפעלה
 
-<img class="alignleft size-full wp-image-2276" src="http://www.lifelongstudent.net/wp-content/uploads/2015/10/OS_Stack.png" alt="OS_Stack" width="280" height="259" srcset="http://www.lifelongstudent.net/wp-content/uploads/2015/10/OS_Stack.png 280w, http://www.lifelongstudent.net/wp-content/uploads/2015/10/OS_Stack-150x139.png 150w" sizes="(max-width: 280px) 100vw, 280px" />מערכת הפעלה היא תוכנה שמנהלת את חומרת המחשב. מערכות הפעלה גם מספקות בסיס להרצת אפליקציות שונות ומשמשות תווך בין משתמשי המחשב לבין החומרה (תמונה משמאל). למרות שמערכת ההפעלה משמשת כתווך, אין זה אומר שכל פעולה שאפליקציה או שירות מסוים יבצעו עוברת דרך מערכת ההפעלה (לכן ישנו קו בצד שמאל שמקשר בין האפליקציה ישירות לחומרה). חשבו מה היה קורה אילו כל הוראה של תוכנית משתמש הייתה מצריכה פנייה לממשק המשתמש ומשם לגרעין מערכת ההפעלה (kernel), איזה דיילי ועל כמה משאבים מבוזבזים מדובר. ובמקרים מסויימים, אין צורך אפילו בפנייה לחומרה (לדוג' כאשר תוכנית מסויימת מבקשת לבצע הוראה הדורשת קיום הרשאה מיוחדת, ההרשאה תיתן ע"י מערכת ההפעלה, ללא קשר לחומרה).
+<div class="left">
+  <img src="/assets/img/posts/operating-system-part-1/os_stack.jpg" alt="OS Stack">
+</div>
+מערכת הפעלה היא תוכנה שמנהלת את חומרת המחשב. מערכות הפעלה גם מספקות בסיס להרצת אפליקציות שונות ומשמשות תווך בין משתמשי המחשב לבין החומרה (תמונה משמאל). למרות שמערכת ההפעלה משמשת כתווך, אין זה אומר שכל פעולה שאפליקציה או שירות מסוים יבצעו עוברת דרך מערכת ההפעלה (לכן ישנו קו בצד שמאל שמקשר בין האפליקציה ישירות לחומרה). חשבו מה היה קורה אילו כל הוראה של תוכנית משתמש הייתה מצריכה פנייה לממשק המשתמש ומשם לגרעין מערכת ההפעלה (kernel), איזה דיילי ועל כמה משאבים מבוזבזים מדובר. ובמקרים מסויימים, אין צורך אפילו בפנייה לחומרה (לדוג' כאשר תוכנית מסויימת מבקשת לבצע הוראה הדורשת קיום הרשאה מיוחדת, ההרשאה תיתן ע"י מערכת ההפעלה, ללא קשר לחומרה).
 
 החץ מהחומרה אל גרעין המערכת (Kernel) מתייחס למקרים בהן אין צורך בפנייה לחומרה, אך ישנו צורך בפנייה אל ה kernel (כמו שניתן לשים לב, אין חץ ישיר ממלבן האפליקציות אל גרעין המערכת). כאשר הוראות כאלו מגיעות (מכונות גם הוראות מיוחסות) המעבד עובר למצב המכונה מצב מיוחס (kernel mode או supervisor mode), בעוד הוראות שאינן מיוחסות מתבצעות במצב משתמש (user mode), ז"א שהמעבד מספק תמיכה כדי שמערכת ההפעלה תוכל להגן על משאביה. ההגנה מיועדת לחסום את אפשרות ההתערבות של המשתמשים בפעולתה של המערכת עצמה (בפועל, ההבחנה בין מצב מיוחס למצב משתמש נעשית ע"י מידור של קבוצת פקודות מכונה מיוחסות שאינן עומדות לעולם לרשות המשתמש הרגיל).
 
@@ -86,9 +39,13 @@ tags:
 
 &nbsp;
 
-## **<span style="text-decoration: underline;">2. ההיסטוריה של מערכות ההפעלה</span>**
+#### 2. ההיסטוריה של מערכות ההפעלה
 
-[<img class="alignleft wp-image-2284" src="http://www.lifelongstudent.net/wp-content/uploads/2015/10/Punched_Cards_Programming.png" alt="Punched_Cards_Programming" width="350" height="331" srcset="http://www.lifelongstudent.net/wp-content/uploads/2015/10/Punched_Cards_Programming.png 400w, http://www.lifelongstudent.net/wp-content/uploads/2015/10/Punched_Cards_Programming-150x142.png 150w, http://www.lifelongstudent.net/wp-content/uploads/2015/10/Punched_Cards_Programming-300x284.png 300w" sizes="(max-width: 350px) 100vw, 350px" />](http://www.lifelongstudent.net/wp-content/uploads/2015/10/Punched_Cards_Programming.png)במחשבים הראשונים, ללא מערכות ההפעלה, כל תוכנית הייתה צריכה מפרט מלא של החומרה כדי לפעול כראוי ולבצע משימות סטנדרטיות. והמורכבות ההולכת וגדלה של החומרה ושל התוכניות (האפליקציות) הפכו בסופו של דבר את מערכות ההפעלה להכרח. מערכת ההפעלה מספקת סט של פונקציות נחוצות המשמשת את רוב תוכניות המחשב (האפליקציות), ולינקים הדרושים כדי לשלוט ולסנכרן את חומרת המחשב.
+<div class="left">
+  <img src="/assets/img/posts/operating-system-part-1/punched_cards_programming.jpg" alt="Punched Cards Programming">
+</div>
+
+במחשבים הראשונים, ללא מערכות ההפעלה, כל תוכנית הייתה צריכה מפרט מלא של החומרה כדי לפעול כראוי ולבצע משימות סטנדרטיות. והמורכבות ההולכת וגדלה של החומרה ושל התוכניות (האפליקציות) הפכו בסופו של דבר את מערכות ההפעלה להכרח. מערכת ההפעלה מספקת סט של פונקציות נחוצות המשמשת את רוב תוכניות המחשב (האפליקציות), ולינקים הדרושים כדי לשלוט ולסנכרן את חומרת המחשב.
 
 המחשבים הראשונים היו מחשבי mainframe (מחשבים מרכזיים חסרי כל צורה של מערכת הפעלה). לכל משתמש היה שימוש בלעדי של המכונה לתקופה קצובה של זמן, והיה מגיע עם התוכנית והנתונים מראש (על <a href="https://en.wikipedia.org/wiki/Punched_card" target="_blank">כרטיסי נייר מנוקבים</a> וסרטים מגנטיים). התוכנית הייתה נטענת למכונה, והמכונה הייתה מוגדרת לעבוד עד שהתוכנית הושלמה או התרסקה (ניתן היה לדבג, Debugging, באמצעות לוח בקרה עם מתגים ונוריות). עם הזמן חל שינוי משמעותי של ממשק מערכות ההפעלה ובדיוק כמו מכוניות ישנות שהיו חסרות מהירות האצה, מכשיר רדיו, מזגן, וכד' שהפכו אח"כ לסטנדרטיים, כך יותר ויותר מהתוכנות האופציונליות (עורכי טקסט, מנהלי קבצים, דפדפן, וכד') הפכו לסטנדרט בכל חבילה של מערכת הפעלה. אך הצאצא האמיתי של מערכות ההפעלה המוקדמות הוא מה שנקרא היום ליבה / גרעין (kernel).
 
@@ -100,7 +57,7 @@ tags:
 
 &nbsp;
 
-## **<span style="text-decoration: underline;">3. גן החיות של מערכות ההפעלה</span>**
+#### 3. גן החיות של מערכות ההפעלה
 
 במהלך השנים התפתחו סוגים רבים ושונים של מערכות הפעלה, שלכל אחת ייעוד מרכזי משלה. בשנים האחרונות הרבה מסוגים אלו מתמזגים ומתאחדים, בעיקר בגלל ההתקדמות במחשוב האישי. למרות זאת בפסקה זו אציג בקצרה את הסוגים העיקריים של מערכות ההפעלה, גם אם כבר אינן איתנו. להלן הסוגים העיקריים:
 
@@ -114,29 +71,31 @@ tags:
 
 &nbsp;
 
-## <span style="text-decoration: underline;"><strong>4. מושגים בסיסיים</strong></span>
-
-[<img class="alignleft wp-image-2291" src="http://www.lifelongstudent.net/wp-content/uploads/2015/10/Ubuntu_Terminal.png" alt="Ubuntu_Terminal" width="280" height="228" srcset="http://www.lifelongstudent.net/wp-content/uploads/2015/10/Ubuntu_Terminal.png 724w, http://www.lifelongstudent.net/wp-content/uploads/2015/10/Ubuntu_Terminal-150x122.png 150w, http://www.lifelongstudent.net/wp-content/uploads/2015/10/Ubuntu_Terminal-300x244.png 300w" sizes="(max-width: 280px) 100vw, 280px" />](http://www.lifelongstudent.net/wp-content/uploads/2015/10/Ubuntu_Terminal.png)במהלך הפוסטים הבאים נעמיק יותר בנושאים הבאים, אך כדי כבר להכירם היכרות ראשונית ולהבין באופן כללי את משמעותם נעבור עליהם באופן מהיר:
+#### 4. מושגים בסיסיים
 
-  * **תהליך (process) &#8211;** תכנית ריצה (executable) בביצוע. באופן בסיסי, תהליך מכיל את התכנית עצמה (code), את התונים שהיא יוצרת ומשתמשת בהם (data), מצביע למחסנית, מונה פקודות, ואוגרים אחרים שמכילים מידע על הסטטוס הנוכחי של הביצוע (התהליך גם מכיל מידע על הקבצים שהוא משתמש בהם, ונתונים רבים נוספים, אך על זה נרחיב בהמשך).
-  * **מצב קיפאון (deadlock) &#8211;** קבוצה של תהליכים נמצאת במצב קיפאון אם כל אחד מהתהליכים אינו יכול להתקדם אלא לאחר שיקרה אירוע אשר יכול להיגרם אך ורק על ידי תהליך אחר בקבוצה. תופעת הקיפאון בצורתה הפשוטה ביותר מתרחשת כאשר קיימים מינימום של שני תהליכים, שכל אחד מחזיק ברשותו משאב בלעדי הנחוץ לתהליך השני. במצב זה אף אחד מהתהליכים אינו יכול להתקדם.
-  * **ניהול זיכרון (memory management) &#8211;** בהמשך נדבר על שיטות ניהול זיכרון המאפשרות לשכן בו זמנית מספר תהליכים בזיכרון, ואף בחלק מהמקרים להריץ תוכניות שמשתמשות בכמות של זיכרון גדולה יותר מהזיכרון הפיזי.
-  * **קלט / פלט (input / output) &#8211;** התקן קלט / פלט הוא רכיב חומרה אשר נועד לאחסן ו/או להעברת מידע. לדוג' דיסק קשיח, דיסק און קיי, כרטיס רשת וכ'ו. ישנם התקני קלט / פלט אשר משמשים כהתקני קלט בלבד (לדוג' עכבר ומקלדת), או כהתקני פלט בלבד (לדוג' מדפסת ומסך). אחד התפקידים החשובים ביותר של מערכת ההפעלה הוא הניהול של התקנים אלו.
-  * **קבצים (files) &#8211;** קובץ הוא יחידת מידע לוגית לאחסון במדיה חיצונית. כיוון שקבצים הם מבנים לוגיים, מימושים נעשה בתוכנה ולא בחומרה. מערכת ניהול הקבצים (שהיא חלק ממערכת ההפעלה) אחראית למימוש הקבצים.
-  * **מעבד פקודות סדרתי (shell) &#8211;** תכנית המהווה ממשק אינטראקטיבי למערכת ההפעלה. ה shell מקבל פקודות שמוקלדות ע"י המשתמש ומבצע אותן על ידי שימוש בשירותי מערכת ההפעלה.
+<div class="left">
+  <img src="/assets/img/posts/operating-system-part-1/ubuntu_terminal.jpg" alt="Ubuntu Terminal">
+</div>
 
-&nbsp;
+במהלך הפוסטים הבאים נעמיק יותר בנושאים הבאים, אך כדי כבר להכירם היכרות ראשונית ולהבין באופן כללי את משמעותם נעבור עליהם באופן מהיר:
 
-## <span style="text-decoration: underline;"><strong>5. קריאות מערכת</strong></span>
+* **תהליך (process) &#8211;** תכנית ריצה (executable) בביצוע. באופן בסיסי, תהליך מכיל את התכנית עצמה (code), את התונים שהיא יוצרת ומשתמשת בהם (data), מצביע למחסנית, מונה פקודות, ואוגרים אחרים שמכילים מידע על הסטטוס הנוכחי של הביצוע (התהליך גם מכיל מידע על הקבצים שהוא משתמש בהם, ונתונים רבים נוספים, אך על זה נרחיב בהמשך).
+* **מצב קיפאון (deadlock) &#8211;** קבוצה של תהליכים נמצאת במצב קיפאון אם כל אחד מהתהליכים אינו יכול להתקדם אלא לאחר שיקרה אירוע אשר יכול להיגרם אך ורק על ידי תהליך אחר בקבוצה. תופעת הקיפאון בצורתה הפשוטה ביותר מתרחשת כאשר קיימים מינימום של שני תהליכים, שכל אחד מחזיק ברשותו משאב בלעדי הנחוץ לתהליך השני. במצב זה אף אחד מהתהליכים אינו יכול להתקדם.
+* **ניהול זיכרון (memory management) &#8211;** בהמשך נדבר על שיטות ניהול זיכרון המאפשרות לשכן בו זמנית מספר תהליכים בזיכרון, ואף בחלק מהמקרים להריץ תוכניות שמשתמשות בכמות של זיכרון גדולה יותר מהזיכרון הפיזי.
+* **קלט / פלט (input / output) &#8211;** התקן קלט / פלט הוא רכיב חומרה אשר נועד לאחסן ו/או להעברת מידע. לדוג' דיסק קשיח, דיסק און קיי, כרטיס רשת וכ'ו. ישנם התקני קלט / פלט אשר משמשים כהתקני קלט בלבד (לדוג' עכבר ומקלדת), או כהתקני פלט בלבד (לדוג' מדפסת ומסך). אחד התפקידים החשובים ביותר של מערכת ההפעלה הוא הניהול של התקנים אלו.
+* **קבצים (files) &#8211;** קובץ הוא יחידת מידע לוגית לאחסון במדיה חיצונית. כיוון שקבצים הם מבנים לוגיים, מימושים נעשה בתוכנה ולא בחומרה. מערכת ניהול הקבצים (שהיא חלק ממערכת ההפעלה) אחראית למימוש הקבצים.
+* **מעבד פקודות סדרתי (shell) &#8211;** תכנית המהווה ממשק אינטראקטיבי למערכת ההפעלה. ה shell מקבל פקודות שמוקלדות ע"י המשתמש ומבצע אותן על ידי שימוש בשירותי מערכת ההפעלה.
 
 &nbsp;
 
+#### 5. קריאות מערכת
+
 מערכת ההפעלה לא רק מנהלת את החומרה, אלא גם צריכה להגן על משאבי המערכת (לדוג', מפני הרצה של קוד זדוני במעבד). הגנה כזאת איננה יכולה להיות תוכנתית, מכיוון שאם מערכת ההפעלה תקבל כל פקודה ופקודה ותצטרך לנתח אותה (ואולי גם בהתאם לפקודות הקודמות שקיבלה מאותה תוכנית) לפני העברתה למעבד הדבר ישפיע בצורה קריטית על משאבי המערכת (בהנחה וזה בכלל אפשרי, הרי שורת קוד אחת לבדה יכולה להיות תמימה, אך בצירוף כמה שורות נוספות יהיה מדובר כבר על קוד זדוני שיכול להסב למערכת נזק).
 
 לכן, המסקנה היא שההגנה צריכה להיות חומרתית, ז"א ביט דלוק (1) או מכובה (0) שמייצג מצב מיוחס (kernel mode) או מצב משתמש (user mode). כאשר תוכנה מסויימת מבקשת את השירותים של המעבד, כדי לבצע חישוב כלשהו, המערכת תעביר את הביט במעבד למצב user mode ותעביר את השליטה לאותה תוכנה כדי לבצע את חישוביה. מכאן ישנן 2 אפשרויות:
 
-  * הראשון הוא שהתוכנה תסיים את פעולותיה ותחזיר את המעבד למערכת ההפעלה, אך נזכור שכרגע המעבד במצב user mode ואי אפשר לבצע איתו פעולות מסויימות, כמו לדוג' להדליק את הביט ולהעביר את המעבד למצב kernel mode. אז נשארנו נעולים ב user mode, עד מתי? עד איזה time out? (אז מי מבטיח שהתוכנה תחזיר את משאבי המעבד למערכת ההפעלה לפני ה time out ולא תשאיר אותו אצלה גם אחרי שיקרה ה time out והמעבד יחזור למצב kernel mode?).
-  * האפשרות השניה היא שהתוכנה תשאיר אצלה את המעבד עד אין סוף, ולא תחזיר את המשאבים למערכת ההפעלה, ובקיצור תתקע את המחשב. 
+* הראשון הוא שהתוכנה תסיים את פעולותיה ותחזיר את המעבד למערכת ההפעלה, אך נזכור שכרגע המעבד במצב user mode ואי אפשר לבצע איתו פעולות מסויימות, כמו לדוג' להדליק את הביט ולהעביר את המעבד למצב kernel mode. אז נשארנו נעולים ב user mode, עד מתי? עד איזה time out? (אז מי מבטיח שהתוכנה תחזיר את משאבי המעבד למערכת ההפעלה לפני ה time out ולא תשאיר אותו אצלה גם אחרי שיקרה ה time out והמעבד יחזור למצב kernel mode?).
+* האפשרות השניה היא שהתוכנה תשאיר אצלה את המעבד עד אין סוף, ולא תחזיר את המשאבים למערכת ההפעלה, ובקיצור תתקע את המחשב. 
 
 מה שמכריח את התוכנה להחזיר את משאבי המעבד חזרה למערכת ההפעלה הוא system call. ישנן מספר פעולות שאינן יכולות להתבצע ב user mode, אלא אך ורק ב kernel mode. כשהתוכנה רוצה לבצע את אחת מהפעולות הללו (לדוג', להתחיל תהליך חדש, או לקרוא ולכתוב אל מערכת הקבצים) היא מבצעת system call כדי לבקש ממערכת ההפעלה לעשות זאת בשבילה. בעת ביצוע ה system call מורמת פסיקה (Interrupt) שנתפסת ע"י בקר הפסיקות (PIC &#8211; ראשי תיבות של Programmable Interrupt Controller. בקר הפסיקות הינו רכיב פיזי, לדוג' <a href="https://en.wikipedia.org/wiki/Intel_8259" target="_blank">Intel 8259</a>), והוא זה שמעביר את השליטה למערכת ההפעלה ומדליק את הביט במעבד כדי להעבירו למצב מיוחס (kernel mode).
 
@@ -146,7 +105,8 @@ tags:
 
 כדי להבין כיצד עוברת השליטה למערכת ההפעלה בעת הקריאה פונקציות אשר מכילות קריאת מערכת, להלן תוכנית בשפת C המדפיסה "hello world" על המסך, ומשתמשת בפונ' write אשר מכילה קריאה לשירות של מערכת ההפעלה.
 
-<pre class="lang:c decode:true">#include &lt;unistd.h&gt;
+```c
+#include &lt;unistd.h&gt;
 #include &lt;string.h&gt;
 #define STDOUT 1
 
@@ -155,11 +115,13 @@ int main(){
     if (write(STDOUT, msg, strlen(msg)) &lt; 0)
         exit(1);
     return(0);
-}</pre>
+}
+```
 
 להלן התוכנית בשפת assembly שמבצעת את המשימה:
 
-<pre class="lang:asm decode:true ">.data			# Data section
+```c
+.data			# Data section
 
 msg:	.asciz "Hello world\n"	# The string to print
 	len = . - msg - 1	# The length of the string
@@ -181,7 +143,8 @@ mov1	$1, %eax	# Exit
 
 do_syscall:
 	int	$0x80		# Call kernel
-	ret</pre>
+	ret
+```
 
 בשורות 10-12 מתבצעת העברת שלושה פרמטרים המכילים אינדיקציה של יעד הפלט (STDOUT), מצביע להודעה הנפלטת, ומספר התווים שבהודעת. בשורה 13 מועבר מספר השירות המסופק על ידי מערכת ההפעלה (במקרה שלנו write). ובשורה 22 מתבצעת הוראת TRAP שמעבירה את המעבד למצב מיוחס וגורמת למעבר השליטה למערכת ההפעלה.
 
@@ -189,388 +152,57 @@ do_syscall:
 
 להלן הרשימה של הקריאות מערכת (system calls) במערכות UNIX:
 
-<table style="border-color: #000000;" border="1">
-  <tr>
-    <td style="text-align: left;">
-      <span style="text-decoration: underline;"><strong>Description</strong></span>
-    </td>
-
-    <td style="text-align: left;">
-      <span style="text-decoration: underline;"><strong>WIN32</strong></span>
-    </td>
-
-    <td style="text-align: left;">
-      <span style="text-decoration: underline;"><strong>UNIX</strong></span>
-    </td>
-  </tr>
-
-  <tr>
-    <td style="text-align: left;">
-      Create a new process
-    </td>
-
-    <td style="text-align: left;">
-      CreateProcess
-    </td>
-
-    <td style="text-align: left;">
-      fork
-    </td>
-  </tr>
-
-  <tr>
-    <td style="text-align: left;">
-      Can wait for a process to exit
-    </td>
-
-    <td style="text-align: left;">
-      WaitForSingleObject
-    </td>
-
-    <td style="text-align: left;">
-      waitpid
-    </td>
-  </tr>
-
-  <tr>
-    <td style="text-align: left;">
-      CreateProcess = fork + execve
-    </td>
-
-    <td style="text-align: left;">
-      (none)
-    </td>
-
-    <td style="text-align: left;">
-      execve
-    </td>
-  </tr>
-
-  <tr>
-    <td style="text-align: left;">
-      Terminate execution
-    </td>
-
-    <td style="text-align: left;">
-      ExitProcess
-    </td>
-
-    <td style="text-align: left;">
-      exit
-    </td>
-  </tr>
-
-  <tr>
-    <td style="text-align: left;">
-      Create a file or open an existing file
-    </td>
-
-    <td style="text-align: left;">
-      CreateFile
-    </td>
-
-    <td style="text-align: left;">
-      open
-    </td>
-  </tr>
-
-  <tr>
-    <td style="text-align: left;">
-      Close a file
-    </td>
-
-    <td style="text-align: left;">
-      CloseHandle
-    </td>
-
-    <td style="text-align: left;">
-      close
-    </td>
-  </tr>
-
-  <tr>
-    <td style="text-align: left;">
-      Read data from a file
-    </td>
-
-    <td style="text-align: left;">
-      ReadFile
-    </td>
-
-    <td style="text-align: left;">
-      read
-    </td>
-  </tr>
-
-  <tr>
-    <td style="text-align: left;">
-      Write data to a file
-    </td>
-
-    <td style="text-align: left;">
-      WriteFile
-    </td>
-
-    <td style="text-align: left;">
-      write
-    </td>
-  </tr>
-
-  <tr>
-    <td style="text-align: left;">
-      Move the file pointer
-    </td>
-
-    <td style="text-align: left;">
-      SetFilePointer
-    </td>
-
-    <td style="text-align: left;">
-      lseek
-    </td>
-  </tr>
-
-  <tr>
-    <td style="text-align: left;">
-      Get various file attributes
-    </td>
-
-    <td style="text-align: left;">
-      GetFileAtterbutesEx
-    </td>
-
-    <td style="text-align: left;">
-      stat
-    </td>
-  </tr>
-
-  <tr>
-    <td style="text-align: left;">
-      Create a new directory
-    </td>
-
-    <td style="text-align: left;">
-      CreateDirectory
-    </td>
-
-    <td style="text-align: left;">
-      mkdir
-    </td>
-  </tr>
-
-  <tr>
-    <td style="text-align: left;">
-      Remove an empty directory
-    </td>
-
-    <td style="text-align: left;">
-      RemoveDirectory
-    </td>
-
-    <td style="text-align: left;">
-      rmdir
-    </td>
-  </tr>
-
-  <tr>
-    <td style="text-align: left;">
-      Win32 does not support links
-    </td>
-
-    <td style="text-align: left;">
-      (none)
-    </td>
-
-    <td style="text-align: left;">
-      link
-    </td>
-  </tr>
-
-  <tr>
-    <td style="text-align: left;">
-      Destroy an existing file
-    </td>
-
-    <td style="text-align: left;">
-      DeleteFile
-    </td>
-
-    <td style="text-align: left;">
-      unlink
-    </td>
-  </tr>
-
-  <tr>
-    <td style="text-align: left;">
-      Win32 does not support mount
-    </td>
-
-    <td style="text-align: left;">
-      (none)
-    </td>
-
-    <td style="text-align: left;">
-      mount
-    </td>
-  </tr>
-
-  <tr>
-    <td style="text-align: left;">
-      Win32 does not support mount
-    </td>
-
-    <td style="text-align: left;">
-      (none)
-    </td>
-
-    <td style="text-align: left;">
-      umount
-    </td>
-  </tr>
-
-  <tr>
-    <td style="text-align: left;">
-      Change the current working directory
-    </td>
-
-    <td style="text-align: left;">
-      SetCurrentDirectory
-    </td>
-
-    <td style="text-align: left;">
-      chdir
-    </td>
-  </tr>
-
-  <tr>
-    <td style="text-align: left;">
-      Win32 does not support securiry (although NT does)
-    </td>
-
-    <td style="text-align: left;">
-      (none)
-    </td>
-
-    <td style="text-align: left;">
-      chmod
-    </td>
-  </tr>
-
-  <tr>
-    <td style="text-align: left;">
-      Win32 does not support signals
-    </td>
-
-    <td style="text-align: left;">
-      (none)
-    </td>
-
-    <td style="text-align: left;">
-      kill
-    </td>
-  </tr>
-
-  <tr>
-    <td style="text-align: left;">
-      Get the current time
-    </td>
-
-    <td style="text-align: left;">
-      GetLocalTime
-    </td>
-
-    <td style="text-align: left;">
-      time
-    </td>
-  </tr>
-</table>
+| UNIX | WIN32	| Description |
+| :---------:|:-----:|:----:|
+| fork | CreateProcess	| Create a new process	|
+| waitpid | WaitForSingleObject | Can wait for a process to exit |
+| execve | (none) | CreateProcess = fork + execve |
+| exit | ExitProcess | Terminate execution |
+| open | CreateFile | Create a file or open an existing file |
+| close | CloseHandle | Close a file |
+| read | ReadFile | Read data from a file	|
+| write | WriteFile | Write data to a file |
+| lseek | SetFilePointer | Move the file pointer |
+| stat | GetFileAtterbutesEx | Get various file attributes |
+| mkdir | CreateDirectory | Create a new directory |
+| rmdir | RemoveDirectory | Remove an empty directory |
+| link | (none) | Win32 does not support links |
+| unlink | DeleteFile | Destroy an existing file |
+| mount | (none) | Win32 does not support mount |
+| umount | (none) | Win32 does not support mount |
+| chdir | SetCurrentDirectory | Change the current working directory |
+| chmod | (none) | Win32 does not support securiry (although NT does)	|
+| kill | (none) | Win32 does not support signals |
+| time | GetLocalTime | Get the current time |
+
+<div class="left" style="width: 35%">
+  <img src="/assets/img/posts/operating-system-part-1/monolithic_systems.jpg" alt="Monolithic Systems">
+</div>
 
 &nbsp;
 
-## <span style="text-decoration: underline;"><strong><a href="http://www.lifelongstudent.net/wp-content/uploads/2015/10/monolithic_systems.jpeg"><img class="alignleft wp-image-2311" src="http://www.lifelongstudent.net/wp-content/uploads/2015/10/monolithic_systems.jpeg" alt="monolithic_systems" width="300" height="139" srcset="http://www.lifelongstudent.net/wp-content/uploads/2015/10/monolithic_systems.jpeg 1088w, http://www.lifelongstudent.net/wp-content/uploads/2015/10/monolithic_systems-150x69.jpeg 150w, http://www.lifelongstudent.net/wp-content/uploads/2015/10/monolithic_systems-300x139.jpeg 300w, http://www.lifelongstudent.net/wp-content/uploads/2015/10/monolithic_systems-1024x473.jpeg 1024w" sizes="(max-width: 300px) 100vw, 300px" /></a>6. המבנה של מערכות הפעלה</strong></span>
+#### 6. המבנה של מערכות הפעלה
 
 מערכות הפעלה הן מערכות גדולות, המכילות, לרוב, עשרות ולפעמים מאות אלפי שורות קוד. אך כדי שכל האופרציה הזאת תפעל כשורה דרוש עיצוב כללי כלשהו, ולכל מערכת יש רעיון עיצובי משלה:
 
-  * מערכות מונוליתיות (monolithic systems) &#8211; מערכת מונוליתית היא למעשה אוסף גדול של פונקציות שונות.
-  * מערכות מרובדות (layered systems) &#8211; אלו הן מערכות שמרכיביהן מאורגנים ברבדים הנמצאים ביחס היררכי. לכל רובד מוגדר ממשק שדרכו הרבדים הסמוכים בהיררכיה יכולים לתקשר בינהם.
-
-<table>
-  <tr>
-    <td style="text-align: left;">
-      <strong><span style="text-decoration: underline;">Function</span></strong>
-    </td>
-
-    <td style="text-align: left;">
-      <strong><span style="text-decoration: underline;">Layer</span></strong>
-    </td>
-  </tr>
-
-  <tr>
-    <td style="text-align: left;">
-      The operator
-    </td>
-
-    <td style="text-align: left;">
-      5
-    </td>
-  </tr>
-
-  <tr>
-    <td style="text-align: left;">
-      User programs
-    </td>
-
-    <td style="text-align: left;">
-      4
-    </td>
-  </tr>
-
-  <tr>
-    <td style="text-align: left;">
-      input/output management
-    </td>
-
-    <td style="text-align: left;">
-      3
-    </td>
-  </tr>
-
-  <tr>
-    <td style="text-align: left;">
-      Operator-process communication
-    </td>
-
-    <td style="text-align: left;">
-      2
-    </td>
-  </tr>
-
-  <tr>
-    <td style="text-align: left;">
-      Memory and drum management
-    </td>
-
-    <td style="text-align: left;">
-      1
-    </td>
-  </tr>
-
-  <tr>
-    <td style="text-align: left;">
-      Processor allocation and multiprogramming
-    </td>
-
-    <td style="text-align: left;">
-    </td>
-  </tr>
-</table>
-
-  * מכונה מדומה (virtual machine) &#8211; בחלק הראשון ראינו שאחד התפקידים של מערכת ההפעלה הוא אספקה של שירותים של המכונה המורחבת ושל המכונה המדומה. ניתן לראות את מערכת ההפעלה כשכבת תוכנה המספקת לשכבות שמעליה מס' העתקים של החומרה עם כמות משאבים פחותה מזו שבחומרה הפיזית בפועל (במובן מסוים זו אינה מערכת הפעלה רגילה, שכן על כל מכונה מדומה יכולה לרוץ מערכת הפעלה חדשה). התוכונות הפופלריות בשוק כדי ליצור ולהפעיל מכונות מדומות הן <a href="https://www.virtualbox.org/wiki/Downloads" target="_blank">virtualbox</a> של חברת oracle ו <a href="http://www.vmware.com/il" target="_blank">vmware</a>.
-  * מערכות Exokernel &#8211; במערכות אלה השירותים המסורתיים כגון מערכת קבצים, ניהול זיכרון, תזמון תהליכים ותקשורת הוצאו אל מחוץ לגרעין של מערכת ההפעלה. ההחלטה הזאת נובעת מכך שמערכת ההפעלה איננה כופה על המשתמש את צורת השימוש במשאבים (אלא רק דואגת להגנה על המשאבים וניהולם).
-  * מערכות שרת לקוח (client &#8211; server systems) &#8211; מערכות שרת לקוח מבוססות על הרעיון של גרעין מנינימליסטי (micro kernel), ז"א גרעיון מערכת ההפעלה מתפקד כדוור המריץ בקשות של לקוחות (תהליכים) אל שרתים עצמאיים (גם תהליכים), המפוזרים במערכת, כגון שרתי מערכת הקבצים, מנהל הזיכרון, תכנית התקשורת, תכנית המסך (מנהל חלונות), וכ'ו. כאשר מתקבלות תשובות מהשרתים, הגרעין מחזיר את התשובה להתליך המבקש. בשיטה זו התוכנה מורכבת מיחידות עצמאיות, שכל אחת מהן ממלאת תפקיד מוגדר. שיטה זו מצמצת מאוד את התלות בחומרה.
+* מערכות מונוליתיות (monolithic systems) - מערכת מונוליתית היא למעשה אוסף גדול של פונקציות שונות.
+* מערכות מרובדות (layered systems) - אלו הן מערכות שמרכיביהן מאורגנים ברבדים הנמצאים ביחס היררכי. לכל רובד מוגדר ממשק שדרכו הרבדים הסמוכים בהיררכיה יכולים לתקשר בינהם.
+
+| Function | Layer|
+|:----:|:--------:|
+| The operator | 5 |
+| User programs | 4 |
+| input/output management | 3 |
+| Operator-process communication | 2 |
+| Memory and drum management | 1 |
+| Processor allocation and multiprogramming | 0 |
+
+* מכונה מדומה (virtual machine) &#8211; בחלק הראשון ראינו שאחד התפקידים של מערכת ההפעלה הוא אספקה של שירותים של המכונה המורחבת ושל המכונה המדומה. ניתן לראות את מערכת ההפעלה כשכבת תוכנה המספקת לשכבות שמעליה מס' העתקים של החומרה עם כמות משאבים פחותה מזו שבחומרה הפיזית בפועל (במובן מסוים זו אינה מערכת הפעלה רגילה, שכן על כל מכונה מדומה יכולה לרוץ מערכת הפעלה חדשה). התוכונות הפופלריות בשוק כדי ליצור ולהפעיל מכונות מדומות הן <a href="https://www.virtualbox.org/wiki/Downloads" target="_blank">virtualbox</a> של חברת oracle ו <a href="http://www.vmware.com/il" target="_blank">vmware</a>.
+* מערכות Exokernel &#8211; במערכות אלה השירותים המסורתיים כגון מערכת קבצים, ניהול זיכרון, תזמון תהליכים ותקשורת הוצאו אל מחוץ לגרעין של מערכת ההפעלה. ההחלטה הזאת נובעת מכך שמערכת ההפעלה איננה כופה על המשתמש את צורת השימוש במשאבים (אלא רק דואגת להגנה על המשאבים וניהולם).
+* מערכות שרת לקוח (client &#8211; server systems) &#8211; מערכות שרת לקוח מבוססות על הרעיון של גרעין מנינימליסטי (micro kernel), ז"א גרעיון מערכת ההפעלה מתפקד כדוור המריץ בקשות של לקוחות (תהליכים) אל שרתים עצמאיים (גם תהליכים), המפוזרים במערכת, כגון שרתי מערכת הקבצים, מנהל הזיכרון, תכנית התקשורת, תכנית המסך (מנהל חלונות), וכ'ו. כאשר מתקבלות תשובות מהשרתים, הגרעין מחזיר את התשובה להתליך המבקש. בשיטה זו התוכנה מורכבת מיחידות עצמאיות, שכל אחת מהן ממלאת תפקיד מוגדר. שיטה זו מצמצת מאוד את התלות בחומרה.
 
 &nbsp;
 
-## <span style="text-decoration: underline;"><strong>סיכום</strong></span>
+#### סיכום
 
 בחלק זה למדנו את שני התפקידים של מערכת ההפעלה, ראינו מהן קריאות מערכת, ביצענו יישור קו לגבי הסוגים השונים של המבנה של מערכות הפעלה, ועברנו גם על מושגים יסודיים בתחום (קבצים, תהליכים, ניהול זיכרון, וכד'). חלק זה הינו תיאורטי (ברובו) ואנו עדין לא צוללים אל עומק הדברים, למרות זאת הבסיס הוא חשוב להבנה לפני שממשיכים לפן הטכני של הנושא (כדי שלא נאבד את הידיים והרגליים).
diff --git a/_posts/2015-12-13-operating-system-part-2.md b/_posts/2015-12-13-operating-system-part-2.md
index 1575ca1..77ee9a4 100644
--- a/_posts/2015-12-13-operating-system-part-2.md
+++ b/_posts/2015-12-13-operating-system-part-2.md
@@ -7,61 +7,6 @@ base-images-url: 'operating-system-part-2'
 hero-image: 'hero_image.svg'
 categories:
   - Operating Systems
-tags:
-  - CPU
-  - IR
-  - Kernel
-  - lock
-  - Lottery Scheduling
-  - mutex
-  - PC
-  - process
-  - Program
-  - PSW
-  - Quantum
-  - Queue
-  - Registers
-  - Round Robin
-  - semaphore
-  - SPN
-  - SRTN
-  - STN
-  - Threads
-  - User
-  - אוגרים
-  - אלוגריתמים
-  - בינארי
-  - הוראה
-  - זיכרון
-  - חוט
-  - מבני פיקוח
-  - מודל העוגה
-  - מיוחס
-  - מכונת מצבים
-  - מניעה הדדית
-  - מנעול
-  - מעבד
-  - מערכות אינטראקטיביות
-  - מערכות אצווה
-  - מערכות זמן אמת
-  - מערכת הפעלה
-  - מצב
-  - מקביליות
-  - מרחב כתובות
-  - משתמש
-  - סמפור
-  - פילוסופים
-  - קדימויות
-  - ריצה
-  - תהליך
-  - תהליכון
-  - תהליכונים
-  - תוכנית
-  - תור
-  - תזמון
-  - תזמון בשיטת ההגרלה
-  - תזמון מובטח
-  - תזמון עדיפויות
 ---
 הגענו לפוסט השני בסדרת פוסטים על מערכות הפעלה. הפוסט הזה יתמקד בתהליכים ותהליכונים והבעיות השונות שמגיעות איתן. שוב, אציין מראש כי הפוסטים יהיו כבדים (בעלי מלל רב) וטכניים. הפוסטים נועדו למי שולמד מערכות הפעלה כחלק מתואר במדעי המחשב ו/או למי שמעוניין ללמוד לבד ו/או לאנשים שרק רוצים להיזכר (בראש כל פוסט יהיה תוכן עניינים). 
 
@@ -76,7 +21,7 @@ tags:
 
 &nbsp;
 
-## 1. תהליכים (Processes)
+#### 1. תהליכים (Processes)
 
 אחת המשימות העיקריות של כל מערכת הפעלה היא ניהול תהליכים. מערכת ההפעלה דואגת לעקוב אחר המצבים השונים בהם התהליכים נמצאים ולאכוף במידת הצורך את הגישה של התהליכים הרצים בה למשאבי המערכת. לצורך כך היא מתחזקת מבני נתונים המשמשים לניהול התהליכים.
 
@@ -96,7 +41,10 @@ tags:
 
 פסיקות חומרה נועדו, בעיקר, להגדיל את ניצולת ה CPU. למשל, בעת ביצוע I/O. תוכנית שמבקשת לבצע I/O, קריאה או כתיבה, מושהית ע"י מערכת ההפעלה עד לסיום פעולת ה I/O. בזמן ההשהיה תתבצע תכנית אחרת ב CPU. כאשר ההתקן שעליו התבצעה פעולת ה I/O יסיים את המשימה, יישלח סיגנל (signal) בקשה לפסיקה ל CPU. עם קבלת הסיגנל, המעבד משהה מיד את הביצוע של ההוראות שהוא מבצע כעת, ומפעיל שגרה מיוחדת הנקראת 'שגרה לטיפול בפסיקות' (או interrupt handler routine). השגרה לטיפול בפסיקות היא בדרך כלל חלק ממערכת ההפעלה. לאחר סיום השגרה לטיפול בפסיקות, ה CPU יכול לחזור לביצוע של התכנית המקורית שביצע לפי שקיבל את הסיגנל (למרות שייתכן והעניינים יתנהלו לפי תסריט אחר. השגרה לטיפול בפסיקות יכולה להורות להפעיל מתזמן תהליכים שיכול "לתת" את ה CPU לתכנית אחרת).
 
-![Interrupt Processor](/assets/img/posts/operating-system-part-2/Interrupt_Processor.jpeg "Interrupt Processor")
+<div class="left" style="width: 35%">
+  <img src="/assets/img/posts/operating-system-part-2/interrupt_processor.jpg" alt="Interrupt Processor">
+</div>
+
 המעבר הזה, לביצוע של השגרה לטיפול בפסיקות, יוצר תקורה, מכיוון שצריך לבצע שמירת תוכן של התהליך על מנת לאפשר שחזור של ביצוע התוכנית מהנקודה שבה הופסקה. שמירת התוכן מתבצעת ע"י החומרה ותלויה במעבד (שלב 6 באיור משמאל). שמירת ה PSW וה PC מתבצעת גם ע"י המעבד עצמו (שלב 4) אשר קורא לשגרה לטיפול בפסיקות (בשלב 5). תהליך השמירה עצמו מתואר בצורה סכמתית באיור משמאל (בעקבות ריבוי הארכיטקטורות השונות של המעבד, ייתכנו גם אפשרויות נוספות).
 
 &nbsp;
@@ -131,7 +79,9 @@ tags:
   3. <span style="text-decoration: underline;">סיום בעקבות שגיאטה פטאלית &#8211;</span> תהליך שמסתיים בעקבות שגיאה שלא נצפתה מראש ולא היה קיים מענה לתרחיש בעייתי בקוד התוכנית. סיום מסוג זה גורם לקריסה של התוכנית (crash).
   4. <span style="text-decoration: underline;">סיום בעקבות הריגת תהליך &#8211;</span> תהליך שמתסיים בעקבות הבקשה המפורשת ממערכת ההפעלה לסיים את ריצתו. מערכת ההפעלה שמקבלת בקשה כזאת בוחנת את הרשאות המבקש (המבקש יכול להיות תהליך אחר, ובפרט תהליך של מערכת ההפעלה עצמה), ואם קיימות הרשאות מתאימות, היא מסיימת את ריצתו של התהליך המבוקש.
 
-![finite-state machine](/assets/img/posts/operating-system-part-2/finite_state_machine.png "finite-state machine")
+<div class="left" style="width: 30%">
+  <img src="/assets/img/posts/operating-system-part-2/finite_state_machine.jpg" alt="Finite-state Machine">
+</div>
 מודל התהליכים מתאפיין בהגדרה של מבנה היררכי בין תהליכי מערכת ההפעלה. אחד המרכיבים החשובים ביותר של מודל התהליכים הוא **מכונת מצבים**, המתארת את תקופת חייו של התהליך.
 
   1. התהליך חסום לקלט.
@@ -153,14 +103,17 @@ tags:
 
 כל מערכת הפעלה מנהלת מבני נתונים רבים כדי לאפשר החלפת תהליכים וכדי לאפשר קיום מעברים בין מצב משתמש (user mode) למצב מיוחס (kernel mode). אז כיצד מתבצע הקוד של מערכת ההפעלה? (האם המערכת היא אוסף של תהליכים? או אולי היא חלק מתהליכי המשתמש?) השאלות האלו מגדירות גישות שונות (גישת השרת &#8211; לקוח עליה דיברנו בפוסט הראשון ממומשת כאוסף של תהליכים. לעומת זאת מערכות הפעלה במחשבים ביתיים רצות במרחב הכתובות של תהליכי המשתמש).
 
-![CPU_Utilization](/assets/img/posts/operating-system-part-2/CPU_Utilization.jpeg "CPU_Utilization")
+<div class="left">
+  <img src="/assets/img/posts/operating-system-part-2/cpu_utilization.jpg" alt="CPU Utilization">
+</div>
+
 כמו שאמרנו, העלאת רמת המקביליות של המערכת מביאה לניצול טוב יותר של המשאבים. נניח שתהליך מבלה חלק מזמנו בפעולת קלט / פלט (ז"א 0 < p וגם 1 > p). כאשר n תהליכים נמצאים בזיכרון בבת אחת, ההסתברות לכך שכל התהליכים מבצעים פעולת קלט / פלט היא p^n (בהנחה שהתהליכים אינם תלויים זה בזה). בתנאים אלה, ההסתברות לכך שהמעבד פעיל היא 1 פחות p^n (וזאת הנוסחה לחישוב הניצולת של המעבד).
 
 באיור משמאל ניתן לראות את גרף הניצולת כפונקציה של מספר התהליכים במערכת, אשר גם נקרא הדרגה של ריבוי התוכנית (ציר x מראה את כמות התהליכים בזיכרון, וציר y את אחוז ניצולת ה CPU). נציין בנוסף, כי במציאות הניצולת תגדל בצורה לינארית עד לנק' מסויימת ומשם תיהיה האטה בגידול הניצולת עם הגדלת רמת המקביליות. ולאחר מכן, בשלב מסוים, הגדלת רמת המקביליות לא רק שלא תגרום לגידול הניצולת אלא יתרחיש תהליך הפוך. המערכת תעבוד תחת עומס כבד, וככל שהעומס יגבר, כך תפחת יעילותה של המערכת (תארו לכם מצב קיצוני בו משאבי המעבד עוברים מתהליך אחד לשני לפני שהראשון הספיק בכלל לבצע חישוב כלשהו). בנקודה זאת המערכת חייבת להוציא תהליכים מהזיכרון הראשי אל הדיסק (הקשיח).
 
 &nbsp;
 
-## 2. תהליכונים (Threads)
+#### 2. תהליכונים (Threads)
 
 ניתן לומר שלכל תהליך יש חוט (תהליכון, thread) אחד, אך קורה שאנו צריכים יותר מחוט יחיד במרחב הכתובות של כל תהליך. למשל, חוטים נפרדים עבור פרוצדורות שרצות במקביל. בניגוד להתהליכים, כל התהליכונים של תהליך יחיד חולקים את אותו מרחב כתובות. לתהליך יש שני היבטים שונים: האחד, הוא היבט הבקרה של ביצוע סדרתי של תוכנית, והשני הוא ניהול המשאבים של המערכת. התהליך מתאפיין כמשאב בקבוצת המשאבים, אולם התהליכונים מאופיינים כישויות הניתנות לתזמון. מערכות הפעלה אשר תומכות בתהליכונים נקראות <a href="https://en.wikipedia.org/wiki/Multithreading_(computer_architecture)" target="_blank">Multithreading Operating System</a>.
 
@@ -208,7 +161,7 @@ tags:
 
 &nbsp;
 
-## 3. תקשורת בין תהליכים
+#### 3. תקשורת בין תהליכים
 
 תקשורת בין תהליכים הינה פועל יוצא מהצורף בשיתוף פעולה בין תהליכים. לשיתוף פעולה זה 2 היבטים: הראשון הוא שתהליכים צריכים להחליף מידע. והשני הוא קבוצת תהליכים אשר חייבת לשתף פעולה ולפעול תוך התחשבות בקיומם של תהליכים אחרים בקבוצה, וזאת מכיוון שתהליכים עלולים לבצע פעילויות שיכולות להשפיע על תקינות התוצאה של תהליכים אחרים. (באופן עקרוני הנושאים שקשורים בשיתוף פעולה בין תהליכים תקפים גם לגבי תהליכונים, לכן, למרות שבסעיף זה אדבר על תהליכים, הדברים נכונים גם לגבי תהליכונים).
 
@@ -227,7 +180,9 @@ deleteFirst(){
 }
 ```
 
-![Critical Race](/assets/img/posts/operating-system-part-2/Critical_Race.jpeg "Critical Race")
+<div class="left" style="width: 40%">
+  <img src="/assets/img/posts/operating-system-part-2/critical_race.jpg" alt="Critical Race">
+</div>
 התוצאה הרצויה היא ששני התהליכונים ימחקו מראש הרשימה שני איברים ראשונים. אך נניח שבתור ישנם ארבעה עצמים. תהליכון 1 מגיע לפרוצדורה ()deleteFirst ומבצע את השורה הראשונה. לאחר ביצוע השורה, מתרחשת החלפת תהליכונים ותהליכון 2 מגיע לפונ' ()deleteFirst שלו ומבצע גם כן את השורה הראשונה. נניח שהתלהיכונים ממשיכים להתחלף כל שורה. באיור משמאל (חלק b) ניתן לראות מה מתרחש בתור לאחר שהתהליכונים ביצעו את השורה השנייה. ובחלק האחרון, c, ניתן לראות כי לאחר שהתהליכונים סיימו לבצע (כל אחד את העותק שלו של ()deleteFirst. הרי לכל תהליכון יש מחסנית נפרדת, ולכן עותקים נפרדים של הפרוצדורה רצים במקביל, המשתנה TmpNodePtr הוא משתנה מקומי ולכן בתמונה משמאל אנו רואים 2 כאלו -עותקים נפרדים שלו יפיעו בכל מחסנית. המשתנה ListNodePtr הוא משתנה גלובלי בספרייה ולכן הוא משותף לשני התהליכונים), רק איבר אחד נמחק מהרשימה.
 
 ברור שבלעדי ההחלפה התדירה הדברים היו קורים באופן תקין. אך במציאות, ההסתברות לתרחישים מהסוג הזה היא ניכרת. מצבים כאלה, בהם התוצאה הסופית תלויה בתזמונם של תהליכים או תהליכונים, מכונים **_מצבי מירוץ_**.
@@ -236,10 +191,10 @@ deleteFirst(){
 
 שיתוף פעולה מסוג מניעה הדדית אינו מספיק (הוא מהווה תנאי הכרחי לפתרון סביר של בעיית המירוץ), ישנם ארבעה תנאים הדרושים להשגת פתרון סביר:
 
-  * שני תהליכים לא ישהו בו זמנית בתוך קטע קריטי.
-  * הפתרון לא יסתמך על השערות הקשורות למהירות או למס' מעבדים.
-  * תהליך מחוץ לקטע קריטי לא ימנע מתהליך אחר להיכנס לקטע קריטי.
-  * תהליך לא ימתין לנצח כדי להיכנס לקטע קריטי (בעיית הרעבה).
+* שני תהליכים לא ישהו בו זמנית בתוך קטע קריטי.
+* הפתרון לא יסתמך על השערות הקשורות למהירות או למס' מעבדים.
+* תהליך מחוץ לקטע קריטי לא ימנע מתהליך אחר להיכנס לקטע קריטי.
+* תהליך לא ימתין לנצח כדי להיכנס לקטע קריטי (בעיית הרעבה).
 
 &nbsp;
 
@@ -422,7 +377,37 @@ int TSL (int lock){
 
 נניח שנתונים שני תהליכים, האחד קרוי יצרן והוא מכניס פרמטרים למאגר, והשני קרוי צרכן והוא נוהג להוציא את הפריטים מהמאגר. מכיוון שגודל המאגר חסום (הנחה כדי להקשות את הבעיה), מתעוררת בעיה כאשר היצרן רוצה להכניס פריט למאגר מלא. הפתרון כמובן הוא שהיצרן ירדים את עצמו, ויתעורר רק כאשר הצרכן הוציא לפחות פריט אחד. ומה קורה כאשר המאגר ריק? אם הצרכן רוצה להוציא פריט והמאגר ריק, הוא מרדים את עצמו עד שהיצרן יכניס פריט ויעיר אותו.
 
-![producer-consumer problem](/assets/img/posts/operating-system-part-2/Screenshot-from-2015-11-21-11-13-49.jpeg "producer-consumer problem")
+```c
+#define N 100     /* number of slots in the buffer */
+int count = 0;    /* number of items in the buffer */
+
+void producer(void)
+{
+  int item;
+
+  while (TRUE) {                      /* repeat forever */
+    item = produce_item();            /* generate next item */
+    if (count == N) sleep();          /* if buffer is full, go to sleep */
+    insert_item(item);                /* put item in buffer */
+    count = count + 1;                /* increment count of item in buffer */
+    if (count == 1) wakeup(consumer); /* was buffer empty? */
+  }
+}
+
+void consumer(void)
+{
+  int item;
+
+  while (TRUE) {                          /* repeat forever */
+    if (count == 0) sleep();              /* if buffer is empty, go to sleep */
+    item = remove_item();                 /* take item out of buffer */
+    count = count - 1;                    /* decrement count of items in buffer */
+    if (count == N -1) wakeup(producer);  /* was buffer full? */
+    consume_item(item);                   /* print item */
+  }
+}
+```
+
 כדי לעקוב אחר מס' הפריטים במאגר נשתמש בתמונה, count. ונניח שהמאגר יכול להכיל N פריטים. היצרן בודק האם count שווה ל N, ואם זה המצב הוא הולך לישון, אחרת הוא מאחסן פריט ומגדיל את המונה בהתאם. היצרן גם דואג לקרוא ל WAKEUP כדי להעיר את הצרכן כאשר הוא מאחסן את הפריט הראשון, כי במקרה שהמאגר היה ריק והיצרן אכסן פריט חדש, הוא צריך לגרום לצרכן להתעורר על מנת לאפשר מחדש עבודה במקביל.
 
 הצרכן מצדו הולך לישון כאשר הוא מגלה ש count שווה ל 0. אחרת הוא מפנה פריטים מהמאגר ודואג להעיר את היצרן אם יש מקום פנוי במאגר. הפרימיטיבם SLEEP ו WAKEUP אכן מונעים את בעיית ההמתנה הפעילה. אך הפתרון בכל זאת סובל מבעיית מירוץ (מצב זה יכול לקרות מכיוון שהגישה למשתנה של המונה אינה מבוקרת ולכן עקב המרוץ שנוצר על המשתנה, יתכן שאחת מהקריאות של WAKEUP תאבד).
@@ -441,8 +426,6 @@ down(s){
         s--;
 }
 
------
-
 up(s){
     if (there is at least one process sleeping in the semaphore queue){
         wake him up;
@@ -570,7 +553,7 @@ main(){
 
 &nbsp;
 
-## 4. תזמון תהליכים
+#### 4. תזמון תהליכים
 
 תזמון תהליכים הוא נושא מורכב מאוד ויש לו השפעה על כל מרכיבי המערכת (ניהול זיכרון, מערכת קבצים וכ'ו). במהלך הסעיף הנל נתמקד באלוגריתמים לתזמון תהליכים שנמצאים במצב מוכן לריצה (ז"א בהינתן קבוצה של תהליכים מוכנים לריצה, המשימה תיהיה לבחור מתוכה איזה מן התהליכים יהיה התהליך הבא שמקבל זמן CPU ומתי תהליך שרץ ב CPU עובר למצב מוכן, ז"א במעברים בין מצב Ready למצב Running). אלוגריתמים אלה נקראים _אלוגריתמי תזמון לטווח קצר _(Short-time Scheduling Algorithms) ונראה בהמשך כיצד הם משתלבים במנגון התזמון שלוקח החלטות תזמון לטווח ארוך.
 
@@ -723,7 +706,7 @@ E(4) = 0.5T(3) + 0.25T(2) + 0.125T(1) + 0.125E(1)
 
 
 
-## 5. בעיות IPC קלאסיות
+#### 5. בעיות IPC קלאסיות
 
 ניזכר כי בסעיף בו דיברנו על סמאפורים הבנו שהפרוטוקול לפתרון בעיית הקטע הקריטי לזוג תהליכים בעזרת סמפור בינארי כולל 3 כללים: קיים סמפור בינארי S המאותחל למצב S=1, תהליך הנכנס לקטע קריטי מבצע (DOWN(S, תהליך היוצא מקטע קריטי מבצע (UP(S. ושלושת כללים אלה יוצרים את הפרוטוקול המבוקש.
 
@@ -731,10 +714,10 @@ E(4) = 0.5T(3) + 0.25T(2) + 0.125T(1) + 0.125E(1)
 
 <span style="text-decoration: underline;"><strong>בעיית הפילוסופים הסועדים</strong></span>
 
-<a href="https://en.wikipedia.org/wiki/Dining_philosophers_problem" target="_blank">הבעיה המפורסמת ביותר</a>
-
-![Dining philosophers](/assets/img/posts/operating-system-part-2/Dining_philosophers-289x300.png "Dining philosophers")
- בהקשר זה, והפתרון שלה משמש כמודל שבאמצעותו בוחנים יעילות של מנגנונים חדשים לתקשורת בין תהליכים בסביבה בעלת מספר מוגבל של משאבים (כמו התקני קלט / פלט).
+<div class="left">
+  <img src="/assets/img/posts/operating-system-part-2/dining_philosophers_problem.jpg" alt="Dining Philosophers">
+</div>
+<a href="https://en.wikipedia.org/wiki/Dining_philosophers_problem" target="_blank">הבעיה המפורסמת ביותר</a> בהקשר זה, והפתרון שלה משמש כמודל שבאמצעותו בוחנים יעילות של מנגנונים חדשים לתקשורת בין תהליכים בסביבה בעלת מספר מוגבל של משאבים (כמו התקני קלט / פלט).
 
 להלן תיאור הבעיה: מספר פילוסופים יושבים מסביב לשולחן עגול ולפני כל אחד מהם מונחת צלחת ספגטי. בין כל שתי צלחות מונח מזלג. כדי לאכול פילוסוף צירך לאחוז בשני מזלגות בו זמנית. חייו של פילוסוף מתחלקים לתקופות שבהן הוא חושב (אינו רעב), רעב אך אין ברשותו 2 מזלגות, ואוכל (וברשותו, כמובן, 2 מזלגות). כאשר פילוסוף הופך לרעב, הוא מנסה לקחת את 2 המזלגות. אם הוא מצליח לקבל את 2 המזגלות, הוא אוכל. כשהוא מסיים לאכול הוא מניח את המזלגות בחזרה בשני הצדדים של הצלחת שלו וחוזר להרהר בבעיות החשובות בעולם. המטרה היא למצוא פרוטוקול שמבטיח שאף פילוסוף לא יגווע ברעב.
 
@@ -744,6 +727,6 @@ E(4) = 0.5T(3) + 0.25T(2) + 0.125T(1) + 0.125E(1)
 
 &nbsp;
 
-## לסיכום
+#### לסיכום
 
 שלושת הנושאים החשובים ביותר בחלק זה היו בעיית המירוץ הקריטי, תיאום ושיתוף פעולה בין תהליכים או תהליכונים שוים, ותזמון תהליכים ותהליכונים. אך דיברנו על עוד דברים כמו כיצד תהליכים ותהליכונים נוצרים וכיצד הם מסתיימים, הכרנו את היררכיה שלהם, המימוש בקרנל, תקשורת בינהם והבעיות שמגיעות איתם (מירוץ קריטי ומגוון הפתרונות שלו), דיברנו על סמפורים, מנעולים, ומבני פיקוח, ולבסוף על תזמון התהליכים במערכות השונות והבעייה הקלאסית של הפילוסופים הסועדים.
diff --git a/assets/img/posts/operating-system-part-1/monolithic_systems.jpg b/assets/img/posts/operating-system-part-1/monolithic_systems.jpg
new file mode 100644
index 0000000..157b838
Binary files /dev/null and b/assets/img/posts/operating-system-part-1/monolithic_systems.jpg differ
diff --git a/assets/img/posts/operating-system-part-1/os_stack.jpg b/assets/img/posts/operating-system-part-1/os_stack.jpg
new file mode 100644
index 0000000..408ce80
Binary files /dev/null and b/assets/img/posts/operating-system-part-1/os_stack.jpg differ
diff --git a/assets/img/posts/operating-system-part-1/punched_cards_programming.jpg b/assets/img/posts/operating-system-part-1/punched_cards_programming.jpg
new file mode 100644
index 0000000..5aa8891
Binary files /dev/null and b/assets/img/posts/operating-system-part-1/punched_cards_programming.jpg differ
diff --git a/assets/img/posts/operating-system-part-1/ubuntu_terminal.jpg b/assets/img/posts/operating-system-part-1/ubuntu_terminal.jpg
new file mode 100644
index 0000000..18c30be
Binary files /dev/null and b/assets/img/posts/operating-system-part-1/ubuntu_terminal.jpg differ
diff --git a/assets/img/posts/operating-system-part-2/CPU_Utilization.jpeg b/assets/img/posts/operating-system-part-2/CPU_Utilization.jpeg
deleted file mode 100644
index 92e500b..0000000
Binary files a/assets/img/posts/operating-system-part-2/CPU_Utilization.jpeg and /dev/null differ
diff --git a/assets/img/posts/operating-system-part-2/Critical_Race.jpeg b/assets/img/posts/operating-system-part-2/Critical_Race.jpeg
deleted file mode 100644
index 60a0a05..0000000
Binary files a/assets/img/posts/operating-system-part-2/Critical_Race.jpeg and /dev/null differ
diff --git a/assets/img/posts/operating-system-part-2/Dining_philosophers-289x300.png b/assets/img/posts/operating-system-part-2/Dining_philosophers-289x300.png
deleted file mode 100644
index b6f03b2..0000000
Binary files a/assets/img/posts/operating-system-part-2/Dining_philosophers-289x300.png and /dev/null differ
diff --git a/assets/img/posts/operating-system-part-2/Interrupt_Processor.jpeg b/assets/img/posts/operating-system-part-2/Interrupt_Processor.jpeg
deleted file mode 100644
index 1391393..0000000
Binary files a/assets/img/posts/operating-system-part-2/Interrupt_Processor.jpeg and /dev/null differ
diff --git a/assets/img/posts/operating-system-part-2/Screenshot-from-2015-11-21-11-13-49.jpeg b/assets/img/posts/operating-system-part-2/Screenshot-from-2015-11-21-11-13-49.jpeg
deleted file mode 100644
index f94c060..0000000
Binary files a/assets/img/posts/operating-system-part-2/Screenshot-from-2015-11-21-11-13-49.jpeg and /dev/null differ
diff --git a/assets/img/posts/operating-system-part-2/cpu_utilization.jpg b/assets/img/posts/operating-system-part-2/cpu_utilization.jpg
new file mode 100644
index 0000000..66f0892
Binary files /dev/null and b/assets/img/posts/operating-system-part-2/cpu_utilization.jpg differ
diff --git a/assets/img/posts/operating-system-part-2/critical_race.jpg b/assets/img/posts/operating-system-part-2/critical_race.jpg
new file mode 100644
index 0000000..3f01db6
Binary files /dev/null and b/assets/img/posts/operating-system-part-2/critical_race.jpg differ
diff --git a/assets/img/posts/operating-system-part-2/dining_philosophers_problem.jpg b/assets/img/posts/operating-system-part-2/dining_philosophers_problem.jpg
new file mode 100644
index 0000000..835db81
Binary files /dev/null and b/assets/img/posts/operating-system-part-2/dining_philosophers_problem.jpg differ
diff --git a/assets/img/posts/operating-system-part-2/finite_state_machine.jpg b/assets/img/posts/operating-system-part-2/finite_state_machine.jpg
new file mode 100644
index 0000000..143ad27
Binary files /dev/null and b/assets/img/posts/operating-system-part-2/finite_state_machine.jpg differ
diff --git a/assets/img/posts/operating-system-part-2/finite_state_machine.png b/assets/img/posts/operating-system-part-2/finite_state_machine.png
deleted file mode 100644
index 49cd725..0000000
Binary files a/assets/img/posts/operating-system-part-2/finite_state_machine.png and /dev/null differ
diff --git a/assets/img/posts/operating-system-part-2/interrupt_processor.jpg b/assets/img/posts/operating-system-part-2/interrupt_processor.jpg
new file mode 100644
index 0000000..2a7f4fd
Binary files /dev/null and b/assets/img/posts/operating-system-part-2/interrupt_processor.jpg differ
diff --git a/assets/scss/layouts/post.scss b/assets/scss/layouts/post.scss
index a36622f..ec0401d 100644
--- a/assets/scss/layouts/post.scss
+++ b/assets/scss/layouts/post.scss
@@ -9,6 +9,14 @@
     margin-right: 40px;
   }
 
+  ul {
+    list-style-type: disc;
+
+    li {
+      list-style-type: disc;
+    }
+  }
+
   blockquote {
     border-left: initial;
     border-right: 4px solid #e8e8e8;
@@ -21,6 +29,8 @@
   }
 
   table {
+    width: 50%;
+    margin: 1% auto;
     border-spacing: 0;
     border-collapse: collapse;
 
diff --git a/assets/scss/tools/_normalize.scss b/assets/scss/tools/_normalize.scss
index 18ddf7f..655c197 100644
--- a/assets/scss/tools/_normalize.scss
+++ b/assets/scss/tools/_normalize.scss
@@ -150,7 +150,7 @@ dfn {
  */
 
 h1 {
-  font-size: 2em;
+  font-size: 3em;
   margin: 0.67em 0;
 }