שפת תכנות

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

בניסוח אחר, שפת תכנות היא אוסף של חוקים תחביריים (Syntax) וסמנטיים (Semantic) המגדירים שפה פורמלית. תוכנית הנכתבת בשפת תכנות מגדירה ביצוע תהליך אלגוריתמי. שפת התכנות קובעת את הכלים העומדים לרשות מחבר התוכנית כדי לבצע הגדרות כאלו.

נהוג (וכחלק ממחווה) שהדבר הראשון שלומדים לתכנת, כאשר לומדים שפת תיכנות חדשה, היא תוכנית שתדפיס כפלט על המסך את המסר "hello world".
מאפייני שפות התכנות
שפת תכנות מנסה להגשים בד בבד שלוש תכליות: ראשית, גישור בין התקן מתוכנת (לרוב, מחשב), ש"שפתו", הקרויה לעיתים שפת מכונה, מורכבת מרצפי סיביות, ואשר כל פקודה שבה מבצעת חישוב פשוט ביותר, לבין המתכנת המעדיף להגדיר את התהליך החישובי באורח מילולי, תוך הסתמכות על פקודות בסיסיות חזקות יותר מאלו המצויות בשפת מכונה. שנית, רמת ההפשטה הגבוהה יותר שמציעה שפת תכנות, מסייעת לתקשורת טובה בין מתכנתים. שלישית, שפת תכנות מסייעת למתכנת לארגן ולבטא את הגדרת התהליך החישובי, באופן הנתפס כרצוי על ידי מתכנן שפת התכנות.

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

לכל שפת תכנות, בדומה לשפה טבעית, יש אוצר מילים משלה וכללי תחביר ייחודיים. בכל זאת, הדמיון בין שפות תכנות ושפות טבעיות הוא מוגבל, בעיקר בגלל הדרישה הקריטית לחד משמעיות משפות תכנות. אוצר המילים של שפת תכנות מצומצם ביותר, והוא נע בין עשרות בודדות למאות אחדות של מילים. לכל שפה ישנם כללי תחביר נוקשים שכל חריגה מהם עשויה להתפרש כשגיאה, או לגרום בעיות בהפעלת המערכת כולה. מאפייניה של שפת תכנות כוללים את הרכיבים הבאים:
 נתונים ומבני נתונים, כגון סוגי המספרים שהשפה יודעת לטפל בהם, ומבנים מורכבים יותר המוכרים על ידי השפה, כגון מערכים, רשימות, מבנים, אובייקטים ופונקציות.
 פקודות ומבני בקרה שהשפה יודעת לבצע – הצהרה על משתנים, פעולות אריתמטיות, לולאות וכדומה.
 עקרונות העיצוב של השפה ותפישת העולם שמאחוריה, בין אלה ניתן למנות פרדיגמות כגון תכנות אימפרטיבי (הכולל תכנות מבני ורוב הגרסאות של תכנות מונחה עצמים) לעומת תכנות הצהרתי (כולל תכנות פונקציונלי, תכנות לוגי ותכנות אילוצים), תכנות גנרי ועוד. שפות רבות הן מרובות-פרדיגמות, למשל פייתון ו-#C.
 מערכת הטיפוסים. שפות עשויות להיות בעלות טיפוסיות חזקה, חלשה, או לא קיימת (למשל ב-Pawn ו-Forth). בנוסף ניתן לשאול מתי מתבצעת הבדיקה של תקינות הטיפוסים – דינמית (בזמן ריצה) או סטטית (בזמן הידור). כן ניתן לשאול מי אחראי להצהיר על הטיפוס: המתכנת או המהדר.

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

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

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

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

מעבר משפת תכנות לביצוע בתוכנית
שפת התכנות עצמה אינה מובנת ישירות על ידי המעבד, ולכן יש צורך בתיווך בין התוכנית הכתובה בשפת תכנות ובין המעבד, על מנת שיהיה ניתן להפעיל את התוכנה. מטרה זו ניתן להשיג באחת משלוש דרכים:
 שימוש במהדרים (Compilers) שמקבלים את קוד המקור של התוכנה שכתוב בשפת התכנות ומתרגמים אותו אל קובץ שפת מכונה, שמוכן לביצוע על ידי המעבד. שפה כזו קרויה גם שפה סטטית. בשיטה זו מתקבלים על פי רוב הביצועים הטובים ביותר, אך על פי רוב קשה לנייד תוכניות הכתובות בשפות אלו בין מערכות שונות, ותהליך הפיתוח הוא הפחות ידידותי. דוגמאות לשפות בקטגוריה זו הן: פסקל, C, ++C וגם שפות הוותיקות כגון Cobol, ו-PL/I.
 שימוש במפרשים (Interpreters), הקוראים את התוכנית בשפת תכנות, ומפרשים ומבצעים באופן מיידי את הכתוב בה שורה אחר שורה. שפה מסוג זה קרויה גם שפת תסריט (Scripting Programming Language). או שפה דינמית. שיטה זו ידידותית לפיתוח ונוחה יותר לביצוע שינויים וקלה יותר לניוד בין מערכות, אך מביאה על פי רוב לביצועים נחותים באופן משמעותי מהידור, כיוון שלפני ביצוע כל פעולה קיימת פעולת תרגום. דוגמאות לשפות בקטגוריה הזו הן: בייסיק, PHP, פייתון, Perl, Ruby, VBScript, C Shell, JavaScript.
 עבודה בשיטת שפת ביניים, כלומר הידור אל שפת ביניים (דמוית שפת מכונה), ובזמן ריצה הידור (או פירוש) לשפת מכונה באמצעות "מכונה וירטואלית". שיטה זאת מאפשרת מזעור של התלות בסביבת ההפעלה של התוכנית, וכן מיטוב אלגוריתמים תוך כדי ריצה. הביצועים של שיטה זו זאת טובים מאלה של שפות מפורשות, אך ירודות לעומת שפות מקומפלות כמו C++, בשל השימוש בקוד מנוהל ומכונה וירטואלית. בשיטה זו משתמשות שפת Java שמהודרת ל-bytecode ומפורשת על ידי JVM, וכל שפות סביבת NET. (ביניהן #C), שמהודרות לשפת הביניים CIL.

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

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

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

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

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

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

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

דוגמה לתוכנית
התוכנית המופיעה להלן כתובה בשפת פייתון, והיא בודקת האם מספר שהועבר אליה הוא מספר ראשוני. התוכנית כוללת פונקציה שמקבלת כפרמטר מספר שלם ומחזירה את המחלק הגבוה ביותר שלו. גוף התוכנית מקבל קלט מהמשתמש ובודק האם המחלק הגבוה ביותר שלו הוא אחד. אם כן, זהו מספר ראשוני. אם לא, המספר איננו ראשוני. הטקסט האפור הוא הערות עבור הקורא, ואיננו חלק מהתוכנית.
from math import sqrt # מייבאים" פונקציה שתחשב שורש ריבועי של מספר"

def getHigherDivisor(num): # נגדיר פונקציה שמוצאת את המספר השלם הגדול ביותר המחלק ללא שארית
    for d in range(round(sqrt(num)),0,-1): # עבור כל המספרים מהשורש עד 1, נבדוק את השארית בחלוקה
        if num % d == 0: # אם השארית (%) היא 0, סימן שמצאנו את המחלק הגבוה ביותר
            return d # אנו "מחזירים" את המחלק אל התוכנית הראשית

# :זהו גוף התוכנית
num = int(input("Enter positive integer:")) # פקודה זו מקבלת את הקלט מהמשתמש אל תוך משתנה מסוג מספר

if num < 1: # בדיקת שגיאות: הקלט חייב להיות מספר הגדול מאפס
    raise Exception("The number should be positive") # פקודה לעצירת התוכנית עקב שגיאה

higherDivisor = getHigherDivisor(num) # בדוק מהו המחלק הגבוה ביותר של המספר שהתקבל כקלט
if higherDivisor == 1: # אם המחלק הגבוה ביותר הוא 1, המספר ראשוני
    print(num, " is a prime number.")
else: # אחרת, המספר איננו ראשוני
    print(num, " is not a prime number.")
    print(num, "=", higherDivisor, "x", num/higherDivisor)

התפתחותן של שפות התכנות
מרכז|ממוזער|700px|התפתחות שפות תכנות. במלבן מעוגל מופיעות שפות מונחות עצמים
צעד ראשון להתנתקות מהכורח לכתוב תוכניות בשפת מכונה נעשה עם יצירת האסמבלי. מרבית שפות התכנות הן שפות עיליות, שבהן לפקודות דמיון מסוים לשפה טבעית. כל פקודה בשפה עילית מתורגמת על ידי המהדר לסדרה ארוכה של פקודות בשפת מכונה. בשפת אסמבלי, לעומתן, כל פקודת אסמבלי מתורגמת לפקודה אחת בשפת מכונה (אך למען נוחות הקריאה, לעיתים מתאימות לפקודת מכונה אחת פקודות אסמבלר שונות, המייצגות פונקציות שונות של אותה פקודת מכונה).

בתחילת שנות ה-50 נעשו צעדים ראשונים ביצירת מהדרים, כלומר כלים שיאפשרו כתיבת תוכניות בשפה קרובה יותר לשפת אנוש. בשנת 1952 יצרה גרייס הופר את המהדר הראשון, שנקרא A. בשנת 1953 החל צוות בראשותו של ג'ון באקוס מחברת IBM לפתח את שפת FORTRAN, וצעד זה הושלם בשנת 1957. FORTRAN (ושפת ALGOL שפותחה בעקבותיה בשנת 1958) התאימו במיוחד למשימות מדעיות (שהן תוכניות בתחומי הפיזיקה, המתמטיקה וכדומה) אך התאימו פחות למשימות של עיבוד נתונים. למטרה זו באה לעולם בשנת 1960 שפת COBOL, השונה מ-FORTRAN במידה רבה, ובעלת תחביר המזכיר את השפה האנגלית. היוזמה לפיתוח COBOL באה ממשרד ההגנה האמריקני, ובפרויקט השתתפו נציגים של הממשל האמריקני ויצרני המחשבים. שתי שפות אלה, FORTRAN ו-COBOL, זכו לתפוצה רחבה, והן בשימוש עד עצם היום הזה.

בתחילת שנות ה-60 פותחה שפת LISP, על ידי ג'ון מקארתי מאוניברסיטת MIT. שפה זו יעילה במיוחד בטיפול בטקסטים הכתובים בשפת אנוש, ולכן זכתה להצלחה בקרב חוקרי בינה מלאכותית. מספר שנים לאחר מכן פיתחה חברת IBM את שפת PL/I, שנועדה לשלב את התכונות של FORTRAN ו-COBOL גם יחד, כך שתתאים למשימות תכנות עסקיות ומדעיות כאחד. השפה שפותחה הגשימה יעד זה, וכללה מאפיינים נוספים שנבעו מהניסיון שנצבר בפיתוח שפות תכנות, אך לא זכתה להצלחה שלה זכו שתי קודמותיה. אחד מהפרויקטים הראשונים שפותחו בשפת PL/I הוא מערכת ההפעלה Multics. שפת PL/I נלמדה באוניברסיטאות בישראל (אלה שהעמידו מחשב IBM לרשות תלמידיהן) עד אמצע שנות ה-80. PL/I לא נחשבת לשפה מוצלחת, והלקח שנלמד מהשפה היא שהעמסת פיצ'רים בלבד איננה ערובה להצלחה של שפת תכנות; בעת תכנון השפה ההחלטות החשובות ביותר הן אילו פיצ'רים מוטב להותיר מחוץ לשפה, על מנת ליצור שפה עקבית וקלה ללמידה ופיתוח.

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

בסוף שנות ה-60 פיתח סימור פאפרט את שפת לוגו (LOGO). שפה זו התפתחה משפת LISP, אך התחביר שלה פשוט יותר, כך שתתאים לשימושם של ילדים. שפת BASIC, שפותחה באמצע שנות ה-60 בדארטמות' קולג', נועדה במיוחד לשימושם של תלמידים הכותבים תוכניות באמצעות מסופים. בסוף שנות ה-70 זכתה שפה זו להצלחה רבה על ראשוני המחשבים האישיים, והפכה לכלי פיתוח מקובל למחשבים אישיים.

בשנת 1968 התפרסם מאמרו של א. וו. דייקסטרה, שיצר תפנית בתחביר של שפות תכנות, בהסבו את תשומת הלב לקושי שגורם השימוש בפקודת goto לקריאותן של תוכניות. בעקבות מאמר זה נוצר התכנות המובנה, שבו יש מבני בקרה המאפשרים קריאות גבוהה. שפות קיימות, כגון PL/I, הורחבו כך שיטפלו גם במבני בקרה אלה.

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

בתחילת שנות ה-70 יצר ניקלאוס וירת, במטרה להקל על לימוד תכנות את שפת Pascal, שמימשה היטב את העקרונות של התכנות המובנה, וזכתה לפופולריות רבה באוניברסיטאות. גרסה מסחרית שלה, Turbo Pascal של חברת בורלנד, זכתה להצלחה רבה ככלי לפיתוח תוכנה למחשבים אישיים. השפה נחשבת קלה יחסית ללמידה, אך יש לה חסרונות הנוגעים ליכולת לכתוב באמצעותה מערכות-תוכנה בקנה מידה גדול. זמן מה לאחר מכן פיתח דניס ריצ'י ממעבדות בל את שפת C, והשתמש בה לפיתוח מערכת ההפעלה UNIX. שפה זו פופולרית לתכנות מערכות הפעלה ולפיתוח יישומים והפכה לשפת תכנות נפוצה ביותר. שפה זו השפיעה רבות על פיתוחן של שפות תכנות אחדות, שהבולטת בהן היא C++.

בשפת הסימולציה Simula 67, המתבססת על ALGOL, מומשו לראשונה רעיונות של תכנות מונחה עצמים, פרדיגמה שהבשילה בשפת Smalltalk, שפותחה בשנות ה־70 במעבדות זירוקס פארק. לתפוצה רחבה זכתה מתודולוגיה זו החל משנות ה־90, תחילה בשפת התכנות C++ (שפותחה בשנות ה-80), ולאחריה בשפת Java.

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

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

בשנת 2000 פותחה השפה #C על ידי צוות מחברת מיקרוסופט שבראשו עמד אנדרס הלסברג. שפה זו נבנתה עבור תפיסת .NET אשר ראתה אור בשנת 2002. שפה זו מבוססת על השפות Java ו-++C, ועוצבה במטרה ליצור שפה מונחית-עצמים פשוטה, מודרנית וכללית.

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

רשת האינטרנט נתנה דחיפה לפיתוחן של שפות תכנות אחדות:
 שפות לפיתוח יישומי אינטרנט בצד הלקוח. השפה העיקרית בקטגוריה זו היא JavaScript, שפותחה על ידי חברת Netscape Communications כשפת תסריט שהדפדפן פועל כמפרש שלה. שפה זו העניקה לדפדפן את היכולת לעבור מהצגה סטטית של מידע להצגת דפים דינמיים. התקן לשפה זו קרוי EMCAScript. שפה שהותאמה על ידי חברת מיקרוסופט למטרה זו היא VBScript, שהיא וריאציה פשוטה של Visual Basic.
 שפות לפיתוח יישומי אינטרנט בצד השרת, ובהן PHP, שהיא השפה שבה כתובה התוכנה המשרתת את ויקיפדיה, למשל.

שפת תכנות אזוטרית
שפת תכנות אזוטרית  (Esoteric programming language, לפעמים מקוצר ל-esolang) היא שפת תכנות שנועדה לבחון את גבולות עיצוב שפת תכנות המחשב, כהוכחה לתפיסה, כאומנות תוכנה, כממשק פריצה לשפה אחרת (במיוחד שפות תכנות פונקציונליות או שפות תכנות פרוצדורליות), או כבדיחה. השימוש בשפות ה-esolang נבדל משפות תכנות בהן מפתחים משתמשים לכתיבת תוכנה. אלו שפות תיכנות לכל דבר, עם כללים, דקדוק, ולעיתים תווים ומילים שמורות, אך כיוון שהתחביר הוא לרוב מינימילי, התכנות בהן לעיתים מאוד ארוך ו/או מסובך. השפה האיזוטרית הראשונה היא INTERCAL שנוצרה בשנת 1972, ומאז שפות אלו מתפתחות במקביל להתפתחות השפות המקובלות, אך נעשות יותר ויותר לא קונבנציונליות.
רשימה קצרה לשפות אלו:
 BrainF**k
 WhiteSpace
 chef
 Shakespeare
 Ook
 LOLCODE
 logo

מבנה של שפת תכנות קלאסית
רוב שפות יבנו בצורה של שפת תכנות דינמית וניתוח תוכנה דינמי והתכנות יורכבו מהמרכיבים הבאים:
 הצהרות
 הצהרות הן הוראות כלליות לתוכנה, כך למשל אפשר להצהיר על מיקומה של פונקציה בקובץ מסוים. ואפשר להצהיר על דרך פעולתה של התוכנה, או על סוגי טיפוסים של משתנים.
 הכרזות
 הכרזות הן הוראות ליצירת קבועים ומשתנים בפועל. בניגוד להצהרה, הכרזה יוצרת בפועל עותק של קבוע או משתנה בזיכרון.
 טיפוסים
 הטיפוסים הם הסוגים המיוחדים של קבועים ומשתנים. ישנם טיפוסי מערכת וישנם טיפוסי משתמש שאפשר להגדיר בתוכנה. טיפוסי המשתמש יוגדרו כקבוצה של טיפוסי מערכת (אפשרי מכמה סוגים) שקיימים באופן מובנה בשפה.
 קבועים
 הקבועים הם שטחים בזיכרון שמוגדרים בשם, מסוג של כל טיפוס, שערכם קבוע ואינו יכול להשתנות במהלך הרצת התוכנה. למשל PI הוא קבוע. השימוש בקבועים נועד להקל על ייצוג של מספרים ארוכים ידועים ונועד לרכז ערכים.
 משתנים
 משתנים הם כשמם, שטחים בזיכרון שמוגדרים בשם ומכילים ערך בר שינוי, שהתוכנה אמורה לשנות במהלך הרצתה. ישנם טיפוסי מערכת של המשתנים. (טיפוסי המשתנים הנפוצים הם: מספר (באורכים שונים), נקודה צפה, בוליאני (כן ולא), אלפאנומרי (כל תו, משמש למחרוזות) ומצביע. בשפות מתקדמות יש גם משתנים מסוג מטבע, תאריך, אובייקט, אוספים) וישנם גם מבנים מורכבים של משתנים, הכוללים מערכים ומבנים. לפני השימוש במשתנה יש להכריז עליו.
 מילים שמורות
 לכל שפה יש סדרה של מילים בעלות משמעות לזיהוי ההוראות המוכרות לשפה. כך למשל ל-include בשפת C יש משמעות שקובץ מקודד מסוים יהיה נכלל בתוכנה. בחלק מהשפות אלה הן מילים שמורות, כלומר אסור להשתמש בהן כשמות של משתנים, ובאחרות אין הגבלה כזו.
 אופרטורים
 בכל שפה קיימת קבוצה של אופרטורים, שהם פונקציות בינאריות המיוצגים בדרך כלל באמצעות תו או מילה המופיע בין שני המשתנים (האופרנדים) שעליהם פועל האופרטור. חלק מהאופרטורים שווים בכל שפות התכנות, וחלקם משתנים משפה לשפה. ישנן שפות בהן ניתן להוסיף או לשנות אופרטורים, במיוחד בהקשר של מחלקות חדשות.
 מבני בקרה
 מבני הבקרה הם פקודות המשמשות לבקרת הזרימה של התוכנית. בין מבני הבקרה אפשר לציין תנאים ולולאות. בתנאי אפשר לקבוע שקטע קוד יתקיים רק במקרה מסוים, בלולאה אפשר להורות למחשב לבצע קטע קוד מספר מסוים של פעמים, או רק כאשר תנאי מסוים מתבצע או לא מתבצע.
 שגרות
 שגרה או פרוצדורה היא מקטע קוד שלם, שמבצע תהליך תכנותי, ושיש לו משמעות משלו. יש שפות שאין בהן הבחנה ברורה בין שגרה לבין פונקציה. כדי להפעיל את השגרה יש לקרוא לה באמצעות כתיבת שמה.
 פונקציות
 פונקציה היא מקטע קוד שלם, שמקבל פרמטרים מבצע תהליך ומחזיר ערך כל שהוא. כדי להפעיל את הפונקציה יש לקרוא לה באמצעות כתיבת שמה. אם קוראים לפונקציה מתוך עצמה מתקבלת רקורסיה.

שפות תכנות חזותיות

המעבר לממשק משתמש גרפי, ובפרט הפיכתה של מערכת ההפעלה Windows לדומיננטית, יצר מגמה הולכת ומתפשטת להעניק לשפות התכנות ייצוג חזותי, שהחלה בסביבות פיתוח דוגמת ויז'ואל סטודיו, Asymetrix ToolBook, פאואר בילדר, אובג'קט ויז'ין (ObjectVision) ודלפי, ומחוללי יישומים כדוגמת Oracle JDeveloper ו-אקסס. התכנות החזותי מקצר את תהליך הפיתוח, מקל על תחזוקת התוכנה, ופותח את עולם התכנות לשכבה נוספת של אוכלוסייה, שהייתה מתקשה לפתח בשפות כדוגמת שפת C.

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

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

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

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

היבטים של מגמה זו השפיעו גם על השפות הטקסטואליות #C ו־Java, באמצעות עורכי טפסים ואשפים ליצירת קוד. ברוב מסדי הנתונים נכנסו דפוסים שונים לעיצוב חזותי ועבודה עם מסד הנתונים. אחד המפורסמים שבהם הוא QBE – שהיא שיטה לתכנון ויצירת שאילתות SQL באמצעות עבודה על הייצוג הגרפי שלהן באמצעות העכבר. ישנם כלים מיוחדים שמאפשרים לשרטט סכמה חזותית של ארכיטקטורת מסד הנתונים (ERD) שמומר לקוד ליצירת מסד נתונים.

ראו גם

 שפת תכנות Low-level
 שפת תכנות עילית
 מונחים בתוכנה
 תכנות מחשבים
 תכנות חזותי

קישורים חיצוניים

 Ninety Nine Bottles of Beer, מציג תוכנית אחת ב־1019 שפות תכנות.
 עודד רגב, למה יש מגוון רחב כל-כך של שפות תכנות?, מתוך בלוג "המדריך המלא להייטקיסט המתחיל", 8 בספטמבר 2012
 יוסי גיל, שפות תכנות, באתר הטכניון
 codemonkey – הקוף והבננה, משחק תכנות המלמד את שפת התכנות.



הערות שוליים

*
קטגוריה:ערכים שבהם תבנית אתר רשמי אינה מתאימה להוספה אוטומטית
תכנות
קטגוריה:ויקיפדיה - ערכים מומלצים לשעבר
קטגוריה:מונחים בתוכנה