มีความสัมพันธ์ระหว่างขนาดของโครงการและความเข้มงวดของภาษาหรือไม่

การอธิบายถึงความแตกต่างระหว่างความเข้มงวดของภาษาและกระบวนทัศน์ต่อเพื่อนร่วมงานของฉันฉันจึงยืนยันว่า:

• ภาษาที่ทนทานเช่นภาษาที่มีการเปลี่ยนแปลงและถูกตีความใช้ดีที่สุดสำหรับต้นแบบและโครงการขนาดเล็กหรือเว็บแอปพลิเคชันขนาดกลาง เมื่อเลือกภาษาไดนามิกที่หรูหราเช่น Python หรือ JavaScript ที่มี Node.js ประโยชน์คือ:

  1. การพัฒนาที่รวดเร็ว

  2. ลดรหัสสำเร็จรูป

  3. ความสามารถในการดึงดูดโปรแกรมเมอร์หนุ่มสาวผู้สร้างสรรค์ที่หนี“ ภาษาองค์กร”   เช่น Java

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

  1. กระบวนทัศน์และรูปแบบที่รู้จักกันดีพัฒนามานานหลายทศวรรษ

  2. ความง่ายในการตรวจสอบแบบคงที่

  3. ความสามารถในการค้นหานักพัฒนามืออาชีพจำนวนมากที่มีประสบการณ์มานานหลายทศวรรษ

• ภาษาที่เข้มงวดเช่น Haskell, Ada หรือเทคนิคต่าง ๆ เช่นสัญญา Code ใน C # นั้นดีกว่าสำหรับระบบที่ให้ความปลอดภัยมากกว่าความยืดหยุ่น (แม้ว่า Haskell จะมีความยืดหยุ่นสูงมาก) เช่นระบบที่มีความสำคัญต่อชีวิตและระบบซึ่งคาดว่าจะเสถียรมาก ประโยชน์คือ:

  1. ความสามารถในการจับข้อบกพร่องให้ได้มากที่สุดในเวลารวบรวม

  2. ความง่ายในการตรวจสอบแบบคงที่

  3. ความง่ายในการพิสูจน์อย่างเป็นทางการ

อย่างไรก็ตามโดยดูที่ภาษาและเทคโนโลยีที่ใช้สำหรับโครงการขนาดใหญ่โดย บริษัท ขนาดใหญ่, ดูเหมือนว่าการยืนยันของฉันเป็นสิ่งที่ผิด ตัวอย่างเช่น Python ใช้สำหรับระบบขนาดใหญ่เช่น YouTube หรือแอปพลิเคชันอื่น ๆ ของ Google ที่ต้องการความเข้มงวดเป็นจำนวนมาก

ยังมีความสัมพันธ์ระหว่างขนาดของโครงการและความเข้มงวดของภาษา / กระบวนทัศน์ที่ควรใช้หรือไม่?

มีปัจจัยที่สามที่ฉันลืมที่จะคำนึงถึง?

ฉันผิดตรงไหน

กรณีศึกษาที่น่าสนใจในเรื่องของโครงงานขนาดที่ใช้ภาษาไดนามิกและการตีความสามารถพบได้ในBeginning Scalaโดย David Pollak

ฉันเริ่มค้นหาวิธีในการแสดงรหัสในสมองของฉันในวิธีที่ง่ายกว่าและตรงกว่ามากขึ้น ฉันพบ Ruby และ Rails ฉันรู้สึกเป็นอิสระ Ruby อนุญาตให้ฉันแสดงแนวคิดในบรรทัดของโค้ดที่น้อยลง Rails นั้นใช้งานได้ง่ายกว่า Spring MVC, Hibernate และเฟรมเวิร์กเว็บ Java“ คล่องตัว” อื่น ๆ ด้วย Ruby และ Rails ฉันต้องแสดงให้เห็นถึงสิ่งที่อยู่ในหัวของฉันในเวลาอันสั้น มันคล้ายกับการปลดปล่อยที่ฉันรู้สึกเมื่อฉันย้ายจาก C ++ เป็น Java ...

เมื่อโครงการ Ruby และ Rails ของฉันเติบโตเกินกว่าสองสามพันบรรทัดของรหัสและเมื่อฉันเพิ่มสมาชิกในทีมของฉันโครงการความท้าทายของภาษาแบบไดนามิกก็ชัดเจน

เรามีค่าใช้จ่ายมากกว่าครึ่งหนึ่งของการเขียนโปรแกรมการทดสอบการเขียนเวลาของเราและมากของกำไรจากการผลิตที่เราเห็นได้หายไปในการเขียนการทดสอบ การทดสอบส่วนใหญ่นั้นไม่จำเป็นใน Java เพราะส่วนใหญ่จะทำการทดสอบเพื่อให้แน่ใจว่าเราได้อัพเดตผู้โทรเมื่อเรา refactored code โดยการเปลี่ยนชื่อเมธอดหรือจำนวนพารามิเตอร์ นอกจากนี้ผมพบว่าการทำงานกับทีมที่มีความคิดผสมผสานระหว่าง 2-4 สมาชิกในทีมเป็นสิ่งที่เป็นไปด้วยดีในรูบี แต่ในขณะที่เราพยายามที่จะนำสมาชิกใหม่เข้าสู่ทีมในการเชื่อมต่อจิตยากที่จะส่งไปยังสมาชิกในทีมใหม่

ฉันไปหาภาษาใหม่และสภาพแวดล้อมการพัฒนา ฉันกำลังมองหาภาษาที่มีความหมายเหมือน Ruby แต่ปลอดภัยและมีประสิทธิภาพสูงเท่ากับ Java ...

อย่างที่คุณเห็นความท้าทายที่สำคัญในการปรับขนาดโครงการสำหรับผู้เขียนกลายเป็นการทดสอบการพัฒนาและการถ่ายโอนความรู้

โดยเฉพาะอย่างยิ่งผู้เขียนเข้าไปในรายละเอียดเพิ่มเติมในการอธิบายความแตกต่างในการเขียนการทดสอบระหว่างภาษาที่พิมพ์แบบไดนามิกและแบบคงที่ในบทที่ 7 ในส่วน "Bunnies ฆ่า Poignantly: Stairs Dwemthy '" กล่าวถึง Scala พอร์ตของตัวอย่างทับทิมเฉพาะ:

ทำไม Lucky Stiff ... แนะนำแนวคิดของ Metaprogrammingของ Ruby ในArray ของ Dwemthyที่กระต่ายต่อสู้กับสิ่งมีชีวิตหลายชนิด N8han14 อัปเดตตัวอย่างเพื่อทำงานใน Scala ...

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

ในทางกลับกันผลลัพธ์นั้นมีประสิทธิภาพมากกว่ารุ่น Ruby หากเราต้องเขียนการทดสอบสำหรับรหัส Ruby ของเราเพื่อทดสอบสิ่งที่คอมไพเลอร์ Scala มั่นใจกับเราเราจะต้องมีโค้ดอีกหลายบรรทัด ตัวอย่างเช่นเราสามารถมั่นใจได้ว่ากระต่ายของเราไม่สามารถขวานได้ ในการรับการรับรองนี้ใน Ruby เราจะต้องเขียนการทดสอบเพื่อให้แน่ใจว่าการเรียกใช้|^Rabbit นั้นล้มเหลว Scala เวอร์ชันของเราช่วยให้มั่นใจได้ว่ามีเพียงอาวุธที่กำหนดไว้สำหรับสิ่งมีชีวิตที่กำหนดเท่านั้นที่สามารถใช้งานได้โดยสิ่งมีชีวิตนั้นสิ่งที่จะต้องใช้จำนวนมากของการสะท้อนภาพ runtime ใน Ruby ...

การอ่านด้านบนสามารถทำให้คิดได้ว่าเมื่อโครงการขยายใหญ่ขึ้นการเขียนทดสอบอาจกลายเป็นเรื่องยุ่งยาก การใช้เหตุผลนี้จะผิดเนื่องจากเป็นตัวอย่างของโครงการขนาดใหญ่ที่ประสบความสำเร็จซึ่งกล่าวถึงในคำถามนี้ ("Python ใช้สำหรับ ... YouTube" สำเร็จแล้ว)

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

Youtube ห้องทดสอบหรือชุด Java ความเข้ากันได้แน่ใจว่าอาศัยอยู่ที่แตกต่างกันชีวิตกว่าการทดสอบในโครงการกวดวิชาเล็ก ๆ เช่นอาร์เรย์ Dwemthy ของ

การยืนยันของคุณไม่ผิด คุณต้องขุดให้ลึกลงไปอีกหน่อย

พูดง่ายๆระบบใหญ่ใช้หลายภาษาไม่ใช่แค่ภาษาเดียว อาจมีบางส่วนที่สร้างขึ้นโดยใช้ภาษา "เข้มงวด" และอาจมีบางส่วนที่สร้างขึ้นโดยใช้ภาษาแบบไดนามิก

สำหรับตัวอย่าง Google และ YouTube ของคุณฉันได้ยินมาว่าพวกเขาใช้ Python เป็นหลักในการ "กาว" ระหว่างระบบต่างๆ มีเพียง Google เท่านั้นที่รู้ว่าระบบเหล่านั้นถูกสร้างขึ้นมาด้วย แต่ฉันคิดว่าระบบที่สำคัญของ Google นั้นถูกสร้างขึ้นโดยใช้ภาษาที่เข้มงวดและ "องค์กร" เช่น C ++ หรือ Java หรืออาจเป็นสิ่งที่พวกเขาสร้างขึ้นเองเช่น Go

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

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

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

ส่วน "ไดนามิก" ของภาษาการเขียนโปรแกรมแบบไดนามิกเป็นเพียงสถานที่ที่จะทำการตรวจสอบประเภท ในภาษาการเขียนโปรแกรมแบบ "พิมพ์แบบไดนามิก" การตรวจสอบชนิดจะทำในขณะที่ดำเนินการคำสั่งแต่ละคำสั่งในขณะที่การตรวจสอบประเภท "ภาษาที่พิมพ์แบบคงที่" จะทำในเวลารวบรวม และคุณสามารถเขียนล่ามสำหรับภาษาการเขียนโปรแกรมแบบคงที่ (เช่นemscriptemทำ) และคุณยังสามารถเขียนคอมไพเลอร์แบบคงที่สำหรับภาษาการเขียนโปรแกรมแบบไดนามิก (เช่นgcc-pythonหรือshed-skin )

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

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

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

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

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

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

ต้องบอกว่าภาษาใด ๆ ที่ช่วยให้คุณเขียนรหัสได้อย่างมีนัยสำคัญน้อยกว่านั้นต้องคุ้มที่จะดู (เช่น Python vs Java) บางทีอนาคตอาจเป็นภาษาที่ฉลาดและพิมพ์ได้แบบคงที่พร้อมการอนุมานประเภทขั้นสูง (เช่นในรูปแบบสกาล่า) หรือไฮบริดเช่น C # กำลังพยายามมีตัวระบุdynamic...

และอย่าลืมประโยชน์การพิมพ์แบบคงที่ "อื่น ๆ ": การเติมโค้ด IDE ที่สมบูรณ์ / intellisense ที่เหมาะสมซึ่งในมุมมองของฉันเป็นคุณลักษณะที่สำคัญไม่ใช่การปรับแต่งที่ดี

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

ฉันได้รับการบอกว่า "เราไม่สามารถใช้ Ruby on Rails ได้เพราะเป็นโอเพ่นซอร์สและบางคนสามารถแฮ็กข้อมูลที่สำคัญหรือมีการป้องกันไว้ได้" ฉันขอโทษ แต่เมื่อมีคนคิดว่าโอเพนซอร์ซ == ชั่วร้ายมันแทบจะเป็นไปไม่ได้เลยที่จะเปลี่ยนแปลง แนวความคิดนั้นเป็นโรคขององค์กร

C # และ Java เป็นที่เชื่อถือได้ภาษาที่มีความน่าเชื่อถือแพลตฟอร์ม Ruby และ Python ไม่ใช่ภาษาที่เชื่อถือได้