ประสิทธิภาพที่ควรได้รับจากการพิมพ์แบบไดนามิกคืออะไร? [ปิด]

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

ดังนั้นสิ่งที่จะกล่าวถึงการเพิ่มผลผลิตด้วยการพิมพ์แบบไดนามิกที่เป็นข้อได้เปรียบของแบบจำลองประเภทเอง?

ชี้แจง: ฉันสนใจโครงการขนาดใหญ่ / กลางมากกว่าในแฮ็กด่วน :-)

จริง ๆ แล้วฉันคิดว่ามันเป็นสายที่ค่อนข้างใกล้ ทั้งการพิมพ์แบบไดนามิกและการพิมพ์แบบคงที่มีข้อดีของพวกเขา

เหตุผลในการพิมพ์แบบไดนามิกมีประสิทธิผลมากขึ้น:

• มันกระชับมากขึ้น - รหัสสำเร็จรูปจำนวนมากสามารถลบออกได้หากทุกอย่างถูกพิมพ์แบบไดนามิก - การประกาศประเภทการพิมพ์แบบลอจิกลอจิก ฯลฯ สิ่งอื่น ๆ ที่เท่าเทียมกันรหัสที่สั้นกว่านั้นสั้นกว่าเล็กน้อย รักษาไว้ (เนื่องจากคุณไม่จำเป็นต้องลุยหน้าหลาย ๆ หน้าของโค้ดเพื่อรับรู้ว่าเกิดอะไรขึ้น)
• เทคนิค"แฮ็ก" ที่ง่ายกว่าเช่นการพิมพ์เป็ดและการปะแก้ลิงจะทำให้คุณได้ผลเร็วมาก (แม้ว่าคุณอาจสับสนในภายหลัง ... )
• โต้ตอบได้มากกว่า - การพิมพ์แบบไดนามิกเหมาะสำหรับการโต้ตอบการเขียนโปรแกรมแบบ REPL เพื่อการสร้างต้นแบบที่รวดเร็วการดีบักแบบเรียลไทม์ของการรันอินสแตนซ์ของโปรแกรมหรือแม้แต่การเข้ารหัสสด
• กรณีทดสอบสามารถตรวจจับข้อผิดพลาดรันไทม์ - สมมติว่าคุณกำลังใช้ TDD หรืออย่างน้อยที่สุดก็มีชุดทดสอบที่ดีซึ่งจะทำให้เกิดปัญหาการพิมพ์ใด ๆ ในรหัสของคุณ
• Better polymorphism - ภาษาไดนามิกมีแนวโน้มที่จะส่งเสริมการสร้างฟังก์ชั่น polymorphic และ abstractions ซึ่งสามารถเพิ่มประสิทธิภาพการผลิตและการใช้รหัสซ้ำ ตัวอย่างเช่น Clojure ใช้ประโยชน์จากความแตกต่างหลากหลายแบบไดนามิกในabstractionsมากมาย
• ต้นแบบ - ต้นแบบตามข้อมูล / รูปแบบของวัตถุที่อยู่ในมุมมองของฉันมีประสิทธิภาพมากขึ้นและมีความยืดหยุ่นกว่าพิมพ์แบบคงที่ heirarchies มรดก ภาษาแบบไดนามิกมีแนวโน้มที่จะอนุญาตหรือสนับสนุนแนวทางแบบต้นแบบโดย Javascript เป็นตัวอย่างที่ดี

เหตุผลที่พิมพ์แบบสแตติกมีประสิทธิผลมากกว่า:

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

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

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

ด้วยภาษาแบบไดนามิกคุณสามารถเขียนโค้ดเส็งเคร็งเร็วกว่าเมื่อใช้ภาษาที่พิมพ์

เมื่อคุณสร้างกองไดนามิกขนาดใหญ่ได้อย่างรวดเร็วคุณสามารถย้ายไปยังโครงการอื่นได้อย่างปลอดภัยโดยไม่ต้องดูแลเกี่ยวกับการบำรุงรักษาในระยะยาว

นี่คือประสิทธิภาพที่เพิ่มขึ้น :)

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

ดังนั้นการเพิ่มผลิตภาพอาจเป็นตำนานสำหรับโครงการขนาดกลาง / ใหญ่ตลอดอายุการใช้งาน

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

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

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

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

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

อย่างไรก็ตามฉันเพิ่งเริ่มใช้ Haskell Haskell ให้ฉันเขียนบทคัดย่อรหัสทั่วไปได้อย่างง่ายดายเหมือนกับภาษาที่พิมพ์แบบไดนามิกใด ๆ ที่ฉันใช้ ตัวอย่าง Java / JavaScript ของฉันด้านบนไม่มีความหมายใน Haskell เนื่องจากไม่มีวัตถุวิธีการเหตุการณ์หรือแม้แต่การกลายพันธุ์มาก แต่รหัสทั่วไปประเภทอื่น ๆ นั้นง่ายต่อการเขียน

ในความเป็นจริง Haskell สามารถเขียนรหัสทั่วไปที่ภาษาที่พิมพ์แบบไดนามิกไม่สามารถทำได้ ตัวอย่างที่สมบูรณ์แบบคือฟังก์ชั่นที่เป็นพื้นตรงข้ามของread toStringคุณสามารถรับประเภทใดประเภทIntหนึ่งDoubleหรือหลายประเภทตามที่คุณต้องการ (ตราบใดที่ยังอยู่ในประเภทคลาสที่กำหนด) คุณยังสามารถมี polymorphic ค่าคงที่เพื่อให้maxBoundสามารถสูงสุดInt, Double, Char... ฯลฯ . ทั้งหมดขึ้นอยู่กับชนิดที่มันควรจะเป็น

ทฤษฏีของฉันในตอนนี้คือความสามารถในการผลิตเพิ่มขึ้นจากการใช้ภาษาแบบไดนามิกอยู่เสมอเมื่อเทียบกับภาษาอย่าง Java ที่มีความสามารถน้อยกว่าระบบ verbose และยืดหยุ่นน้อยกว่า

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

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

ถาม: ฉันมักจะได้ยินคำกล่าวอ้างว่าภาษาที่พิมพ์แบบไดนามิกนั้นมีประสิทธิภาพมากกว่าภาษาที่พิมพ์แบบคงที่ อะไรคือสาเหตุของการเรียกร้องนี้? "

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

นี่คือบางจุดที่ควรพิจารณา:

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

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

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

ห้องสมุดมาตรฐานขนาดใหญ่ Python โฆษณาอย่างมีชื่อเสียงในชื่อ "รวมแบตเตอรี่" เนื่องจากห้องสมุดมาตรฐานขนาดใหญ่ นี่เทียบกับ C ซึ่งมีไลบรารี่มาตรฐานที่เรียบง่ายมาก แต่ด้วยแพลตฟอร์มเช่น Java และ. net ไลบรารีมาตรฐานที่กว้างใหญ่กำลังกลายเป็นมาตรฐานและภาษาที่ใหม่กว่าอย่าง Scala และ F # กำลังสืบทอดสิ่งนี้ "ฟรี"

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

การปิดล้อมและแลมบ์ดา - โดยทั่วไปภาษาไดนามิกจะมีสิ่งนี้ตั้งแต่เริ่มต้น แต่ภาษาแบบสแตติกได้นำสิ่งนี้ไปใช้ Java ล่าสุด

REPLความสามารถในการทดสอบตัวอย่างโค้ดแบบโต้ตอบได้อย่างรวดเร็วนั้นเป็นประโยชน์อย่างมาก แต่ถึงแม้ว่าเครื่องมือ IDE เช่นหน้าต่าง "ทันที" ใน Visual Studio ภาษาคงที่สามารถเลียนแบบสิ่งนี้ได้ในระดับหนึ่ง

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

Bottom line: ในอดีตมันเป็นความจริง แต่วันนี้คำตอบคือการตัดที่ชัดเจนน้อยกว่า

ถาม: ดังนั้นสิ่งใดที่จะกล่าวถึงความสามารถในการผลิตด้วยการพิมพ์แบบไดนามิกที่เป็นข้อได้เปรียบของแบบจำลองประเภทเอง?

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

Reflection Reflection เป็นพื้นฐานของคุณสมบัติการพิมพ์แบบไดนามิก คุณตรวจสอบประเภทวัตถุที่ rater รันไทม์กว่าเวลารวบรวม เมื่อมันถูกนำมาใช้มันเป็นเรื่องขมวดคิ้ว แต่ใน C # การใช้งานของการสะท้อนจะแพร่หลายมากขึ้นตัวอย่างเช่น ASP.Net MVC ใช้การสะท้อนอย่างหนัก

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

Linq เป็น SQL, EF mv หม้อแปลง Linq ต่างๆตรวจสอบคำสั่งเป็นวัตถุรันไทม์และสร้าง sql ได้ทันที มันไม่ได้มีพลังมากกว่าการตรวจสอบโค้ดตอนรันไทม์ CodeDom เป็นอีกด้านหนึ่งของเหรียญซึ่งสามารถสร้างรหัสที่รันไทม์

โรสลิน โรสลินโดยทั่วไปดำเนินการevalซึ่งได้รับการพิจารณาเมื่อกำหนดคุณลักษณะของภาษาแบบไดนามิกอย่างแท้จริง

แบบไดนามิกdynamicชนิดเป็นคุณลักษณะแบบไดนามิกอย่างชัดเจนมากที่สุดใน C # และมีการโฆษณาที่จะทำให้การมีปฏิสัมพันธ์กับวัตถุภายนอกและภาษาที่เรียบง่ายและมีประสิทธิภาพมากขึ้น แต่มันยังใช้ใน Asp.net MVC เพื่อความสะดวก

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

คุณสมบัติภาษาทั้งหมดที่ทันสมัยมีขนาดใหญ่มากการพิมพ์แบบคงที่และแบบไดนามิกไม่ได้มีน้ำหนักมากนัก

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

ในอีกทางหนึ่งคุณมีภาษาจำนวนมากที่มีระบบการพิมพ์ที่แสดงออกซึ่งไม่เป็นไปตามที่คุณต้องการ และบางคนก็อนุญาตให้ฝังโค้ดที่ไม่ได้พิมพ์เมื่อใดก็ตามที่คุณต้องการหนีจากระบบประเภท

โดยส่วนตัวแล้วฉันใช้ haXe ซึ่งเป็นภาษาที่มีการอนุมานประเภททั้งการระบุย่อยและโครงสร้างย่อยรหัส untyped ที่เป็นตัวเลือกประเภทฟังก์ชั่นชั้นหนึ่งประเภทข้อมูลเกี่ยวกับพีชคณิตและแมโครมาโครเกี่ยวกับพีชคณิต หลังจากใช้ haXe มาประมาณ 3 ปีแล้วฉันก็มาถึงข้อสรุปง่ายๆ:

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

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

แต่อีกครั้งการพิมพ์แบบสแตติกคนเดียวไม่สามารถทำได้ มันเป็นเรื่องของการรวมกัน ฉันคิดว่าอยู่ระหว่าง F #, Scala, Nemerle, OCaml หรือ HaXe คุณสามารถหาจุดที่เหมาะสมที่สุดได้ แต่ท้ายที่สุดนั้นขึ้นอยู่กับคุณเพราะภาษาควรอนุญาตให้คุณฝังความคิดของคุณโดยไม่ต้องใช้ความพยายามแทนที่จะบังคับให้คุณงอมันรอบ ๆ และหลังจากทั้งหมดไม่มีอะไรให้ผลผลิตเพิ่มขึ้นมากกว่าการเขียนโปรแกรมสนุก

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

ฉันคิดว่าก่อนอื่นคุณต้องกำหนด "ผลิตภาพ" "ผลิตภาพ" หมายถึงอะไรและรวมถึงอะไร

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

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

ข้อได้เปรียบที่สำคัญของการพิมพ์แบบไดนามิกคือประสิทธิภาพ

Python, Ruby ฯลฯ มี boosters เพิ่มประสิทธิภาพอื่น ๆ อีกมากมายนอกเหนือจากการพิมพ์แบบไดนามิก (พารามิเตอร์เริ่มต้น, พจนานุกรมที่สร้างขึ้นในประเภทอื่น ๆ เป็นต้น) ผลกระทบสะสมต่อผลผลิตของโปรแกรมเมอร์นั้นน่าประทับใจ

บทลงโทษในแง่ของความเร็ว (หรือขาด!) ​​และการใช้ทรัพยากรนั้นไม่เลวร้ายอย่างที่คุณคาดหวังและในกรณีส่วนใหญ่มากกว่าการชดเชยด้วยความเร็วในการพัฒนาและความยืดหยุ่น

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

สิ่งที่อาจจะแตกต่างกันคือการศึกษาที่จะดำเนินการในวันนี้: -

1. Java JVMs ได้รับการพัฒนาให้ดียิ่งขึ้น
2. Modern IDEs จะปรับปรุงประสิทธิภาพของ C ++ และตัวแปลงสัญญาณ Java แต่สร้างความแตกต่างเพียงเล็กน้อยกับภาษาสคริปต์
3. จะรวม C # และอาจอยู่ใน ball ball เดียวกับ Java แต่ดีกว่าเล็กน้อย

ดังนั้นข้อความคือหากประสิทธิภาพเป็นภาษาที่มีปัญหาร้ายแรงจริงๆจะช่วยเพิ่มผลผลิตของคุณ