ช่วยย่อโค้ดหน่อยครับ ภาษาซี เขียนใน Keil

  • 21 Replies
  • 6286 Views
ถ้ายังไม่เข้าใจก็
ลองเขียน for loop ประมาณหลักล้านๆ ลูป
แล้วเปรียบเทียบ
NOP ในลูป while สัก ล้านๆ ลูปดู แล้วดูว่า
อันไหนใช้ทรัพยากรเยอะกว่า? เอาผลมาดูด้วยน่ะครับ ผมก็อยากรู้เหมือนกัน
Quote
พยายามจะทำให้ท่านเข้่าใจนะ บางที ผมอาจใช้คำว่า เหมือนบ้าง คล้ายบ้าง อย่าเพิ่งสับสนนะ
คือทั้ง 2 code เป็นการ delay ทั้งคู่ก็เหมือนกันนะ ใช้ตัวแปรนับเหมือนกัน (แม้อาจมีความแตกต่างในการมาคำนวณก่อน แต่สุดท้ายก็เกิดการนับ ) และก็อาจจะได้ ชุดคำสั่งของ asm แตกต่างกันอยู่บ้างครับ ผมก็เลยไม่รู้ว่าเป็นประเด็๋นสำหรับท่านตรงไหนหรือเปล่าครับ
ครับ ผลลัพธ์ไม่ต่างครับ แต่ทรัพยากรที่ใช้ ต่างครับ
GNU/Linux User.
Underground computer group.
The GNU people aren't evil. but i'm evil. :P

*

Offline ROM

  • ***
  • 167
    • View Profile
ถ้ายังไม่เข้าใจก็
ลองเขียน for loop ประมาณหลักล้านๆ ลูป
แล้วเปรียบเทียบ
NOP ในลูป while สัก ล้านๆ ลูปดู แล้วดูว่า
อันไหนใช้ทรัพยากรเยอะกว่า? เอาผลมาดูด้วยน่ะครับ ผมก็อยากรู้เหมือนกัน
Quote
พยายามจะทำให้ท่านเข้่าใจนะ บางที ผมอาจใช้คำว่า เหมือนบ้าง คล้ายบ้าง อย่าเพิ่งสับสนนะ
คือทั้ง 2 code เป็นการ delay ทั้งคู่ก็เหมือนกันนะ ใช้ตัวแปรนับเหมือนกัน (แม้อาจมีความแตกต่างในการมาคำนวณก่อน แต่สุดท้ายก็เกิดการนับ ) และก็อาจจะได้ ชุดคำสั่งของ asm แตกต่างกันอยู่บ้างครับ ผมก็เลยไม่รู้ว่าเป็นประเด็๋นสำหรับท่านตรงไหนหรือเปล่าครับ
ครับ ผลลัพธ์ไม่ต่างครับ แต่ทรัพยากรที่ใช้ ต่างครับ

ผมไม่ได้อยากรู้นะครับ พยายามช่วยท่านและอธิบายให้ ตามที่ท่านสงสัยเฉยๆครับ  ;D

ถ้ายังไม่เข้าใจก็
ลองเขียน for loop ประมาณหลักล้านๆ ลูป
แล้วเปรียบเทียบ
NOP ในลูป while สัก ล้านๆ ลูปดู แล้วดูว่า
อันไหนใช้ทรัพยากรเยอะกว่า? เอาผลมาดูด้วยน่ะครับ ผมก็อยากรู้เหมือนกัน
Quote
พยายามจะทำให้ท่านเข้่าใจนะ บางที ผมอาจใช้คำว่า เหมือนบ้าง คล้ายบ้าง อย่าเพิ่งสับสนนะ
คือทั้ง 2 code เป็นการ delay ทั้งคู่ก็เหมือนกันนะ ใช้ตัวแปรนับเหมือนกัน (แม้อาจมีความแตกต่างในการมาคำนวณก่อน แต่สุดท้ายก็เกิดการนับ ) และก็อาจจะได้ ชุดคำสั่งของ asm แตกต่างกันอยู่บ้างครับ ผมก็เลยไม่รู้ว่าเป็นประเด็๋นสำหรับท่านตรงไหนหรือเปล่าครับ
ครับ ผลลัพธ์ไม่ต่างครับ แต่ทรัพยากรที่ใช้ ต่างครับ

ผมไม่ได้อยากรู้นะครับ พยายามช่วยท่านและอธิบายให้ ตามที่ท่านสงสัยเฉยๆครับ
ครับผม  ;D
GNU/Linux User.
Underground computer group.
The GNU people aren't evil. but i'm evil. :P

สวัสดี จขกท.

ผมมีเรื่องจะเล่าสู่กันฟัง.....ตามประสาคนเขียนโปรแกรมมาก่อนอ่ะนะ อาจจะ
ไม่เก่งมาก แต่ระดับ level น่าจะพอสอน จขกท.ได้บ้าง

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

ดังนั้นถ้าโจทย์บอกว่า จงพิมพ์ "ฉันรักเธอ" 1000 ครั้ง
คนที่ใช้เครื่องเป็นเค้าจะสั่งวนลูป 1000 รอบ จบแล้ว...ง่ายไหม ?
 
แต่ถ้าเป็น จขกท. คง copy + paste "ฉันรักเธอ" 1000 บรรทัดแทนซะละมั๊ง ::)

มันทำงานได้เหมือนกัน แต่มันไม่เหมาะครับ   ปรัชญาคือเราต้องลดภาระ และโยนไปให้คอมพิวเตอร์ทำงาน
ไม่ใช่เราต้องมาเหนื่อยแบบงานเช่นนี้...
ท่านต้องไปคิดใหม่  คิดว่าทำยังไงก็ได้ ให้เราเหนื่อยน้อยที่สุด ไม่ใช่ไปเขียน code ถึกๆ แบบนี้อีก

=============================================

ต่อมา เรื่องที่สอง
จากปัญหาข้างต้น ทำให้ต้องเข้าใจว่า ที่จริงแล้ว คือเราต้องแบ่งโปรแกรมออกเป็นส่วนย่อย
(เรียกว่า sub routine) แล้วเรียกใช้บ่อยๆ เช่น

printf("ฉันรักเธอ")

ก็สร้างเป็น function ไว้
void i()
{ printf("ฉันรักเธอ"); }


เวลาเรียกใช้ ก็เขียนแค่ i(); 1000 ครั้งก็จบแล้ว
ถึงแม้ว่าจะคล้ายๆ การ copy + paste คำสั่ง printf("ฉันรักเธอ") พันบรรทัด,
แต่ภาพรวมมันสั้นกว่า แถมยังประหยัดหน่วยความจำเยอะนะครับ เพราะ "ฉันรักเธอ" มีแค่บรรทัดเดียว
ที่เหลือคือร่างแยก 1000 ครั้ง ไม่เหมือน printf("ฉันรักเธอ") ตรงๆ พันบรรทัดนะ อันนี้กินเนื้อที่โปรแกรมเยอะกว่า

==========================================================

เรื่องที่สาม
อย่าไปงงกับเรื่อง macro หรือ Compiler Directive
อย่าไปคิดว่า macro เขียนแทน funtion ได้ ทำงานได้เหมือนกัน...

พวกมือใหม่มักจะเข้าใจอย่างนั้น ที่จริงต้องบอกว่ามันคล้ายกัน
แต่ทางปรัชญาการเขียนโปรแกรม มันมีความแตกต่างกันมากทีเดียว

การสร้าง macro หรือการใช้ compiler directive เช่น #define มาสร้างโปรแกรมย่อย
แทนการใช้ function ถือว่าผิดเกณฑ์อย่างร้ายแรง มันแทนกันได้แต่ไม่เหมาะสม

compiler directive คือ "pre processor"  (แปลว่าให้ทำ.....ก่อน ก่อนการเอาไปประมวลผล)
หรือก็คือ มันจะกระทำตามคำสั่ง macro ที่วางไว้ก่อน ก่อนที่จะเอา source code ที่ได้นั้น
ไปเข้ากระบวนการ compile เพื่อสร้างโปรแกรมเพื่อรันในสถาปัตยกรรมนั้นๆต่อไป

เราวาง macro เพื่อให้มันทำงานสักอย่างหนึ่งตอนนั้น แต่ตัวผู้เขียนโปรแกรมเองก็ไม่รู้ว่าเป็นค่าอะไร
(แต่รู้ว่าต้องทำแน่ๆ) ก็เช่น
- ให้ใส่เลขเวอร์ชั่น ตามวันเวลาที่เขียนโปรแกรมเสร็จ ซึ่งไม่รู้เหมือนกันว่าจะเสร็จวันไหน กี่โมง ก็เลยว่า macro เอาไว้
- การให้ compile ตาม speed X'tal ที่มีตอนนั้น ซึ่งไม่รู้เหมือนกันว่าตอน compile จะไปใช้ speed อะไร ก็เลยวาง macro เอาไว้
- การย้าย source code ให้ไปรันที่ต่างสถาปัตยกรรม รู้แน่ๆ ว่ามี int ให้ใช้ แต่ไม่รู้ว่า สถาปัตยกรรมนั้นจะใช้ int ที่ 2 byte หรือ 4 byte หรือ 8 byte ก็เลยวาง macro ไว้
- ฯลฯ

จะสังเกตุได้ว่า macro จะถูกวางไว้ก่อน แล้วอ้างอิงกับมันเสมือนว่าเป็นค่าหนึ่ง แต่ก็ไม่รู้ว่าจะเป็นค่าอะไร
ดังนั้นจึงวางค่าคงที่ ที่แน่นอนใน source code ขณะนั้นๆ ไม่ได้  นั่นจึงเป็นที่มาของ macro

แล้วคุณสามารถเขียน macro แทน function ได้ไหม?
ตอบว่า "ได้" แต่ไม่ควร .... เพราะการนำ macro มา reuse ใช้ในระดับ  source code นั้นทำได้ยาก
อีกทั้ง macro ไม่ได้ถูกออกแบบมาให้เขียน function ที่ซับซ้อน จึงไม่เหมาะ
macro เป็นความสามารถพื้นฐานของ compiler ภาษาซี แต่บางภาษาไม่มี

macro คือ preprosessor ถ้าตั้งเงื่อนไขดีๆ มันสามารถช่วยในการย้ายสถาปัตยกรรมได้โดยง่าย (Portability)
เช่นเขียน library บน PC แต่เอาไปใช้ใน AVR, PIC ,ARM ได้ง่ายๆ แทบไม่ต้องเขียนใหม่
ยกตัวอย่าง int

C# = 64 bit
AVR int = 8 bit
ARM  int = 32 bit


file ใน csharp.h
#define int int64_t

file ใน avr.h
#define int int8_t

file ใน arm.h
#define int int32_t

เพียงแค่นี้ ไม่ว่าเราจะไปใช้ สถาปัตยกรรมไหน
เพียงแค่เรียก int มันจะใช้ตรงตามสถาปัตยกรรมนั้น ขอแค่ include ให้ตรงกับสถาปัตยกรรมนั้นๆ
หลักการนี้เป็นหลักการง่ายๆ ที่ใช้ port พวก linux ที่รันบน x86 ไปรันบน ARM (คนละสถาปัตยกรรมกันเลย)
หรือรันบน powerPC หรือรันบน playstation , XBOX ฯลฯ

ยิ่งถ้าวางคู่กับ ตัว compiler directive อื่นๆ จะทำให้การ compile นั้น จะได้ code native ที่
เหมาะสมกับสถาปัตยกรรมนั้นๆ มาก อุปมาเหมือน สั่งตัดเสื้อผ้า มันจะเข้ากับหุ่นเป๊ะเลย ต่างจากไปซื้อเสื้อผ้าโหลจากโรงงาน
ก็จะมีหลวมบ้าง คับบ้าง ประมาณนั้น

การเขียน macro ถ้าเขียนเทพๆ วางผังดีๆ ใช้่คู่กับ editor ดีๆ เช่นพวก VIM
บางทีเราเอาโปรแกรมที่มีโครงสร้างคล้ายๆ ซี เช่น pascal มาใส่คำสั่งเปลี่ยนรูปใน VIM ไม่กี่ที
แล้วใส่ macro ไป เผลอๆ source code ภาษา pascal อันนั้น เมื่อสั่ง compile ดันผ่านได้ด้วยนะเออ... ทำเป็นเล่นไป... ::)

จำไว้ว่า ถ้าต้องการโปรแกรมย่อย ก็ให้เขียนโปรแกรมย่อย (sub routine)
ถ้าต้องการปรับแต่ง code ณ เวลาจะ compile ก็ให้ใช้ Macro
เพื่อการ reuse ในระดับ source code ที่ค่อนข้างมั่นใจได้มากกว่า

ในการ reuse บนระดับ computer ทั่วไป สมัยนี้เรามักจะใช้เทคนิคที่เรียกว่า OOP (แทบจะเป็นสวรรค์สำหรับใครหลายๆคน)
นั่นคือการ reuse ประเภทหนึ่ง แต่เป็นการ reuse ระดับ "object" ซึ่งจะมี overhead สูงมาก กว่าจะใช้งานสัก funtion นึง(method)
มันจะไปเรียก ญาติโกโหติกา ลูกหลานเหลนโหลนมาประชุมแรมกันอย่างพร้อมหน้า แล้วก็เรียกใช้งาน  เราลดเวลาการพัฒนาได้เยอะขึ้นแต่แลก
กับหน่วยความจำที่เสียไป แต่ด้วย computer สมัยนี้ประสิทธิภาพสูงมาก จึง dont' care!

แต่บน MCU ทรัพยากรมันน้อยมาก เราทำอย่างนั้นไม่ค่อยได้  แต่เราจะทำการ reuse ระดับ "source code" ค่อนข้างบ่อย
ถ้า source code ที่จะ reuse ทำงานไม่เป็นเอกเทศ จะทำงานที ต้องไปเทียบค่ากับ macro
หรือยึดติดแบบ macro จะทำให้ reuse ได้ยาก เผลอๆ เขียนใหม่เร็วกว่า ด้วยประการฉะนี้... :)

*

Offline JENG

  • *****
  • 808
  • รู้ทุกเรื่องเว้นเรื่องจริง
    • View Profile
สวัสดี จขกท.

ผมมีเรื่องจะเล่าสู่กันฟัง.....ตามประสาคนเขียนโปรแกรมมาก่อนอ่ะนะ อาจจะ
ไม่เก่งมาก แต่ระดับ level น่าจะพอสอน จขกท.ได้บ้าง

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

ดังนั้นถ้าโจทย์บอกว่า จงพิมพ์ "ฉันรักเธอ" 1000 ครั้ง
คนที่ใช้เครื่องเป็นเค้าจะสั่งวนลูป 1000 รอบ จบแล้ว...ง่ายไหม ?
 
แต่ถ้าเป็น จขกท. คง copy + paste "ฉันรักเธอ" 1000 บรรทัดแทนซะละมั๊ง ::)

มันทำงานได้เหมือนกัน แต่มันไม่เหมาะครับ   ปรัชญาคือเราต้องลดภาระ และโยนไปให้คอมพิวเตอร์ทำงาน
ไม่ใช่เราต้องมาเหนื่อยแบบงานเช่นนี้...
ท่านต้องไปคิดใหม่  คิดว่าทำยังไงก็ได้ ให้เราเหนื่อยน้อยที่สุด ไม่ใช่ไปเขียน code ถึกๆ แบบนี้อีก

=============================================

ต่อมา เรื่องที่สอง
จากปัญหาข้างต้น ทำให้ต้องเข้าใจว่า ที่จริงแล้ว คือเราต้องแบ่งโปรแกรมออกเป็นส่วนย่อย
(เรียกว่า sub routine) แล้วเรียกใช้บ่อยๆ เช่น

printf("ฉันรักเธอ")

ก็สร้างเป็น function ไว้
void i()
{ printf("ฉันรักเธอ"); }


เวลาเรียกใช้ ก็เขียนแค่ i(); 1000 ครั้งก็จบแล้ว
ถึงแม้ว่าจะคล้ายๆ การ copy + paste คำสั่ง printf("ฉันรักเธอ") พันบรรทัด,
แต่ภาพรวมมันสั้นกว่า แถมยังประหยัดหน่วยความจำเยอะนะครับ เพราะ "ฉันรักเธอ" มีแค่บรรทัดเดียว
ที่เหลือคือร่างแยก 1000 ครั้ง ไม่เหมือน printf("ฉันรักเธอ") ตรงๆ พันบรรทัดนะ อันนี้กินเนื้อที่โปรแกรมเยอะกว่า

==========================================================

เรื่องที่สาม
อย่าไปงงกับเรื่อง macro หรือ Compiler Directive
อย่าไปคิดว่า macro เขียนแทน funtion ได้ ทำงานได้เหมือนกัน...

พวกมือใหม่มักจะเข้าใจอย่างนั้น ที่จริงต้องบอกว่ามันคล้ายกัน
แต่ทางปรัชญาการเขียนโปรแกรม มันมีความแตกต่างกันมากทีเดียว

การสร้าง macro หรือการใช้ compiler directive เช่น #define มาสร้างโปรแกรมย่อย
แทนการใช้ function ถือว่าผิดเกณฑ์อย่างร้ายแรง มันแทนกันได้แต่ไม่เหมาะสม

compiler directive คือ "pre processor"  (แปลว่าให้ทำ.....ก่อน ก่อนการเอาไปประมวลผล)
หรือก็คือ มันจะกระทำตามคำสั่ง macro ที่วางไว้ก่อน ก่อนที่จะเอา source code ที่ได้นั้น
ไปเข้ากระบวนการ compile เพื่อสร้างโปรแกรมเพื่อรันในสถาปัตยกรรมนั้นๆต่อไป

เราวาง macro เพื่อให้มันทำงานสักอย่างหนึ่งตอนนั้น แต่ตัวผู้เขียนโปรแกรมเองก็ไม่รู้ว่าเป็นค่าอะไร
(แต่รู้ว่าต้องทำแน่ๆ) ก็เช่น
- ให้ใส่เลขเวอร์ชั่น ตามวันเวลาที่เขียนโปรแกรมเสร็จ ซึ่งไม่รู้เหมือนกันว่าจะเสร็จวันไหน กี่โมง ก็เลยว่า macro เอาไว้
- การให้ compile ตาม speed X'tal ที่มีตอนนั้น ซึ่งไม่รู้เหมือนกันว่าตอน compile จะไปใช้ speed อะไร ก็เลยวาง macro เอาไว้
- การย้าย source code ให้ไปรันที่ต่างสถาปัตยกรรม รู้แน่ๆ ว่ามี int ให้ใช้ แต่ไม่รู้ว่า สถาปัตยกรรมนั้นจะใช้ int ที่ 2 byte หรือ 4 byte หรือ 8 byte ก็เลยวาง macro ไว้
- ฯลฯ

จะสังเกตุได้ว่า macro จะถูกวางไว้ก่อน แล้วอ้างอิงกับมันเสมือนว่าเป็นค่าหนึ่ง แต่ก็ไม่รู้ว่าจะเป็นค่าอะไร
ดังนั้นจึงวางค่าคงที่ ที่แน่นอนใน source code ขณะนั้นๆ ไม่ได้  นั่นจึงเป็นที่มาของ macro

แล้วคุณสามารถเขียน macro แทน function ได้ไหม?
ตอบว่า "ได้" แต่ไม่ควร .... เพราะการนำ macro มา reuse ใช้ในระดับ  source code นั้นทำได้ยาก
อีกทั้ง macro ไม่ได้ถูกออกแบบมาให้เขียน function ที่ซับซ้อน จึงไม่เหมาะ
macro เป็นความสามารถพื้นฐานของ compiler ภาษาซี แต่บางภาษาไม่มี

macro คือ preprosessor ถ้าตั้งเงื่อนไขดีๆ มันสามารถช่วยในการย้ายสถาปัตยกรรมได้โดยง่าย (Portability)
เช่นเขียน library บน PC แต่เอาไปใช้ใน AVR, PIC ,ARM ได้ง่ายๆ แทบไม่ต้องเขียนใหม่
ยกตัวอย่าง int

C# = 64 bit
AVR int = 8 bit
ARM  int = 32 bit


file ใน csharp.h
#define int int64_t

file ใน avr.h
#define int int8_t

file ใน arm.h
#define int int32_t

เพียงแค่นี้ ไม่ว่าเราจะไปใช้ สถาปัตยกรรมไหน
เพียงแค่เรียก int มันจะใช้ตรงตามสถาปัตยกรรมนั้น ขอแค่ include ให้ตรงกับสถาปัตยกรรมนั้นๆ
หลักการนี้เป็นหลักการง่ายๆ ที่ใช้ port พวก linux ที่รันบน x86 ไปรันบน ARM (คนละสถาปัตยกรรมกันเลย)
หรือรันบน powerPC หรือรันบน playstation , XBOX ฯลฯ

ยิ่งถ้าวางคู่กับ ตัว compiler directive อื่นๆ จะทำให้การ compile นั้น จะได้ code native ที่
เหมาะสมกับสถาปัตยกรรมนั้นๆ มาก อุปมาเหมือน สั่งตัดเสื้อผ้า มันจะเข้ากับหุ่นเป๊ะเลย ต่างจากไปซื้อเสื้อผ้าโหลจากโรงงาน
ก็จะมีหลวมบ้าง คับบ้าง ประมาณนั้น

การเขียน macro ถ้าเขียนเทพๆ วางผังดีๆ ใช้่คู่กับ editor ดีๆ เช่นพวก VIM
บางทีเราเอาโปรแกรมที่มีโครงสร้างคล้ายๆ ซี เช่น pascal มาใส่คำสั่งเปลี่ยนรูปใน VIM ไม่กี่ที
แล้วใส่ macro ไป เผลอๆ source code ภาษา pascal อันนั้น เมื่อสั่ง compile ดันผ่านได้ด้วยนะเออ... ทำเป็นเล่นไป... ::)

จำไว้ว่า ถ้าต้องการโปรแกรมย่อย ก็ให้เขียนโปรแกรมย่อย (sub routine)
ถ้าต้องการปรับแต่ง code ณ เวลาจะ compile ก็ให้ใช้ Macro
เพื่อการ reuse ในระดับ source code ที่ค่อนข้างมั่นใจได้มากกว่า

ในการ reuse บนระดับ computer ทั่วไป สมัยนี้เรามักจะใช้เทคนิคที่เรียกว่า OOP (แทบจะเป็นสวรรค์สำหรับใครหลายๆคน)
นั่นคือการ reuse ประเภทหนึ่ง แต่เป็นการ reuse ระดับ "object" ซึ่งจะมี overhead สูงมาก กว่าจะใช้งานสัก funtion นึง(method)
มันจะไปเรียก ญาติโกโหติกา ลูกหลานเหลนโหลนมาประชุมแรมกันอย่างพร้อมหน้า แล้วก็เรียกใช้งาน  เราลดเวลาการพัฒนาได้เยอะขึ้นแต่แลก
กับหน่วยความจำที่เสียไป แต่ด้วย computer สมัยนี้ประสิทธิภาพสูงมาก จึง dont' care!

แต่บน MCU ทรัพยากรมันน้อยมาก เราทำอย่างนั้นไม่ค่อยได้  แต่เราจะทำการ reuse ระดับ "source code" ค่อนข้างบ่อย
ถ้า source code ที่จะ reuse ทำงานไม่เป็นเอกเทศ จะทำงานที ต้องไปเทียบค่ากับ macro
หรือยึดติดแบบ macro จะทำให้ reuse ได้ยาก เผลอๆ เขียนใหม่เร็วกว่า ด้วยประการฉะนี้... :)

ข้อมูลแน่น แถมคัดกรองมาเป็นอย่างดี ... ;D
สามารถติดตาม electoday ได้ที่

Facebook
www.facebook.com/groups/coopmicro

Google+
https://plus.google.com/communities/103482067769375459277

☺☺☺ความรู้ และความฉลาด ไม่ใช่สิ่งเดียวกัน จะมีประโยชน์อะไร ถ้าฉลาดแต่อยู่ในกะลา☺☺☺

สวัสดี จขกท.

ผมมีเรื่องจะเล่าสู่กันฟัง.....ตามประสาคนเขียนโปรแกรมมาก่อนอ่ะนะ อาจจะ
ไม่เก่งมาก แต่ระดับ level น่าจะพอสอน จขกท.ได้บ้าง

เรื่องแรก...
ผมเห็น code ท่านแล้ว ถ้าผมเป็นอ.ที่สอนท่านคงปวดตับเช่นกัน  :P
ปรัชญาการมีเครื่องคอมพิวเตอร์ หรือเครื่องคิดเลขทรงประสิทธิภาพนี้ก็เพราะว่า
มันเก่งในเรื่องที่ต้องคำนวน (งานโพรเซส) หรือการทำงานซ้ำๆ (งานรูทีน) ครับ
งานพวกนี้เครื่องมันเก่ง ที่จริงมนุษย์ก็ทำได้ครับ แต่มนุษย์ขี้เกียจ และผิดพลาดบ่อย
เค้าเลยต้องโยนให้เครื่องมันทำให้
level นี้คงต้องเป็น อ. สอนใจมหาลัยแล้วล่ะ  ;D
ตอนเห็นโค้ดผมก็ปวดตับเหมือนกัน แต่ไม่ใช่พวก function น่ะ เป็นพวก Indent style พอเห็นนี่ไม่อยากดูโค้ดเลยถึงกับิด VIM เลยทีเดียว!!
เรื่อง macro vs function แถมอีกอัน ฝรั่งเค้าสรุปสั้นๆ ง่ายๆ ดีครับ
http://programmers.stackexchange.com/questions/937/why-arent-macros-included-in-most-modern-programming-languages
GNU/Linux User.
Underground computer group.
The GNU people aren't evil. but i'm evil. :P