ทำไมคำถาม“ ให้ห้าสิ่งที่คุณเกลียดเกี่ยวกับ C #” นั้นตอบยากในระหว่างการสัมภาษณ์? [ปิด]

ในพอดคาสต์ 73โจเอลสปอลสกี้และเจฟฟ์แอทวู้ดพูดคุยกันในหมู่เรื่องอื่น ๆ "ห้าสิ่งที่ทุกคนควรเกลียดเกี่ยวกับภาษาโปรแกรมที่พวกเขาโปรดปราน":

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

ฉันถามคำถามนี้กับผู้สมัครที่ฉันสัมภาษณ์ ไม่มีใครสามารถอ้างอย่างน้อยสิ่งหนึ่งที่พวกเขาเกลียดเกี่ยวกับ C # ¹

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

มีคำถามเกี่ยวกับคำถามนี้ซึ่งทำให้แย่สำหรับการสัมภาษณ์หรือไม่?

เห็นได้ชัดว่ามันไม่ได้หมายความว่า C # นั้นสมบูรณ์แบบ ฉันมีรายการห้าสิ่งที่ฉันเกลียดเกี่ยวกับ C #:

• การขาดจำนวนตัวแปรชนิดใน generics (คล้ายกับparamsอาร์กิวเมนต์)
  Action<T>,
  Action<T1, T2>,
  Action<T1, T2, T3>,
        ⁞ อย่างจริงจัง ?!
  Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
  

• การขาดการสนับสนุนหน่วยวัดเช่นใน F #

• การขาดคุณสมบัติอ่านอย่างเดียว การเขียนprivate readonlyเขตข้อมูลสำรองทุกครั้งที่ฉันต้องการให้คุณสมบัติอ่านอย่างเดียวน่าเบื่อ

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

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

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

^{people คนไม่กี่คนวิพากษ์วิจารณ์การชุมนุมบางอย่างใน. NET Framework หรือขาดห้องสมุดบางอย่างในกรอบหรือวิพากษ์วิจารณ์ CLR นี้ไม่นับเนื่องจากคำถามเกี่ยวกับภาษาของตัวเองและในขณะที่ฉันอาจยอมรับคำตอบเกี่ยวกับสิ่งที่เป็นลบในแกนกลางของ. NET Framework (ตัวอย่างเช่นสิ่งที่ดูเหมือนว่าไม่มีอินเทอร์เฟซทั่วไปสำหรับTryParseดังนั้นหาก คุณต้องการที่จะแยกสตริงเป็นหลายประเภทคุณต้องทำซ้ำตัวเองสำหรับทุกประเภท) คำตอบเกี่ยวกับ JSON หรือ WCF นอกหัวข้อทั้งหมด}

ถ้าฉันจะต้องเดา:

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

2. โปรแกรมเมอร์บางคนเป็นเพียงรหัสลิง พวกเขาแทบจะวิเคราะห์ปัญหาที่อยู่ตรงหน้าพวกเขาอย่างเดียวอย่างเช่นวิธีการเขียนโปรแกรมภาษาของพวกเขาจะดีขึ้น

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

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

ฉันคิดว่าคำถามนี้ยากที่จะตอบในระหว่างการสัมภาษณ์เพราะ:

1. คาดไม่ถึงจริงๆ

2. ต้องใช้ความคิดมากและการคิดต่างไปจากที่ใช้ในการสัมภาษณ์

3. เป็นการยากที่จะตอบโดยทั่วไปในระยะเวลาอันสั้น (เว้นแต่จะเตรียมไว้ก่อนการสัมภาษณ์)

1. มันไม่คาดคิด

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

- อะไรคือความแตกต่างระหว่างHashSet<T>และList<T>?
- hashset ได้รับการปรับให้เหมาะสมที่สุดในการค้นหาองค์ประกอบที่รวดเร็วมาก ตัวอย่างเช่นหากคุณใช้set.Contains()ภายในวงวนมากการย้ายsetจากรายการไปยังแฮชเซ็ตอาจทำให้สิ่งต่าง ๆ เร็วขึ้น
- คุณสร้างคุณสมบัติอ่านอย่างเดียวได้อย่างไร
- ฉันใช้เขตข้อมูลที่ทำเครื่องหมายว่าreadonlyเป็นเขตข้อมูลสำรองสำหรับคุณสมบัติที่มีเพียงผู้ทะเยอทะยาน
- การใช้งานของsealedคืออะไร?
- คุณใช้สำหรับคลาสที่ต้องไม่สืบทอด
- ครั้งสุดท้ายที่คุณเห็นหมอฟันคืออะไร?
- อะไร?!

2. มันต้องการความแตกต่างมากมายความคิดที่

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

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

3. ต้องใช้เวลา

ตรงไปตรงมาฉันมีรายการสิ่งที่ฉันเกลียดห้ารายการ (มากกว่าจริง) ห้ารายการ แต่ฉันคิดถึงเรื่องนี้เป็นระยะเวลานาน บางสิ่งมาจากยุค. NET Framework 2; ปัญหาส่วนใหญ่ที่ฉันระบุไว้สำหรับ. NET Framework 2 นั้นไม่ถูกต้องอีกต่อไปเพราะมันถูกลบออกบางส่วนมี LINQ และสิ่งที่โปรแกรมการทำงานทั้งหมดนี้อื่น ๆ ที่มีการเขียนโปรแกรมแบบไดนามิก ฉันไม่แน่ใจว่าหากไม่ได้เตรียมคำถามนี้ฉันจะสามารถค้นหาองค์ประกอบทั้งห้าได้ในระหว่างการสัมภาษณ์

ฉันคิดว่ามันเป็นเรื่องยากเพราะของคำว่าห้า และในระดับน้อยเพราะของคำว่าความเกลียดชัง

ห้า ? จะเกิดอะไรขึ้นถ้าคุณมีเพียงสี่คนเท่านั้น? คุณไม่สามารถตอบคำถามได้หรือไม่ เกิดอะไรขึ้นถ้าคุณมีมากขึ้นกว่าห้า? ตอนนี้คุณต้องหาว่าอันไหนดีที่สุดในการใช้ห้าอัน

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

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

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

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

ในคำอื่น ๆ See-Sharpers ถือว่าค่อนข้างดีทุกสิ่งที่พิจารณา

นี่คือรายการของฉัน:

• คำสั่งแลมบ์ดาไม่สามารถดู / ประเมินผลได้ วิธีการโทรไปยังชื่อที่กำหนดสามารถเสียบเข้ากับ QuickWatch ของ VS ดังนั้นการแสดงออกสามารถ แต่ลูกแกะ? ไม่ (อย่างน้อยไม่ได้อยู่ใน VS2010) ทำการดีบัก Linq เชนงานน่าเบื่อจริง

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

• C # จะกลายเป็นพอเก่าจะมีปัญหารหัสเดิมที่ร้ายแรง โค้ดที่เขียนขึ้นสำหรับ 1.1 นั้นจะทำให้ทุกคนที่เคยใช้ 4.0 เพื่อประจบประแจงด้วยความสยองขวัญ แม้กระทั่งรหัส 2.0 ที่พลาดไปมากมาย ในเวลาเดียวกันห้องสมุดของบุคคลที่สามได้เข้ามาทำให้สิ่งต่าง ๆ เช่น ADO.NET ดูดั้งเดิมอย่างน่ารังเกียจ แต่สำหรับความเข้ากันได้แบบย้อนหลัง. NET schleps พร้อมรองรับโค้ดเก่า ๆ ที่ไม่ดีไม่กล้าพูดอะไรบางอย่างเช่น "ArrayList เป็นวิธีที่แย่มากที่จะทำเราเสียใจที่เราใส่มันเข้าไป List<Object>มันออกรายการใช้แทนและหากคุณต้องการอย่างรายการของชนิดที่แตกต่างกันประกาศว่ามันเป็น

• อย่างจริงจังกฎคำสั่งสวิทช์ จำกัด อาจเป็นหนึ่งในสิ่งที่ดีที่สุดที่ฉันสามารถพูดเกี่ยวกับ PowerBuilder คืออนุญาตให้ใช้คำสั่ง Choose Case (เทียบเท่ากับสวิตช์) ที่อนุญาตให้ใช้นิพจน์บูลีนตามตัวแปร นอกจากนี้ยังอนุญาตให้สลับคำสั่งร่วงผ่านแม้ว่าจะมีรหัสก็ตาม ฉันเข้าใจเหตุผลที่ว่าสิ่งที่สองไม่ได้รับอนุญาต (มีแนวโน้มที่จะทำโดยไม่ตั้งใจมากกว่าที่ตั้งใจ) แต่มันก็ยังดีในบางครั้งในการเขียนข้อความเช่น:

  switch(someInt)
  {
      case < 0: //all negative values enter here
         //...
         break;
      case 0: 
         //...
         break;
      case 1:
         //...
         //no break; continue through to the code for > 1
      case > 1 // all positive values enter here (including 1)
         //...
         break;
  }

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

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

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

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

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

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

หากไม่มีการขุดพอคุณจะไม่ไปถึงขีด จำกัด ของภาษาและหวังว่าพวกเขาจะหายไป ห้าอันดับแรกของฉันในกรณีที่มีใครสงสัย

1. วัตถุที่ไม่เปลี่ยนรูปต้องมีพิธีจำนวนมากในการสร้าง (ตรงข้ามกับภาษาที่ใช้งานได้ซึ่งวัตถุจะไม่เปลี่ยนรูปโดยค่าเริ่มต้น)
2. Metaprogramming นั้นทำได้ยาก เปรียบเทียบ type emit กับ Lisp macros (บริการคอมไพเลอร์จะช่วยได้มากในเรื่องนี้ในอนาคต)
3. วิธีการขยายที่ยอดเยี่ยม ... คุณสมบัติส่วนขยายและตัวดำเนินการส่วนขยาย (โดยเฉพาะตัวดำเนินการโดยนัยและโดยชัดแจ้ง) จะดีกว่า
4. การปลดเปลื้องอย่างชัดเจนได้รับการแก้ไขในเวลารวบรวมแทนที่จะใช้เวลาทำงาน
5. ไม่มีลำดับที่ตรงกันมันสะอาดกว่าฟังก์ชั่นมากไป

ฉันคิดว่าในรอบของเขาเกี่ยวกับวิธีที่เขาพูด ถ้าคุณคิดว่ามันพังคุณอาจไม่เข้าใจว่าทำไมมันถึงเป็นแบบนั้น อาจมีรูในความรู้ของคุณ

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

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

ผู้ให้สัมภาษณ์อยู่ภายใต้แรงกดดันอย่างมากที่จะยังคงมองโลกในแง่ดีระหว่างการสัมภาษณ์

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

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

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

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

และเมื่อคุณกลับมาที่ C # คุณจะเป็นเหมือน "ทำไมฉันต้องใช้ C # ถึงหนึ่งร้อยบรรทัดเพื่อทำสิ่งง่าย ๆ นี้นั่นเป็นเพียงหนึ่งบรรทัดใน Haskell" คุณจะเกลียดหลายสิ่งเกี่ยวกับ C #

• C # ไม่มีประเภทการอ้างอิงที่ไม่เป็นโมฆะ
• ไม่มีประเภทข้อมูลเกี่ยวกับพีชคณิต
• ไม่มีการแก้ไขสตริง
• ไวยากรณ์มีความหมายมากเกินไปทุกที่
• ไม่มีระบบมาโคร
• การอนุมานประเภทมี จำกัด
• ไม่มีตัวอักษร regexp
• ไม่มีการพิมพ์โครงสร้าง
• การสนับสนุนที่ไม่ดีสำหรับการเปลี่ยนไม่ได้
• C # structs เกิดข้อผิดพลาดได้ง่าย
• ไลบรารีคอลเลกชันมาตรฐานมี จำกัด มาก
• ไม่สามารถกำหนดข้อ จำกัด เกี่ยวกับพารามิเตอร์ของตัวสร้าง
• ไม่สามารถตั้งโปรแกรมโดยทั่วไปด้วยข้อ จำกัด เกี่ยวกับตัวดำเนินการทางคณิตศาสตร์
• ไม่ใช่ 'newtype'
• ไม่มีการแบ่งอาร์เรย์ไม่มีช่วงตัวอักษร
• ฟังก์ชั่นไม่แสดงรายการผลข้างเคียงที่พวกเขาสามารถทำได้โดยเป็นส่วนหนึ่งของประเภท :)

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

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