โปรแกรมคอมพิวเตอร์คือลำดับหรือชุด^{[ a ]}ของคำสั่งในภาษาโปรแกรมเพื่อให้คอมพิวเตอร์ดำเนินการเป็นส่วนประกอบหนึ่งของซอฟต์แวร์ซึ่งรวมถึงเอกสารและส่วนประกอบที่จับต้องไม่ได้อื่นๆ ด้วย ^{[ 1 ]}

โปรแกรมคอมพิวเตอร์ใน รูปแบบ ที่มนุษย์อ่านได้เรียกว่าซอร์สโค้ดซอร์สโค้ดต้องการโปรแกรมคอมพิวเตอร์อื่นเพื่อประมวลผล เนื่องจากคอมพิวเตอร์สามารถประมวลผลได้เฉพาะคำสั่งเครื่อง ดั้งเดิมเท่านั้น ดังนั้น ซอร์สโค้ดจึงอาจถูกแปลงเป็นคำสั่งเครื่องโดยใช้คอมไพเลอร์ที่เขียนขึ้นสำหรับภาษานั้น ( โปรแกรมภาษาแอสเซมบลี จะถูกแปลงโดยใช้ แอสเซมเบลอร์ ) ไฟล์ที่ได้เรียกว่าไฟล์ปฏิบัติการหรืออีกทางหนึ่ง ซอร์สโค้ดอาจประมวลผลภายในอินเตอร์พรีเตอร์ที่เขียนขึ้นสำหรับภาษานั้น^{[ 2 ]}

หากมีการร้องขอไฟล์ปฏิบัติการเพื่อดำเนินการ^{[ b ]}ระบบปฏิบัติการจะโหลดไฟล์นั้นลงในหน่วยความจำ^{[ 3 ]}และเริ่มกระบวนการ[ ^{4 ] หน่วย}ประมวลผลกลางจะสลับไปยังกระบวนการนี้ในไม่ช้า เพื่อให้สามารถดึงข้อมูล ถอดรหัส และดำเนินการคำสั่งเครื่องแต่ละคำสั่งได้^{[ 5 ]}

หากมีการร้องขอโค้ดต้นฉบับเพื่อดำเนินการ ระบบปฏิบัติการจะโหลดตัวแปลภาษาที่เกี่ยวข้องลงในหน่วยความจำและเริ่มกระบวนการ จากนั้นตัวแปลภาษาจะโหลดโค้ดต้นฉบับลงในหน่วยความจำเพื่อแปลและดำเนินการแต่ละคำสั่งการรันโค้ดต้นฉบับจะช้ากว่าการรันไฟล์ปฏิบัติการ^{[ 6 ] [ c ]}นอกจากนี้ ตัวแปลภาษาจะต้องได้รับการติดตั้งบนคอมพิวเตอร์

โปรแกรม"Hello, World!"ใช้เพื่อแสดงไวยากรณ์พื้นฐานของภาษา ไวยากรณ์ของภาษาBASIC (1964) ถูกจำกัดโดยเจตนาเพื่อให้เรียนรู้ภาษาได้ง่าย^{[ 7 ]}ตัวอย่างเช่นตัวแปรจะไม่ถูกประกาศก่อนใช้งาน^{[ 8 ]}นอกจากนี้ ตัวแปรจะถูกกำหนดค่าเริ่มต้นเป็นศูนย์โดยอัตโนมัติ^{[ 8 ]}นี่คือตัวอย่างโปรแกรมคอมพิวเตอร์ในภาษา Basic เพื่อ หาค่า เฉลี่ยของรายการตัวเลข: ^{[ 9 ]}

10 INPUT "ต้องการหาค่าเฉลี่ยของตัวเลขกี่ตัว?" , A 20 FOR I = 1 TO A 30 INPUT "ป้อนตัวเลข:" , B 40 LET C = C + B 50 NEXT I 60 LET D = C / A 70 PRINT "ค่าเฉลี่ยคือ" , D 80 END

เมื่อเรียนรู้กลไกการเขียนโปรแกรมคอมพิวเตอร์ขั้นพื้นฐานแล้ว ก็สามารถใช้ภาษาที่ซับซ้อนและทรงพลังกว่าในการสร้างระบบคอมพิวเตอร์ขนาดใหญ่ได้^{[ 10 ]}

การพัฒนาซอฟต์แวร์ที่ดีขึ้นเป็นผลมาจากการพัฒนาฮาร์ดแวร์คอมพิวเตอร์ในแต่ละช่วงของประวัติศาสตร์ฮาร์ดแวร์ งานเขียนโปรแกรมคอมพิวเตอร์ก็เปลี่ยนแปลงไปอย่างมาก

ในปี ค.ศ. 1837 เครื่องทอผ้าของจาการ์ดเป็นแรงบันดาลใจให้ชาร์ลส์ แบ็บเบจพยายามสร้างเครื่องวิเคราะห์^{[ 11 ]} ชื่อของส่วนประกอบต่างๆ ของอุปกรณ์คำนวณนั้นยืมมาจากอุตสาหกรรมสิ่งทอ ในอุตสาหกรรมสิ่งทอ เส้นด้ายจะถูกนำมาจากโกดังเพื่อนำไปปั่น อุปกรณ์นี้มีโกดังเก็บข้อมูลซึ่งประกอบด้วยหน่วยความจำสำหรับเก็บตัวเลข 1,000 ตัว โดยแต่ละตัวมีทศนิยม 50 หลัก^{[ 12 ]}ตัวเลขจากโกดังจะถูกถ่ายโอนไปยังโรงงานเพื่อประมวลผล เครื่องนี้ถูกตั้งโปรแกรมโดยใช้การ์ดเจาะรูสองชุด ชุดหนึ่งควบคุมการทำงาน และอีกชุดหนึ่งป้อนตัวแปร^{[ 11 ] [ 13 ]}อย่างไรก็ตาม ล้อและเฟืองหลายพันตัวไม่เคยทำงานร่วมกันได้อย่างสมบูรณ์^{[ 14 ]}

Ada Lovelaceทำงานให้กับ Charles Babbage เพื่อสร้างคำอธิบายของ Analytical Engine (1843) ^{[ 15 ]}คำอธิบายดังกล่าวมีหมายเหตุ G ซึ่งอธิบายวิธีการคำนวณเลข Bernoulli โดยใช้ Analytical Engine อย่างละเอียด หมายเหตุนี้ได้รับการยอมรับจากนักประวัติศาสตร์บางคนว่าเป็น โปรแกรมคอมพิวเตอร์เครื่องแรกของโลก^{[ 14 ]}

ในปี พ.ศ. 2479 อลัน ทิวริงได้แนะนำเครื่องจักรทิวริงสากลซึ่งเป็นอุปกรณ์เชิงทฤษฎีที่สามารถจำลองการคำนวณทุกอย่างได้^{[ 16 ]} มันเป็นเครื่องจักรสถานะจำกัดที่มีเทปอ่าน/เขียนที่ยาวไม่สิ้นสุด เครื่องจักรสามารถเลื่อนเทปไปมา เปลี่ยนเนื้อหาของเทปขณะที่ดำเนินการอัลกอริทึมเครื่องจักรเริ่มต้นในสถานะเริ่มต้น ผ่านลำดับขั้นตอน และหยุดเมื่อพบสถานะหยุด^{[ 17 ]}คอมพิวเตอร์ในปัจจุบันทั้งหมดมีความสมบูรณ์แบบตามทฤษฎีของทิวริง^{[ 18 ]}

เครื่องคำนวณเชิงตัวเลขอิเล็กทรอนิกส์ (ENIAC) ถูกสร้างขึ้นระหว่างเดือนกรกฎาคม พ.ศ. 2486 ถึงฤดูใบไม้ร่วง พ.ศ. 2488 เป็นคอมพิวเตอร์อเนกประสงค์ที่สมบูรณ์แบบตามทฤษฎีของทัวริง ซึ่งใช้หลอดสุญญากาศ 17,468 หลอด ในการสร้างวงจรโดยแกนหลักคือชุดของเครื่อง Pascalineที่ต่อสายเข้าด้วยกัน^{[ 19 ]}เครื่องจำนวน 40 เครื่องมีน้ำหนัก 30 ตัน ใช้พื้นที่ 1,800 ตารางฟุต (167 ตารางเมตร⁾และใช้ไฟฟ้า 650 ดอลลาร์ต่อชั่วโมง ( ในสกุลเงินปี 2483 ) เมื่อไม่ได้ใช้งาน ^{[ 19 ]}มีตัวสะสมฐาน 10 จำนวน 20 ตัว การตั้งโปรแกรม ENIAC ใช้เวลานานถึงสองเดือน^{[ 19 ]}โต๊ะฟังก์ชันสามโต๊ะมีล้อและต้องกลิ้งไปยังแผงฟังก์ชันที่ติดตั้ง โต๊ะฟังก์ชันเชื่อมต่อกับแผงฟังก์ชันโดยการเสียบสายเคเบิลสีดำขนาดใหญ่เข้ากับแผงเสียบแต่ละโต๊ะฟังก์ชันมีปุ่มหมุน 728 ปุ่ม การตั้งโปรแกรม ENIAC ยังเกี่ยวข้องกับการตั้งค่าสวิตช์บางส่วนจากทั้งหมด 3,000 ตัวด้วย การแก้ไขข้อผิดพลาดของโปรแกรมใช้เวลาหนึ่งสัปดาห์^{[ 20 ]} โปรแกรม นี้ทำงานตั้งแต่ปีพ.ศ. 2490 จนถึงปีพ.ศ. 2498 ที่Aberdeen Proving Groundโดยคำนวณพารามิเตอร์ของระเบิดไฮโดรเจน ทำนายรูปแบบสภาพอากาศ และสร้างตารางการยิงเพื่อเล็งปืนใหญ่^{[ 21 ]}

แทนที่จะเสียบสายไฟและเปิดสวิตช์คอมพิวเตอร์แบบโปรแกรมจัดเก็บจะโหลดคำสั่งลงในหน่วยความจำเช่นเดียวกับการโหลดข้อมูลลงในหน่วยความจำ^{[ 22 ]}ด้วยเหตุนี้ คอมพิวเตอร์จึงสามารถตั้งโปรแกรมได้อย่างรวดเร็วและทำการคำนวณด้วยความเร็วสูงมาก^{[ 23 ]} Presper EckertและJohn Mauchlyสร้าง ENIAC วิศวกรทั้งสองได้แนะนำแนวคิดโปรแกรมจัดเก็บในบันทึกสามหน้าซึ่งลงวันที่เดือนกุมภาพันธ์ พ.ศ. 2487 ^{[ 24 ]}ต่อมาในเดือนกันยายน พ.ศ. 2487 John von Neumannเริ่มทำงานในโครงการ ENIAC ในวันที่ 30 มิถุนายน พ.ศ. 2488 von Neumann ได้เผยแพร่รายงานฉบับร่างแรกเกี่ยวกับ EDVACซึ่งเปรียบเทียบโครงสร้างของคอมพิวเตอร์กับโครงสร้างของสมองมนุษย์^{[ 23 ]}การออกแบบนี้กลายเป็นที่รู้จักในชื่อสถาปัตยกรรมvon Neumannสถาปัตยกรรมนี้ถูกนำไปใช้พร้อมกันในการก่อสร้าง คอมพิวเตอร์ EDVACและEDSACในปี พ.ศ. 2492 ^{[ 25 ] [ 26 ]}

IBM System/360 (1964) เป็นตระกูลคอมพิวเตอร์ที่มีสถาปัตยกรรมชุดคำสั่ง เดียวกัน รุ่นModel 20เป็นรุ่นที่เล็กที่สุดและราคาถูกที่สุด ลูกค้าสามารถอัปเกรดและใช้งานซอฟต์แวร์แอปพลิเคชันเดิมได้[ 27 ^{]รุ่นModel} 195 เป็นรุ่นพรีเมียมที่สุด แต่ละรุ่นของ System/360 มีคุณสมบัติมัลติโปรแกรมมิ่ง^{[ 27 ]}ซึ่งหมายถึงการมีหลายกระบวนการในหน่วยความจำพร้อมกัน เมื่อกระบวนการหนึ่งกำลังรออินพุต/เอาต์พุตอีกกระบวนการหนึ่งก็สามารถคำนวณได้

IBM วางแผนให้แต่ละรุ่นเขียนโปรแกรมโดยใช้PL/I [ ^{28 ] มี}การจัดตั้งคณะกรรมการซึ่งประกอบด้วย โปรแกรมเมอร์ COBOL , FORTRANและALGOLจุดประสงค์คือเพื่อพัฒนาภาษาที่ครอบคลุม ใช้งานง่าย ขยายได้ และจะมาแทนที่ COBOL และ FORTRAN ^{[ 28 ]}ผลลัพธ์ที่ได้คือภาษาขนาดใหญ่และซับซ้อนซึ่งใช้เวลานานในการคอมไพล์^{[ 29 ]}

คอมพิวเตอร์ที่ผลิตจนถึงทศวรรษ 1970 มีสวิตช์แผงด้านหน้าสำหรับการตั้งโปรแกรมด้วยตนเอง^{[ 30 ]}โปรแกรมคอมพิวเตอร์ถูกเขียนลงบนกระดาษเพื่อใช้อ้างอิง คำสั่งจะถูกแทนด้วยการกำหนดค่าของการตั้งค่าเปิด/ปิด หลังจากตั้งค่าการกำหนดค่าแล้ว จะกดปุ่มดำเนินการ จากนั้นกระบวนการนี้จะถูกทำซ้ำ โปรแกรมคอมพิวเตอร์ยังถูกป้อนโดยอัตโนมัติผ่านเทปกระดาษบัตรเจาะรูหรือเทปแม่เหล็กหลังจากโหลดสื่อแล้ว ที่อยู่เริ่มต้นจะถูกตั้งค่าผ่านสวิตช์ และกดปุ่มดำเนินการ^{[ 30 ]}

ความก้าวหน้าครั้งสำคัญในการพัฒนาซอฟต์แวร์คือการคิดค้น วงจร รวมขนาดใหญ่มาก (VLSI) (ปี 1964)

โรเบิร์ต นอยซ์ผู้ร่วมก่อตั้งFairchild Semiconductor (1957) และIntel (1968) ได้พัฒนาเทคโนโลยีเพื่อปรับปรุงการผลิตทรานซิสเตอร์แบบสนามไฟฟ้า (1963) ^{[ 31 ]}เป้าหมายคือการเปลี่ยนแปลงความต้านทานไฟฟ้าและการนำไฟฟ้าของรอยต่อเซมิคอนดักเตอร์ขั้นแรกแร่ซิลิเกต ที่เกิดขึ้นตามธรรมชาติ จะถูกแปลงเป็นแท่งโพลีซิลิคอนโดย ใช้ กระบวนการ Siemens ^{[ 32 ]} จากนั้น กระบวนการCzochralskiจะแปลงแท่งเหล่านั้นเป็นผลึกซิลิคอนโมโนคริสตัลไลน์แบบบูล[ 33 ] จากนั้นผลึก^{จะถูกหั่น}เป็นแผ่นบางๆ เพื่อสร้างพื้นผิวเวเฟอร์จากนั้นกระบวนการโฟโตลิโทกราฟีแบบระนาบ จะ รวมทรานซิสเตอร์แบบขั้วเดียวตัวเก็บประจุไดโอดและตัวต้านทาน^{[ 34 ]}ลงบนเวเฟอร์เพื่อสร้างเมทริกซ์ของ ทรานซิสเตอร์ โลหะออกไซด์เซมิคอนดักเตอร์ (MOS) ทรานซิสเตอร์ MOS เป็นส่วนประกอบหลักในชิปวงจรรวม^{[ 31 ]}

เดิมที ชิป วงจรรวม (Integrated Circuit Chips) จะถูกกำหนดหน้าที่การทำงานตั้งแต่ขั้นตอนการผลิต ในช่วงทศวรรษ 1960 การควบคุมการไหลของกระแสไฟฟ้าได้เปลี่ยนไปเป็นการเขียนโปรแกรมลงในเมทริกซ์หน่วยความจำแบบอ่านอย่างเดียว (ROM) เมทริกซ์นี้มีลักษณะคล้ายกับแผงฟิวส์สองมิติ กระบวนการในการฝังคำสั่งลงในเมทริกซ์คือการทำลายการเชื่อมต่อที่ไม่จำเป็นออกไป

ในปี พ.ศ. 2512 Busicomบริษัทผลิตเครื่องคิดเลขของญี่ปุ่น ได้ทำสัญญากับIntelเพื่อผลิตชิปวงจรรวม 12 ชิ้น โดยแต่ละชิ้นทำหน้าที่เฉพาะในเครื่องคิดเลขTed Hoffวิศวกรที่ได้รับมอบหมายงานนี้ ตระหนักว่าเขาสามารถสร้างชิปเพียงชิ้นเดียวที่สามารถประมวลผลโปรแกรมคอมพิวเตอร์เพื่อทำหน้าที่ทั้ง 12 ฟังก์ชันของเครื่องคิดเลขได้^{[ 35 ]} ชิปที่ได้นั้นเรียกว่าไมโครโปรเซสเซอร์Intel 4004

ปัจจุบัน คำว่าไมโครโปรเซสเซอร์และหน่วยประมวลผลกลาง (CPU) ถูกใช้แทนกันได้ อย่างไรก็ตาม CPU มีมาก่อนไมโครโปรเซสเซอร์ ตัวอย่างเช่นIBM System/360 (1964) มี CPU ที่ทำจากแผงวงจรที่มีส่วนประกอบแยกชิ้นบนแผ่นเซรามิก^{[ 36 ]}

ในปี พ.ศ. 2521 สภาพแวดล้อมการพัฒนาซอฟต์แวร์สมัยใหม่ได้เริ่มต้นขึ้นเมื่อ Intel อัปเกรดIntel 8080เป็นIntel 8086 Intel ได้ลดความซับซ้อนของ Intel 8086 เพื่อผลิตIntel 8088ที่ ราคาถูกกว่า ^{[ 37 ]} IBMได้นำ Intel 8088 มาใช้เมื่อเข้าสู่ ตลาด คอมพิวเตอร์ส่วนบุคคล (พ.ศ. 2524) เมื่อความต้องการของผู้บริโภค สำหรับคอมพิวเตอร์ส่วนบุคคลเพิ่มขึ้น การพัฒนาไมโครโปรเซสเซอร์ของ Intel ก็เพิ่มขึ้นเช่นกัน ลำดับการพัฒนานี้เรียกว่าซีรี่ส์ x86ภาษาแอสเซมบลี x86เป็นตระกูลของคำสั่งเครื่องที่เข้ากันได้กับ เวอร์ชันก่อนหน้า คำสั่งเครื่องที่สร้างขึ้นในไมโครโปรเซสเซอร์รุ่นก่อนหน้าจะถูกเก็บรักษาไว้ตลอดการอัปเกรดไมโครโปรเซสเซอร์ ทำให้ผู้บริโภคสามารถซื้อคอมพิวเตอร์เครื่องใหม่ได้โดยไม่ต้องซื้อ ซอฟต์แวร์แอปพลิเคชันใหม่หมวดหมู่หลักของคำสั่ง ได้แก่: ^{[ d ]}

• คำสั่งหน่วยความจำสำหรับตั้งค่าและเข้าถึงตัวเลขและสตริงในหน่วยความจำแบบเข้าถึงโดยสุ่ม (RAM )
• คำสั่ง หน่วยประมวลผลทางคณิตศาสตร์และตรรกะ(ALU) สำหรับดำเนินการคำนวณทางคณิตศาสตร์ ขั้นพื้นฐาน กับจำนวนเต็ม
• คำสั่ง ALU สำหรับการคำนวณเลขทศนิยม เพื่อดำเนินการทางคณิตศาสตร์พื้นฐานกับจำนวนจริง
• คำสั่ง Call Stackเพื่อเพิ่มและลบคำที่จำเป็นในการจัดสรรหน่วยความจำและเชื่อมต่อกับฟังก์ชันต่างๆ
• คำสั่ง Single instruction, multiple data (SIMD) ^{[ e ]}เพื่อเพิ่มความเร็วเมื่อมีโปรเซสเซอร์หลายตัวพร้อมใช้งานเพื่อดำเนินการอัลกอริทึม เดียวกัน กับอาร์เรย์ของข้อมูล

วงจร VLSI ช่วยให้สภาพแวดล้อมการเขียนโปรแกรมพัฒนาจากเทอร์มินัลคอมพิวเตอร์ (จนถึงช่วงทศวรรษ 1990) ไปสู่ คอมพิวเตอร์ ที่มีส่วนติดต่อผู้ใช้แบบกราฟิก (GUI) เทอร์มินัลคอมพิวเตอร์จำกัดโปรแกรมเมอร์ให้ใช้ได้เพียง เชลล์เดียวที่ทำงานในสภาพแวดล้อมแบบบรรทัดคำสั่งในช่วงทศวรรษ 1970 การแก้ไขซอร์สโค้ดแบบเต็มหน้าจอเป็นไปได้ผ่านส่วนติดต่อผู้ใช้แบบข้อความไม่ว่าเทคโนโลยีที่มีอยู่จะเป็นอย่างไร เป้าหมายก็คือการเขียนโปรแกรมด้วยภาษา โปรแกรม

คุณสมบัติของภาษาการเขียนโปรแกรมมีอยู่เพื่อให้มีส่วนประกอบพื้นฐานที่จะนำมารวมกันเพื่อแสดงอุดมคติของการเขียนโปรแกรม^{[ 38 ]}ตามอุดมคติแล้ว ภาษาการเขียนโปรแกรมควร: ^{[ 38 ]}

• ถ่ายทอดความคิดโดยตรงผ่านโค้ด
• แสดงความคิดที่เป็นอิสระอย่างเป็นอิสระ
• แสดงความสัมพันธ์ระหว่างแนวคิดต่างๆ โดยตรงในโค้ด
• ผสมผสานความคิดอย่างอิสระ
• ควรผสมผสานแนวคิดต่างๆ เฉพาะในกรณีที่การผสมผสานนั้นเหมาะสมเท่านั้น
• นำเสนอแนวคิดง่ายๆ ด้วยถ้อยคำที่เรียบง่าย

รูปแบบการเขียนโปรแกรมของภาษาโปรแกรมเพื่อให้ส่วนประกอบพื้นฐานเหล่านี้สามารถจัดประเภทเป็นกระบวนทัศน์การเขียนโปรแกรมได้^{[ 39 ]}ตัวอย่างเช่น กระบวนทัศน์ที่แตกต่างกันอาจแยกแยะได้ดังนี้: ^{[ 39 ]}

• ภาษาเชิงกระบวนการภาษาเชิงฟังก์ชันและภาษาเชิงตรรกะ
• ระดับนามธรรมของข้อมูลที่ แตกต่างกัน
• ระดับต่างๆ ของ ลำดับชั้น ทางสังคม
• ระดับต่างๆ ของชนิดข้อมูล อินพุต เช่นชนิดข้อมูลคอนเทนเนอร์และ การ เขียนโปรแกรมแบบเจเนริก

รูปแบบการเขียนโปรแกรมแต่ละแบบนี้มีส่วนช่วยในการสังเคราะห์ภาษาการเขียนโปรแกรมที่ แตกต่างกัน ^{[ 39 ]}

ภาษาโปรแกรมคือชุดของคำหลักสัญลักษณ์ตัวระบุและกฎที่โปรแกรมเมอร์สามารถสื่อสารคำสั่งไปยังคอมพิวเตอร์ได้[ ^{40 ] โดย}ปฏิบัติตามชุดของกฎที่เรียกว่าไวยากรณ์^{[ 40 ]}

• คำหลักคือคำสงวนที่ใช้ในการสร้างข้อความและคำแถลง
• สัญลักษณ์คืออักขระที่ใช้ในการสร้างการดำเนินการการกำหนดค่าการควบคุมการไหลของโปรแกรมและตัวคั่น
• คำระบุตัวตนคือคำที่โปรแกรมเมอร์สร้างขึ้นเพื่อใช้ในการกำหนดค่าคงที่ชื่อตัวแปรชื่อโครงสร้างและชื่อฟังก์ชัน
• กฎไวยากรณ์ถูกกำหนดในรูปแบบ Backus– Naur

ภาษาโปรแกรมได้รับพื้นฐานมาจากภาษาทางการ [ ^{41 ] จุด}ประสงค์ของการกำหนดวิธีแก้ปัญหาในแง่ของภาษาทางการคือการสร้างอัลกอริทึมเพื่อแก้ปัญหาพื้นฐาน^{[ 41 ]}อัลกอริทึมคือลำดับของคำสั่งง่ายๆ ที่แก้ปัญหา^{[ 42 ]}

วิวัฒนาการของภาษาโปรแกรมเริ่มขึ้นเมื่อEDSAC (1949) ใช้ โปรแกรมคอมพิวเตอร์ที่จัดเก็บไว้เป็นครั้งแรกในสถาปัตยกรรม von Neumann ^{[ 43 ]}การเขียนโปรแกรม EDSAC อยู่ในภาษาโปรแกรมรุ่น แรก ^{[ 44 ]}

• ภาษาโปรแกรมรุ่นแรกคือภาษาเครื่อง[ ^{45 ] ภาษา}เครื่องต้องการให้โปรแกรมเมอร์ป้อนคำสั่งโดยใช้หมายเลขคำสั่งที่เรียกว่ารหัสเครื่องตัวอย่างเช่น การดำเนินการ ADD บนPDP-11มีหมายเลขคำสั่ง 24576 ^{[ f ] [ 46 ]}

• ภาษาโปรแกรมรุ่นที่สองคือภาษาแอสเซมบลี [ ^{45 ] ภาษา}แอสเซมบลีช่วยให้โปรแกรมเมอร์สามารถใช้คำสั่งแบบจำ แทนการจำหมายเลขคำสั่งได้แอสเซมเบลอร์จะแปลงคำสั่งแบบจำในภาษาแอสเซมบลีแต่ละคำสั่งให้เป็นหมายเลขในภาษาเครื่อง ตัวอย่างเช่น บน PDP-11 การดำเนินการ 24576 สามารถอ้างอิงได้เป็น ADD R0,R0 ในซอร์สโค้ด^{[ 46 ]}การดำเนินการทางคณิตศาสตร์พื้นฐานสี่อย่างมีคำสั่งแอสเซมบลี เช่น ADD, SUB, MUL และ DIV ^{[ 46 ]}แอสเซมเบลอร์ยังมีคำสั่งเช่น DW (Define Word ) เพื่อสำรอง เซลล์หน่วย ความจำจากนั้นคำสั่ง MOV สามารถคัดลอกจำนวนเต็มระหว่างรีจิสเตอร์และเซลล์หน่วยความจำเหล่านั้นได้

• โครงสร้างพื้นฐานของคำสั่งภาษาแอสเซมบลีประกอบด้วยป้ายกำกับการดำเนินการ ตัว ถูกดำเนินการและคำอธิบาย^{[ 47 ]}

• ป้ายกำกับช่วยให้โปรแกรมเมอร์สามารถทำงานกับชื่อตัวแปรได้ต่อมาตัวประกอบโปรแกรมจะแปลงป้ายกำกับเหล่านั้นเป็นที่อยู่หน่วยความจำจริง
• การดำเนินการต่างๆช่วยให้โปรแกรมเมอร์สามารถทำงานกับตัวช่วยจำ (mnemonics) ได้
• ตัวถูกดำเนินการจะบอกแอสเซมเบลอร์ว่าข้อมูลใดที่การดำเนินการนั้นจะประมวลผล แอสเซมเบลอร์จะแปลงตัวย่อและตัวถูกดำเนินการให้เป็นหมายเลขคำสั่งในภายหลัง
• การใส่คำอธิบายช่วยให้โปรแกรมเมอร์สามารถเล่าเรื่องราวได้ชัดเจนขึ้น เพราะคำสั่งเพียงอย่างเดียวอาจเข้าใจยากสำหรับมนุษย์

ลักษณะสำคัญของโปรแกรมภาษาแอสเซมบลีคือการสร้างการจับคู่แบบหนึ่งต่อหนึ่งกับเป้าหมายภาษาเครื่องที่สอดคล้องกัน^{[ 48 ]}

• ภาษาโปรแกรมรุ่นที่สามใช้คอมไพเลอร์และอินเตอร์พรีเตอร์ในการประมวลผลโปรแกรมคอมพิวเตอร์ คุณลักษณะเด่นของ ภาษาโปรแกรม รุ่นที่สามคือความเป็นอิสระจากฮาร์ดแวร์เฉพาะ^{[ 49 ]}ภาษารุ่นแรกๆ ได้แก่FORTAN (1958), COBOL (1959), ALGOL (1960) และBASIC (1964) ^{[ 45 ]}ในปี 1973 ภาษาโปรแกรม Cได้ถือกำเนิดขึ้นในฐานะภาษาโปรแกรมระดับสูงที่สร้างคำสั่งภาษาเครื่องที่มีประสิทธิภาพ^{[ 50 ]}ในขณะที่ ภาษาโปรแกรม รุ่นที่สามในอดีตสร้างคำสั่งเครื่องจำนวนมากสำหรับแต่ละคำสั่ง^{[ 51 ]}ภาษา C มีคำสั่งที่อาจสร้างคำสั่งเครื่องเพียงคำสั่งเดียว^{[ g ]}ยิ่งไปกว่านั้นคอมไพเลอร์ที่ปรับแต่งประสิทธิภาพอาจลบล้างคำสั่งของโปรแกรมเมอร์และสร้างคำสั่งเครื่องน้อยกว่าคำสั่ง ปัจจุบัน ภาษาโปรแกรมหลายรูปแบบได้เติมเต็มสเปกตรัมของภาษาโปรแกรมเชิงคำสั่งรุ่นที่สาม

• ภาษาโปรแกรมรุ่นที่สี่เน้นผลลัพธ์ที่ต้องการมากกว่าวิธีการสร้างคำสั่งโปรแกรม^{[ 45 ]}ภาษาเชิงประกาศพยายามจำกัดผลข้างเคียงและอนุญาตให้โปรแกรมเมอร์เขียนโค้ดโดยมีข้อผิดพลาดน้อยลง^{[ 45 ]} ภาษาโปรแกรม รุ่นที่สี่ที่เป็นที่นิยมภาษาหนึ่งเรียกว่าภาษาการสอบถามเชิงโครงสร้าง (SQL) ^{[ 45 ]} นักพัฒนา ฐานข้อมูลไม่จำเป็นต้องประมวลผลแต่ละระเบียนฐานข้อมูลทีละรายการอีกต่อไป นอกจากนี้คำสั่งเลือก แบบง่ายๆ สามารถสร้างระเบียนเอาต์พุตได้โดยไม่ต้องเข้าใจวิธีการดึงข้อมูล

ภาษาเชิงคำสั่งระบุอัลกอริทึม ตามลำดับ โดยใช้การประกาศนิพจน์และคำสั่ง : ^{[ 52 ]}

• การประกาศจะแนะนำ ชื่อ ตัวแปรให้กับโปรแกรมคอมพิวเตอร์และกำหนดให้กับชนิดข้อมูล^{[ 53 ]} – ตัวอย่างเช่น:var x: integer;
• นิพจน์จะให้ค่าออกมา – ตัวอย่างเช่น: 2 + 2ให้ค่าเป็น 4
• คำสั่งอาจกำหนดค่าให้กับตัวแปร หรือใช้ค่าของตัวแปรเพื่อเปลี่ยนแปลงการควบคุมการทำงาน ของโปรแกรม ตัวอย่างเช่น:x := 2 + 2; if x = 4 then do_something();

FORTRAN (1958) เปิดตัวในชื่อ "ระบบแปลสูตรคณิตศาสตร์ของ IBM" ออกแบบมาเพื่อการคำนวณทางวิทยาศาสตร์ โดยไม่มี ฟังก์ชันการจัดการ สตริงนอกจากการประกาศตัวแปร นิพจน์และคำสั่งแล้ว ยังรองรับ:

• อาร์เรย์​
• ซับรูทีน
• ลู ป"do"

มันประสบความสำเร็จเพราะ:

• ค่าใช้จ่ายในการเขียนโปรแกรมและการแก้ไขข้อผิดพลาดต่ำกว่าค่าใช้จ่ายในการใช้งานคอมพิวเตอร์
• โครงการนี้ได้รับการสนับสนุนจาก IBM
• แอปพลิเคชันในขณะนั้นเป็นไปในเชิงวิทยาศาสตร์^{[ 54 ]}

อย่างไรก็ตาม ผู้จำหน่ายที่ไม่ใช่ IBM ก็ได้เขียนคอมไพเลอร์ Fortran เช่นกัน แต่มีไวยากรณ์ที่อาจทำให้คอมไพเลอร์ของ IBM ล้มเหลว^{[ 54 ]}สถาบันมาตรฐานแห่งชาติอเมริกัน (ANSI) ได้พัฒนามาตรฐาน Fortran ฉบับแรกในปี 1966 ในปี 1978 Fortran 77 ได้กลายเป็นมาตรฐานจนถึงปี 1991 Fortran 90 รองรับ:

• บันทึก​
• ตัวชี้ไปยังอาร์เรย์

COBOL (1959) ย่อมาจาก "COmmon Business Oriented Language" (ภาษาที่เน้นธุรกิจทั่วไป) Fortran ใช้สัญลักษณ์ในการประมวลผล ต่อมาจึงได้ตระหนักว่าสัญลักษณ์ไม่จำเป็นต้องเป็นตัวเลข จึงได้มีการนำสตริง มาใช้ ^{[ 55 ]}กระทรวงกลาโหมของสหรัฐอเมริกามีอิทธิพลต่อการพัฒนา COBOL โดยGrace Hopperเป็นผู้มีส่วนร่วมสำคัญ คำสั่งต่างๆ มีลักษณะคล้ายภาษาอังกฤษและค่อนข้างละเอียด เป้าหมายคือการออกแบบภาษาเพื่อให้ผู้จัดการสามารถอ่านโปรแกรมได้ อย่างไรก็ตาม การขาดคำสั่งที่มีโครงสร้างทำให้เป้าหมายนี้เป็นไปได้ยาก^{[ 56 ]}

การพัฒนา COBOL ถูกควบคุมอย่างเข้มงวด ดังนั้นจึงไม่มีภาษาถิ่นเกิดขึ้นที่ต้องใช้มาตรฐาน ANSI ส่งผลให้ไม่มีการเปลี่ยนแปลงเป็นเวลา 15 ปี จนกระทั่งปี 1974 เวอร์ชันในช่วงทศวรรษ 1990 ได้ทำการเปลี่ยนแปลงที่สำคัญ เช่น การ เขียนโปรแกรมเชิงวัตถุ^{[ 56 ]}

ALGOL (1960) ย่อมาจาก "ALGOrithmic Language" ซึ่งมีอิทธิพลอย่างมากต่อการออกแบบภาษาโปรแกรม^{[ 57 ]}เกิดขึ้นจากคณะกรรมการผู้เชี่ยวชาญด้านภาษาโปรแกรมจากยุโรปและอเมริกา โดยใช้สัญลักษณ์ทางคณิตศาสตร์ มาตรฐาน และมีการออกแบบโครงสร้างที่อ่านง่าย Algol เป็นภาษาแรกที่กำหนดไวยากรณ์โดยใช้รูปแบบ Backus–Naur [ ^{57 ] ซึ่ง}นำไปสู่ คอมไพเลอร์ ที่กำกับด้วยไวยากรณ์ นอกจากนี้ ยังเพิ่มคุณสมบัติต่างๆ เช่น:

• โครงสร้างแบบบล็อกโดยที่ตัวแปรต่างๆ จะอยู่ภายในบล็อกนั้นๆ
• อาร์เรย์ที่มีขอบเขตแปรผันได้
• ลู ป"for"
• ฟังก์ชัน​
• การเรียกซ้ำ^{[ 57 ]}

ลูกหลานโดยตรงของ Algol ได้แก่Pascal , Modula-2 , Ada , DelphiและOberon ในสาขาหนึ่ง ^ส่วนลูกหลานในอีกสาขาหนึ่ง ได้แก่C , C++และJava ^{[ 57} ]

BASIC (1964) ย่อมาจาก "Beginner's All-Purpose Symbolic Instruction Code" (รหัสคำสั่งเชิงสัญลักษณ์อเนกประสงค์สำหรับผู้เริ่มต้น) พัฒนาขึ้นที่วิทยาลัยดาร์ทมัธเพื่อให้นักเรียนทุกคนได้เรียนรู้^{[ 9 ]}หากนักเรียนไม่ได้เรียนต่อในภาษาที่มีประสิทธิภาพมากกว่า นักเรียนก็ยังคงจำภาษา Basic ได้^{[ 9 ]}มีการติดตั้งตัวแปลภาษา Basic ในไมโครคอมพิวเตอร์ที่ผลิตในช่วงปลายทศวรรษ 1970 เมื่ออุตสาหกรรมไมโครคอมพิวเตอร์เติบโตขึ้น ภาษา Basic ก็เติบโตขึ้นเช่นกัน^{[ 9 ]}

Basic เป็นผู้บุกเบิกเซสชันแบบโต้ตอบ^{[ 9 ]}โดยนำเสนอ คำสั่ง ระบบปฏิบัติการภายในสภาพแวดล้อม:

• คำสั่ง 'new' สร้างหน้าว่างเปล่าขึ้นมา
• คำให้การจะได้รับการประเมินทันที
• สามารถตั้งโปรแกรมคำสั่งได้โดยใส่หมายเลขบรรทัดนำหน้าคำสั่งนั้น^{[ h ]}
• คำสั่ง 'list' แสดงรายการโปรแกรม
• คำสั่ง 'run' ได้เรียกใช้โปรแกรม

อย่างไรก็ตาม ไวยากรณ์ Basic นั้นง่ายเกินไปสำหรับโปรแกรมขนาดใหญ่^{[ 9 ]}ภาษาถิ่นล่าสุดได้เพิ่มโครงสร้างและส่วนขยายเชิงวัตถุVisual BasicของMicrosoftยังคงใช้กันอย่างแพร่หลายและสร้าง อินเทอร์เฟ ซผู้ใช้แบบกราฟิก^{[ 8 ]}

ภาษาโปรแกรม C (1973) ได้รับชื่อนี้เนื่องจากภาษาBCPLถูกแทนที่ด้วยBและAT&T Bell Labsเรียกเวอร์ชันถัดไปว่า "C" จุดประสงค์คือเพื่อเขียนระบบปฏิบัติการUNIX ^{[ 50 ]} C เป็นภาษาที่มีขนาดค่อนข้างเล็ก ทำให้เขียนคอมไพเลอร์ได้ง่าย การเติบโตของมันสะท้อนให้เห็นถึงการเติบโตของฮาร์ดแวร์ในช่วงทศวรรษ 1980 ^{[ 50 ]}การเติบโตของมันยังเป็นเพราะมีคุณสมบัติของภาษาแอสเซมบลีแต่ใช้ไวยากรณ์ระดับสูงมันได้เพิ่มคุณสมบัติขั้นสูงเช่น:

• ตัวประกอบแบบอินไลน์
• การคำนวณเลขคณิตบนตัวชี้
• ตัวชี้ไปยังฟังก์ชัน
• การดำเนินการบิต
• การรวม ตัวดำเนินการที่ซับซ้อนอย่างอิสระ^{[ 50 ]}

ภาษาCอนุญาตให้โปรแกรมเมอร์ควบคุมได้ว่าจะจัดเก็บข้อมูลในส่วนใดของหน่วยความจำตัวแปรส่วนกลางและตัวแปรคง ที่ใช้ รอบการทำงานของนาฬิกาน้อยที่สุดในการจัดเก็บ สแต็กจะถูกใช้โดยอัตโนมัติสำหรับการประกาศ ตัวแปรมาตรฐาน หน่วยความจำ ฮีปจะถูกส่งกลับไปยังตัวแปรพอยเตอร์จากmalloc()ฟังก์ชัน

• ส่วนข้อมูลส่วนกลางและคงที่นั้นตั้งอยู่เหนือ ส่วน โปรแกรม (ส่วนโปรแกรมในทางเทคนิคเรียกว่า ส่วน ข้อความซึ่งเป็นที่เก็บคำสั่งของเครื่อง)

• พื้นที่ข้อมูลทั่วโลกและคงที่นั้นในทางเทคนิคแล้วประกอบด้วยสองพื้นที่^{[ 58 ]}พื้นที่หนึ่งเรียกว่าส่วนข้อมูลที่เริ่มต้นแล้วซึ่งเป็นที่เก็บตัวแปรที่ประกาศด้วยค่าเริ่มต้น อีกพื้นที่หนึ่งเรียกว่าส่วนบล็อกที่เริ่มต้นโดยซึ่งเป็นที่เก็บตัวแปรที่ประกาศโดยไม่มีค่าเริ่มต้น
• ตัวแปรที่จัดเก็บในพื้นที่ข้อมูลส่วนกลางและแบบคงที่ จะถูกกำหนด ที่อยู่เมื่อทำการคอมไพล์ และจะคงค่าเดิมไว้ตลอดอายุการใช้งานของกระบวนการ

• พื้นที่ทั่วโลกและคงที่จัดเก็บตัวแปรทั่วโลกที่ประกาศไว้ด้านบน (นอก) main()ฟังก์ชัน^{[ 59 ]}ตัวแปรทั่วโลกสามารถมองเห็นได้โดยmain()ทุกฟังก์ชันอื่นในซอร์สโค้ด

ในทางกลับกัน การประกาศตัวแปรภายในmain()ฟังก์ชันอื่นหรือภายใน{}ตัวคั่นบล็อกถือเป็นตัวแปรโลคอลตัวแปรโลคอลยังรวมถึงตัวแปรพารามิเตอร์อย่างเป็นทางการด้วย ตัวแปรพารามิเตอร์จะอยู่ภายในวงเล็บของคำจำกัดความฟังก์ชัน^{[ 60 ]}พารามิเตอร์จะให้ส่วนต่อประสานกับฟังก์ชัน

• ตัวแปรโลคอลที่ประกาศโดยใช้staticคำนำหน้าจะถูกจัดเก็บไว้ในพื้นที่ข้อมูลส่วนกลางและคงที่ด้วย^{[ 58 ]}ต่างจากตัวแปรส่วนกลาง ตัวแปรคงที่สามารถมองเห็นได้เฉพาะภายในฟังก์ชันหรือบล็อกเท่านั้น ตัวแปรคงที่ยังคงรักษาค่าของมันไว้เสมอ ตัวอย่างการใช้งานคือฟังก์ชันint increment_counter(){static int counter = 0; counter++; return counter;}^{[ i ]}

• พื้นที่ สแต็กเป็นบล็อกหน่วยความจำที่ต่อเนื่องกันซึ่งอยู่ใกล้กับที่อยู่หน่วยความจำด้านบน^{[ 61 ]}ตัวแปรที่อยู่ในสแต็กจะถูกเติมจากบนลงล่าง^{[ j ] [ 61 ]}ตัวชี้สแต็ก เป็น รีจิสเตอร์เฉพาะที่ใช้ติดตามที่อยู่หน่วยความจำสุดท้ายที่ถูกเติม^{[ 61 ]}ตัวแปรจะถูกวางลงในสแต็กโดยใช้ คำสั่ง PUSH ใน ภาษาแอสเซมบลีดังนั้น ที่อยู่ของตัวแปรเหล่านี้จึงถูกตั้งค่าในระหว่างการทำงานวิธีการที่ทำให้ตัวแปรในสแต็กสูญเสียขอบเขตคือการใช้คำสั่ง POP

• ตัวแปรโลคอลที่ประกาศโดยไม่มีstaticคำนำหน้า รวมถึงตัวแปรพารามิเตอร์อย่างเป็นทางการ^{[ 62 ]}เรียกว่าตัวแปรอัตโนมัติ^{[ 59 ]}และจะถูกเก็บไว้ในสแต็ก^{[ 58 ]}ตัวแปรเหล่านี้สามารถมองเห็นได้ภายในฟังก์ชันหรือบล็อก และจะสูญเสียขอบเขตเมื่อออกจากฟังก์ชันหรือบล็อก

• พื้นที่ฮีปตั้งอยู่ด้านล่างของสแต็ก^{[ 58 ]}มันถูกเติมจากล่างขึ้นบนระบบปฏิบัติการจัดการฮีปโดยใช้ตัวชี้ฮีปและรายการของบล็อกหน่วยความจำที่จัดสรร^{[ 63 ]}เช่นเดียวกับสแต็ก ที่อยู่ของตัวแปรฮีปจะถูกตั้งค่าในระหว่างการทำงาน ข้อผิดพลาด หน่วยความจำไม่เพียงพอจะเกิดขึ้นเมื่อตัวชี้ฮีปและตัวชี้สแต็กมาบรรจบกัน

• Cมีmalloc()ฟังก์ชันไลบรารีสำหรับจัดสรรหน่วยความจำฮีป^{[ k ] [ 64 ]}การเติมข้อมูลลงในฮีปเป็นฟังก์ชันการคัดลอกเพิ่มเติม^{[ l ]}ตัวแปรที่จัดเก็บในฮีปจะถูกส่งไปยังฟังก์ชันโดยใช้พอยเตอร์อย่างประหยัด หากไม่มีพอยเตอร์ ข้อมูลทั้งบล็อกจะต้องถูกส่งไปยังฟังก์ชันผ่านทางสแต็ก

ในช่วงทศวรรษ 1970 วิศวกรซอฟต์แวร์ต้องการการสนับสนุนทางภาษาเพื่อแบ่งโครงการขนาดใหญ่ออกเป็นโมดูล[ ^{65 ] คุณสมบัติ}ที่เห็นได้ชัดอย่างหนึ่งคือการแบ่งโครงการขนาดใหญ่ออก เป็น ไฟล์แยกต่างหากคุณสมบัติที่ไม่ชัดเจนนักคือการแบ่งโครงการขนาดใหญ่ออกเป็นประเภทข้อมูลนามธรรม [ 65 ^{]ในขณะ}นั้น ภาษาต่างๆ รองรับ ประเภทข้อมูล ที่เป็นรูปธรรม (สเกลาร์)เช่นจำนวนเต็ม จำนวน ทศนิยมและสตริงของอักขระประเภทข้อมูลนามธรรมเป็นโครงสร้างของประเภทข้อมูลที่เป็นรูปธรรม โดยมีการกำหนดชื่อใหม่ ตัวอย่างเช่นรายการของจำนวนเต็มสามารถเรียกว่า integer_list

ในศัพท์เฉพาะเชิงวัตถุ ประเภทข้อมูลนามธรรมเรียกว่าคลาสอย่างไรก็ตามคลาสเป็นเพียงคำจำกัดความเท่านั้น ไม่มีการจัดสรรหน่วยความจำ เมื่อมีการจัดสรรหน่วยความจำให้กับคลาสและผูกกับตัวระบุจะเรียกว่าวัตถุ^{[ 66 ]}

ภาษาเชิงวัตถุแบบคำสั่งได้รับการพัฒนาโดยการผสมผสานความต้องการคลาสและความต้องการการเขียนโปรแกรมเชิงฟังก์ชันที่ปลอดภัย[ 67 ^{]ในภาษา}เชิงวัตถุ ฟังก์ชันจะถูกกำหนดให้กับคลาส ฟังก์ชันที่กำหนดแล้วจะถูกเรียกว่าเมธอดฟังก์ชันสมาชิกหรือการดำเนินการ การ เขียน^{โปรแกรม}เชิงวัตถุคือการดำเนินการกับวัตถุ^[ 68 ^]

ภาษาเชิงวัตถุสนับสนุนไวยากรณ์เพื่อจำลอง ความสัมพันธ์ระหว่าง เซตย่อยและเซตใหญ่ในทฤษฎีเซต องค์ประกอบของเซตย่อยจะสืบทอดคุณลักษณะทั้งหมดที่มีอยู่ในเซตใหญ่ ตัวอย่างเช่น นักเรียนเป็นบุคคล ดังนั้น เซตของนักเรียนจึงเป็นเซตย่อยของเซตของบุคคล ผลที่ตามมาคือ นักเรียนจะสืบทอดคุณลักษณะทั้งหมดที่เหมือนกันในบุคคลทั้งหมด นอกจากนี้ นักเรียนยังมีคุณลักษณะเฉพาะที่คนอื่นไม่มีภาษาเชิงวัตถุจำลอง ความสัมพันธ์ ระหว่างเซตย่อยและเซตใหญ่โดยใช้การสืบทอด [ ^{69 ] การ}เขียนโปรแกรมเชิงวัตถุกลายเป็นกระบวนทัศน์ภาษาที่โดดเด่นในช่วงปลายทศวรรษ 1990 ^{[ 65 ]}

C++ (1985) เดิมทีเรียกว่า "C with Classes" ^{[ 70 ]}ออกแบบมาเพื่อขยายขีด ความสามารถ ของ Cโดยเพิ่มฟังก์ชันเชิงวัตถุของภาษาSimula ^{[ 71 ]}

โมดูลเชิงวัตถุประกอบด้วยไฟล์สองไฟล์ ไฟล์ที่กำหนดนิยามเรียกว่าไฟล์ส่วนหัว นี่คือ ไฟล์ส่วนหัว C++ สำหรับคลาส GRADEในแอปพลิเคชันโรงเรียนอย่างง่าย:

// grade.h // -------// ใช้เพื่ออนุญาตให้ไฟล์ต้นฉบับหลายไฟล์สามารถรวม// ไฟล์ส่วนหัวนี้ได้โดยไม่มีข้อผิดพลาดจากการทำซ้ำ// ---------------------------------------------- #ifndef GRADE_H #define GRADE_HคลาสGRADE { public : // นี่คือการดำเนินการของคอนสตรัคเตอร์// ---------------------------------- GRADE ( const char letter );// นี่คือตัวแปรคลาส// ------------------------- char letter ;// นี่คือการดำเนินการกับสมาชิก// --------------------------- int grade_numeric ( const char letter );// นี่คือตัวแปรคลาส// ------------------------- int numeric ; }; #endif

การ ดำเนินการ ตัวสร้างคือฟังก์ชันที่มีชื่อเดียวกันกับชื่อคลาส^{[ 72 ]}จะถูกดำเนินการเมื่อการดำเนินการที่เรียกใช้ดำเนินการnewคำสั่ง

ไฟล์อีกไฟล์หนึ่งของโมดูลคือไฟล์ซอร์สโค้ดนี่คือไฟล์ซอร์สโค้ด C++ สำหรับคลาส GRADEในแอปพลิเคชันโรงเรียนอย่างง่าย:

// grade.cpp // --------- #include "grade.h"GRADE :: GRADE ( const char letter ) { // อ้างอิงถึงอ็อบเจ็กต์โดยใช้คีย์เวิร์ด 'this' // ---------------------------------------------- this -> letter = letter ;// นี่คือความสอดคล้องเชิงเวลา// ------------------------- this -> numeric = grade_numeric ( letter ); }int GRADE :: grade_numeric ( const char letter ) { if ( ( letter == 'A' || letter == 'a' ) ) return 4 ; else if ( ( letter == 'B' || letter == 'b' ) ) return 3 ; else if ( ( letter == 'C' || letter == 'c' ) ) return 2 ; else if ( ( letter == 'D' || letter == 'd' ) ) return 1 ; else if ( ( letter == 'F' || letter == 'f' ) ) return 0 ; else return -1 ; }

นี่คือ ไฟล์เฮดเดอร์ C++ สำหรับคลาส PERSONในแอปพลิเคชันโรงเรียนอย่างง่าย:

// person.h // -------- #ifndef PERSON_H #define PERSON_HคลาสPERSON { public : PERSON ( const char * name ); const char * name ; }; #endif

นี่คือ ไฟล์ซอร์สโค้ด C++ สำหรับคลาส PERSONในแอปพลิเคชันโรงเรียนอย่างง่าย:

// person.cpp // ---------- #include "person.h"บุคคล:: บุคคล( const char * name ) { this -> name = name ; }

นี่คือ ไฟล์เฮดเดอร์ C++ สำหรับคลาส STUDENTในแอปพลิเคชันโรงเรียนอย่างง่าย:

// student.h // --------- #ifndef STUDENT_H #define STUDENT_H#include "person.h" #include "grade.h"// นักเรียนเป็นส่วนย่อยของบุคคล// -------------------------------- class STUDENT : public PERSON { public : STUDENT ( const char * name ); GRADE * grade ; }; #endif

นี่คือ ไฟล์ซอร์สโค้ด C++ สำหรับคลาส STUDENTในแอปพลิเคชันโรงเรียนอย่างง่าย:

// student.cpp // ----------- #include "student.h" #include "person.h"นักเรียน:: นักเรียน( const char * name ) : // เรียกใช้คอนสตรัคเตอร์ของคลาสแม่ PERSON // ------------------------------------------------- PERSON ( name ) { // ไม่ต้องทำอะไรเพิ่มเติม// ------------------- }

นี่คือโปรแกรมไดรเวอร์สำหรับสาธิต:

// student_dvr.cpp // --------------- #include <iostream> #include "student.h"int main ( void ) { STUDENT * student = new STUDENT ( "The Student" ); student -> grade = new GRADE ( 'a' );std :: cout // สังเกตว่านักเรียนสืบทอดชื่อมาจาก PERSON << student- > name << ": เกรดตัวเลข = " << student- > grade- > numeric << " \n " ; return 0 ; }

นี่คือไฟล์ makefileสำหรับคอมไพล์ทุกอย่าง:

# makefile # -------- ทั้งหมด: student_dvrล้างไฟล์: rm student_dvr *.o student_dvr : student_dvr . cpp grade . o student . o person . o c++ student_dvr.cpp grade.o student.o person.o -o student_dvrgrade.o : grade.cpp grade.h c ++ -c grade.cpp​​​student.o : student.cpp student.h c ++ -c student.cpp​​​person.o : person.cpp person.h c ++ -c person.cpp ​​​

ภาษาเชิงคำสั่งมีข้อวิจารณ์สำคัญประการหนึ่งคือ การกำหนดนิพจน์ให้กับ ตัวแปร ที่ไม่ใช่ตัวแปรท้องถิ่นอาจทำให้เกิดผลข้างเคียง ที่ไม่ได้ ตั้งใจ^{[ 73 ]} โดยทั่วไปแล้ว ภาษาเชิงประกาศจะละเว้นคำสั่งการกำหนดค่าและการควบคุมการไหล พวกมันอธิบายว่า ควรดำเนินการคำนวณ อะไรไม่ใช่ ว่าจะคำนวณ อย่างไรภาษาเชิงประกาศแบ่งออกเป็นสองประเภทใหญ่ๆ คือภาษาเชิงฟังก์ชันและภาษาเชิงตรรกะ

หลักการเบื้องหลังภาษาเชิงฟังก์ชันคือการใช้แคลคูลัสแลมบ์ดาเป็นแนวทางสำหรับความหมาย ที่กำหนดไว้อย่าง ชัดเจน^{[ 74 ]}ในทางคณิตศาสตร์ ฟังก์ชันคือกฎที่แมปองค์ประกอบจากนิพจน์ไปยังช่วงของค่าพิจารณาฟังก์ชัน:

times_10(x) = 10 * x

นิพจน์ นี้10 * xถูกแปลงโดยฟังก์ชันtimes_10()ไปยังช่วงของค่าต่างๆ โดย ค่าหนึ่งคือ 20 ซึ่งเกิดขึ้นเมื่อ x มีค่าเท่ากับ 2 ดังนั้น การประยุกต์ใช้ฟังก์ชันจึงเขียนในทางคณิตศาสตร์ได้ดังนี้:

times_10(2) = 20

คอม ไพเลอร์ ภาษาเชิงฟังก์ชันจะไม่เก็บค่านี้ไว้ในตัวแปร แต่จะผลักค่าลงบนสแต็ก ของคอมพิวเตอร์ ก่อนที่จะตั้ง ค่า ตัวนับโปรแกรมกลับไปยังฟังก์ชันที่เรียกใช้ จากนั้นฟังก์ชันที่เรียกใช้จะดึงค่าออกจากสแต็ก^{[ 75 ]}

ภาษาเชิงคำสั่งรองรับฟังก์ชัน ดังนั้นการเขียนโปรแกรมเชิงฟังก์ชันจึงสามารถทำได้ในภาษาเชิงคำสั่ง หากโปรแกรมเมอร์ใช้ระเบียบวินัย อย่างไรก็ตามภาษาเชิงฟังก์ชันจะบังคับให้โปรแกรมเมอร์ใช้ระเบียบวินัยนี้ผ่านทางไวยากรณ์ ภาษาเชิงฟังก์ชันมีไวยากรณ์ที่ออกแบบมาเพื่อเน้นย้ำถึงสิ่งที่จะทำ^{[ 76 ]}

โปรแกรมเชิงฟังก์ชันได้รับการพัฒนาด้วยชุดฟังก์ชันพื้นฐานตามด้วยฟังก์ชันขับเคลื่อนเพียงฟังก์ชันเดียว^{[ 73 ]}พิจารณาส่วนย่อยนี้ :

function max( a, b ){/* code omitted */}

function min( a, b ){/* code omitted */}

function range( a, b, c ) {

return max( a, max( b, c ) ) - min( a, min( b, c ) );

}

ส่วนประกอบพื้นฐานคือmax()และmin()ฟังก์ชันขับเคลื่อนคือrange()กำลังดำเนินการ:

put( range( 10, 4, 7) );จะแสดงผลลัพธ์เป็น 6

ภาษาฟังก์ชันถูกนำมาใช้ใน การวิจัย วิทยาศาสตร์คอมพิวเตอร์เพื่อสำรวจคุณสมบัติภาษาใหม่^{[ 77 ]}นอกจากนี้ การที่ไม่มีผลข้างเคียงทำให้ภาษาฟังก์ชันเป็นที่นิยมในการเขียนโปรแกรมแบบขนานและ การ เขียนโปรแกรมพร้อมกัน^{[ 78 ]}อย่างไรก็ตาม นักพัฒนาแอปพลิเคชันชอบคุณสมบัติเชิงวัตถุของภาษาเชิงคำสั่งมากกว่า^{[ 78 ]}

Lisp (1958) ย่อมาจาก "LISt Processor" ^{[ 79 ]}มันถูกปรับแต่งมาเพื่อประมวลผลลิสต์โครงสร้างข้อมูลทั้งหมดถูกสร้างขึ้นโดยการสร้างลิสต์ของลิสต์ ในหน่วยความจำ จะมีการสร้าง โครงสร้างข้อมูลแบบต้นไม้ภายใน โครงสร้างต้นไม้นั้นเหมาะสำหรับฟังก์ชันแบบเรียกซ้ำ^{[ 80 ]}ไวยากรณ์ในการสร้างต้นไม้คือการใส่ส่วนประกอบที่คั่นด้วยช่องว่างไว้ในวงเล็บ ต่อไปนี้เป็นลิสต์ของสามส่วนประกอบ สองส่วนประกอบแรกเป็นลิสต์ของสองส่วนประกอบ:

((A B) (HELLO WORLD) 94)

Lisp มีฟังก์ชันสำหรับแยกและสร้างองค์ประกอบขึ้นใหม่^{[ 81 ]}ฟังก์ชันhead()จะส่งคืนรายการที่มีองค์ประกอบแรกในรายการ ฟังก์ชันtail()จะส่งคืนรายการที่มีทุกอย่างยกเว้นองค์ประกอบแรก ฟังก์ชันcons()จะส่งคืนรายการที่เป็นการต่อกันของรายการอื่นๆ ดังนั้นนิพจน์ต่อไปนี้จะส่งคืนรายการx:

cons(head(x), tail(x))

ข้อเสียอย่างหนึ่งของ Lisp คือ เมื่อมีการซ้อนฟังก์ชันจำนวนมาก วงเล็บอาจดูสับสน^{[ 76 ]}สภาพแวดล้อม Lisp สมัยใหม่ช่วยให้มั่นใจได้ว่าวงเล็บตรงกัน นอกจากนี้ Lisp ยังรองรับ การดำเนินการ ภาษาเชิงคำสั่งของคำสั่งกำหนดค่าและลูป goto ^{[ 82 ]}ยิ่งไปกว่านั้นLispไม่ได้กังวลเกี่ยวกับชนิดข้อมูลขององค์ประกอบในเวลาคอมไพล์^{[ 83 ]}แต่จะกำหนด (และอาจกำหนดใหม่) ชนิดข้อมูลในเวลาทำงานการกำหนดชนิดข้อมูลในเวลาทำงานเรียกว่า การผูก แบบไดนามิก^{[ 84 ]}แม้ว่าการผูกแบบไดนามิกจะเพิ่มความยืดหยุ่นของภาษา แต่ข้อผิดพลาดในการเขียนโปรแกรมอาจยังคงอยู่จนถึงช่วงท้ายของกระบวนการพัฒนาซอฟต์แวร์^{[ 84 ]}

การเขียนโปรแกรม Lisp ขนาดใหญ่ที่เชื่อถือได้และอ่านง่ายนั้นต้องอาศัยการวางแผนล่วงหน้า หากวางแผนอย่างเหมาะสม โปรแกรมอาจสั้นกว่าโปรแกรมภาษาเชิงคำสั่ง ที่เทียบเท่ากันมาก ^{[ 76 ]} Lispถูกใช้กันอย่างแพร่หลายในปัญญาประดิษฐ์อย่างไรก็ตาม การใช้งานของมันได้รับการยอมรับก็ต่อเมื่อมี การดำเนินการ ภาษาเชิงคำสั่งซึ่งทำให้เกิดผลข้างเคียงที่ไม่ได้ตั้งใจได้^{[ 78 ]}

ML (1973) ^{[ 85 ]}ย่อมาจาก "Meta Language" ML ตรวจสอบเพื่อให้แน่ใจว่ามีการเปรียบเทียบเฉพาะข้อมูลประเภทเดียวกันเท่านั้น^{[ 86 ]}ตัวอย่างเช่น ฟังก์ชันนี้มีพารามิเตอร์อินพุตหนึ่งตัว (จำนวนเต็ม) และส่งคืนค่าจำนวนเต็ม:

fun times_10 ( n : int ) : int = 10 * n ;

MLไม่ได้ยึดติดกับวงเล็บเหมือนLispตัวอย่างต่อไปนี้คือการประยุกต์ใช้times_10():

10 ครั้ง 2 

ฟังก์ชันนี้จะคืนค่า "20 : int" (ทั้งผลลัพธ์และชนิดข้อมูลจะถูกส่งคืน)

เช่นเดียวกับLisp , MLถูกออกแบบมาเพื่อประมวลผลรายการ แต่ต่างจากLisp ตรง ที่แต่ละองค์ประกอบมีชนิดข้อมูลเดียวกัน^{[ 87 ]}ยิ่งไปกว่านั้นMLจะกำหนดชนิดข้อมูลขององค์ประกอบในระหว่าง การคอม ไพล์การกำหนดชนิดข้อมูลในระหว่างการคอมไพล์เรียกว่าการผูกแบบคงที่ (static binding ) การผูกแบบคงที่ช่วยเพิ่มความน่าเชื่อถือเนื่องจากคอมไพเลอร์จะตรวจสอบบริบทของตัวแปรก่อนที่จะนำไปใช้^{[ 88 ]}

Prolog (1972) ย่อมาจาก "PROgramming in LOGic" (การเขียนโปรแกรมในตรรกะ) เป็น ภาษา การเขียนโปรแกรมเชิงตรรกะที่อิงตามตรรกะเชิง รูปธรรม ภาษานี้ได้รับการพัฒนาโดยAlain Colmerauerและ Philippe Roussel ในเมืองมาร์เซย์ ประเทศฝรั่งเศส เป็นการนำการแก้ปัญหาข้อความเชิงเส้นที่แน่นอนแบบเลือกสรรมาใช้ซึ่งริเริ่มโดยRobert Kowalskiและคนอื่นๆ ที่มหาวิทยาลัยเอดินบะระ^{[ 89 ]}

องค์ประกอบพื้นฐานของโปรแกรม Prolog คือข้อเท็จจริงและกฎ ต่อไปนี้เป็นตัวอย่างง่ายๆ:

แมว( ทอม) % ทอมเป็นแมวหนู( เจอร์รี่) % เจอร์รี่เป็นหนูสัตว์( X ) :- แมว( X ) % แมวแต่ละตัวเป็นสัตว์สัตว์( X ) :- หนู( X ) % หนูแต่ละตัวเป็นสัตว์ใหญ่( X ) :- แมว( X ) % แมวแต่ละตัวมีขนาดใหญ่เล็ก( X ) :- หนู( X ) % หนูแต่ละตัวมีขนาดเล็กกิน( X , Y ) :- หนู( X ), ชีส( Y ) % หนูแต่ละตัวกินชีสแต่ละก้อนกิน( X , Y ) :- ใหญ่( X ), เล็ก( Y ) % สัตว์ใหญ่แต่ละตัวกินสัตว์เล็กแต่ละตัว

หลังจากป้อนข้อเท็จจริงและกฎเกณฑ์ทั้งหมดแล้ว จึงจะสามารถถามคำถามได้:

ทอมจะกินเจอร์รี่ไหม?

?- กิน( ทอม, เจอร์รี่) จริง

ตัวอย่างต่อไปนี้แสดงวิธีที่ Prolog จะแปลงเกรดตัวอักษรเป็นค่าตัวเลข:

numeric_grade ( 'A' , 4 ). numeric_grade ( 'B' , 3 ). numeric_grade ( 'C' , 2 ). numeric_grade ( 'D' , 1 ). numeric_grade ( 'F' , 0 ). numeric_grade ( X , - 1 ) :- ไม่ใช่X = 'A' , ไม่ใช่X = 'B' , ไม่ใช่X = 'C' , ไม่ใช่X = 'D' , ไม่ใช่X = 'F' . grade ( 'นักเรียน' , 'A' ).

?- เกรด( 'นักเรียน' , X ), เกรดตัวเลข( X , Y ). X = 'A' , Y = 4

นี่คือตัวอย่างที่ครอบคลุม: ^{[ 90 ]}

1) มังกรทุกตัวพ่นไฟได้ หรือในทำนองเดียวกัน สิ่งใดสิ่งหนึ่งจะพ่นไฟได้หากสิ่งนั้นเป็นมังกร:

billows_fire ( X ) :- is_a_dragon ( X ).

2) สัตว์ตัวนั้นจะพ่นไฟได้ก็ต่อเมื่อพ่อหรือแม่ของมันพ่นไฟได้:

billows_fire ( X ) :- is_a_creature ( X ), is_a_parent_of ( Y , X ), billows_fire ( Y ).

3) สิ่ง X เป็นพ่อแม่ของสิ่ง Y ก็ต่อเมื่อ X เป็นแม่ของ Y หรือ X เป็นพ่อของ Y:

เป็นผู้ปกครองของ( X , Y ):- เป็นแม่ของ( X , Y ) เป็นผู้ปกครองของ( X , Y )- เป็นพ่อของ( X , Y )

4) สิ่งใดสิ่งหนึ่งจะเป็นสิ่งมีชีวิตได้ก็ต่อเมื่อสิ่งนั้นเป็นมังกร:

เป็นสิ่งมีชีวิต( X ) :- เป็นมังกร( X )

5) นอร์เบอร์ตาเป็นมังกร และพัฟเป็นสิ่งมีชีวิต นอร์เบอร์ตาเป็นแม่ของพัฟ

เป็นมังกร( นอร์เบอร์ตา) เป็นสิ่งมีชีวิต( พัฟ) เป็นแม่ของ( นอร์เบอร์ตา, พัฟ)

กฎ (2) เป็น นิยามแบบ เรียกซ้ำ (อุปนัย) สามารถเข้าใจได้แบบประกาศ โดยไม่จำเป็นต้องเข้าใจวิธีการดำเนินการ

กฎ (3) แสดงวิธี การแสดง ฟังก์ชันโดยใช้ความสัมพันธ์ ในที่นี้ ฟังก์ชันแม่และพ่อทำให้มั่นใจได้ว่าแต่ละบุคคลจะมีแม่เพียงคนเดียวและพ่อเพียงคนเดียว

Prolog เป็นภาษาที่ไม่มีประเภท อย่างไรก็ตามการสืบทอดสามารถแสดงได้โดยใช้述语 กฎ (4) ยืนยันว่าสิ่งมีชีวิตเป็นคลาสแม่ของมังกร

คำถามเหล่านี้ได้รับการตอบโดยใช้วิธีการให้เหตุผลย้อนกลับโดยให้คำถามว่า:

?- billows_fire ( X ).

Prolog สร้างคำตอบสองคำตอบ:

X = นอร์เบอร์ตาX = พัฟ

การประยุกต์ใช้ Prolog ในทางปฏิบัติ ได้แก่การแสดงความรู้และการแก้ปัญหาในปัญญา ประดิษฐ์

การเขียนโปรแกรมเชิงวัตถุเป็นวิธีการเขียนโปรแกรมเพื่อดำเนิน^{การ (ฟังก์ชัน) บนวัตถุ [ 91 ]}แนวคิดพื้นฐานคือการจัด^{กลุ่ม}ลักษณะ^ของปรากฏการณ์ลง ใน คอนเทนเนอร์วัตถุและตั้งชื่อให้กับคอนเทนเนอร์นั้นการดำเนินการกับปรากฏการณ์ก็ถูกจัดกลุ่มลงในคอนเทนเนอร์เช่นกัน^{[ 91 ]}การเขียนโปรแกรมเชิงวัตถุพัฒนาขึ้นโดยการรวมความต้องการคอนเทนเนอร์และความต้องการการเขียนโปรแกรมเชิงฟังก์ชันที่ปลอดภัย[ 92 ^{]วิธีการ}เขียนโปรแกรมนี้ไม่จำเป็นต้องจำกัดอยู่เฉพาะภาษาเชิงวัตถุ^{[ 93 ]}ในภาษาเชิงวัตถุ คอนเทนเนอร์วัตถุเรียกว่าคลาสในภาษาที่ไม่ใช่เชิงวัตถุโครงสร้างข้อมูล (ซึ่งเรียกอีกอย่างว่าเรคอร์ด ) อาจกลายเป็นคอนเทนเนอร์วัตถุได้ ในการเปลี่ยนโครงสร้างข้อมูลให้เป็นคอนเทนเนอร์วัตถุ จำเป็นต้องเขียนการดำเนินการเฉพาะสำหรับโครงสร้างนั้น โครงสร้างที่ได้เรียกว่าชนิดข้อมูลนามธรรม^{[ 94 ]}อย่างไรก็ตาม จะไม่มี การสืบทอดแต่ข้อบกพร่องนี้สามารถเอาชนะได้

นี่คือไฟล์เฮดเดอร์ภาษาซี สำหรับชนิดข้อมูลนามธรรม GRADEในแอปพลิเคชันโรงเรียนอย่างง่าย:

/* grade.h */ /* ------- *//* ใช้เพื่ออนุญาตให้ไฟล์ต้นฉบับหลายไฟล์รวมไฟล์ส่วนหัวนี้ได้โดยไม่มีข้อผิดพลาดจากการทำซ้ำ */ /* ---------------------------------------------- */ #ifndef GRADE_H #define GRADE_Htypedef struct { char letter ; } GRADE ;/* คอนสตรัคเตอร์ */ /* ----------- */ GRADE * grade_new ( char letter );int grade_numeric ( char letter ); #endif

ฟังก์ชัน นี้grade_new()ดำเนินการตามอัลกอริทึมเดียวกับการทำงาน ของตัวสร้างใน ภาษา C++

นี่คือ ไฟล์ซอร์สโค้ดภาษาซีสำหรับชนิดข้อมูลนามธรรม GRADEในแอปพลิเคชันโรงเรียนอย่างง่าย:

/* grade.c */ /* ------- */ #include "grade.h"เกรด* เกรดใหม่( char letter ) { เกรด* เกรด;/* จัดสรรหน่วยความจำฮีป */ /* -------------------- */ if ( ! ( grade = calloc ( 1 , sizeof ( GRADE ) ) ) ) { fprintf ( stderr , "ERROR in %s/%s/%d: calloc() returned empty. \n " , __FILE__ , __FUNCTION__ , __LINE__ ); exit ( 1 ); }เกรด-> ตัวอักษร= ตัวอักษร; คืนค่าเกรด; }int grade_numeric ( char letter ) { if ( ( letter == 'A' || letter == 'a' ) ) return 4 ; else if ( ( letter == 'B' || letter == 'b' ) ) return 3 ; else if ( ( letter == 'C' || letter == 'c' ) ) return 2 ; else if ( ( letter == 'D' || letter == 'd' ) ) return 1 ; else if ( ( letter == 'F' || letter == 'f' ) ) return 0 ; else return -1 ; }

ในฟังก์ชันคอนสตรัคเตอร์ จะใช้ฟังก์ชันนี้calloc()แทนmalloc()เนื่องจากเซลล์หน่วยความจำแต่ละเซลล์จะถูกตั้งค่าเป็นศูนย์

นี่คือ ไฟล์เฮดเดอร์ของภาษาโปรแกรม C สำหรับชนิดข้อมูลนามธรรม PERSONในแอปพลิเคชันโรงเรียนอย่างง่าย:

/* person.h */ /* -------- */ #ifndef PERSON_H #define PERSON_Htypedef struct { char * name ; } PERSON ;/* คอนสตรัคเตอร์ */ /* ----------- */ PERSON * person_new ( char * name ); #endif

นี่คือ ไฟล์ซอร์สโค้ดภาษาซีสำหรับชนิดข้อมูลนามธรรม PERSONในแอปพลิเคชันโรงเรียนอย่างง่าย:

/* person.c */ /* -------- */ #include "person.h"PERSON * person_new ( char * name ) { PERSON * person ;/* ละเว้นการตรวจสอบข้อผิดพลาด */ person = calloc ( 1 , sizeof ( PERSON ) );บุคคล-> ชื่อ= ชื่อ; ส่งคืนบุคคล; }

นี่คือ ไฟล์เฮดเดอร์ภาษา C สำหรับชนิดข้อมูลนามธรรม STUDENTในแอปพลิเคชันโรงเรียนอย่างง่าย:

/* student.h */ /* --------- */ #ifndef STUDENT_H #define STUDENT_H#include "person.h" #include "grade.h"typedef struct { /* นักเรียนเป็นส่วนย่อยของบุคคล */ /* -------------------------------- */ บุคคล* person ;เกรด* เกรด; } นักเรียน;/* คอนสตรัคเตอร์ */ /* ----------- */ STUDENT * student_new ( char * name ); #endif

นี่คือ ไฟล์ซอร์สโค้ดภาษาซีสำหรับชนิดข้อมูลนามธรรม STUDENTในแอปพลิเคชันโรงเรียนอย่างง่าย:

/* student.c */ /* --------- */ #include "student.h" #include "person.h"นักเรียน* student_new ( char * name ) { นักเรียน* student ;/* ละเว้นการตรวจสอบข้อผิดพลาด */ student = calloc ( 1 , sizeof ( STUDENT ) ); /* เรียกใช้คอนสตรัคเตอร์ของคลาสแม่ PERSON */ /* ------------------------------------------------- */ student -> person = person_new ( name ); return student ; }

นี่คือโปรแกรมไดรเวอร์สำหรับสาธิต:

/* student_dvr.c */ /* ------------- */ #include <stdio.h> #include "student.h"int main ( void ) { STUDENT * student = student_new ( "The Student" ); student -> grade = grade_new ( 'a' );printf ( "%s: เกรดตัวเลข = %d \n " , /* ในขณะที่มีเซตย่อยอยู่ การสืบทอดไม่มีอยู่ */ student -> person -> name , /* การเขียนโปรแกรมเชิงฟังก์ชันคือการเรียกใช้ฟังก์ชันแบบทันเวลา (JIT) */ grade_numeric ( student -> grade -> letter ) );ส่งคืนค่า0 ; }

นี่คือไฟล์ makefileสำหรับคอมไพล์ทุกอย่าง:

# makefile # -------- ทั้งหมด: student_dvrล้างไฟล์: rm student_dvr *.o student_dvr : student_dvr . c grade . o student . o person . o gcc student_dvr.c grade.o student.o person.o -o student_dvrgrade.o : grade . c grade . h gcc -c grade.cstudent.o : student . c student . h gcc -c student.cperson.o : person . c person . h gcc -c person.c 

กลยุทธ์อย่างเป็นทางการในการสร้างวัตถุเชิงวัตถุคือ: ^{[ 95 ]}

• ระบุวัตถุเหล่านั้น ส่วนใหญ่แล้วจะเป็นคำนาม
• ระบุคุณลักษณะของวัตถุแต่ละชิ้น อะไรบ้างที่ช่วยอธิบายวัตถุนั้นได้?
• ระบุการกระทำของแต่ละวัตถุ ส่วนใหญ่จะเป็นคำกริยา
• ระบุความสัมพันธ์ระหว่างวัตถุกับวัตถุ โดยส่วนใหญ่จะเป็นคำกริยา

ตัวอย่างเช่น:

• บุคคล คือ มนุษย์ที่สามารถระบุตัวตนได้ด้วยชื่อ
• เกรดคือผลสัมฤทธิ์ทางการเรียนที่ระบุด้วยตัวอักษร
• นักเรียนคือบุคคลที่ได้รับเกรด

ไวยากรณ์ของโปรแกรมคอมพิวเตอร์คือรายการของกฎการผลิตซึ่งประกอบเป็นไวยากรณ์ ของ โปรแกรม^{[ 96 ]}ไวยากรณ์ของภาษาโปรแกรมจะวางการประกาศ นิพจน์ และคำสั่งต่างๆ อย่างถูกต้อง[ 97 ]ไวยากรณ์ของภาษา^{จะเสริมด้วย}ความหมายความหมายจะ อธิบาย ความหมายที่แนบมากับโครงสร้างทางไวยากรณ์ต่างๆ^{[ 98 ]}โครงสร้างทางไวยากรณ์อาจต้องการคำอธิบายความหมายเนื่องจากกฎการผลิตอาจมีการตีความที่ไม่ถูกต้อง^{[ 99 ]}นอกจากนี้ ภาษาต่างๆ อาจมีไวยากรณ์เหมือนกัน แต่พฤติกรรมของภาษาเหล่านั้นอาจแตกต่างกัน

ไวยากรณ์ของภาษาได้รับการอธิบายอย่างเป็นทางการโดยการแสดงรายการกฎการผลิต ในขณะที่ไวยากรณ์ของภาษาธรรมชาติมีความซับซ้อนอย่างมาก เซตย่อยของภาษาอังกฤษสามารถมีรายการกฎการผลิตนี้ได้: ^{[ 100 ]}

1. ประโยคประกอบด้วย วลี คำนามตามด้วยวลีคำกริยา
2. วลีนามประกอบด้วยคำนำหน้าคำนามตามด้วยคำคุณศัพท์และตามด้วยคำนาม
3. วลีคำกริยาประกอบด้วยคำกริยาตามด้วยวลีคำนาม
4. คำนำ หน้าคำนามคือ 'the';
5. คำคุณศัพท์คือ 'ใหญ่' หรือ
6. คำคุณศัพท์คือ 'เล็ก'
7. คำนามคือ 'แมว' หรือ
8. คำนามคือ 'หนู'
9. คำกริยาคือ 'กิน'

คำที่พิมพ์ตัวหนาเรียกว่าคำที่ไม่ใช่เทอร์มินัลคำที่อยู่ในเครื่องหมายอัญประกาศเดี่ยวเรียกว่าคำเทอร์มินัล^{[ 101 ]}

จากรายการกฎการผลิตนี้ ประโยคที่สมบูรณ์อาจถูกสร้างขึ้นโดยใช้ชุดของการแทนที่^{[ 102 ]}กระบวนการคือการแทนที่ไม่ใช่เทอร์มินัลด้วยไม่ใช่เทอร์มินัล ที่ถูกต้อง หรือเทอร์มินัล ที่ถูกต้อง กระบวนการแทนที่ทำซ้ำจนกว่าจะเหลือแต่เทอร์มินัล ประโยคที่ถูกต้องประโยคหนึ่งคือ:

• ประโยค
• วลีคำนามวลีคำกริยา
• บทความ คำคุณศัพท์คำนาม วลีคำกริยา
• วลีคุณศัพท์นามกริยา
• วลีนามกริยาขนาดใหญ่
• วลีคำกริยาแมวใหญ่
• แมวใหญ่คำกริยา- คำนาม-วลี
• แมวใหญ่กินวลีคำนาม
• แมวใหญ่กินบทความ คำคุณศัพท์คำนาม
• แมวใหญ่กินคำคุณศัพท์และคำนาม
• แมวตัวใหญ่กินคำนามตัวเล็ก
• แมวใหญ่กินหนูตัวเล็ก​

อย่างไรก็ตาม การรวมกันอีกแบบหนึ่งส่งผลให้ประโยคไม่ถูกต้อง:

• หนูตัวเล็กกินแมวตัวใหญ่

ดังนั้น จึง จำเป็นต้องมี หลักอรรถศาสตร์เพื่ออธิบายความหมายของกิจกรรม การกิน ได้อย่างถูกต้อง

วิธีการแสดงรายการ กฎการผลิต วิธี หนึ่งเรียกว่ารูปแบบ Backus–Naur (BNF) ^{[ 103 ]} BNF อธิบายไวยากรณ์ของภาษาและตัวมันเองก็มีไวยากรณ์คำจำกัดความแบบเรียกซ้ำนี้เป็นตัวอย่างของเมตาภาษา [ ^{98 ] ไวยากรณ์}ของBNF ประกอบด้วย:

• ::=ซึ่งแปลว่าประกอบด้วยเมื่อมีสัญลักษณ์ที่ไม่ใช่เทอร์มินัลอยู่ทางด้านขวา และแปลว่า คือเมื่อมีสัญลักษณ์เทอร์มินัลอยู่ทางด้านขวา
• |ซึ่งแปลได้ว่าหรือ
• <และ>ซึ่งล้อมรอบสิ่งที่ไม่ใช่เทอร์มินัล

เมื่อใช้ BNF ภาษาอังกฤษส่วนย่อยสามารถมีกฎการผลิตดังต่อไปนี้:

< ประโยค> ::= < วลีนาม>< วลีกริยา> < วลีนาม> ::= < คำนำหน้าคำนาม >< คำคุณศัพท์>< คำนาม> < วลีกริยา> ::= < กริยา> < วลีนาม> < คำนำหน้า คำนาม> ::= the < คำคุณศัพท์> ::=ใหญ่ | เล็ก < คำนาม> ::=แมว | หนู < กริยา> ::=กิน 

การใช้ BNF จำนวน เต็มที่มีเครื่องหมาย มีกฎการผลิตดังนี้: ^{[ 104 ]}

< จำนวนเต็มที่มีเครื่องหมาย> ::= < เครื่องหมาย>< จำนวนเต็ม> < เครื่องหมาย> ::= + | - < จำนวนเต็ม> ::= < ตัวเลข> | < ตัวเลข>< จำนวนเต็ม> < ตัวเลข> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 

โปรดสังเกตกฎการผลิตแบบเรียกซ้ำ:

< จำนวนเต็ม> ::= < ตัวเลข> | < ตัวเลข>< จำนวนเต็ม>

สิ่งนี้ทำให้เกิดความเป็นไปได้นับไม่ถ้วน ดังนั้นจึง จำเป็นต้องมี นิยามทางความหมายเพื่ออธิบายข้อจำกัดของจำนวนหลัก

โปรดสังเกตความเป็นไปได้ของเลขศูนย์นำหน้าในกฎการผลิต:

< จำนวนเต็ม> ::= < ตัวเลข> | < ตัวเลข>< จำนวนเต็ม> < ตัวเลข> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 

ดังนั้น จึง จำเป็นต้องมีคำอธิบาย เชิงความหมายเพื่อระบุว่าเลขศูนย์นำหน้าจะต้องถูกละเลย

มีวิธีการที่เป็นทางการสองวิธีในการอธิบายความหมายได้แก่ความหมายเชิงสัญลักษณ์และความหมายเชิงสัจพจน์^{[ 105 ]}

วิศวกรรมซอฟต์แวร์คือเทคนิคต่างๆ เพื่อสร้างโปรแกรมคอมพิวเตอร์ที่มีคุณภาพ^{[ 106 ]}การเขียนโปรแกรมคอมพิวเตอร์คือกระบวนการเขียนหรือแก้ไขซอร์สโค้ดในสภาพแวดล้อมที่เป็นทางการนักวิเคราะห์ระบบจะรวบรวมข้อมูลจากผู้จัดการเกี่ยวกับกระบวนการทั้งหมดขององค์กรที่ต้องการทำให้เป็นระบบอัตโนมัติ จากนั้นผู้เชี่ยวชาญจะจัดทำแผนโดยละเอียดสำหรับระบบใหม่หรือระบบที่ได้รับการแก้ไข^{[ 107 ]}แผนดังกล่าวเปรียบได้กับพิมพ์เขียวของสถาปนิก^{[ 107 ]}

นักวิเคราะห์ระบบมีเป้าหมายที่จะส่งมอบข้อมูลที่ถูกต้องให้กับบุคคลที่ถูกต้องในเวลาที่เหมาะสม^{[ 108 ]}ปัจจัยสำคัญในการบรรลุเป้าหมายนี้คือ: ^{[ 108 ]}

1. คุณภาพของผลลัพธ์ ผลลัพธ์นั้นมีประโยชน์ต่อการตัดสินใจหรือไม่?
2. ความถูกต้องของผลลัพธ์ สะท้อนสถานการณ์ที่แท้จริงหรือไม่?
3. รูปแบบของผลลัพธ์ เข้าใจง่ายหรือไม่?
4. ความเร็วในการแสดงผล ข้อมูลที่ต้องส่งมอบตรงเวลาเป็นสิ่งสำคัญเมื่อสื่อสารกับลูกค้าแบบเรียลไทม์

การบรรลุเป้าหมายด้านประสิทธิภาพควรคำนึงถึงต้นทุนทั้งหมดด้วย ซึ่งรวมถึง: ^{[ 109 ]}

1. ต้นทุนการพัฒนา
2. ความเป็นเอกลักษณ์นั้นมีต้นทุน ระบบที่นำกลับมาใช้ใหม่ได้อาจมีราคาแพง แต่ก็อาจเป็นที่ต้องการมากกว่าระบบที่มีการใช้งานจำกัด
3. ต้นทุนด้านฮาร์ดแวร์
4. ค่าใช้จ่ายในการดำเนินงาน

การใช้กระบวนการพัฒนาระบบจะช่วยลดผลกระทบของหลักการที่ว่า ยิ่งตรวจพบข้อผิดพลาดในขั้นตอนที่ช้าเท่าไหร่ การแก้ไขก็จะยิ่งมีค่าใช้จ่ายสูงขึ้นเท่านั้น^{[ 110 ]}

แบบจำลองน้ำตกเป็นการนำกระบวนการพัฒนาระบบไป ใช้ ^{[ 111 ]}ดังที่ ชื่อ น้ำตกบ่งบอก ขั้นตอนพื้นฐานจะทับซ้อนกัน^{[ 112 ]}

1. ขั้นตอน การสืบสวนมีจุดประสงค์เพื่อทำความเข้าใจปัญหาที่เป็นต้นเหตุ
2. ขั้นตอนการวิเคราะห์มีจุดประสงค์เพื่อทำความเข้าใจแนวทางแก้ไขที่เป็นไปได้
3. ขั้นตอนการออกแบบคือการวางแผนหาทางออกที่ดีที่สุด
4. ขั้นตอนการนำไปปฏิบัติคือการเขียนโปรแกรมเพื่อหาทางออกที่ดีที่สุด
5. ระยะการบำรุงรักษาจะดำเนินไปตลอดอายุการใช้งานของระบบ อาจจำเป็นต้องมีการเปลี่ยนแปลงระบบหลังจากที่ได้ใช้งานแล้ว^{[ 113 ]}อาจมีข้อผิดพลาดเกิดขึ้นได้ รวมถึงข้อผิดพลาดด้านข้อกำหนด ข้อผิดพลาดด้านการออกแบบ หรือข้อผิดพลาดด้านการเขียนโค้ด อาจจำเป็นต้องมีการปรับปรุง อาจจำเป็นต้องมีการปรับตัวเพื่อตอบสนองต่อสภาพแวดล้อมที่เปลี่ยนแปลงไป

โปรแกรมเมอร์คอมพิวเตอร์เป็นผู้เชี่ยวชาญที่รับผิดชอบในการเขียนหรือแก้ไขซอร์สโค้ดเพื่อนำแผนงานโดยละเอียดไปใช้^{[ 107 ]}อาจจำเป็นต้องมีทีมโปรแกรมเมอร์ เนื่องจากระบบส่วนใหญ่มีขนาดใหญ่เกินกว่าที่โปรแกรมเมอร์คนเดียวจะทำให้เสร็จสมบูรณ์ได้^{[ 114 ]}อย่างไรก็ตาม การเพิ่มโปรแกรมเมอร์ในโครงการอาจไม่ได้ทำให้เวลาในการดำเนินการสั้นลง แต่กลับอาจทำให้คุณภาพของระบบลดลง^{[ 114 ]}เพื่อให้มีประสิทธิภาพ โมดูลโปรแกรมจำเป็นต้องได้รับการกำหนดและแจกจ่ายให้กับสมาชิกในทีม^{[ 114 ]}นอกจากนี้ สมาชิกในทีมต้องมีปฏิสัมพันธ์ซึ่งกันและกันในลักษณะที่มีความหมายและมีประสิทธิภาพ^{[ 114 ]}

โปรแกรมเมอร์คอมพิวเตอร์อาจเขียนโปรแกรมในระดับเล็ก : เขียนโปรแกรมภายในโมดูลเดียว^{[ 115 ]}มีโอกาสที่โมดูลจะเรียกใช้โมดูลที่อยู่ในไฟล์ซอร์สโค้ดอื่น ดังนั้น โปรแกรมเมอร์คอมพิวเตอร์อาจเขียนโปรแกรมในระดับใหญ่ : เขียนโปรแกรมโมดูลเพื่อให้เชื่อมโยงกันอย่างมีประสิทธิภาพ^{[ 115 ]}การเขียนโปรแกรมในระดับใหญ่รวมถึงการมีส่วนร่วมในอินเทอร์เฟซการเขียนโปรแกรมแอปพลิเคชัน (API)

การเขียนโปรแกรมแบบโมดูลาร์เป็นเทคนิคในการปรับปรุง โปรแกรม ภาษาเชิงคำสั่ง โปรแกรมที่ได้รับการปรับปรุงอาจลดขนาดซอฟต์แวร์ แยกความรับผิดชอบ และด้วยเหตุนี้จึงช่วยลดการเสื่อมสภาพของซอฟต์แวร์โมดูลของโปรแกรมคือลำดับของคำสั่งที่ถูกจำกัดไว้ภายใน^{บล็อก}และระบุร่วมกันด้วยชื่อ^{[ 116 ]}โมดูลมีฟังก์ชันบริบทและตรรกะ [ ^{117 ]}

• หน้าที่ ของ โมดูลคือสิ่งที่มันทำ
• บริบทของโมดูลคือองค์ประกอบต่างๆ ที่กำลังถูกดำเนินการ
• ตรรกะของโมดูลคือวิธีการที่โมดูลนั้นทำหน้าที่ของมัน

ชื่อของโมดูลควรได้มาจากฟังก์ชัน ก่อน จากนั้นจึงได้มาจากบริบทตรรกะของโมดูลไม่ควรเป็นส่วนหนึ่งของชื่อ^{[ 117 ]}ตัวอย่างเช่นfunction compute_square_root( x )หรือfunction compute_square_root_integer( i : integer )เป็นชื่อโมดูลที่เหมาะสม แต่function compute_square_root_by_division( x )ไม่ใช่

ระดับของการปฏิสัมพันธ์ภายในโมดูลคือระดับของความเชื่อมโยง [ ^{117 ] ความ}เชื่อมโยงคือการตัดสินความสัมพันธ์ระหว่างชื่อของโมดูลกับหน้าที่ ของมัน ระดับของการปฏิสัมพันธ์ระหว่างโมดูลคือระดับของการเชื่อมโยง [ ^{118 ] การ}เชื่อมโยงคือการตัดสินความสัมพันธ์ระหว่างบริบท ของโมดูล กับองค์ประกอบที่กำลังดำเนินการอยู่

ระดับความสอดคล้องจากแย่ที่สุดไปดีที่สุดคือ: ^{[ 119 ]}

• ความสอดคล้องโดยบังเอิญ : โมดูลมีความสอดคล้องโดยบังเอิญหากทำหน้าที่หลายอย่าง และหน้าที่เหล่านั้นไม่เกี่ยวข้องกันโดยสิ้นเชิง ตัวอย่างเช่นfunction read_sales_record_print_next_line_convert_to_float()ความสอดคล้องโดยบังเอิญเกิดขึ้นในทางปฏิบัติหากฝ่ายบริหารบังคับใช้กฎที่ไร้สาระ ตัวอย่างเช่น "ทุกโมดูลจะมีคำสั่งที่สามารถดำเนินการได้ระหว่าง 35 ถึง 50 คำสั่ง" ^{[ 119 ]}
• ความสอดคล้องเชิงตรรกะ: โมดูลจะมีความสอดคล้องเชิงตรรกะหากมีฟังก์ชันหลายฟังก์ชันให้ใช้งาน แต่มีเพียงฟังก์ชันเดียวเท่านั้นที่ถูกเรียกใช้งาน ตัวอย่างเช่นfunction perform_arithmetic( perform_addition, a, b ).
• ความเชื่อมโยงเชิงเวลา : โมดูลจะมีความเชื่อมโยงเชิงเวลาหากทำหน้าที่ที่เกี่ยวข้องกับเวลา ตัวอย่างเช่น ... อีกfunction initialize_variables_and_open_files()ตัวอย่างหนึ่ง...stage_one()stage_two()
• ความสอดคล้องเชิงกระบวนการ : โมดูลจะมีความสอดคล้องเชิงกระบวนการหากทำหน้าที่หลายอย่างที่เกี่ยวข้องกันอย่างหลวมๆ ตัวอย่างเช่นfunction read_part_number_update_employee_record().
• ความสอดคล้องในการสื่อสาร : โมดูลจะมีความสอดคล้องในการสื่อสารหากทำหน้าที่หลายอย่างที่เกี่ยวข้องกันอย่างใกล้ชิด ตัวอย่างเช่นfunction read_part_number_update_sales_record()...
• ความสอดคล้องเชิงข้อมูล : โมดูลจะมีความสอดคล้องเชิงข้อมูลก็ต่อเมื่อมันทำหน้าที่หลายอย่าง แต่แต่ละหน้าที่นั้นมีจุดเริ่มต้นและจุดสิ้นสุดของตัวเอง นอกจากนี้ หน้าที่เหล่านั้นยังใช้โครงสร้างข้อมูลเดียวกัน คลาสเชิงวัตถุทำงานได้ในระดับนี้
• ความสอดคล้องเชิงฟังก์ชัน : โมดูลจะมีความสอดคล้องเชิงฟังก์ชันหากสามารถบรรลุเป้าหมายเดียวโดยทำงานเฉพาะกับตัวแปรภายในเท่านั้น นอกจากนี้ยังสามารถนำกลับมาใช้ใหม่ได้ในบริบทอื่นๆ ด้วย

ระดับของการเชื่อมโยงจากแย่ที่สุดไปดีที่สุดคือ: ^{[ 118 ]}

• การเชื่อมโยงเนื้อหา (Content Coupling ): โมดูลจะมีการเชื่อมโยงเนื้อหาหากมันแก้ไขตัวแปรโลคอล ของฟังก์ชันอื่น COBOL เคยใช้ คำสั่งalterในการทำเช่นนี้
• การเชื่อมโยงร่วม (Common Coupling ): โมดูลจะมีการเชื่อมโยงร่วมหากมีการแก้ไขตัวแปรส่วนกลาง
• การเชื่อมโยงการควบคุม (Control Coupling ): โมดูลหนึ่งจะมีการเชื่อมโยงการควบคุมหากโมดูลอื่นสามารถแก้ไขการไหลของการควบคุม ได้ ตัวอย่างเช่นperform_arithmetic( perform_addition, a, b )แทนที่จะเป็นเช่นนั้น การควบคุมควรอยู่ที่องค์ประกอบของวัตถุที่ส่งคืน
• การเชื่อมโยงแบบ Stamp Coupling : โมดูลจะมี Stamp Coupling หากมีการแก้ไของค์ประกอบของโครงสร้างข้อมูลที่ส่งผ่านเป็นพารามิเตอร์ คลาสเชิงวัตถุทำงานในระดับนี้
• การเชื่อมโยงข้อมูล (Data Coupling ): โมดูลจะมีการเชื่อมโยงข้อมูลหากพารามิเตอร์อินพุตทั้งหมดของโมดูลนั้นจำเป็นต้องใช้และไม่มีการแก้ไขใดๆ นอกจากนี้ ผลลัพธ์ของฟังก์ชันจะต้องถูกส่งคืนเป็นอ็อบเจ็กต์เดียว

การวิเคราะห์การไหลของข้อมูลเป็นวิธีการออกแบบที่ใช้เพื่อให้ได้โมดูลที่มีความสอดคล้องกันทางฟังก์ชันและการเชื่อมโยงข้อมูล^{[ 120 ]}อินพุตของวิธีการนี้คือแผนภาพการไหลของข้อมูลแผนภาพการไหลของข้อมูลคือชุดของวงรีที่แสดงถึงโมดูล ชื่อของแต่ละโมดูลจะแสดงอยู่ภายในวงรี โมดูลอาจอยู่ที่ระดับที่สามารถเรียกใช้งานได้หรือระดับฟังก์ชัน

แผนภาพยังมีลูกศรเชื่อมต่อโมดูลเข้าด้วยกัน ลูกศรที่ชี้เข้าไปในโมดูลแสดงถึงชุดอินพุต แต่ละโมดูลควรมีลูกศรเพียงลูกเดียวที่ชี้ออกมาเพื่อแสดงถึงวัตถุเอาต์พุตเดียว (อาจมีลูกศรข้อยกเว้นเพิ่มเติมชี้ออกมาด้วย) วงรีที่เรียงต่อกัน เป็นลูกโซ่จะสื่อถึง อัลกอริทึมทั้งหมดโมดูลอินพุตควรเริ่มต้นแผนภาพ โมดูลอินพุตควรเชื่อมต่อกับโมดูลการแปลง โมดูลการแปลงควรเชื่อมต่อกับโมดูลเอาต์พุต^{[ 121 ]}

โปรแกรมคอมพิวเตอร์สามารถแบ่งประเภทตามสายงานได้ ประเภทงานหลักคือซอฟต์แวร์แอปพลิเคชันและซอฟต์แวร์ระบบซอฟต์แวร์ระบบประกอบด้วยระบบปฏิบัติการซึ่งเชื่อมโยงฮาร์ดแวร์คอมพิวเตอร์กับซอฟต์แวร์แอปพลิเคชัน^{[ 122 ]}วัตถุประสงค์ของระบบปฏิบัติการคือการจัดสภาพแวดล้อมที่ซอฟต์แวร์แอปพลิเคชันสามารถทำงานได้อย่างสะดวกและมีประสิทธิภาพ^{[ 122 ]}ทั้งซอฟต์แวร์แอปพลิเคชันและซอฟต์แวร์ระบบต่างก็เรียกใช้โปรแกรมยูทิลิตี้ในระดับฮาร์ดแวร์โปรแกรมไมโครโค้ดจะควบคุมวงจรต่างๆ ทั่วทั้ง หน่วยประมวล ผล กลาง

ซอฟต์แวร์แอปพลิเคชันเป็นกุญแจสำคัญในการปลดล็อกศักยภาพของระบบคอมพิวเตอร์^{[ 123 ]}ซอฟต์แวร์แอปพลิเคชันระดับองค์กรประกอบด้วยแอปพลิเคชันด้านบัญชี บุคลากร ลูกค้า และผู้ขาย ตัวอย่างเช่น ซอฟต์แวร์ การวางแผนทรัพยากรองค์กรการจัดการความสัมพันธ์กับลูกค้าและซอฟต์แวร์ การจัดการห่วงโซ่อุปทาน

แอปพลิเคชันระดับองค์กรอาจได้รับการพัฒนาภายในองค์กรในรูปแบบซอฟต์แวร์เฉพาะของตนเอง [ ^{124 ] หรือ}อาจซื้อเป็นซอฟต์แวร์สำเร็จรูป ก็ได้ ซอฟต์แวร์ที่ซื้อมาอาจได้รับการแก้ไขเพื่อให้เป็นซอฟต์แวร์ที่กำหนดเองหากแอปพลิเคชันได้รับการปรับแต่งแล้ว อาจใช้ทรัพยากรของบริษัทเองหรือจ้างบุคคลภายนอกมาพัฒนาซอฟต์แวร์ การพัฒนาซอฟต์แวร์ที่จ้างบุคคลภายนอกอาจมาจากผู้จำหน่ายซอฟต์แวร์ดั้งเดิมหรือนักพัฒนาบุคคลที่สาม^{[ 125 ]}

ข้อดีที่อาจเกิดขึ้นของซอฟต์แวร์ที่พัฒนาภายในองค์กรคือ คุณสมบัติและรายงานอาจได้รับการพัฒนาให้ตรงตามข้อกำหนด^{[ 126 ]}ฝ่ายบริหารอาจมีส่วนร่วมในกระบวนการพัฒนาและให้การควบคุมในระดับหนึ่ง^{[ 127 ]}ฝ่ายบริหารอาจตัดสินใจที่จะตอบโต้ความคิดริเริ่มใหม่ของคู่แข่งหรือดำเนินการตามข้อกำหนดของลูกค้าหรือผู้ขาย^{[ 128 ]} การควบรวมกิจการหรือการเข้าซื้อกิจการอาจทำให้จำเป็นต้องมีการเปลี่ยนแปลงซอฟต์แวร์ขององค์กร ข้อเสียที่อาจเกิดขึ้นของซอฟต์แวร์ที่พัฒนาภายในองค์กรคือ ต้นทุนด้านเวลาและทรัพยากรอาจสูงมาก^{[ 124 ]}นอกจากนี้ ความเสี่ยงเกี่ยวกับคุณสมบัติและประสิทธิภาพอาจมีอยู่

ข้อดีที่อาจเกิดขึ้นของซอฟต์แวร์สำเร็จรูปคือ ต้นทุนเริ่มต้นสามารถระบุได้ ความต้องการพื้นฐานควรได้รับการตอบสนอง และประสิทธิภาพและความน่าเชื่อถือมีประวัติการใช้งาน^{[ 124 ]}ข้อเสียที่อาจเกิดขึ้นของซอฟต์แวร์สำเร็จรูปคือ อาจมีฟีเจอร์ที่ไม่จำเป็นซึ่งทำให้ผู้ใช้ปลายทางสับสน อาจขาดฟีเจอร์ที่องค์กรต้องการ และการไหลของข้อมูลอาจไม่ตรงกับกระบวนการทำงานขององค์กร^{[ 124 ]}

แนวทางหนึ่งในการจัดหาแอปพลิเคชันองค์กรแบบกำหนดเองอย่างประหยัดคือการใช้ผู้ให้บริการแอปพลิเคชัน [ ^{129 ] บริษัท}เฉพาะทางจะจัดหาฮาร์ดแวร์ ซอฟต์แวร์ที่กำหนดเอง และการสนับสนุนผู้ใช้ปลายทาง พวกเขาอาจเร่งการพัฒนาแอปพลิเคชันใหม่ ๆ เนื่องจากพวกเขามีพนักงานระบบสารสนเทศที่มีทักษะ ข้อได้เปรียบที่สำคัญที่สุดคือช่วยลดภาระงานภายในองค์กรจากการจัดหาบุคลากรและจัดการโครงการคอมพิวเตอร์ที่ซับซ้อน^{[ 129 ]}ผู้ให้บริการแอปพลิเคชันหลายรายมุ่งเป้าไปที่บริษัทขนาดเล็กที่เติบโตอย่างรวดเร็วซึ่งมีทรัพยากรระบบสารสนเทศจำกัด^{[ 129 ]}ในทางกลับกัน บริษัทขนาดใหญ่ที่มีระบบหลัก ๆ มักจะมีโครงสร้างพื้นฐานทางเทคนิคอยู่แล้ว ความเสี่ยงอย่างหนึ่งคือการต้องไว้วางใจองค์กรภายนอกด้วยข้อมูลที่ละเอียดอ่อน ความเสี่ยงอีกประการหนึ่งคือการต้องไว้วางใจความน่าเชื่อถือของโครงสร้างพื้นฐานของผู้ให้บริการ^{[ 129 ]}

ระบบปฏิบัติการคือซอฟต์แวร์ระดับต่ำที่สนับสนุนฟังก์ชันพื้นฐานของคอมพิวเตอร์ เช่นการจัดตารางกระบวนการและการควบคุม อุปกรณ์ ต่อพ่วง^{[ 122 ]}

ในช่วงทศวรรษ 1950 โปรแกรมเมอร์ซึ่งเป็นผู้ควบคุมการทำงานด้วย จะเขียนโปรแกรมและรันโปรแกรมนั้น หลังจากโปรแกรมทำงานเสร็จสิ้น ผลลัพธ์อาจถูกพิมพ์ออกมา หรืออาจถูกเจาะลงบนเทปกระดาษหรือการ์ดเพื่อนำไปประมวลผลในภายหลัง^{[ 30 ]}บ่อยครั้งที่โปรแกรมไม่ทำงาน โปรแกรมเมอร์จึงดูไฟแสดงสถานะบนคอนโซลและปรับสวิตช์บนคอนโซล หากโชคไม่ดี ก็จะมีการพิมพ์ข้อมูลจากหน่วยความจำเพื่อนำไปศึกษาเพิ่มเติม ในช่วงทศวรรษ 1960 โปรแกรมเมอร์ลดเวลาที่เสียไปโดยเปล่าประโยชน์ลงด้วยการทำให้งานของผู้ควบคุมการทำงานเป็นไปโดยอัตโนมัติ โปรแกรมที่เรียกว่าระบบปฏิบัติการจะถูกเก็บไว้ในคอมพิวเตอร์ตลอดเวลา^{[ 130 ]}

คำว่าระบบปฏิบัติการอาจหมายถึงซอฟต์แวร์สองระดับ^{[ 131 ]}ระบบปฏิบัติการอาจหมายถึงโปรแกรมเคอร์เนลที่จัดการกระบวนการหน่วยความจำและอุปกรณ์ต่างๆในความหมายที่กว้างกว่านั้น ระบบปฏิบัติการอาจหมายถึงแพ็กเกจซอฟต์แวร์ส่วนกลางทั้งหมด แพ็กเกจนี้ประกอบด้วยโปรแกรมเคอร์เนล ตัวแปลคำสั่งบรรทัด อินเท อร์เฟ ซผู้ใช้แบบกราฟิกโปรแกรมยูทิลิตี้และโปรแกรมแก้ไข^{[ 131 ]}

หน้าที่หลักของเคอร์เนลคือการจัดการทรัพยากรที่มีจำกัดของคอมพิวเตอร์:

• โปรแกรมเคอร์เนลควรดำเนินการจัดกำหนดการกระบวนการ^{[ 132 ]}ซึ่งเรียกอีกอย่างว่าการสลับบริบทเคอร์เนลสร้างบล็อกควบคุมกระบวนการเมื่อโปรแกรมคอมพิวเตอร์ถูกเลือกสำหรับการดำเนินการอย่างไรก็ตาม โปรแกรมที่ดำเนินการจะได้รับสิทธิ์การเข้าถึงหน่วยประมวลผลกลาง แบบพิเศษ เฉพาะในช่วงเวลา หนึ่งเท่านั้น เพื่อให้ผู้ใช้แต่ละคนดูเหมือนว่าสามารถเข้าถึงได้อย่างต่อเนื่องเคอร์เนลจึงแย่งชิงบล็อกควบคุมกระบวนการแต่ละบล็อกอย่างรวดเร็วเพื่อดำเนินการบล็อกอื่น เป้าหมายสำหรับนักพัฒนาระบบคือการลดความหน่วงแฝงในการส่งคำสั่งให้ น้อยที่สุด

• โปรแกรมเคอร์เนลควรทำหน้าที่จัดการหน่วยความจำ

• เมื่อเคอร์เนลโหลดไฟล์ปฏิบัติการลงในหน่วยความจำในครั้งแรก มันจะแบ่งพื้นที่แอดเดรสเชิงตรรกะออกเป็นส่วนๆ [ ^{133 ] เคอร์เนล}จะรักษาตารางมาสเตอร์รีเจียนและตารางเพอร์โปรเซสรีเจียน (pregion) จำนวนมากไว้ โดยแต่ละ ตารางจะแทน โปรเซสที่ กำลังทำงาน อยู่^{[ 133 ]}ตารางเหล่านี้ประกอบกันเป็นพื้นที่แอดเดรสเสมือนตารางมาสเตอร์รีเจียนใช้เพื่อกำหนดตำแหน่งของเนื้อหาในหน่วยความจำทางกายภาพตาราง pregion อนุญาตให้แต่ละโปรเซสมี pregion โปรแกรม (ข้อความ) ของตนเอง pregion ข้อมูล และ pregion สแต็กของตนเอง
• โปรแกรม pregion จะเก็บคำสั่งเครื่อง เนื่องจากคำสั่งเครื่องไม่เปลี่ยนแปลง โปรแกรม pregion จึงสามารถใช้ร่วมกันได้ในหลายกระบวนการของไฟล์ปฏิบัติการเดียวกัน^{[ 133 ]}
• เพื่อประหยัดเวลาและหน่วยความจำ เคอร์เนลอาจโหลดเฉพาะบล็อกของคำสั่งการดำเนินการจากไดรฟ์ดิสก์ ไม่ใช่ไฟล์การดำเนินการทั้งหมดโดยสมบูรณ์^{[ 132 ]}
• เคอร์เนลมีหน้าที่ในการแปลงที่อยู่เสมือนเป็นที่อยู่จริงเคอร์เนลอาจร้องขอข้อมูลจากตัวควบคุมหน่วยความจำแต่กลับได้รับข้อผิดพลาดของเพจแทน [ ^{134 ] หาก}เป็นเช่นนั้น เคอร์เนลจะเข้าถึงหน่วยจัดการหน่วยความจำเพื่อเติมข้อมูลในพื้นที่ข้อมูลจริงและแปลงที่อยู่^{[ 135 ]}
• เคอร์เนลจะจัดสรรหน่วยความจำจากฮีปตามคำขอของกระบวนการ^{[ 64 ]}เมื่อกระบวนการใช้หน่วยความจำเสร็จแล้ว กระบวนการอาจร้องขอให้ปล่อยหน่วยความจำนั้นหากกระบวนการออกจากระบบโดยไม่ร้องขอให้ปล่อยหน่วยความจำที่จัดสรรไว้ทั้งหมด เคอร์เนลจะทำการเก็บขยะเพื่อปล่อยหน่วยความจำนั้น
• เคอร์เนลยังรับประกันว่ากระบวนการจะเข้าถึงเฉพาะหน่วยความจำของตนเองเท่านั้น ไม่ใช่หน่วยความจำของเคอร์เนลหรือกระบวนการอื่น^{[ 132 ]}

• โปรแกรมเคอร์เนลควรดำเนิน การ จัดการระบบไฟล์^{[ 132 ]}เคอร์เนลมีคำสั่งในการสร้าง ดึงข้อมูล อัปเดต และลบไฟล์
• โปรแกรมเคอร์เนลควรดำเนิน การ จัดการอุปกรณ์^{[ 132 ]}เคอร์เนลจัดเตรียมโปรแกรมเพื่อสร้างมาตรฐานและลดความซับซ้อนของอินเทอร์เฟซไปยังเมาส์ คีย์บอร์ด ดิสก์ไดรฟ์ เครื่องพิมพ์ และอุปกรณ์อื่นๆ นอกจากนี้ เคอร์เนลควรตัดสินการเข้าถึงอุปกรณ์หากมีสองกระบวนการร้องขอพร้อมกัน
• โปรแกรมเคอร์เนลควรดำเนิน การ จัดการเครือข่าย^{[ 136 ]}เคอร์เนลส่งและรับแพ็กเก็ตในนามของกระบวนการ บริการหลักอย่างหนึ่งคือการค้นหาเส้นทาง ที่มีประสิทธิภาพ ไปยังระบบเป้าหมาย
• โปรแกรมเคอร์เนลควรจัดเตรียมฟังก์ชันระดับระบบเพื่อให้โปรแกรมเมอร์ใช้งานได้^{[ 137 ]}
  • โปรแกรมเมอร์เข้าถึงไฟล์ผ่านอินเทอร์เฟซที่ค่อนข้างเรียบง่าย ซึ่งจะเรียกใช้อินเทอร์เฟซการรับส่งข้อมูลระดับต่ำที่ค่อนข้างซับซ้อน อินเทอร์เฟซระดับต่ำนี้ประกอบด้วยการสร้างไฟล์ตัวระบุไฟล์การค้นหาไฟล์ การอ่านทางกายภาพ และการเขียนทางกายภาพ
  • โปรแกรมเมอร์สร้างกระบวนการผ่านอินเทอร์เฟซที่ค่อนข้างเรียบง่าย ซึ่งในทางกลับกันจะเรียกใช้อินเทอร์เฟซระดับต่ำที่ค่อนข้างซับซ้อน
  • โปรแกรมเมอร์ทำการคำนวณวันที่/เวลาผ่านอินเทอร์เฟซที่ค่อนข้างเรียบง่าย ซึ่งในทางกลับกันจะดำเนินการอินเทอร์เฟซเวลาระดับต่ำที่ค่อนข้างซับซ้อน^{[ 138 ]}
• โปรแกรมเคอร์เนลควรจัดเตรียมช่องทางการสื่อสารระหว่างกระบวนการที่กำลังดำเนินการ^{[ 139 ]}สำหรับระบบซอฟต์แวร์ขนาดใหญ่ อาจเป็นที่พึงปรารถนาที่จะออกแบบระบบให้เป็นกระบวนการที่เล็กลง กระบวนการต่างๆ อาจสื่อสารกันโดยการส่งและรับสัญญาณ

เดิมทีระบบปฏิบัติการถูกเขียนโปรแกรมด้วย^ภาษาแอสเซมบลีแต่ระบบปฏิบัติการสมัยใหม่มักเขียนด้วยภาษาโปรแกรมระดับสูง เช่นC , Objective-CและSwift ^{[ m} ]

โปรแกรมยูทิลิตี้คือโปรแกรมที่ช่วยในการบริหารระบบและการทำงานของซอฟต์แวร์ โดยทั่วไประบบปฏิบัติการจะมีโปรแกรมยูทิลิตี้เพื่อตรวจสอบฮาร์ดแวร์ เช่น หน่วยเก็บข้อมูล หน่วยความจำ ลำโพง และเครื่องพิมพ์^{[ 140 ]}โปรแกรมยูทิลิตี้อาจช่วยเพิ่มประสิทธิภาพการทำงานของอุปกรณ์จัดเก็บข้อมูล โปรแกรมยูทิลิตี้ของระบบจะตรวจสอบประสิทธิภาพของฮาร์ดแวร์และเครือข่าย และอาจแจ้งเตือนเมื่อค่าเมตริกอยู่นอกช่วงปกติ^{[ 141 ]}โปรแกรมยูทิลิตี้อาจบีบอัดไฟล์เพื่อลดพื้นที่จัดเก็บข้อมูลและเวลาในการส่งข้อมูลผ่านเครือข่าย^{[ 140 ]}โปรแกรมยูทิลิตี้อาจจัดเรียงและรวมชุดข้อมูล^{[ 141 ]}หรือตรวจจับไวรัสคอมพิวเตอร์^{[ 141 ]}

โปรแกรมไมโครโค้ดคือตัวแปลระดับล่างสุด^{[ n ]}ที่ควบคุมเส้นทางข้อมูลของคอมพิวเตอร์ที่ขับเคลื่อนด้วยซอฟต์แวร์^{[ 143 ]} (ความก้าวหน้าในด้านฮาร์ดแวร์ได้ย้ายการดำเนินการเหล่านี้ไปยังวงจรการประมวลผลฮาร์ดแวร์ ) ^{[ 143 ]}คำสั่งไมโครโค้ดช่วยให้โปรแกรมเมอร์สามารถใช้งานระดับตรรกะดิจิทัล ได้ง่ายขึ้น ^{[ 144 ]}ซึ่งเป็นฮาร์ดแวร์ที่แท้จริงของคอมพิวเตอร์ ระดับตรรกะดิจิทัลเป็นขอบเขตระหว่างวิทยาศาสตร์คอมพิวเตอร์และวิศวกรรมคอมพิวเตอร์^{[ 145 ]}

เกตตรรกะคือทรานซิสเตอร์ ขนาดเล็ก ที่สามารถส่งสัญญาณกลับได้สองอย่างคือ เปิดหรือปิด^{[ 146 ]}

• การมีทรานซิสเตอร์เพียงตัวเดียวจะทำให้เกิดวงจรNOT gate
• การต่อทรานซิสเตอร์สองตัวแบบอนุกรมจะทำให้เกิดวงจรNAND gate
• การต่อทรานซิสเตอร์สองตัวแบบขนานจะทำให้เกิดวงจรNOR gate
• การเชื่อมต่อเกต NOT เข้ากับเกต NAND จะทำให้เกิด เก ตAND
• การเชื่อมต่อเกต NOT เข้ากับเกต NOR จะทำให้เกิด เก ตOR

ประตูทั้งห้านี้เป็นส่วนประกอบพื้นฐานของพีชคณิตไบนารีซึ่งเป็นฟังก์ชันตรรกะดิจิทัลของคอมพิวเตอร์

คำสั่งไมโครโค้ดเป็นตัวย่อที่โปรแกรมเมอร์อาจใช้เพื่อดำเนินการฟังก์ชันตรรกะดิจิทัลแทนที่จะสร้างเป็นพีชคณิตไบนารี คำสั่งเหล่านี้จะถูกเก็บไว้ในหน่วยความจำควบคุมของหน่วยประมวลผลกลาง (CPU) ^{[ 147 ]} คำสั่งระดับฮาร์ดแวร์เหล่านี้จะย้ายข้อมูลไปตามเส้นทาง ข้อมูล

วงจรคำสั่งไมโครเริ่มต้นเมื่อไมโครซี เควนเซอร์ ใช้ตัวนับโปรแกรมไมโครเพื่อดึงคำสั่งเครื่องถัดไปจากหน่วยความจำเข้าถึงแบบสุ่ม [ ^{148 ] ขั้น}ตอนต่อไปคือการถอดรหัสคำสั่งเครื่องโดยการเลือกสายเอาต์พุตที่เหมาะสมไปยังโมดูลฮาร์ดแวร์^{[ 149 ]} ขั้นตอนสุดท้ายคือการดำเนินการคำสั่งโดยใช้ชุดเกตของโมดูลฮาร์ดแวร์

คำสั่งในการดำเนินการทางคณิตศาสตร์จะถูกส่งผ่านหน่วยตรรกะทางคณิตศาสตร์ (ALU) ^{[ 150 ]} ALU มีวงจรสำหรับดำเนินการพื้นฐาน เช่น การบวก การเลื่อน และการเปรียบเทียบจำนวนเต็ม โดยการรวมและวนซ้ำการดำเนินการพื้นฐานผ่าน ALU CPU จะทำการคำนวณทางคณิตศาสตร์ที่ซับซ้อน

คำสั่งไมโครโค้ดจะย้ายข้อมูลระหว่าง CPU และตัวควบคุมหน่วยความจำคำสั่งไมโครโค้ดของตัวควบคุมหน่วยความจำจะจัดการรีจิสเตอร์ สองตัว รีจิสเตอร์ที่อยู่หน่วยความจำใช้สำหรับเข้าถึงที่อยู่ของเซลล์หน่วยความจำแต่ละเซลล์รีจิสเตอร์ข้อมูลหน่วยความจำใช้สำหรับตั้งค่าและอ่านเนื้อหาของแต่ละเซลล์^{[ 151 ]}