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

ฉันได้อ่านบทความบนอินเทอร์เน็ตเกี่ยวกับการเลือกภาษาโปรแกรมในองค์กร เมื่อเร็ว ๆ นี้ภาษาที่พิมพ์แบบไดนามิกจำนวนมากได้รับความนิยมเช่น Ruby, Python, PHP และ Erlang แต่องค์กรจำนวนมากยังคงอยู่กับภาษาที่พิมพ์แบบคงที่เช่น C, C ++, C # และ Java

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

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

แต่มีดูเหมือนจะเป็นคำวิจารณ์ที่แข็งแกร่งกับพิมพ์แบบไดนามิกในองค์กร แต่ฉันไม่ได้รับมันจริงๆว่าทำไมมันเป็นที่แข็งแกร่ง

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

ใช่ฉันเชื่อว่าพวกเขาทำ

มีเหตุผลบางประการที่ต้องพิจารณาในการเลือกภาษาสำหรับโครงการใหม่:

• ความเร็วรันไทม์ เมื่อเทียบกับ C / C ++ / Fortran, Perl และ Python ช้ามากมันตลกดี
• ความเร็วการเริ่มต้น เมื่อเปรียบเทียบกับภาษาที่รวดเร็วข้างต้นJava มีมากกว่าและร้องไห้เมื่อ JVM ทำการโหลดและโหลดและ ... while(1)....
• ต้นแบบความสามารถ การผ่านและการทำงานประกาศ / คำจำกัดความที่จำเป็นสำหรับ C ++ หรือ Java จะเพิ่ม LOC อย่างละเอียดซึ่งเป็นตัวชี้วัดที่เป็นที่รู้จักเพียงอย่างเดียวที่มีความสัมพันธ์อย่างน่าเชื่อถือกับ bugcounts นอกจากนี้ยังใช้เวลานานมาก นอกจากนี้ยังต้องใช้ความคิดอีกเล็กน้อยเกี่ยวกับประเภทและการเชื่อมต่อ
• Fiddlability ภายใน แบบไดนามิก messing รอบด้วย internals ของคุณเป็นที่ดีจนกว่าคุณจะเริ่มที่จะแก้ปัญหาของคุณรหัสตนเองการปรับเปลี่ยน (Python, Lisp, Perl)
• การตรวจสอบความถูกต้อง คอมไพเลอร์สามารถให้รหัสผ่านที่ถูกต้องแบบกึ่งสำเร็จในครั้งเดียวได้อย่างรวดเร็วใน C ++ และนี่อาจเป็นสิ่งที่ดีจริงๆ
• รายละเอียดการวิเคราะห์แบบคงที่ C และ Java มีการวิเคราะห์สแตติกที่ดีพอสมควร Perl นั้นไม่สามารถวิเคราะห์ได้อย่างคงที่ในระดับทฤษฎี (อาจเป็น Python ด้วย) ฉันค่อนข้างแน่ใจว่า LISP ไม่เหมือนกัน
• แพลตฟอร์มแปลก ๆ ใช้ C เท่านั้นโดยทั่วไป
• ห่วงโซ่การสนับสนุน ถ้าคุณสามารถมีสัญญาที่คุณจะได้รับข้อบกพร่องของคุณมองไปที่และทำงานในที่มีขนาดใหญ่

หากคุณสามารถสันนิษฐานได้ว่าองค์กรที่คุณทำงานด้วยมีหลักการ "ก้าวไปข้างหน้า" (มีข้อกำหนดทางบัญชีสำหรับเรื่องนี้) และจะไม่เพียงแค่เลือกที่จะไม่ทำงานกับซอฟต์แวร์คุณจะมีกรณีที่ดีกว่ามากสำหรับ ใช้ซอฟต์แวร์ เนื่องจากไม่มีการขายธุรกิจที่สำคัญ(มีนัยในการรับผิดชอบในการดูแลรักษา) Python / Perl / $ dynamic_language จึงช่วยลดความเสี่ยงได้อย่างมาก

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

แน่นอนว่าฉันไม่ได้พูดถึงโลกของ webapp / startup ซึ่งมีแนวโน้มที่จะเล่นโดยกฎความเสี่ยงสูง / รางวัลสูงและเปิดกว้างมากที่จะอยู่บนขอบของเทคโนโลยี

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

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

และอย่าลืมรหัสที่เขียนใน VBA!

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

รัฐวิสาหกิจทำดูแลเกี่ยวกับ:

• ค่าใช้จ่ายในการบำรุงรักษาระยะยาว : คุณสามารถคาดหวังว่าสิ่งต่าง ๆ จะยังคงทำงานได้ดีในเวลา 10 ปี? มันเป็นสิ่งที่ดีถ้าวิวัฒนาการทางภาษานั้นอนุรักษ์นิยมและเข้ากันได้ย้อนหลัง (เช่นเดียวกับ Java) การพิมพ์แบบสแตติกมีประโยชน์ที่นี่เพราะมันจะจับข้อบกพร่องหลัก ๆ ในเวลารวบรวมก่อนที่มันจะเข้าสู่ระบบการผลิตของคุณ .....
• ความพร้อมใช้งานที่มีความสามารถ - คุณจะสามารถค้นหานักพัฒนาเพื่อรักษาระบบใหม่ของคุณได้หรือไม่? จะเกิดอะไรขึ้นถ้านักพัฒนาดั้งเดิมออกไปทุกคนจะเข้าใจรหัสหรือไม่ สิ่งนี้ทำให้เกิดอุปสรรคสูงในการแนะนำภาษา "ใหม่" ใด ๆ (โดยเฉพาะอย่างยิ่งถ้ามันยังสร้างข้อกำหนดใหม่สำหรับการปรับใช้สร้างระบบสนับสนุนการดำเนินงาน ฯลฯ ) สิ่งนี้ให้ประโยชน์อย่างมากกับภาษาที่ใช้กันอย่างแพร่หลาย (C, C ++, C # และ Java)
• ค่าใช้จ่ายในการรวมระบบ : เป็นเรื่องง่ายที่จะเชื่อมต่อ / รวมเข้ากับเทคโนโลยีอื่น ๆ ที่คุณมีอยู่แล้วหรือมีแนวโน้มที่จะได้รับ? หากคุณมีระบบ J2EE รุ่นเก่าอยู่แล้วคุณจำเป็นต้องรวมเข้ากับระบบเหล่านั้น โซลูชัน Java EE ใหม่มีแนวโน้มที่จะใช้งานได้จริงมากกว่านี้เช่น Python
• Predicatbility / low risk : เป็นแพลตฟอร์ม / ภาษาที่พิสูจน์แล้วและฉันสามารถมั่นใจได้ว่ามันจะทำงานได้หรือไม่ ซึ่งมักจะเป็นมากขึ้นที่สำคัญกว่าการผลิตที่เรียบง่าย มันง่ายกว่ามากสำหรับผู้จัดการที่จะชักชวนให้เจ้านายของเขามอบงบประมาณขนาดใหญ่สำหรับกำลังคนในการสร้างระบบใหม่กว่าที่เขาจะต้องกลับไปในภายหลังและบอกว่ามันไม่ได้ทำงาน .....
• การสนับสนุนองค์กร / การสนับสนุน - องค์กรระหว่างประเทศที่สำคัญมุ่งมั่นที่จะสนับสนุนภาษาและแพลตฟอร์มหรือไม่ พวกเขาจะลงนามในสัญญาเพื่อสนับสนุนฉันหรือไม่
• ความเป็นกลางของผู้ขาย / แพลตฟอร์มอิสระ - ฉันจะถูกล็อคเข้ากับซัพพลายเออร์รายเดียวหรือไม่ หรือฉันมีทางเลือก / เส้นทางการเปลี่ยนผ่านของผู้จัดหาในอนาคตมากมาย คุณไม่ต้องการที่จะติดอยู่ในทางตันสถาปัตยกรรมไม่สามารถก้าวหน้าได้ในขณะที่คู่แข่งของคุณกินอาหารกลางวันของคุณ หากคุณทำงานอย่างถูกต้องในฐานะสถาปนิกขององค์กรคุณต้องคิดล่วงหน้าอย่างน้อย 5-10 ปีสำหรับสิ่งนี้

โดยส่วนตัวแล้วฉันคิดว่าถ้าคุณต้องการใช้ภาษาแบบไดนามิกใน Enterprise โอกาสที่ดีที่สุดของคุณคือการใช้บางสิ่งที่หมูหยอดบนระบบนิเวศขององค์กรที่มีอยู่ สิ่งที่น่าสังเกตมากที่สุดคือภาษา JVM แบบไดนามิกใหม่: เช่น JRuby, Groovy, Clojure เท่าที่ฝ่ายบริหารไอทีกังวลสิ่งเหล่านี้คือตัวเลือกภาษาแบบไดนามิกที่ "ปลอดภัย" เนื่องจากทำงานภายในและเล่นได้ดีกับระบบนิเวศองค์กรส่วนที่เหลือของ Java

เหตุผลหลักที่องค์กรไม่เริ่มใช้ภาษาอย่าง Erlang, Ruby และ Python ดูเหมือนว่าพวกเขาเป็นแบบไดนามิก

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

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

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

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

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

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

ภาษาที่พิมพ์แบบไดนามิกนั้นช้ากว่าภาษาที่พิมพ์แบบคงที่ (แต่เราจะดูว่าการเปลี่ยนแปลง JIT ทำงานได้ดีเพียงใด)

หมายเหตุ: ส่วนใหญ่จะเป็นอัตนัยและขึ้นอยู่กับประสบการณ์และความประทับใจของฉัน

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

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

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

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

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

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

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

tl; dr:ภาษาแบบคงที่รู้สึกเหมือนระบบราชการมากขึ้นดังนั้นผู้จัดการระดับมืออาชีพก็ชอบพวกเขาดีกว่า

ไม่ฉันไม่คิดว่าภาษาที่พิมพ์แบบไดนามิกควรได้รับการวิจารณ์ทั้งหมด (หรือหากคุณต้องการพวกเขาสมควรได้รับการวิจารณ์มากพอ ๆ กับภาษาที่พิมพ์แบบคงที่)

จากประสบการณ์ของฉัน (และฉันไม่พยายามที่จะพูดคุยเรื่องนี้กับคนทั่วไป) โปรแกรมเมอร์ที่วิจารณ์ภาษาแบบไดนามิกไม่ได้ใช้มัน บทสนทนามักจะ "แต่ด้วยการพิมพ์คอมไพเลอร์คงที่จับข้อผิดพลาดมากมาย!" และฉันพูดว่า "ดีนั่นไม่ใช่แค่ปัญหาในประสบการณ์ของฉัน" (โดยปกติแล้วโปรแกรมเมอร์คนอื่น ๆ จาก Java, Delphi หรือพื้นหลังที่คล้ายกันฉันไม่รู้จักโปรแกรมเมอร์ Haskell หรือ ML)

สิ่งเดียวที่มันเจ็บปวดฉันคือเมื่อการเรียกร้องคนที่เทคนิคฟูไม่สามารถเป็นไปได้ที่จะทำ (หรืออาจจะเป็นเรื่องยากมากที่จะทำ) ในภาษาพิมพ์แบบไดนามิก ... เมื่อเทคนิคที่ถูกประดิษฐ์ขึ้นในโดยและสำหรับพิมพ์แบบไดนามิก ภาษา. IDEs? หูฟัง. การปรับโครงสร้างใหม่อัตโนมัติหรือไม่ หูฟัง. โทรติดต่อของ / implementors ของ? หูฟัง.

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