היסטוריה של שפות התכנות

ההיסטוריה של שפות התכנות משתרעת מתיעוד של מחשבים מכניים מוקדמים ועד לכלים מודרניים לפיתוח תוכנה. שפות התכנות המוקדמות היו מיוחדות מאוד, והסתמכו על סימונים מתמטיים ותחביר לא ברור. לאורך המאה ה-20, מחקרים בתאוריית המהדר הובילו ליצירת שפות תכנות עיליות, המשתמשות בתחביר נגיש יותר כדי להעביר הוראות.

שפת התכנות העילית הראשונה הייתה פלנקלקול, שנוצרה על ידי קונרד זוסה בין 1942 ל-1945. השפה העילית הראשונה שהיה לה מהדר נוצרה על ידי קוראדו בוהם בשנת 1951, עבור התזה שלו. השפה המסחרית הראשונה הייתה FORTRAN, שפותחה ב-1956 (המדריך הראשון הופיע ב-1956, אך פותח לראשונה ב-1954) על ידי צוות בראשותו של ג'ון בקאוס ב-IBM.

היסטוריה מוקדמת 
במהלך השנים 1842–1849, עדה לאבלייס תרגמה את ספר הזיכרונות של המתמטיקאי האיטלקי לואיג'י מנברה על המכונה המוצעת החדשה ביותר של צ'ארלס בבג': המנוע האנליטי. היא הוסיפה לספר הזיכרונות הערות שציינו בפירוט שיטה לחישוב מספרי ברנולי באמצעות המנוע, המוכרת על ידי רוב ההיסטוריונים כתוכנת המחשב הראשונה בעולם שפורסמה.

קודי המחשב הראשונים היו מיוחדים ליישומים שלהם. לדוגמה, אלונזו צ'רץ' הצליח לבטא את תחשיב הלמבדה בצורה נוסחתית ומכונת טיורינג הייתה הפשטה של פעולתה של מכונת סימון סרטים.

למנועי הפרשים של צ'ארלס באבג' ושל ג'קארד לומס היו שפות פשוטות לתיאור הפעולות שהמכונות הללו צריכות לבצע ולכן, כיום, הם נחשבים ליוצרים של שפת התכנות הראשונה.

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

הצעה מוקדמת לשפת תכנות עילית הייתה פלנקלקול, שפותחה על ידי קונראד צוזה עבור מחשב הZ1 בין השנים 1942 ל-1945 אך לא יושמה באותה עת.

שפות התכנות המתפקדות הראשונות שנועדו להעביר הוראות למחשב נכתבו בתחילת שנות החמישים. Short Code של ג'ון מאוצ'לי, שהוצעה ב-1949, הייתה אחת השפות הראשונות אי פעם שפותחו עבור מחשב אלקטרוני. בשונה מקוד מכונה, הצהרות Short Code ייצגו ביטויים מתמטיים בצורה מובנת. עם זאת, היה צורך לפרש את התוכנית לקוד מכונה בכל פעם שהיא רצה, מה שהופך את התהליך לאיטי בהרבה מהפעלת קוד המכונה המקביל.

בשנת 1954, FORTRAN הומצאה ב-IBM על ידי צוות בראשות ג'ון באקוס. FORTRAN הייתה השפה הראשונה בשימוש נרחב למטרות כלליות עם מימוש פונקציונלי. כאשר FORTRAN הוצגה לראשונה, היא נתפסה בספקנות עקב באגים, עיכובים בפיתוח והיעילות בהשוואה לתוכנות "מקודדות ביד" שנכתבו באסמבלי. עם זאת, בשוק החומרה שהתפתח במהירות בתקופה, השפה נודעה בסופו של דבר ביעילותה. היא עדיין שפה פופולרית עבור מחשוב בעל ביצועים גבוהים והיא משמשת עבור תוכניות כמו "טופ500" שבודקות ומדרגות את מחשבי העל החזקים ביותר בעולם.

שפת תכנות מוקדמת נוספת הומצאה על ידי גרייס הופר בארצות הברית, בשם FLOW-MATIC. היא פותחה עבור UNIVAC I ברמינגטון ראנד במהלך התקופה מ-1955 עד 1959. הופר גילתה שלקוחות עיבוד נתונים עסקיים לא חשו בנוח עם סימון מתמטי, ובתחילת 1955, היא והצוות שלה כתבו מפרט לשפת תכנות מבוססת אנגלית ויישמו אב טיפוס. המהדר FLOW-MATIC הפך זמין לציבור בתחילת 1958 והושלם ב-1959. ל-Flow-Matic הייתה השפעה מרכזית בעיצוב של קובול, מכיוון שרק הוא והצאצא הישיר שלו AIMACO היו בשימוש באותה תקופה.

שפות נוספות שעדיין נמצאות בשימוש כיום כוללות את LISP, שהומצאה על ידי ג'ון מקארתי ו-קובול, שנוצרה על ידי ה-Short Range Committee. ציון דרך נוסף בסוף שנות ה-50 היה פרסום של ועדה של מדעני מחשב אמריקאים ואירופים, של "שפה חדשה לאלגוריתמים". דו"ח זה איחד רעיונות רבים שהסתובבו באותה תקופה והציג שלושה חידושים מרכזיים:
 מבנה בלוקים מקוננים: ניתן לקבץ רצפים דומים של קוד לבלוקים מבלי שיהיה צורך להפוך אותם לשיטות נפרדות בעלי שם מפורש.
 תחום הכרזה: לבלוק יכול להיות משתנים פרטיים ופונקציות משלו, הלא נגישים לקוד מחוץ לבלוק זה.

חידוש נוסף הקשור לכך היה באופן שתוארה השפה:
 סימון מדויק מבחינה מתמטית, שיטת בקוס-נאור (BNF), שימש לתיאור תחביר השפה. כמעט כל שפות התכנות הבאות השתמשו בגרסה של BNF כדי לתאר את החלק חסר ההקשר של התחביר שלהן.

ALGOL 60 השפיע במיוחד על עיצובן של שפות מאוחרות יותר, שחלקן הפכו במהרה לפופולריות.

הרעיונות המרכזיים של ALGOL המשיכו, ויצרו את ALGOL 68:
 תחביר וסמנטיקה נעשו אפילו יותר אורתוגונליים, עם שגרות אנונימיות, מערכת הקלדה רקורסיבית עם פונקציות מסדר גבוה וכו'.
 לא רק החלק חסר ההקשר, אלא תחביר השפה המלא והסמנטיקה הוגדרו פורמלית, במונחים של דקדוק ואן ויגארדן, פורמליזם שתוכנן במיוחד למטרה זו.

תכונות השפה הרבות של ALGOL 68 שאינן בשימוש, המערכת המורכבת של קיצורי דרך תחביריים והכפייה האוטומטית של טיפוסים הפכו אותה לשפה לא פופולרית בקרב מיישמים והשיגה את התדמית של היותה קשה. ניקלאוס וירת למעשה עזב את וועדת העיצוב כדי ליצור את שפת פסקל הפשוטה יותר.

כמה שפות בולטות שפותחו בתקופה זו כוללות:
 1951 – שפת סף
 1952 – Autocode
 1954 – IPL (השפיעה על Lisp)
 1955 – FLOW-MATIC (הובילה ל-COBOL)
 1957 – FORTRAN (המהדר הראשון)
 1957 – COMTRAN (השפיעה על COBOL)
 1958 – LISP
 1958 – ALGOL 58
 1959 – FACT (השפיעה על COBOL)
 1959 – COBOL
 1959 – RPG
 1960 – ALGOL 60
 1962 – APL
 1962 – Simula
 1962 – SNOBOL
 1963 – CPL (השפיעה על C)
 1964 – Speakeasy
 1964 – BASIC
 1964 – PL/I
 1966 – JOSS
 1966 – MUMPS
 1967 – BCPL (השפיעה על C)
 1967 – לוגו (שפה חינוכית שהשפיעה על Smalltalk ו-Scratch).

הקמת פרדיגמות יסוד 

התקופה מסוף שנות ה-60 ועד סוף שנות ה-70 הביאה פריחה גדולה של שפות תכנות. רוב פרדיגמות השפה העיקריות שנמצאות כיום בשימוש הומצאו בתקופה זו:
 Speakeasy, שפותחה ב-1964 במעבדה הלאומית של Argonne על ידי סטנלי כהן, היא מערכת תכנות מונחה עצמים (OOPS), בדומה לחבילות המתמטיות המאוחרת של MATLAB, IDL ו-Mathematica. ל-Speakeasy יש תחביר ברור על בסיס Fortran. המערכת נועדה תחילה למחשוב יעיל של פיזיקה באופן פנימי במעבדה הלאומית של Argonne, שונתה לשימוש מחקרי (כ-"Modeleasy") עבור מועצת הפדרל ריזרב בתחילת שנות ה-70 ולאחר מכן נהפכה לזמינה מסחרית.
 Simula, שהומצאה בסוף שנות ה-60 על ידי קריסטן ניגארד ואולה יוהאן דאל כהרחבה של ALGOL 60, הייתה השפה הראשונה שנועדה לתמוך בתכנות מונחה עצמים.
 C, שפת תכנות מערכות מוקדמת, פותחה על ידי דניס ריצ'י וקן תומפסון ב-מעבדות נוקיה בל בין השנים 1969 ו-1973.
 Smalltalk (אמצע שנות ה-70) סיפקה עיצוב יסודי שלם של שפה מונחה עצמים.
 פרולוג, שתוכננה ב-1972 על ידי אלן קולמר, פיליפ רוסל ורוברט קובלסקי, הייתה שפת התכנות הלוגית הראשונה.
 ML בנתה מערכת מסוג פולימורפי (הומצאה על ידי רובין מילנר ב-1973) על Lisp, שהניחה את אבני היסוד של שפות תכנות פונקציונליות עם הקלדה סטטית. כל אחת מהשפות הללו הולידה משפחה שלמה של צאצאים, ורוב השפות המודרניות סופרות לפחות אחת מהן במוצאן.

גם בשנות השישים והשבעים של המאה ה-20 היה ויכוח רב על היתרונות של "תכנות מובנה", שפירושו בעצם תכנות ללא שימוש בפקודת ה-goto. חלק ניכר מהמתכנתים האמינו שאפילו בשפות המספקות goto, זה סגנון תכנות גרוע להשתמש בו למעט בנסיבות נדירות. הוויכוח הזה היה קשור קשר הדוק לעיצוב שפות: לחלק מהשפות לא היה goto, מה שאילץ את השימוש בתכנות מובנה.

כמה שפות בולטות שפותחו בתקופה זו כוללות:
 1967 – BCPL (השפיעה על B)
 1968 – Logo
 1969 – B (השפיעה על C)
 1970 – פסקל
 1970 – Forth
 1972 – C
 1972 – Smalltalk
 1972 – Prolog
 1973 – ML
 1975 – Scheme
 1978 – SQL (שפת שאילתות, הורחבה מאוחר יותר)

שנות ה-80: איחוד, מודולים, ביצועים 
שנות ה-80 היו שנים של גיבוש יחסי בשפות אימפרטיביות. במקום להמציא פרדיגמות חדשות, כל התנועות הללו פיתחו את הרעיונות שהומצאו בעשור הקודם. ++C שילבה תכנות מונחה עצמים ותכנות מערכות. ממשלת ארצות הברית תיקנה את עדה, שפת תכנות מערכות המיועדת לשימוש על ידי קבלני ביטחון. ביפן ובמקומות אחרים, הוצאו סכומים אדירים בחקירת שפות תכנות מהדור החמישי ששילבו מבני תכנות לוגיים. קהילת השפות הפונקציונליות החלה להפוך את ML ו-Lisp לסטנדרט. המחקר במירנדה, שפה פונקציונלית עם הערכה עצלנית, החל לתפוס אחיזה בעשור הזה.

מגמה חדשה וחשובה אחת בעיצוב שפה הייתה התמקדות מוגברת בתכנות עבור מערכות בקנה מידה גדול באמצעות שימוש במודולים. עדה, מודולה ו-ML פיתחו כולם מערכות מודול בולטות בשנות ה-80. מערכות מודולים הוצמדו לעיתים קרובות למבני תכנות גנריים: גנריות היא, במהותה, מודולים עם פרמטרים (ראה גם פולימורפיזם).

אף על פי שלא הופיעו פרדיגמות חדשות מרכזיות לשפות תכנות אימפרטיביות, חוקרים רבים הרחיבו את הרעיונות של שפות קודמות והתאימו אותם להקשרים חדשים. לדוגמה, השפות של מערכות Argus ו-Emerald התאימו תכנות מונחה עצמים למערכות מחשוב מבוזרות.

שנות ה-80 הביאו גם התקדמות ביישום שפות תכנות. תנועת המיחשוב עם סט פקודות מצומצם (RISC) בארכיטקטורת המחשב הניחה כי יש לתכנן את החומרה עבור מהדרים ולא עבור מתכנתי שפת הסף אנושיים. בסיוע שיפורי מהירות המעבד (CPU) שאיפשרו שיטות קומפילציה אגרסיביות יותר ויותר, תנועת RISC עוררה עניין רב יותר בטכנולוגיית מהדר לשפות עיליות.

טכנולוגיית השפה המשיכה בקו הזה גם בשנות ה-90.

כמה שפות בולטות שפותחו בתקופה זו כוללות:
 1980 – ++C (כ-"C with classes", שמה שונה ב-1983)
 1983 – עדה
 1984 – Common Lisp
 1984 – MATLAB
 1985 – אייפל
 1986 – Objective-C
 1986 – LabVIEW (שפת תכנות חזותית)
 1986 – Erlang
 1987 – Perl
 1988 – PIC (שפת סימון)
 1988 – Tcl
 1988 – Wolfram Language (כחלק מ-Mathematica, הופרד ביוני 2013)

שנות ה-90: עידן האינטרנט 
הצמיחה המהירה של האינטרנט באמצע שנות ה-90 הייתה האירוע ההיסטורי הגדול הבא בשפות התכנות. באמצעות פתיחת פלטפורמה חדשה לחלוטין למערכות מחשב, האינטרנט יצר הזדמנות לאימוץ שפות חדשות. במיוחד, שפת התכנות JavaScript עלתה לפופולריות בגלל השילוב המוקדם שלה עם דפדפן האינטרנט Netscape Navigator. שפות תסריט שונות אחרות השיגו שימוש נרחב בפיתוח יישומים מותאמים אישית עבור שרתי אינטרנט כגון PHP. שנות ה-90 לא ראו שום חידוש מהותי בשפות אימפרטיביות, אלא הרבה שילוב מחדש והבשלה של רעיונות ישנים. עידן זה החל את התפשטותן של שפות פונקציונליות. היבט נוסף שהשפיע באופן מהותי היה פרודוקטיביות המתכנת. שפות רבות לפיתוח מהיר של יישומים (RAD) צצו, שבדרך כלל הגיעו עם סביבת פיתוח משולבת (IDE), איסוף זבל והיו צאצאים של שפות ישנות יותר. כל השפות הללו היו מונחות עצמים. אלה כללו את ויז'ואל בייסיק, ג'אווה, Object Pascal ו-OCaml. ג'אווה במיוחד זכתה לתשומת לב רבה.

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

כמה שפות בולטות שפותחו בתקופה זו כוללות:
 1990 – Haskell
 1990 – פייתון
 1991 – ויז'ואל בייסיק
 1993 – Lua
 1993 – R
 1994 – CLOS (חלק מה-ANSI Common Lisp)
 1995 – Ruby
 1995 – עדה 95
 1995 – ג'אווה

מגמות עדכניות 
התפתחות שפות התכנות נמשכת, הן בתעשייה והן במחקר. חלק מהמגמות האחרונות כללו:
 תחביר לשיפור תמיכה בתכנות מקבילי ובתכנות מבוזר.
 מנגנונים חלופיים לשילוביות ומודולריות: Mixins, מחלקות טיפוסים, היבטים.
 פיתוח תוכנה מבוסס מוצרי מדף (Component-oriented software development)
 עניין מוגבר בהפצה ובניידות.
 אינטגרציה עם מסדי נתונים, כולל XML ומסדי נתונים יחסיים .
 קוד פתוח כפילוסופיית פיתוח לשפות, כולל אוסף המהדרים של GNU ושפות כגון PHP, Python, Ruby ו- Scala .
 עניין רב יותר בשפות תכנות חזותיות כמו Scratch, LabVIEW ו-PWCT
 שפות מקבילות ביותר עבור יחידות עיבוד גרפיות (GPU) ומערכי מחשבי-על, כולל OpenCL.
 מחקר מוקדם על שפות תכנות במחשוב קוונטי.
 מחקר מוקדם ביישום שיטות בינה מלאכותית (AI) ליצירת קוד באמצעות AI כמו שימוש ב-GPT-3.

כמה שפות בולטות שפותחו בתקופה זו כוללות:
 2000 – ActionScript
 2001 – #C
 2001 – D
 2002 – Scratch
 2003 – Groovy
 2003 – Scala
 2005 – #F
 2005 - Haxe
 2006 – PowerShell
 2007 – Clojure
 2008 – Nim
 2009 – Go
 2010 – Rust
 2011 – Dart
 2011 – Kotlin
 2011 – Red
 2012 – ג'וליה
 2012 – TypeScript
 2012 – Elm
 2012 – Elixir
 2014 – סוויפט
 2014 – קריסטל
 2015 – Raku
 2016 – Zig
 2019 – Bosque
 2021 – Microsoft Power Fx

הערות שוליים

היסטוריה של המחשוב
תכנות
מחשבים