วิธีคิดแบบนักวิทยาการคอมพิวเตอร์/The way of the program

บทที่ 1 The way of the program.
The way of the program.
เป้าหมายของหนังสือเล่มนี้คือต้องการที่จะสอนคุณให้คิดอย่างนักวิทยาศาสตร์คอมพิวเตอร์ แนวทางการคิดนี้ผสมกันด้วยระหว่างลักษณะที่สำคัญในการคิดทาง คณิตศาสตร์ วิศวกรรมศาสตร์ และวิทยาศาสตร์ ธรรมชาติ
อย่างนักวิทยาศาสตร์ นักวิทยาศาสตร์ คอมพิวเตอร์ ใช้ภาษาที่เป็นทางการในการแสดงถึงความคิด(โดยเฉพาะ การคำนวณ) อย่างวิศวกร พวกเค้าสร้างสรรค์ออกแบบสิ่งของ เอาส่วนประกอบมารวมกันเป็นระบบและการแลกเปลี่ยนที่มีการประเมินท่ามกลางตัวเลือกที่หลากหลาย อย่างนักวิทยาศาสตร์ พวกเค้าทำการสำรวจพฤติกรรมที่ซับซ้อนของระบบ ตั้งสมมติฐาน และมีการคาดการณ์ผลการทดลองล่วงหน้า
ทักษะที่สำคัญที่สุดสำหรับนักวิทยาศาสตร์ คอมพิวเตอร์คือการแก้ไขปัญหา การแก้ไขปัญหาหมายถึง ความสามารถในการกำหนดปัญหา คิดสร้างสรรค์เกี่ยวกับการแก้ไขปัญหา และแสดงวิธีแก้ไขปัญหาอย่างชัดเจนและแม่นยำ กระบวนการของการเรียนรู้โปรแกรมเป็นโอกาสที่ดีของการฝึกฝนทักษะในการแก้ไขปัญหา นั่นเป็นเหตุผลที่บทนี้มีชื่อเรียกว่า "The way of the program"
ในขั้นแรก คุณจะได้เรียนรู้โปรแกรม ทักษะที่มีประโยชน์จากโปรแกรม ในขั้นอื่นๆ คุณจะใช้ กระบวนการเขียนและทดสอบโปรแกรมทางคอมพิวเตอร์จนจบ เมื่อเราไปได้ดี ในตอนจบก็จะชัดเจนและเข้าใจมากขึ้น
1.1 The Python programming language.
ภาษาทางการเขียนโปรแกรมที่คุณจะได้เรียนรู้คือ Python Python เป็นตัวอย่างของภาษาระดับสูง ซึ่งภาษาระดับสูงตัวอื่นๆที่คุณเคยได้ยินมาคือ C, C++, Perl and Java
อย่างที่คุณอนุมานจากชื่อ ภาษาระดับสูง (high-level language) เช่นเดียวกันก็มี ภาษาระดับล่าง (low-level languages) ในบางครั้งหมายถึง ภาษาเครื่อง (machine languages) หรือ “assembly language” พูดอย่างง่ายๆ คอมพิวเตอร์สามารถที่จำดำเนินการกับโปรแกรมที่เขียนใน low-level languages เท่านั้น ดังนั้น โปรแกรมที่ถูกเขียนขึ้นใน high-level language จะต้องถูกประเมินผลก่อนที่มันจะสามรถรัน นี่เป็นกระบวนการพิเศษที่ต้องใช้เวลา ซึ่งเป็นข้อเสียของ high-level languages
แต่ข้อดีนั้นก็มีมากมายนัก อย่างแรก มันมีความง่ายมากที่จะเขียนโปรแกรมใน high-level languages โปรแกรมที่เขียนจาก high-level languages ใช้เวลาน้อยในการเขียน ภาษาที่เขียนจะสั้นกว่าและง่ายต่อการอ่าน และมีความถูกต้องสูงกว่า อย่างที่สอง high-level languages มีความสะดวกและง่าย ซึ่งหมายถึงมันสามารถที่จะทำงานบนเครื่องคอมพิวเตอร์ที่ต่างกันได้ด้วยการแก้ไขเพียงเล็กน้อยหรือไม่ต้องแก้ไขใดๆเลย low-level program สามารถรันได้บนคอมพิวเตอร์เพียงชนิดเดียวเท่านั้นและจะต้องทำการเขียนใหม่เพื่อที่จะรันบนเครื่องอื่น
สืบเนื่องจากประโยชน์เหล่านี้ โปรแกรมเกือบทั้งหมดถูกเขียนด้วย high-level languages low-level languages จะถูกใช้เพียงสำหรับโปรแกรมที่มีลักษณะเฉพาะ
กระบวนการสองอย่างที่จะทำให้ high-level languages ไปเป็น low-level languages:
interpreters และ compliers Interpreter อ่าน high-level program และดำเนินการมัน หมายความว่ามันทำอย่างที่โปรแกรมว่าไว้ มันดำเนินการโปรแกรมเล็กน้อยทีละน้อย สลับกับการอ่านบรรทัดและกระทำการคำนวณ
 *compiler = ตัวแปลภาษาโปรแกรมที่เขียนใน high-level language ไปเป็น low- level language โดยแปลทั้งหมดภายในครั้งเดียว ในการเตรียมพร้อมสำหรับดำเนินการต่อไป
 *interpreter = ตัวดำเนินการโปรแกรมใน high-level language ด้วยการแปลหนึ่งบรรทัดต่อครั้ง
compiler อ่านโปรแกรมและแปลมันอย่างสมบูรณ์ก่อนที่โปรแกรมจะเริ่มรัน ในกรณีนี้ high-level program ถูกเรียกว่า source code และโปรแกรมที่ถูกแปลเรียกว่า object code หรือ executable เมื่อโปรแกรมถูกคอมไพล์ครั้งนึงแล้ว คุณสามารถดำเนินการมันอย่างซ้ำได้โดยไม่ต้องมีการแปลมากขึ้น
Python เป็น interpreted language เนื่องจาก Python program ถูกดำเนินการโดย interpreter มีสองทางที่จะใช้ interpreter: command line mode และ script mode ใน command line mode คุณพิมพ์โปรแกรมและ interpreter แสดงผล:
 $ python
 Python 241 (#1 Apr 29 2005 00:28:56)
 Type “help” “copyright” “credits” or “license” for more information
 »> print 1 + 1
 2
 บรรทัดแรกของตัวอย่างคือคำสั่งที่เริ่มต้น Python interpreter สองบรรทัดถัดมาเป็นข้อความของ interpreter บรรทัดที่สามเริ่มด้วย »> ซึ่งเป็น prompt ของ interpreter ใช้เพื่อบ่งบอกว่ามันพร้อม เราได้พิมพ์ print 1 + 1และ interpreter ตอบ 2
อย่างหลากหลาย คุณสามารถเขียนโปรแกรมเป็น file และใช้ interpreter ดำเนินการ file นั้น เช่น file ที่เรียกว่า script ตัวอย่าง เราได้ใช้ text editor ในการสร้าง file ชื่อ latoyapy ด้วยหัวข้อเหล่านี้:
 print 1 + 1
 ตามธรรมเนียมปฏิบัติ file ที่บรรจุด้วย Python program ชื่อต้องลงท้ายด้วย py
เพื่อดำเนินการโปรแกรม เราจะต้องบอกให้ interpreter รู้ชื่อของ script:
 $ python latoyapy
 2
 ตัวอย่างโดยส่วนใหญ่ในหนังสือนี้ดำเนินการบน command line ทำงานบน command line เป็นธรรมเนียมปฏิบัติสำหรับการพัฒนาโปรแกรมและทดสอบโปรแกรม เนื่องจากคุณสามารถที่จะพิมพ์โปรแกรมและดำเนินการมันได้ในทันที เมื่อครั้งที่คุณทำงานกับโปรแกรม คุณควรเก็บมันไว้เป็น script เพื่อที่จะ คุณสามารถดำเนินการหรือแก้ไขมันในครั้งต่อไป
1.2 What is a program?
program คือการต่อเนื่องกันของชุดคำสั่งที่ระบุหรือกำหนดว่าจะแสดงการคำนวณอย่างไร การคำนวณอาจเป็นบางอย่างที่เกี่ยวกับคณิตศาสตร์ เช่น การหาผลลัพธ์ของระบบสมการ หรือหา roots of a polynomial แต่มันสามารถจะเป็นการคำนวณทางสัญลักษณ์ด้วยเช่นกัน เช่น การค้นหาและการแทนที่ข้อความในเอกสารหรือการคอมไพล์โปรแกรม
 รายละเอียดดูแตกต่างกับภาษาอื่นๆ แต่ชุดคำพื้นฐานจำนวนหนึ่งปรากฏเหมือนกับในทุกๆภาษา:
 input: รับข้อมูลจากคีย์บอร์ด ไฟล์ หรืออุปกรณ์อื่นๆ
 output: แสดงข้อมูลบนหน้าจอหรือส่งข้อมูลไปเป็นไฟล์หรือไปยังอุปกรณ์อื่นๆ
 math: แสดงการดำเนินการทางคณิตศาสตร์พื้นฐานอย่างการบวกและการคูณ
 conditional execution: ตรวจสอบเงื่อนไขบางอย่างและดำเนินการลำดับของ statement ที่จัดสรรไว้
 repetition: แสดงการกระทำซ้ำบางอย่าง โดยปรกติกับการเปลี่ยนแปลงบางอย่าง
1.3 What is debugging?
การเขียนโปรแกรมเป็นกระบวนการที่ซับซ้อน เพราะมนุษย์เป็นผู้เขียน บ่อยครั้งที่มีความผิดพลาด เหตุผลที่แปลก คือ โปรแกรมที่ผิดพลาดถูกเรียกว่า Bugs กระบวนการแกะรอยและการแก้ไขข้อผิดพลาดนั้นเรียกว่า debugging
 ข้อผิดพลาดสามชนิดที่สามารถพบในโปรแกรม syntax errors, runtime errors และ semantic errors มันเป็นประโยชน์ในการจำแนกความแตกต่างระหว่างข้อผิดพลาดในการหาข้อผิดพลาดเร็วขึ้น
1.3.1 Syntax errors
 Python สามารถดำเนินการโปรแกรมได้เพียงถ้าโปรแกรมนั้นมีการสร้างประโยคอย่างถูกต้อง มิฉะนั้นกระบวนการล้มเหลวและจะreturn ข้อความที่แสดงความผิดพลาด syntax อ้างอิงไปยังตรงสร้างของโปรแกรมและกฎเกณฑ์เกี่ยวกับโครงสร้าง ตัวอย่าง ในภาษาอังกฤษ ประโยคต้องเริ่มต้นด้วยตัวอักษรพิมพ์ใหญ่และจบด้วยจุด
 สำหรับผู้อ่านส่วนใหญ่ syntax errors เพียงเล็กน้อย ไม่ทำให้เกิดปัญหากับความหมาย ซึ่งคือทำไมเราสามารถอ่านบทกวีของ ee cummings โดยปราศจากข้อความผิดพลาด Python จะไม่ยอมให้ถ้ามี syntax errorเพียงตัวเดียวไม่ว่าจะอยู่ที่ใดในโปรแกรมของคุณ Pythonจะแสดงข้อความที่ผิดพลาดและหยุด โดยคุณจะไม่สามารถรันโปรแกรมของคุณได้ ในช่วงสัปดาห์แรกๆของอาชีพเขียนโปรแกรมของคุณแน่นอนว่าคุณจะใช้เวลาส่วนใหญ่กับการติดตามแกะรอย syntax errors ขณะที่คุณได้รับประสบการณ์ อย่างไรก็ดีคุณก็จะสร้างข้อผิดพลาดได้น้อยลงและหามันได้เร็วขึ้น
1.3.2 Runtime errors
 ข้อผิดพลาดรูปแบบที่สองคือ runtime error ที่เรียกดังนั้นเนื่องจากข้อผิดพลาดจะไม่ปรากฏขึ้นกระทั่งคุณได้รันโปรแกรม ข้อผิดพลาดนี้ถูกเรียกว่า exception ด้วยเช่นกัน ก็เพราะโดยปกติมันจะบ่งชี้บางอย่างที่ผิดปกติที่ได้เกิดขึ้น
 Runtime error จะพบได้ยากในโปรแกรมอย่างง่าย ซึ่งจะได้เห็นในบทแรกๆ
1.3.3 Semantic errors
 ข้อผิดพลาดชนิดที่สาม คือ semantic error ถ้ามี semantic error ในโปรแกรมของคุณมันจะสามารถรันโปรแกรมได้สมบูรณ์ คอมพิวเตอร์ไม่สามารถตรวจพบข้อความผิดพลาดใดๆแต่มันจะไม่สามารถทำงานที่ถูกต้องได้ มันจะทำอย่างอื่นแทน โดยเฉพาะมันจะทำอย่างที่คุณบอกมันให้ทำ ปัญหาคือโปรแกรมที่คุณเขียนนั้นไม่ได้เป็นโปรแกรมที่คุณต้องการที่จะเขียน ความหมายของโปรแกรมผิด การระบุ semantic error สามารถทำได้ยาก เนื่องจากมันต้องการให้คุณทำงานถอยหลังด้วยการดูผลลัพธ์ของโปรแกรมและพยายามคิดว่ามันกำลังจะทำอะไร
1.3.4 Experimental debugging
 หนึ่งในทักษะที่สำคัญที่ผู้อ่านจะได้รับคือdebugging (กระบวนของการค้นหาและการลบข้อผิดพลาดใดๆทั้งสามชนิดของ programming errors) ถึงแม้ว่ามันสามารถทำให้เกิดความท้อแท้ debugging เป็นส่วนหนึ่งในสิ่งมีค่าทางสติปัญญา ความท้าทาย และเป็นส่วนที่น่าสนใจของการเขียนโปรแกรม
 ในบางวิธี debugging เป็นเหมือนกับการทำงานของนักสืบ คุณจะพบร่องรอยและคุณต้องสรุปกระบวนการและเหตุการณ์ที่จะนำไปสู่ผลลัพธ์ที่คุณเห็น
Debugging เป็นเหมือนกับการทดลองทางวิทยาศาสตร์ ครั้งนึงคุณมีความคิดว่าเกิดผิดพลาดอะไรขึ้น คุณทำการแก้ไขตัวโปรแกรมและทดลองใหม่ ถ้าสมมติฐานที่คุณตั้งไว้ถูกต้อง จากนั้นคุณสามารถทำนายผลของการแก้ไขและคุณก็จะเข้าใกล้กับโปรแกรมที่สามารถใช้งานได้ ถ้าสมมติฐานผิดคุณต้องตั้งมันขึ้นมาใหม่ อย่างที่ Sherlock Homes ชี้ให้เห็น “เมื่อคุณได้ขจัดสิ่งที่เป็นไปไม่ได้ อะไรก็ตามที่คงเหลือไม่ว่าจะไม่น่าเป็นไปได้ขนาดไหนจะต้องเป็นความจริง” (A Conan Doyle The Sign of Four)
 สำหรับบางคน การเขียนโปรแกรมและการแก้ไขข้อผิดพลาดเป็นสิ่งเดียวกัน นั่นก็คือการเขียนโปรแกรมเป็นกระบวนการของการ debugging ทีละน้อยจนได้โปรแกรมที่คุณต้องการ แนวคิดคือคุณก็จะได้โปรแกรมที่ใช้งานได้
 ตัวอย่าง Linux เป็นระบบปฏิบัติการที่บรรจุด้วยโค้ดนับพันบรรทัด แต่เริ่มต้นด้วยการเป็นโปรแกรมง่ายๆ Linux Torvalds
บทต่อๆไปจะให้ข้อเสนอแนะมากขึ้นเกี่ยวกับ debugging และการฝึกเขียนโปรแกรม
1.4 Formal and natural language.
Natural language เป็นภาษาที่ผู้คนพูดกัน เช่น ภาษาอังกฤษ ภาษาสเปน และภาษาฝรั่งเศส มันไม่ได้ถูกประดิษฐ์โดยคน (ถึงแม้ว่าผู้คนพยายามที่จะกำหนดจัดระเบียบบางอย่างกับมัน) มันค่อยๆได้รับการพัฒนาโดยธรรมชาติ
 Formal language เป็นภาษาที่ได้รับการประดิษฐ์ขึ้นโดยมนุษย์สำหรับการประยุกต์ใช้โดยเฉพาะ ตัวอย่าง สัญลักษณ์ที่นักคณิตศาสตร์ใช้เป็น formal language นั่นคือโดยเฉพาะอย่างยิ่ง การแสดงให้เห็นความสัมพันธ์ในระหว่างตัวเลขและสัญลักษณ์ นักเคมีใช้ formal language เพื่อแทนโครงสร้างทางเคมีของโมเลกุล และที่สำคัญที่สุด
ภาษาในการเขียนโปรแกรมเป็น formal language ที่ถูกประดิษฐ์ขึ้นเพื่อแสดงการคำนวณ
 formal language มีแนวโน้มที่จะเข้มงวดกับ syntax ตัวอย่าง 3+3=6 เป็นการสร้างประโยคที่ถูกต้องตาม mathematic statement แต่ 3=+6$ ไม่ถูกต้อง H2O เป็นการสร้างประโยคที่ถูกต้องตามชื่อทางเคมี แต่ 2Zz ไม่ถูกต้อง
 กฎของ syntax(การสร้างประโยค) มีด้วยกันสองอย่าง เกี่ยวข้องกับ token(หนึ่งใน elements พื้นฐานของการสร้างประโยคของโครงสร้างโปรแกรม คล้ายกับคำใน natural language) และโครงสร้าง Token เป็น elements พื้นฐานของภาษา เช่น คำตัวเลข และธาตุทางเคมี หนึ่งในปัญหากับ 3=+6$ คือ $ ไม่ได้เป็น token ที่ถูกต้องในทางคณิตศาสตร์ เช่นเดียวกับ 2Zz ที่ไม่ถูกต้องเนื่องจากไม่มี element ที่เป็นตัวย่อ Zz
 รูปแบบที่สองของ syntax error ที่เกี่ยวข้องกับโครงสร้างของ statement นั่นคือ วิธีการจัดการการเรียง tokens statement 3=+6$ เป็นการสร้างประโยคที่ผิดเนื่องจากคุณไม่สามารถวางเครื่องหมายบวกได้ทันทีหลังจากเครื่องหมายเท่ากับ เช่นเดียวกันกับ สูตรโมเลกุลที่ต้องมีตัวอักษรหรือตัวเลขที่เขียนอยู่ต่ำกว่าตัวอื่นหลังจาก element ที่เป็นชื่อ ไม่ใช่ก่อนชื่อ
 เวลาที่คุณอ่านประโยคในภาษาอังกฤษ หรือ statement ใน formal language คุณต้องคิดคำนวณว่าโครงสร้างของประโยคคืออะไร(ใน natural language คุณต้องทำอย่างนี้อยู่ในจิตสำนึก กระบวนการนี้เรียกว่า parsing(การพินิจพิจารณาโปรแกรมและวิเคราะห์โครงสร้างของการสร้างประโยค) ตัวอย่าง เมื่อคุณได้ยินประโยค ”The other shoe fell” คุณเข้าใจว่า ”The other shoe” คือประธานของประโยค และ ”fell” คือภาคแสดง เมื่อครั้งที่คุณวิเคราะห์คำในประโยค คุณสามารถคิดคำนวณว่ามันหมายถึงอะไร หรือเกี่ยวกับความหมายของประโยค เป็นที่เข้าใจว่าคุณรู้ว่า shoe คืออะไร และอะไรที่ fall คุณจะเข้าใจความหมายโดยนัยของประโยคนี้
 ถึงแม้ว่า formal และ natural language มีลักษณะเฉพาะมากมายที่ร่วมกัน- tokens structure syntax และ semantics- มีความแตกต่างกันมากมาย:
 ambiguity(ข้อความกำกวม): Natural language เต็มไปด้วยข้อความที่กำกวม ซึ่งคนเราเข้าใจโดยใช้ข้อความแวดล้อมที่ช่วยให้เข้าใจความหมายและข้อมูลอื่น Formal language ถูกประดิษฐ์เพื่อให้ใกล้เคียงหรือไม่ให้กำกวมอย่างสมบูรณ์ ซึ่งหมายถึง statement ใดๆ มีหนึ่งความหมายอย่างถูกต้อง
 redundancy(ความซ้ำซ้อน): เพื่อทำให้เกิดความกำกวมและลดความไม่เข้าใจให้น้อยลง natural language ใช้ข้อความที่ซ้ำซ้อนมาก เป็นผลให้บ่อยครั้งมันใช้คำมากเกินไป formal language มีความซ้ำซ้อนน้อยและมีความสั้นกระชับกว่า
 literalness(ความหมายของคำ): Natural language เต็มไปด้วยภาษาถิ่นและคำอุปมา ถ้าผมพูด “the other shoe fell” มีความเป็นไปได้มากว่าไม่มีรองเท้าหรือไม่มีอะไรตกหล่น Formal language จะมีความหมายอย่างชัดเจนเมื่อได้กล่าวอะไรไป
 ผู้คนที่เติบโตขึ้นพูด natural language(ภาษาพูด)-ทุกๆคน-บ่อยครั้งมีช่วงเวลาที่ยากในการปรับตัวกับ formal language ในบางครั้ง ความแตกต่างระหว่าง formal และ natural language เหมือนกับความแตกต่างระหว่าง ร้อยกรองและร้อยแก้ว แต่มากกว่านั้น:
 Poetry(ร้อยกรอง): คำถูกใช้สำหรับเพื่อเสียงที่อ่านและความหมายของคำ และโคลงทั้งหมดก่อให้เกิดผลที่ได้หรือไม่ก็ตอบสนองทางอารมณ์ด้วยกัน คำพูดที่มีความหมายได้สองนัยไม่เพียงแต่ธรรมดื้นๆแต่บ่อยครั้งที่ต้องครุ่นคิด
 Prose(ร้อยแก้ว): ความหมายตามตัวหนังสือของคำมีความสำคัญมากกว่าและโครงสร้างที่ให้ความหมายมากกว่า ร้อยแก้วยอมให้วิเคราะห์มากกว่าร้อยกรองแต่ยังคงมีความหมายกำกวม
 Programs: ความหมายของโปรแกรมคอมพิวเตอร์ไม่มีความหมายกำกวมและตามความหมายที่แท้จริงของคำ แต่สามารถเข้าใจได้ทั้งหมดโดยการวิเคราะห์ของ tokens และโครงสร้าง
 นี่เป็นข้อเสนอแนะบางอย่างสำหรับการอ่านโปรแกรม(และ formal language อื่น)
 อย่างแรก จำไว้ว่า formal language เข้าใจยากมากกว่า natural language ดังนั้นต้องใช้เวลานานในการอ่าน เช่นเดียวกัน โครงสร้างมีความสำคัญมากกว่า ดังนั้นมันเป็นปรกติที่ไม่ใช่ความคิดที่ดีนักที่อ่านจากบนลงล่าง ซ้ายไปขวา แทนที่จะเรียนรู้วิเคราะห์ประโยคในหัวของคุณ การระบุ tokens และการแปลความหมายของโครงสร้าง สุดท้าย เนื้อหาที่มีรายละเอียด สิ่งเล็กๆน้อยๆเช่นความผิดพลาดในเรื่องของการสะกดคำและเครื่องหมายวรรคตอนที่แย่
1.5 The first program.
ตามที่นิยมกัน โปรแกรมแรกที่เขียนในการเรียนรู้ภาษาใหม่ คือ “Hello World!” เนื่องจาก จะให้มันแสดงคำว่า “Hello World!” ใน Python เหมือนดังนี้:
 print “Hello World!”
 นี่เป็นตัวอย่างของ print statement ซึ่งไม่ได้ปริ้นบนกระดาษจริงๆ มันทำการแสดงค่าบนหน้าจอ ในกรณีนี้ผลลัพธ์คือคำว่า:
 Hello World!
 เครื่องหมายคำพูดในโปรแกรมเป็นสัญลักษณ์การเริ่มต้นและจบของค่า มันจะไม่ปรากฏในผลลัพธ์ที่แสดง
 บางคนได้ตัดสินคุณภาพของ programming language ด้วยความง่ายของโปรแกรม “Hello World!”
 ด้วยมาตรฐานนี้ Python ทำได้ดีเท่าที่เป็นไปได้
1.6 Glossary.
 problem solving: The process of formulating a problem, finding a solution, and expressing the solution.
 high-level language: A programming language like Python that is designed to be easy for humans to read and write.
 low-level language: A programming language that is designed to be easy for a computer to execute; also called “machine language” or “assembly language.”
 portability: A property of a program that can run on more than one kind of computer.
 interpret: To execute a program in a high-level language by translating it one line at a time.
 compile: To translate a program written in a high-level language into a lowlevel language all at once, in preparation for later execution.
 source code: A program in a high-level language before being compiled.
 object code: The output of the compiler after it translates the program.
 executable: Another name for object code that is ready to be executed.
 script: A program stored in a ¯le (usually one that will be interpreted).
 program: A set of instructions that speci¯es a computation.
 algorithm: A general process for solving a category of problems.
 bug: An error in a program.
 debugging: The process of finding and removing any of the three kinds of programming errors.
 syntax: The structure of a program.
 syntax error: An error in a program that makes it impossible to parse (and therefore impossible to interpret).
 runtime error: An error that does not occur until the program has started to execute but that prevents the program from continuing.
 exception: Another name for a runtime error.
 semantic error: An error in a program that makes it do something other than what the programmer intended.
 semantics: The meaning of a program.
 natural language: Any one of the languages that people speak that evolved naturally.
formal language: Any one of the languages that people have designed for specific purposes, such as representing mathematical ideas or computer programs; all programming languages are formal languages.
 token: One of the basic elements of the syntactic structure of a program, analogous
to a word in a natural language.
 parse: To examine a program and analyze the syntactic structure.
 print statement: An instruction that causes the Python interpreter to display a value on the screen.