วิชา OS ที่พระจอมเกล้าพระนครเหนือ ไม่ถึงกับสอนให้เขียนเองครับ แต่ในเทอมที่ผมเรียนมีข้อเสนอว่า ถ้าสามารถเขียน OS ให้สามารถบูตขึ้นมาแสดงคำว่า Hello World ได้จะให้ A โดยไม่ต้องเข้าเรียน ไม่ต้องสอบย่อย คะแนนสอบออกมาเท่าไหร่ก็ได้ครับ
ถ้าอยากศึกษารายละเอียดจริงๆ และขยันมากๆ ลองหาหนังสือชื่อ Operating System Concept ของ Silberschatz มาอ่านดูเล่นๆ ก็ได้ครับ คิดว่าเล่มนี้น่าจะอธิบายว่า OS มีอะไรบ้างได้ดี (มียกตัวอย่าง Linux กับ Windows XP ด้วย)
จะว่าไป OS ในปัจจุบันนี่มันกว้างกว่าการเป็นแค่ OS มาก (Windows มีแม้กระทั่งเครื่องคิดเลข ซึ่งไม่ได้เป็นส่วนหนึ่งของ OS ตามนิยาม แต่ช่างมันเถอะ) ดังนั้นถ้าเราจะพูดถึง OS ในปัจจุบันนี่มันเป็นเรื่องกว้างมากครับ 55
ที่นิยมก็เป็น C ครับ
ภาษานู้นภาษานี้ในทางคอมพิวเตอร์นั้น ก็เป็นเพียงโครงสร้างทางภาษาเท่านั้นแหล่ะครับ
ซึ่งมันจำเป็นต้องมีตัวแปรภาษาเพื่อให้เป็นภาษาเครื่องอีกทีนึงน่ะครับ
ภาษาเครื่อง ก็มีแค่ 0 กับ 1 ครับ เทียบกับ มีไฟ กับ ไม่มีไฟ นะแหล่ะ (เรียกว่า bit)
การทำงานที่จริงนั้น ก็จะเกิดจากการเปรียบเทียบตรรกะครับ เช่น 0 เป็น เท็จ 1 เป็นจริง ประมาณนี้
ส่วนการคำนวณ ก็เลยจำเป็นต้องใช้เลขฐานสอง (0 กับ 1 , 1+1 = 10)
ส่วนอักขระต่าง ๆ ก็ใช้การสร้างรหัสมาแทนที่ อย่าง ตาราง ASCII ใช้ bit มาเรียงต่อกัน 8 บิต ก็จะแทนได้ 256 อักขระ ประมาณนี้ (2^8 = 256)
ออกทะเลเปล่านิ อิอิ
ผมว่าตอบไม่ค่อยตรงน่ะ งงๆ แฮะๆ
มันออกไป กฎของ Boolean Algebra แล้วครับท่าน ไหนก็ไหนแล้ว ต่อให้ลงมหาสมุทรเลยแล้วกัน
คือ บนเมนบอร์ดเนี่ย มันมี Digital Logic Gates ครับแล้ว ไอ้ Logic Gates หลายๆ ตัวค่อยทำงานเหมือนสวิตซ์ไฟฟ้าปิด-เปิดหลายล้านครั้งในหนึ่งวินาที ซึ่งไอ้ Logic Gates นี่แหละก็มีหลายชนิดแบ่งแยกไปอีกเช่น And Gate, Nand Gate, NOT Gate, Or Gate, Nor Gate, Xor Gate และ ฯลฯ ซึ่ง Logic Gate เหล่านี้สงสัยกฎของ Boolean Algebra มา resolve คำสั่งที่เราสั่งเข้าไป ถ้าจะถามว่า กฎของ Boolean Algebra คืออะไร ผมแนะนำให้ไปเปิดหนังสือคณิตศาสตร์ ม.4 ครับ
ซึ่งไอ้ตัว Logic Gates นี่ปัจจุบันได้พัฒนาและยกใส่ใน Silicon wafer กลายเป็น CPU ในปัจจุบัน การทำงานของ CPU ก็เป็นดังรูปข้างล่างครับ (ขอบคุณรูปจาก Wikipedia)
คือ มันก็จะมี Logic Gates เป็นจำนวนมากอยู่ใน CPU คอยทำหน้าที่ประมวลผลให้ไฟฟ้าผ่านหรือไม่ให้ผ่าน ซึ่งถ้าให้ผ่าน ก็จะได้ 0 หรือ 1 ตามที่คนเขียนคำสั่งได้ทำคำสั่ง ส่วนคำสั่งของเครื่องเนี่ยก็คงต้องเทียบผลเอาล่ะครับ ในยุคสมัยแรกๆ ที่พัฒนามาเรื่อยๆ จนถึงปัจจุบัน
อันนี้เท่าที่ผมจำได้ตอนเรียน Fundamental of Computing 1, 2 หนังสือเรียนหนาประมาณ 600-800 หน้า รวม Intel ตั้งแต่ 8008 ถึง Pentium 4 ครับ ถ้าจะให้เล่าทั้งหมดตั้งแต่ยุค Pre-x86(8-bit) จนถึง ปัจจุบันนี่คงใช้เวลาครับ //ขอตัวเผ่นไปนอนละครับ
เอาแบบง่ายหรือแบบลึกดีครับ ผมตอบแบบง่ายๆ แล้วกันนะ
มันเอารหัสไฟฟ้าที่ว่าไปเทียบว่าคือตัวอักษรอะไรภาษาอะไรครับ ตัวคอมพิวเตอร์เองก็ไม่ได้จำเป็นรหัสไฟฟ้าเสียทีเดียวหรอกครับ มีภาษาเครื่องของมันเอง ที่เทียบแปลงจากรหัสไฟฟ้ามาอีกทีนึง
แต่รหัสไฟฟ้า จริงๆ ก็ไม่ใช่รหัสไฟฟ้านะครับ แค่เป็นค่าที่บอกได้แค่ว่าใช่หรือไม่ใช่แค่สองค่าเท่านั้นเอง อาจเป็นไฟฟ้า เคมี หรือทางกายภาพอื่นๆ ก็ได้
แล้วแต่ OS ด้วยครับ ยุคแรกสุดเลยน่าจะต้องเขียนทางกายภาพ ไม่แน่ใจว่าเป็นแผ่นกระดาษเจาะรูหรือการสลับต่อสายไฟโดยตรง ยุคหลังๆ มานี้ก็ใช้ภาษาเขียนโปรแกรมนั่นแหละครับ แล้วคอมไพล์ออกมาเป็นภาษาเครื่องอีกที แต่จะบอกว่าพิมพ์ๆ เข้าไปแล้วมันก็ออกมาเลยดูจะง่ายไปหน่อย - -" รอคนอื่นอธิบายเพิ่มแล้วกันครับ
ตอนเขียนเขียนด้วยภาษาอะไรผมไม่แน่ใจครับ แต่เคยแก้ค่าด้วยพวก HEX editor ส่วนเอาไว้ทำอะไร => http://en.wikipedia.org/wiki/BIOS
ใช้ Hex Editor ใส่ SLIC Table รึเปล่าครับ ฮา. :P
ลองนึกภาพดูว่า ถ้าคอมพิวเตอร์ในโลกนี้เหลือแต่ HDD ว่างๆ สื่อบันทึกข้อมูลต่างหายไปหมด ไม่มีตัวติดตั้ง OS หรือ Software ใดๆ เลย
ถ้าเราจะสร้าง OS ขึ้นมาใหม่ให้คอมพิวเตอร์ในโลกนี้ใช้การได้ต่อไป
เราต้องทำยังไงบ้าง? อยากรู้เหมือนกัน
^
^
that's just my two cents.
ก็ทำเหมือนตอนที่เริ่มมีคอมพิวเตอร์ตอนแรกไงครับ :p
วิชา OS ที่พระจอมเกล้าพระนครเหนือ ไม่ถึงกับสอนให้เขียนเองครับ แต่ในเทอมที่ผมเรียนมีข้อเสนอว่า ถ้าสามารถเขียน OS ให้สามารถบูตขึ้นมาแสดงคำว่า Hello World ได้จะให้ A โดยไม่ต้องเข้าเรียน ไม่ต้องสอบย่อย คะแนนสอบออกมาเท่าไหร่ก็ได้ครับ
เพื่อนผมงมอยู่เกือบครึ่งเทอม ไม่สำเร็จ orz
ถึงตอนนี้ ทำได้หรือยังครับ?
ยังไม่ได้ เพราะไม่ได้แตะอีกเลยครับ - -"
ผมช่วยเฉลยให้นะครับ
; เขียนข้อความด้วย PC VIDEO Card BIOS เฉพาะ PC x86 นะครับ
; อยากทำอะไรต่อก็เขียนต่อไปจากนี้... เช่น รอ Keyboard เป็นต้น
string1:
Interrupt 10h เป็น BIOS Interrupt อยู่ใน Firmware บน VIDEO Card ซึ่งถูกใช้งานตั้งแต่ POST ทำงาน
Assembly code นี้ ให้ Compile โดยไม่ต้องระบุ Offset 100 เช่นปกติ เพราะไม่ได้ไปรันใต้ OS ใดๆ แล้วนำไฟล์ .bin ที่ได้ไปเขียนลง Boot sector ของสื่อโดยตรง (มันได้ออกมาแค่ 21 byte เท่านั้นแหละครับ) แล้วก็ Boot เครื่องเลย จะได้ "Hello World" ปรากฏขึ้นที่ col,row ของจอที่ 1,1 ถ้าไม่ใส่ Code อะไรเพิ่มเลย มันจะเป็นไงต่อก็ไม่รู้ เพราะจะ CPU จะวิ่ง Process ไปต่อตามรหัสที่อยู่ใน Memory ตั้งแต่คำว่า "Hello World" ต่อไปเรื่อยๆ จนเละเทะครับ
ผมชอบโจทย์นี้ของ ม. คุณนะ คือที่จริงมันง่ายมากๆ เลย แต่คนที่รู้ว่าทำอย่างไรต้องแตกฉานมากเลยเช่นกัน และขนาดของ Code ที่ได้ เป็นตัวชี้วัดความแตกฉานได้ดีมากเลย
อาจารย์คุณคิดโจทย์ได้เก่งจริงๆ ครับ
ขอบคุณครับ ถ้ามีโอกาสจะลองดูครับ (^.^)d
ขออภัย ผมบอกผิดไปนิด ขนาดของ Binary ไฟล์จะได้ออกมา 32 byte ครับ
เป็น Code ซะ 21 byte และเป็น "Hello World" ท้าย Code อีก 11 byte ครับ
เอ... ปกติต้องเซ็ต magic number ที่ byte 510-511 ด้วยไม่ใช่เหรอครับ? ไม่งั้นบางไปออสมันจะไม่บูท แล้วนี่ก็ยังไม่ได้เซ็ต ss, sp เลย?
แนะต่อ สวนมาก็จบด้วย cli, hlt หรือไม่ก็ hlt, jmp $-1
ใช่ครับ นั่นเป็นส่วนของการกำหนดที่สื่อน่ะครับ เลยไม่ได้พูดถึง และอีกอย่างคือ พอเห็นโจทย์ปั๊บ ผมก็คิดถึงสื่อที่จะใช้ในโจทย์นี้คือ Floppy disk ทันทีน่ะครับ ซึ่งไม่ต้องกำหนด Magic number ครับ
ที่ว่า Magic number นั้น พูดให้ผู้อ่านคนอื่นเข้าใจง่ายๆ ก็คือ Bootable flag นั่นเองครับ
ส่วน ss และ sp สำหรับโจทย์นี้ ไม่จำเป็นต้อง set ครับ เพราะโจทย์ต้องการแค่แสดง Hello World ครับ Binary code ที่ได้จบอยู่ใน 1 segment อยู่แล้ว ไม่ได้ Jump ไปไหนต่อ/ไม่ได้ต้อง Load อะไรจาก Disk มาเพิ่มอีก ดังนั้น Disk parameter จึงไม่จำเป็นต้องกำหนดครับ อีกทั้ง "การโกง" stack เพียง 2 byte ของผมในขณะที่ระบบเพิ่ง Boot จะไม่ส่งผลต่ออะไรอื่นของระบบเลย จึงไม่มีความจำเป็นต้องเตรียม Stack เช่นกัน มันจะ Random ไปที่ไหนก็ไม่ต้องสนใจครับ
การเฉลยแบบที่ผมเฉลยไป เป็นการวางยานักศึกษารุ่นหลังด้วยนะครับ คือผมบอกไม่หมดนั่นเอง ผมคิดไว้แล้วว่า ถ้านักศึกษาเพียงแค่ลอกเฉลยผมไปส่งอาจารย์ อาจารย์จะสามารถยิงคำถามได้ด้วยอีกหลายคำถาม แต่เพียงแค่คำถามเดียวเท่านั้น ก็จะทราบได้ทันทีว่านักศึกษาต้องลอกจากที่ไหนมาแน่ๆ แต่ขาดความรู้/ความเข้าใจอย่างแท้จริงครับ เช่นคำถามที่คุณถามมาก็เช่นกันครับ เอาไว้ใช้ถามนักศึกษาเพื่อ Prove ได้ครับ
ได้ความรู้สึกเหมือนเขียนโปรแกรมบนไมโครคอนโทรเลอร์ธรรมดาเลย
Intial hardware, Load library แล้ว จะเขียนอะไรออกมาก็แล้วแต่อยากเขียน
Micro controller เองก็เป็น computer นี่นา
เขียน custom kernel ง่ายๆซักตัว ไม่ยากนะครับ
http://arjunsreedharan.org/post/82710718100/kernel-101-lets-write-a-kernel
@wittawasw
เท่าที่จำได้ คือต้องเขียนตั้งแต่ boot loader เลยครับ
วิธีการใส่ Ascii ลงไปที่ 0xb8000 ตรงๆ ของคนนี้ ใช้แต่ 100% VGA Compatible เท่านั้นนะครับ หมายความว่า Code ส่วนนี้ต้องอยู่หลังจาก Code ที่ตรวจสอบ Hardware แล้วว่าเป็น VGA ครับ ดังนั้นจึงเป็นส่วนที่อยู่ใน Kernel ดังที่เขาแนะนำ
แต่ถ้าเริ่มตั้งแต่ Boot loader แล้ว ควรใช้ Interrupt 10h ครับ
คณะอะไรหรอครับ ปริญญาตรีหรือเปล่า ผมจะได้เข้า ถูก
ปริญญาตรีคณะวิศวกรรมไฟฟ้า สาขาวิชาวิศวกรรมคอมพิวเตอร์ครับ
คะแนนจะถึงไหมเนี่ย T_T
KMUTT ครับ ลอกหลักสูตรของ MIT มา http://pdos.csail.mit.edu/6.828/ แต่โปรเจคหินกว่าเขา
ทำโปรเจควิชานี้เสร็จ มองโลกกระจ่างหมดเลย
จำได้ตอนเรียนที่ KMUTL (ตอนนั้นยังเป็น RUT) วิชาอะไรสักอย่าง? จำไม่ได้ มีใบงานให้ทำให้แผ่นดิสก์บูสได้
ประมาณว่าเขียนโปรแกรม COMMAND.COM, IO.SYS ใช้ ASM เขียน และคุ้นๆ ว่าโปรแกรมนั้นต้องไปอยู่ที่ Address .ORG 7C00 และลงท้ายด้วย 55 AA
ลืมแล้วกว่า 10 ปี
^
^
that's just my two cents.
ตอบบ้าง ( 'w')/
คอมพิวเตอร์ปัจจุบัน ที่จริงแล้วทำงานแบบสวิตช์เปิดปิด (ที่เปิดปิดวินาทีละหลายล้านครั้ง) ซึ่งทำงานตามข้อมูลและเงื่อนไขต่างๆ ในระบบ
ทีนี้ การที่เราพิมพ์อะไรแล้วออกไปที่จอได้นั้น ถ้าเอาอย่างละเอียดเลย คีย์บอร์ดที่เรากดมันก็เป็นสวิตช์ครับ กดแล้วทำให้ส่วนอินพุต (input) รับรู้ว่าเรากดปุ่มอะไร แล้วก็ส่งต่อไปให้คอนโทรเลอร์อีก (อาจหลายตัว) แล้วก็ไปบอก ซีพียูว่า เห้ย ผู้ใช้กดปุ่มนี้นะ ซีพียูก็ต้องดูว่า กดปุ่มนี้แล้วต้องทำอะไรบ้าง ตามโปรแกรมหรือเงื่อนไขในขณะนั้น ซึ่งอาจจะเป็นให้แสดงอักขระตามรหัสของปุ่มที่ได้รับ หลังจากนั้นก็จะส่งไปบอกคอนโทรเลอร์เอาต์พุต (output) ว่า แสดงผลแบบนี้ที่ตำแหน่งนี้หน่อย จอภาพที่ต่ออยู่กับพอร์ตเอาต์พุตนั้นก็จะเอาคำสั่งที่ได้มาแปลงเพื่อที่จะได้รู้ว่า ต้องเปลี่ยนเม็ดสีที่พิกเซลไหนบ้าง
เรื่องเจอภาษานู้นนี้ อันนี้ต้องเล่าเรื่อง "คอมไพล์เลอร์ (compiler)" ก่อนครับ
คอมไพล์เลอร์ คือชุดโปรแกรมที่คอยเปลี่ยนภาษาที่สูงกว่า (อธิบายง่ายๆ คือภาษาที่ใกล้เคียงกับภาษามนุษย์มากกว่า) ให้เป็นภาษาที่ต่ำกว่า (ก็คือภาษาที่ใกล้เคียงกับชุดคำสั่งของคอมพิวเตอร์มากกว่า) เพื่อให้คอมพิวเตอร์ทำงานได้โดยที่เราไม่ต้องไปนั่งเรียนรู้ภาษา 101011101000101 ของคอมพิวเตอร์ตรงๆ ครับ สมมติว่าเราประกาศตัวแปรเก็บเลขสัก 1 ตัวในภาษา C คอมไพล์เลอร์จะมีหน้าที่แปลงให้การประกาศตัวแปรนั้นเป็นภาษาที่ใกล้เคียงกับภาษาที่คอมพิวเตอร์สามารถทำงานได้ครับ (ซึ่งกระบวนการนี้อาจจะไม่ใช้คอมไพล์เลอร์แค่ตัวเดียว เช่นอาจจะต้องแปลงจาก C เป็น Assembly, แล้วแปลงจาก Assembly เป็น 00100110010 อีกที)
สมัยเริ่มแรกจริงๆ ก็คงใช้ภาษาอื่นๆ ครับ สมัยนี้ก็คง C น่าจะง่ายที่สุดครับ พิมพ์ๆ เข้าไปแล้วต้องเอาไปใส่หน่วยความจำบางอย่าง เพื่อให้ระบบที่เราต้องการทำงานตามคำสั่งที่เราเขียน (แน่นอนว่าต้องมีคอมไพล์เลอร์ที่แปลงภาษาให้ตรงกับระบบที่เราจะใช้งานด้วยเช่นกัน)
ภาษาของ BIOS นี่ผมไม่มั่นใจครับ น่าจะเป็น Assembly หรือภาษาระดับใกล้ๆ กัน เพราะว่า BIOS คืออุปกรณ์ชิ้นแรกที่ระบบของเครื่องจะวิ่งไปดูว่า เปิดเครื่องแล้วต้องทำอะไรต่อ (เช่น BIOS มีคำสั่งเช็คแรมก่อน แล้วค่อยโหลด OS เครื่องก็จะทำตามนั้นเป็นอันดับแรก)
ถ้าอยากศึกษารายละเอียดจริงๆ และขยันมากๆ ลองหาหนังสือชื่อ Operating System Concept ของ Silberschatz มาอ่านดูเล่นๆ ก็ได้ครับ คิดว่าเล่มนี้น่าจะอธิบายว่า OS มีอะไรบ้างได้ดี (มียกตัวอย่าง Linux กับ Windows XP ด้วย)
หวังว่าจะมีประโยชน์บ้างไม่มากก็น้อย #ห๊ะ
Dream high, work hard.
Operating System Concept แพงมากครับ โอยๆ แล้วมีภาษาไทยไหมครับ ดูในอเมซอนนี่ราคา 155.91$ ราคานี้อดขนมหลายเดือนเลยนะครับ แต่ขอบคุณมากครับเดี๋ยวลองหาทดลองอ่านใน kindle ดู
***(ไม่ค่อยเก่งภาษาอังกฤษเท่าไรนะครับ)
ซื้อแพงๆ ภาษาอังกฤษนี่แหละครับ จะได้เสียดายจนพยายามอ่านภาษาอังกฤษจนคล่อง (- -)d
อยู่สายนี้ อย่างน้อยเอาระดับอ่านคล่องไว้ก็ยังดีครับ
ย้ากๆๆ ทุบกระปุก แต่ซื้อที่ไหนหรอ ที่ไทยไม่น่ามีนะครับ
ในไทยเหมือนต้องสั่ง by order เอาครับ แนะนำสั่ง amazon เอาครับ
หาไปหามา มันเล่มไหน หรอครับ
http://www.amazon.com/s/ref=nb_sb_noss?url=search-alias%3Daps&field-keywords=Operating%20System%20Concepts
งง มีเยอะเหลือเกิน
http://www.amazon.com/Operating-System-Concepts-Abraham-Silberschatz/dp/1118063333/ref=sr_1_1?ie=UTF8&qid=1397977145&sr=8-1&keywords=operating+system+concepts+9th+edition
ตอนนี้มัน 9th edition แล้วครับ
ขอบคุณ รอเก็บเงิน ซื้อ $_$
ยุคแรกๆเขียนด้วย Assembly คับ ต่อมามีการสร้างภาษา C ขึ้นมาสำหรับเขียน UNIX ใหม่ ตั้งแต่นั้นเป็นต้นมา OS ส่วนใหญ่และ Firmware (เช่น BIOS) ก็เขียนด้วย C เกือบทั้งหมดคับ (ตระกูล Unix ทั้งหมด และ Linux และ Windows NT) มีบางส่วนที่ต้องเขียนด้วย Assembly แต่แค่นิดเดียว
BIOS คือ Firmware คับ มันคือ Software ตัวแรกที่จะถูกรันด้วย CPU แล้วตัว BIOS จะไปรัน Boot sector อีกทีตามที่เราเซ็ตไว้ใน BIOS ว่าให้บูทจาก HDD ไหน แล้ว Software ที่ถูกเก็บอยู่ใน Boot sector นั้นๆก็จะทำงานต่อไป ซึ่งส่วนใหญ่จะเป็น Boot loader (เช่น GRUB) เสร็จแล้ว Boot loader จะรัน Kernel ของ OS คับ
แล้วใช้อะไรเขียน compiler และ linker ของ Assembly ครับ? Machine Code?
^
^
that's just my two cents.
จะเอาตัวไหนละคับ ถ้า nasm ก็เขียนด้วย C คับ ส่วน Assembler ตัวอื่นๆลองหาข้อมูลเอาคับ
ถ้า nasm เขียนด้วย C ดังนั้นก็ต้องมี compiler ของ C แล้วก็เกิดคำถามอีกว่า ใช้ภาษาอะไรเขียน Compiler ภาษา C อีกนะสิครับ
ถ้าสมมติว่า คอมพิวเตอร์สามารถเข้าใจภาษา ASM ได้เลยนี่ก็จบเลยไงครับ นี่ไม่ได้ถามกวนหรือลองภูมิอะไรนะครับ
อยากทราบจริงๆ เหมือนคล้ายๆ ว่าจะใช้ Machine Code เอา เป็นภาษา ASM แต่อยู่ในรูปแบบของฐาน 16
อย่างเช่น LOAD PC, 00 7C ก็เป็น HA 00 7C (สมมติว่าคำสั่ง LD PC = HA) อะไรเถือกๆ นี้อ่ะครับ เคยเรียนสมัยปวช. บอร์ด ETT มั้ง แต่ไม่รู้ว่ามันจะเป็นจุดเริ่มต้นของคอมพิวเตอร์ได้หรือเปล่านะครับ
แต่พอปวส. เป็นบอร์ดอีกแบบหนึ่ง CPU 8086 หรืออะไรสักอย่างนี่แหละ สามารถป้อนเป็นภาษา ASM ได้เลย LD PC, 00 7C พอตอนป้อนโค้ดเสร็จก็จบด้วยคำสั่ง HALT
^
^
that's just my two cents.
assembler รุ่นแรกก็เขียนด้วย machine code ครับ หลังจากนั้นก็ใช้ตัวเองในการ assemble ตัวเอง (เรียกว่า turing complete) ส่วน C ก็เหมือนกัน รุ่นแรกก็ใช้ assembly ครับ หลังจากนั้นก็ใช้ตัวเองคอมไฟล์ตัวเอง
ขอบคุณครับ :)
^
^
that's just my two cents.
อันนี้รายละเอียดเพิ่มเติมคับ
http://en.wikipedia.org/wiki/Bootstrapping_%28compilers%29
http://stackoverflow.com/questions/1653649/how-was-the-first-compiler-written
เคยอ่านเล่นๆ http://www.wikihow.com/Make-a-Computer-Operating-System
ผมว่าน้องต้องเริ่มจากเรียน Computer Organization ตามด้วย Computer Architecture และ Operating System นะครับ :-)
เรื่องของรหัสไฟฟ้านี่ คือ ตัว Computer โดยรวม ๆ มันจะมีชุดคำสั่งอยู่ ซึ่งจะอยู่ในรูปของเลขฐานสองที่เราสามารถเรียกแต่ละคำสั่งในชุดนี้เพื่อสั่งให้มันทำอะไรก็ได้ เช่น การดึงข้อมูลจากหน่วยความจำมาไว้ที่ Register บน CPU หรือการจับเอาค่าใน Register มาบวกกัน
บน CPU จะมีคำสั่งเป็นคำ ๆ (WORD) ใน Architecture นึง คำสั่ง 0001000100000001 อาจจะหมายถึงการเอา Register A มาบวกกับ Register B โดยผลลัพท์จะอยู่ที่ Register A เป็นต้น ทั้งนี้ผู้ออกแบบ Architecture จะเป็นผู้ออกแบบครับ
ในอดีตชุดคำสั่งพวกนี้ต้องป้อนด้วยมือด้วยการสับสวิตซ์ (ถ้าเป็นคำสั่งข้างบนก็จะมีสวิตซ์ 16 ตัว และเปิดเฉพาะตำแหน่งที่ผมระบุว่าเป็น 1 เท่านั้น) จากนั้นก็พัฒนาขึ้นมาเป็นบัตรเจาะรู (เป็นบัตรกระดาษแข็งที่เจาะรูเอาไว้แทนตัวเลขฐานสอง ก็คล้าย ๆ กับสวิตซ์ คือตำแหน่งที่เป็นเลข 1 ก็เจาะรู ตำแหน่งที่เป็น 0 ก็ไม่เจาะ)
ส่วนในปัจจุบันชุดคำสั่งพวกนี้จะถูกจััดเก็บเอาไว้บนดิสก์ครับ
ส่วนการสร้างชุดคำสั่ง (หรือที่เรียกว่า โปรแกรม) เนี่ย ในอดีตก็ใส่เลขคำสั่งเข้าไป (ถ้านึกไม่ออกก็ลองนึกถึงเครื่องคิดเลขดูครับ) แล้วคอมพิวเตอร์ก็จะสร้างผลลัพท์ออกมา หลังจากนั้นก็มีคนคิดว่าการใส่คำสั่งตัวเลขมันลำบากชีวิต ก็เลยพัฒนาภาษาการเขียนโปรแกรม พร้อมกับตัวแปลคำสั่งออกมา โดยภาษาแรกที่สร้างขึ้นคือ Assembly ที่เป็นแค่การสร้างคำขึ้นมาแทนคำสั่งที่เป็นเลขฐานสอง (อย่าง เปลี่ยนคำสั่งย้ายข้อมูลใน Register เป็นคำว่า MOV เป็นต้น) หลังจากนั้นภาษาการเขียนโปรแกรมก็พัฒนาขึ้นเรื่อย ๆ
อย่างที่ว่าว่าในปัจจุบันชุดคำสั่งมันอ่านจากบนดิสก์ ทางผู้ผลิตเขาก็จะมีสเปคระบุเอาไว้ว่า ตัวคอมพิวเตอร์จะอ่านชุดคำสั่งของเราเริ่มจากที่ตำแหน่งไหนบนดิสก์ เราก็ต้องบันทึกชุดคำสั่งเอาไว้ตรงที่เขาระบุไว้ ไม่เช่นนั้นคอมพิวเตอร์ก็จะไม่ทำงาน (เพราะว่าไม่รู้ว่ามันจะไปดึงมาจากไหน) ตรงนี้อาจจะเป็น OS ทั้งตัวก็ได้ (ถ้าเล็กพอ) หรืออาจจะเป็นแค่โปรแกรมเล็ก ๆ (เรียกว่า bootloader) ที่ไปอ่าน OS อีกตัวมาทำงานแทน (ในปัจจุบันเป็นกรณีหลัง)
ส่วนเรื่องตัว OS เองนี่ เข้าใจว่าเขียนด้วยอะไรก็ได้ ตราบใดที่ bootloader ไปอ่านมันขึ้นมาทำงานได้ครับ ซึ่ีงก็ต้องทำตามสเปคของ bootloader อีก ไม่เช่นนั้นมันก็จะไม่ถูกเรียก
จะว่าไป OS ในปัจจุบันนี่มันกว้างกว่าการเป็นแค่ OS มาก (Windows มีแม้กระทั่งเครื่องคิดเลข ซึ่งไม่ได้เป็นส่วนหนึ่งของ OS ตามนิยาม แต่ช่างมันเถอะ) ดังนั้นถ้าเราจะพูดถึง OS ในปัจจุบันนี่มันเป็นเรื่องกว้างมากครับ 55
ปล. ผมไม่ค่อยเก่งเรื่องพวกนี้เท่าไหร่ อาจจะมีจุดผิดอยู่เยอะทีเดียว
ปล.2 Assembly ของแต่ละ Architecture นี่จะแตกต่างกันไป ขึ้นอยู่กับการออกแบบ Architecture ดังนั้นคำสั่งหนึ่งของ Arch นึงอาจจะไม่มีในอีก Arch ก็ได้
บางครั้งผมรู้สึกว่า ควรเรียนพวก Computer Organization, Computer Architecture, Computer Language ต่อด้วย Compiler ก่อนไป Operating System ด้วยซ้ำมั้ง คือมองภาพรวมก่อนแล้วค่อยไปเล่นของแรง ถ้าอยากแน่นจริงๆ ต้องหา Micro-Controller มาเสริม
คือเนื้อหาพวกนี้มันเชื่อมๆ กันหมด คือเอาแต่ Operating System อย่างเดียวมันจะตันๆ แบบข้างบนอธิบายครับ เพราะมันต้องมีพื้นอย่างอื่นๆ มาก่อน แถมพวก Math ก็สำคัญ เพราะมันจะไปยุ่งตอน Compiler (computational theory) กับ Micro-Controller เนี่ยแหละครับ
ผมเห็นด้วยนะครับ
ปัญหาคือในระดับมหาวิทยาลัย ถ้ามีวิชาที่มี prerequisite เยอะ นศ.จะจัดคอร์สเรียนยาก อย่างม.ผมก็เลยเอา OS ไปต่อกับ Computer Organization อย่างเดียว (แต่วิชานี้พูดเรื่อง overview กว้างอยู่นะครับผมว่า)
เคยดูวิดีโอคอมพิวเตอร์เก่าๆผ่านทาง youtube มีตั้งแต่การโปรแกรมง่ายๆ ด้วยการเปิดปิดสวิชหลอดไฟ ไปจนถึงยุคของบัตรเจาะรูป เทปหมุน เทปคลาสเซ็ต กว่าจะมาถึงตอนนี้ที่เรามีโปรแกรมที่ใช้เขียนโปรแกรมอีกทีอย่างง่ายดาย คนรุ่นก่อนหน้าเค้าสร้างอะไรไว้ให้เราเยอะอยู่เหมือนกันนะครับ
อย่างอันนี้ แค่นั่งฟังเค้าโปรแกรม กับสวิชหน้าเครื่องก็ตาลายแล้วครับ