เหตุใดภาษาการเขียนโปรแกรมบางภาษาจึง“ เร็วกว่า” หรือ“ ช้ากว่า” กว่าภาษาอื่น

ฉันสังเกตเห็นว่าบางแอปพลิเคชันหรืออัลกอริทึมที่สร้างขึ้นด้วยภาษาการเขียนโปรแกรมกล่าวว่า C ++ / Rust ทำงานได้เร็วขึ้นหรือเร็วกว่าแอปพลิเคชันที่สร้างขึ้นบน Java / Node.js ที่ทำงานบนเครื่องเดียวกัน ฉันมีคำถามสองสามข้อเกี่ยวกับเรื่องนี้:

1. ทำไมสิ่งนี้ถึงเกิดขึ้น
2. อะไรคือสิ่งที่ควบคุม "ความเร็ว" ของภาษาการเขียนโปรแกรม?
3. สิ่งนี้เกี่ยวข้องกับการจัดการหน่วยความจำหรือไม่?

ฉันจะซาบซึ้งจริงๆถ้ามีคนทำลายมันลงสำหรับฉัน

ในการออกแบบและการใช้ภาษาโปรแกรมนั้นมีตัวเลือกจำนวนมากที่สามารถส่งผลกระทบต่อประสิทธิภาพการทำงาน ฉันจะพูดถึงเพียงไม่กี่

ในที่สุดทุกภาษาจะต้องถูกเรียกใช้โดยการเรียกใช้งานรหัสเครื่อง ภาษา "เรียบเรียง" เช่น C ++ จะถูกแยกวิเคราะห์ถอดรหัสและแปลเป็นรหัสเครื่องเพียงครั้งเดียวในเวลารวบรวม ภาษา "ตีความ" หากนำมาใช้ในทางตรงจะถูกถอดรหัสที่รันไทม์ทุกขั้นตอนทุกครั้ง นั่นคือทุกครั้งที่เราเรียกใช้คำสั่งผู้บุกรุกต้องตรวจสอบว่าเป็น if-then-else หรือการมอบหมาย ฯลฯ และดำเนินการตามนั้น ซึ่งหมายความว่าหากเราวน 100 ครั้งเราจะถอดรหัสรหัสเดียวกัน 100 ครั้งเสียเวลา โชคดีที่ล่ามมักจะปรับให้เหมาะสมเช่นผ่านระบบการรวบรวมแบบทันเวลา (อย่างถูกต้องมากขึ้นไม่มีสิ่งที่เป็นภาษา "รวบรวม" หรือ "ตีความ" - มันเป็นทรัพย์สินของการดำเนินการไม่ได้ของภาษายังคง

คอมไพเลอร์ / ล่ามที่แตกต่างกันดำเนินการเพิ่มประสิทธิภาพที่แตกต่างกัน

หากภาษามีการจัดการหน่วยความจำอัตโนมัติการใช้งานจะต้องดำเนินการรวบรวมขยะ นี่เป็นค่าใช้จ่ายในการใช้งานจริง แต่จะช่วยให้โปรแกรมเมอร์ไม่ทำงานผิดพลาดได้ง่าย

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

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

บางภาษาจะรายงานข้อผิดพลาดรันไทม์อย่างชาญฉลาดเสมอ หากคุณเขียนa[100]ใน Java ที่aมีเพียง 20 องค์ประกอบคุณจะได้รับข้อยกเว้นรันไทม์ ใน C ซึ่งจะทำให้เกิดพฤติกรรมที่ไม่ได้กำหนดซึ่งหมายความว่าโปรแกรมอาจล้มเหลวเขียนทับข้อมูลสุ่มบางอย่างในหน่วยความจำหรือแม้แต่ดำเนินการอย่างอื่น (มาตรฐาน ISO C ไม่มีข้อ จำกัด ใด ๆ ) สิ่งนี้ต้องการการตรวจสอบรันไทม์ แต่ให้ความหมายที่ดีกว่าแก่โปรแกรมเมอร์

อย่างไรก็ตามโปรดจำไว้ว่าเมื่อประเมินภาษาแล้วประสิทธิภาพไม่ใช่ทุกอย่าง อย่าหมกมุ่นกับมัน เป็นกับดักทั่วไปที่พยายามเพิ่มประสิทธิภาพทุกอย่าง แต่ยังไม่พบว่ามีการใช้อัลกอริทึม / โครงสร้างข้อมูลที่ไม่มีประสิทธิภาพ Knuth เคยกล่าวไว้ว่า "การเพิ่มประสิทธิภาพก่อนวัยอันควรเป็นรากฐานของความชั่วร้ายทั้งหมด"

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

1   700327  Unagi                       Java,C++,C#,PHP,Haskell
2   268752  天羽々斬                     C++, Ruby, Python, Haskell, Java, JavaScript
3   243456  Cult of the Bound Variable  C++, Standard ML, Python

ไม่มีใครใช้ภาษาเดียว

อะไรคือสิ่งที่ควบคุม "ความเร็ว" ของภาษาการเขียนโปรแกรม?

ไม่มีสิ่งเช่น "ความเร็ว" ของภาษาการเขียนโปรแกรม มีความเร็วของโปรแกรมเฉพาะที่เขียนโดย progammer เฉพาะที่ดำเนินการโดยรุ่นเฉพาะของการใช้งานเฉพาะของโปรแกรมเรียกใช้งานเฉพาะที่ทำงานอยู่ในสภาพแวดล้อมเฉพาะ

อาจมีความแตกต่างด้านประสิทธิภาพอย่างมากในการเรียกใช้รหัสเดียวกันที่เขียนในภาษาเดียวกันบนเครื่องเดียวกันโดยใช้การใช้งานที่แตกต่างกัน หรือแม้กระทั่งใช้เวอร์ชันที่แตกต่างกันของการใช้งานเดียวกัน ตัวอย่างเช่นการรัน ECMAScript มาตรฐานเดียวกันบนเครื่องเดียวกันโดยใช้ SpiderMonkey จากเมื่อ 10 ปีที่แล้วกับรุ่นหนึ่งในปีนี้อาจให้ประสิทธิภาพเพิ่มขึ้นระหว่าง 2 × –5 ×อาจเท่ากับ 10 × นั่นหมายความว่า ECMAScript นั้นเร็วกว่า ECMAScript 2 เท่าเพราะการรันโปรแกรมเดียวกันบนเครื่องเดียวกันนั้นเร็วกว่า 2 เท่าเมื่อใช้งานใหม่กว่าหรือไม่ ไม่สมเหตุสมผลเลย

สิ่งนี้เกี่ยวข้องกับการจัดการหน่วยความจำหรือไม่?

ไม่ได้จริงๆ

ทำไมสิ่งนี้ถึงเกิดขึ้น

ทรัพยากร เงิน Microsoft อาจจ้างคนทำกาแฟให้กับโปรแกรมเมอร์คอมไพเลอร์มากกว่าชุมชน PHP, Ruby และ Python รวมกันทำให้คนทำงานกับ VM ของพวกเขา

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

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

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

แต่มีวิธีอื่น: ค่าใช้จ่ายรวมของการพลาดแคชคือจำนวนแคชที่พลาดไปคูณด้วยค่าใช้จ่ายของการแคชแต่ละครั้งที่พลาด ซีพียูหลักพยายามลดจำนวนการพลาด แต่ถ้าคุณสามารถลดค่าใช้จ่ายของการพลาดแต่ละครั้งได้

ซีพียู Azul Vega-3 ได้รับการออกแบบมาโดยเฉพาะสำหรับการใช้งาน JVM แบบเสมือนจริงและมี MMU ที่ทรงพลังมากพร้อมคำแนะนำเฉพาะสำหรับการช่วยในการรวบรวมขยะและตรวจจับการหลบหนี (การวิเคราะห์แบบไดนามิกเทียบเท่ากับ ยังคงสามารถดำเนินการต่อได้โดยมีแคชค้างมากกว่า 20000 รายการที่พลาดอยู่ในเที่ยวบิน น่าเสียดายที่เหมือนกับซีพียูเฉพาะภาษาส่วนใหญ่การออกแบบนั้นใช้งานง่ายและถูกควบคุมโดยเดรัจฉานยักษ์, Intel, AMD, IBM และอื่น ๆ

สถาปัตยกรรม CPU เป็นเพียงตัวอย่างหนึ่งที่มีผลกระทบต่อความง่ายหรือความยากลำบากในการใช้งานภาษาที่มีประสิทธิภาพสูง ภาษาเช่น C, C ++, D, Rust ที่เหมาะสำหรับซีพียูการเขียนโปรแกรมกระแสหลักรุ่นใหม่จะทำให้เร็วกว่าภาษาที่ต้อง "สู้" และหลีกเลี่ยง CPU เช่น Java, ECMAScript, Python, Ruby , PHP

จริงๆแล้วมันเป็นคำถามของเงินทั้งหมด หากคุณใช้จ่ายเงินเท่ากันเพื่อพัฒนาอัลกอริทึมประสิทธิภาพสูงใน ECMAScript, การใช้งาน ECMAScript ประสิทธิภาพสูง, ระบบปฏิบัติการประสิทธิภาพสูงที่ออกแบบมาสำหรับ ECMAScript, CPU ประสิทธิภาพสูงที่ออกแบบมาสำหรับ ECMAScript ตามที่ได้ใช้ไปในช่วงที่ผ่านมา ทศวรรษที่ผ่านมาในการทำให้ภาษาที่มีลักษณะคล้าย C เป็นไปอย่างรวดเร็วจากนั้นคุณจะเห็นประสิทธิภาพที่เท่าเทียมกัน ในเวลานี้เงินจำนวนมากถูกใช้ไปกับการสร้างภาษาแบบ C เร็วกว่าการทำให้ภาษาแบบ ECMAScript เร็วขึ้นและสมมติฐานของภาษาแบบ C จะถูกนำไปใช้กับสแต็กทั้ง MMU และซีพียูไปสู่ระบบปฏิบัติการและ ระบบหน่วยความจำเสมือนมากถึงไลบรารีและกรอบงาน

โดยส่วนตัวแล้วฉันคุ้นเคยกับ Ruby มากที่สุด (ซึ่งโดยทั่วไปถือว่าเป็น "ภาษาช้า") ดังนั้นฉันจะให้สองตัวอย่าง: Hashคลาส (หนึ่งในโครงสร้างข้อมูลกลางใน Ruby, พจนานุกรมค่าคีย์) ใน Rubinius การติดตั้งทับทิมนั้นเขียนด้วยทับทิมบริสุทธิ์ 100% และมีประสิทธิภาพเทียบเท่ากับHashclass ใน YARV (การใช้งานที่ใช้กันอย่างแพร่หลายที่สุด) ซึ่งเขียนใน C. และมีไลบรารี่การจัดการรูปภาพที่เขียนเป็นส่วนขยาย C สำหรับ YARV ซึ่งมี "fallback version" สำหรับทับทิมบริสุทธิ์ ไม่รองรับ C ซึ่งใช้เทคนิค ruby ​​แบบไดนามิกและไตร่ตรองมากมาย สาขาทดลองของ JRuby โดยใช้เฟรมเวิร์กล่าม Truffle AST และเฟรมเวิร์กการรวบรวม Graal JIT โดย Oracle Labs สามารถดำเนินการทับทิม Ruby "fallback version" ได้เร็วที่สุดเท่าที่ YARV สามารถรันเวอร์ชัน C ที่ได้รับการปรับปรุงประสิทธิภาพสูงสุด นี่เป็นเพียงแค่ (ดีอะไรก็ได้) ที่ทำได้โดยคนที่ฉลาดบางคนทำสิ่งที่ฉลาดจริงๆด้วยการเพิ่มประสิทธิภาพรันไทม์แบบไดนามิกการรวบรวม JIT และการประเมินผลบางส่วน

ในทางทฤษฎีถ้าคุณเขียนโค้ดที่เหมือนกันในสองภาษาและคอมไพล์ทั้งสองโดยใช้คอมไพเลอร์ "สมบูรณ์แบบ" ประสิทธิภาพของทั้งสองควรจะเหมือนกัน

ในทางปฏิบัติมีหลายสาเหตุที่ทำให้ประสิทธิภาพแตกต่างกัน:

1. บางภาษายากที่จะปรับให้เหมาะสม

   ซึ่งรวมถึงคุณสมบัติโดยเฉพาะอย่างยิ่งที่ทำให้โค้ดมีความไดนามิกมากขึ้น (การพิมพ์แบบไดนามิกวิธีเสมือนตัวชี้ฟังก์ชั่น) แต่ยังรวมถึงตัวอย่างเช่นการรวบรวมขยะ

   มีหลายวิธีในการสร้างรหัสโดยใช้คุณสมบัติดังกล่าวอย่างรวดเร็ว แต่โดยทั่วไปแล้วจะยังคงช้าลงอย่างน้อยก็ช้ากว่าที่ไม่ได้ใช้

2. การใช้ภาษาบางอย่างต้องรวบรวมบางอย่างที่รันไทม์

   สิ่งนี้ใช้ได้กับภาษาที่มีเครื่องเสมือน (เช่น Java) และภาษาที่เรียกใช้ซอร์สโค้ดโดยไม่มีขั้นตอนกลางสำหรับไบนารี (เช่น JavaScript)

   การใช้ภาษาดังกล่าวต้องทำงานมากขึ้นขณะทำงานซึ่งมีผลต่อประสิทธิภาพโดยเฉพาะเวลาเริ่มต้น / ประสิทธิภาพในไม่ช้าหลังจากเริ่มต้น

3. การใช้ภาษาโดยเจตนาใช้เวลาในการปรับให้เหมาะสมน้อยลงกว่าที่ควรจะเป็น

   คอมไพเลอร์ทั้งหมดใส่ใจกับประสิทธิภาพของคอมไพเลอร์เองไม่ใช่แค่รหัสที่สร้างขึ้น สิ่งนี้มีความสำคัญอย่างยิ่งสำหรับคอมไพเลอร์รันไทม์ (คอมไพเลอร์ JIT) ซึ่งใช้เวลาในการคอมไพล์นานเกินไปทำให้การประมวลผลแอปพลิเคชันช้าลง แต่มันใช้กับคอมไพเลอร์ล่วงหน้าเช่นเดียวกับ C ++ ตัวอย่างเช่นการจัดสรรการลงทะเบียนเป็นปัญหา NP-complete ดังนั้นจึงไม่ใช่ความจริงที่จะแก้ปัญหาได้อย่างสมบูรณ์แบบและใช้ฮิวริสติกที่ดำเนินการในเวลาที่เหมาะสมแทน

4. ความแตกต่างของสำนวนในภาษาต่าง ๆ

   รหัสที่เขียนในรูปแบบทั่วไปสำหรับภาษาหนึ่ง ๆ (รหัสสำนวน) ที่ใช้ไลบรารีทั่วไปอาจส่งผลให้เกิดความแตกต่างในการทำงานเนื่องจากรหัสที่แสดงลักษณะการทำงานนั้นแตกต่างกันในแต่ละภาษา

   ยกตัวอย่างเช่นพิจารณาvector[i]ใน C ++ list[i]ใน C # และlist.get(i)ใน Java รหัส C ++ มีแนวโน้มที่จะไม่ตรวจสอบช่วงและไม่มีการโทรเสมือนรหัส C # ทำการตรวจสอบช่วง แต่ไม่มีสายเสมือนและรหัส Java ทำการตรวจสอบช่วงและมันเป็นการโทรเสมือน ทั้งสามภาษารองรับวิธีการเสมือนและไม่เสมือนและทั้ง C ++ และ C # สามารถรวมช่วงการตรวจสอบหรือหลีกเลี่ยงมันเมื่อเข้าถึงอาร์เรย์ต้นแบบ แต่ห้องสมุดมาตรฐานของภาษาเหล่านี้ตัดสินใจที่จะเขียนฟังก์ชั่นที่เทียบเท่าเหล่านี้แตกต่างกันและดังนั้นประสิทธิภาพของพวกเขาจะแตกต่างกัน

5. คอมไพเลอร์บางตัวอาจขาดประสิทธิภาพบางอย่าง

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

นี่เป็นคำถามที่ทั่วไปมาก แต่ในกรณีของคุณคำตอบอาจง่าย C ++ คอมไพล์ไปยังโค้ดเครื่องโดยที่ Java คอมไพล์โค้ด Java byte ซึ่งรันจากเครื่องเสมือน Java (แม้ว่าจะมีการคอมไพล์แบบทันเวลาพอดีเท่านั้นซึ่งคอมไพล์โค้ด Java byte ให้กับโค้ดเนทีฟเพิ่มเติม) ความแตกต่างอีกอย่างคือการรวบรวมขยะซึ่งเป็นบริการที่ Java มีให้เท่านั้น

คำถามของคุณกว้างเกินไปดังนั้นฉันเกรงว่าฉันไม่สามารถให้คำตอบที่แน่นอนที่คุณต้องการ

สำหรับคำอธิบายที่ดีที่สุดของฉันลองดูที่แพลตฟอร์ม C ++ และ. Net

C ++ ใกล้กับรหัสเครื่องและการเขียนโปรแกรมที่โปรดปรานอย่างหนึ่งในเวลาที่เก่ากว่า (เช่นมากกว่า 10 ปีที่แล้ว?) เนื่องจากประสิทธิภาพ มีทรัพยากรไม่มากที่จำเป็นในการพัฒนาและดำเนินการโปรแกรม C ++ แม้จะมี IDE พวกเขาถือว่ามีน้ำหนักเบาและรวดเร็วมาก คุณยังสามารถเขียนรหัส C ++ ในคอนโซลและพัฒนาเกมได้จากที่นั่น ในแง่ของหน่วยความจำและทรัพยากรฉันลืมคร่าว ๆ ว่ามันต้องใช้ความจุเท่าใดในคอมพิวเตอร์ แต่ความจุเป็นสิ่งที่คุณไม่สามารถเปรียบเทียบกับภาษาการเขียนโปรแกรมในปัจจุบันได้

ทีนี้ลองดูที่. Net สิ่งที่จำเป็นต้องทำในการพัฒนา. Net เป็น IDE ขนาดยักษ์ตัวหนึ่งที่ประกอบด้วยภาษาการเขียนโปรแกรมไม่เพียงชนิดเดียว แม้ว่าคุณเพียงต้องการที่จะพัฒนาในสมมติว่า C #, IDE เองจะรวมถึงแพลตฟอร์มการเขียนโปรแกรมจำนวนมากโดยค่าเริ่มต้นเช่น J #, VB, มือถือและอื่น ๆ โดยค่าเริ่มต้น หากคุณไม่ได้ติดตั้งแบบกำหนดเองและติดตั้งเฉพาะสิ่งที่คุณต้องการเท่านั้นหากคุณมีประสบการณ์เพียงพอที่จะเล่นกับการติดตั้ง IDE

นอกจากการติดตั้งซอฟต์แวร์ IDE แล้ว Net ยังมาพร้อมกับไลบรารีและเฟรมเวิร์กจำนวนมากเพื่อความสะดวกในการเข้าถึงแพลตฟอร์มประเภทใด ๆ ที่นักพัฒนาต้องการและไม่ต้องการ

การพัฒนาใน. Net อาจเป็นประสบการณ์ที่สนุกสนานเพราะมีฟังก์ชั่นและส่วนประกอบทั่วไปหลายอย่างให้บริการตามค่าเริ่มต้น คุณสามารถลากแล้วปล่อยและใช้วิธีการตรวจสอบความถูกต้องอ่านไฟล์เข้าถึงฐานข้อมูลและอีกมากมายใน IDE

เป็นผลให้มันเป็นการแลกเปลี่ยนระหว่างทรัพยากรคอมพิวเตอร์และความเร็วในการพัฒนา ไลบรารีและกรอบเหล่านั้นใช้หน่วยความจำและทรัพยากร เมื่อคุณรันโปรแกรมใน. Net IDE อาจใช้เวลาหลายนาทีในการรวบรวมไลบรารีส่วนประกอบและไฟล์ทั้งหมดของคุณ และเมื่อคุณทำการดีบักคอมพิวเตอร์ของคุณต้องการทรัพยากรจำนวนมากเพื่อจัดการกระบวนการดีบักใน IDE ของคุณ

โดยปกติแล้วในการพัฒนา. net คุณต้องมีคอมพิวเตอร์ที่มี Ram และตัวประมวลผล มิฉะนั้นคุณอาจไม่ได้เขียนโปรแกรมเลย ในแง่นี้แพลตฟอร์ม C ++ ดีกว่า. Net แม้ว่าคุณจะยังคงต้องการคอมพิวเตอร์ที่ดี แต่ความสามารถนั้นไม่ได้กังวลมากนักเมื่อเทียบกับ. Net

หวังว่าคำตอบของฉันจะช่วยคุณได้ แจ้งให้เราทราบในกรณีที่คุณต้องการทราบข้อมูลเพิ่มเติม

แก้ไข:

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

ในมุมมอง IDE การใช้ภาษา C ++ หรือ. Net ใน IDE แบบสัมพัทธ์จะไม่ส่งผลต่อความเร็วในการเขียนโค้ด แต่จะส่งผลต่อความเร็วในการพัฒนาเนื่องจากคอมไพเลอร์ Visual Studio ใช้เวลาในการรันโปรแกรมนานกว่า แต่ C ++ IDE นั้นเบากว่ามาก และใช้ทรัพยากรคอมพิวเตอร์น้อยลง ดังนั้นในระยะยาวคุณสามารถเขียนโปรแกรมได้เร็วขึ้นด้วยประเภท C ++ ของ IDE เปรียบเทียบกับ. NET IDE ซึ่งขึ้นอยู่กับไลบรารีและกรอบงาน หากคุณใช้เวลาในการรอ IDE เริ่มทำการคอมไพล์รันโปรแกรมและอื่น ๆ มันจะส่งผลต่อความเร็วของการเขียนโปรแกรม ยกเว้นว่า "ความเร็วของการเขียนโปรแกรม" นั้นจริง ๆ แล้วมุ่งเน้นที่ "ความเร็วในการเขียนโค้ด" เท่านั้น

จำนวนไลบรารีและกรอบงานใน Visual Studio ใช้ความจุของคอมพิวเตอร์เช่นกัน ฉันไม่แน่ใจว่าสิ่งนี้ตอบคำถามของ "การจัดการหน่วยความจำ" แต่ฉันต้องการชี้ให้เห็นว่า Visual Studio IDE สามารถใช้ทรัพยากรจำนวนมากเมื่อเรียกใช้และทำให้ช้าลงโดยรวม "ความเร็วของการเขียนโปรแกรม" แน่นอนว่าสิ่งนี้ไม่เกี่ยวกับ "ความเร็วในการเขียนโค้ด"

อย่างที่คุณอาจเดาได้ฉันไม่รู้ C ++ มากเกินไปเพราะฉันใช้มันเป็นตัวอย่างประเด็นหลักของฉันคือเกี่ยวกับ Visual Studio ประเภท IDE หนัก ๆ ที่ใช้ทรัพยากรคอมพิวเตอร์

หากฉันมีความคิดและไม่ได้ตอบคำถามเริ่มต้นเธรดเลยขออภัยสำหรับการโพสต์ที่ยาวนาน แต่ฉันจะแนะนำผู้เริ่มต้นเธรดเพื่อทำให้คำถามชัดเจนและถามสิ่งที่เขา / เธอจำเป็นต้องรู้เกี่ยวกับ "เร็วขึ้น" และ "ช้าลง"