คำถามติดแท็ก programming-practices

ฉันกำลังศึกษาอัลกอริธึมเล็กน้อยและดูที่ไซต์อย่าง SPOJ.pl TopCoder เป็นต้นฉันเคยเห็นว่าโปรแกรมเมอร์ชอบ C หรือ C ++ สำหรับการแข่งขันเขียนโปรแกรมอัลกอริทึมส่วนใหญ่ ตอนนี้ฉันมีปัญหาบางอย่างเมื่อเร็ว ๆ นี้ ฉันรู้ทั้ง C และ Python เล็กน้อยและเมื่อพยายามเขียนรหัสฉันดูเหมือนจะชอบ Python มากกว่า C สำหรับอัลกอริธึมส่วนใหญ่ ทุกครั้งที่ฉันนั่งลงเพื่อเขียนรหัสใน CI ยอมแพ้หลังจากนั้นประมาณ 15 นาทีเพราะฉันพบว่ามันยุ่งยากเกินไปและมีแนวโน้มที่จะย้ายไปยังงูใหญ่ การผ่านการฝึกอบรมพอยน์เตอร์พอยน์เตอร์และอื่น ๆ ดูเหมือนจะเป็นเวลาที่ไร้ประโยชน์ที่ฉันสามารถใช้คิดเกี่ยวกับอัลกอริทึมได้จริง ตอนนี้ฉันรู้แล้วและได้ยินจากผู้คนมากมายว่า C เป็นภาษาที่สำคัญมากและเป็นขนมปังและเนยของโปรแกรมเมอร์จำนวนมาก สิ่งที่ฉันอยากรู้คือวิธีการของฉันนี้มีข้อบกพร่อง / ผลกระทบ / ข้อเสียอื่น ๆ หรือไม่ นี่ไม่ใช่การอภิปราย Python vs C; นี่เป็นคำถามเกี่ยวกับวิธีปฏิบัติที่เจาะจงของการเลือกไพ ธ อนมากกว่า C เนื่องจากความสะดวกในการใช้งานจะส่งผลกระทบต่อฉันหรือโปรแกรมเมอร์ / นักวิทยาศาสตร์คอมพิวเตอร์คนอื่น …

16 algorithms  python  c  programming-practices  self-improvement 

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

16 programming-practices  optimization  multi-platform 

ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้เป็นหัวข้อสำหรับ Software Engineering Stack Exchange ปิดให้บริการใน4 ปีที่แล้ว ฉันเคยเขียน C ++ อย่างกว้างขวางระหว่าง 8 และ 10 ปีที่แล้ว ฉันได้ย้ายไปยัง C # ด้วยเหตุผลมืออาชีพ อย่างไรก็ตามบางครั้งฉันเห็นข้อความชอบ "หากคุณยังคงติดตามการอ้างอิงตัวชี้ด้วยตนเองคุณกำลังทำผิด" หรือ "C ++ มีความปลอดภัยอย่างสมบูรณ์แบบตราบใดที่คุณใช้แนวคิดสมัยใหม่เช่น RAII และไม่ได้จัดสรรหน่วยความจำด้วยตนเองเช่นนักพัฒนา C ที่กู้คืน" ทั้งสองเป็นขั้นตอนมาตรฐานเมื่อสิบปีที่แล้ว ฉันได้เห็นว่า C ++ ได้รับการปรับปรุงอย่างมากในช่วงเวลาที่ผ่านมา; โดยเฉพาะอย่างยิ่ง C ++ 0x ดูเหมือนจะมีความสามารถใหม่ ๆ แหล่งข้อมูลที่ดีที่สุดสำหรับโปรแกรมเมอร์ "C / old C ++" …

16 c++  design-patterns  c  programming-practices  c++11 

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

16 programming-practices  design-patterns  anti-patterns 

พิจารณา: public class CtorInjectionExample { public CtorInjectionExample(ISomeRepository SomeRepositoryIn, IOtherRepository OtherRepositoryIn) { this._someRepository = SomeRepositoryIn; this._otherRepository = OtherRepositoryIn; } public void SomeMethod() { //use this._someRepository } public void OtherMethod() { //use this._otherRepository } } ต่อต้าน: public class MethodInjectionExample { public MethodInjectionExample() { } public void SomeMethod(ISomeRepository SomeRepositoryIn) { //use SomeRepositoryIn } …

16 design-patterns  programming-practices  dependency-injection  patterns-and-practices 

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

15 programming-practices  abstraction  strategy  low-level  high-level 

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

15 programming-practices  maintenance 

ฉันมีประสบการณ์มากกว่า 2 ปีในการพัฒนาแอพพลิเคชั่น ในสองปีที่ผ่านมาแนวทางการพัฒนาของฉันมีดังต่อไปนี้ วิเคราะห์ข้อกำหนด Identity Core องค์ประกอบ / วัตถุฟังก์ชันที่จำเป็น, พฤติกรรม, กระบวนการและข้อ จำกัด สร้างคลาสความสัมพันธ์ระหว่างพวกเขาข้อ จำกัด เกี่ยวกับพฤติกรรมของวัตถุ & รัฐ สร้างฟังก์ชั่นการประมวลผลด้วยข้อ จำกัด พฤติกรรมตามความต้องการ ทดสอบแอปพลิเคชันด้วยตนเอง หากความต้องการเปลี่ยนแปลงแก้ไของค์ประกอบ / ฟังก์ชั่นให้ทดสอบโปรแกรมด้วยตนเอง เมื่อเร็ว ๆ นี้ฉันได้รับการแนะนำให้รู้จักกับ TDD และรู้สึกว่านี่เป็นวิธีที่ดีมากในการพัฒนาเนื่องจากโค้ดที่พัฒนาแล้วมีเหตุผลที่แข็งแกร่งที่มีอยู่ แต่ปัญหาของฉันคือฉันไม่สามารถสร้างการทดสอบก่อนได้ แต่ฉันจะระบุส่วนประกอบและเพียงแค่เขียนการทดสอบสำหรับพวกเขาก่อนที่ฉันจะเขียนส่วนประกอบจริง ๆ คำถามของฉันคือ ฉันทำถูกไหม? ถ้าไม่ใช่สิ่งที่ฉันต้องเปลี่ยนแน่นอน มีวิธีใดที่คุณสามารถระบุได้ว่าแบบทดสอบที่คุณเขียนนั้นเพียงพอหรือไม่ เป็นการดีหรือไม่ที่จะทดสอบการเขียนสำหรับฟังก์ชั่นที่ง่ายมากซึ่งอาจเทียบเท่ากับ 1 + 1 = 2 หรือเป็นเพียงภาพซ้อนทับ? มันเป็นการดีที่จะเปลี่ยนฟังก์ชั่นและตามการทดสอบว่ามีการเปลี่ยนแปลงข้อกำหนด?

15 programming-practices  unit-testing  tdd  acceptance-testing 

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

15 programming-practices  refactoring  anti-patterns  regular-expressions  single-responsibility 

โดเมนความรู้ของเราเกี่ยวข้องกับคนที่เดินข้ามแผ่นบันทึกความกดดันด้วยเท้าเปล่า เราทำการจดจำรูปภาพซึ่งส่งผลให้วัตถุของคลาส 'เท้า' หากเท้ามนุษย์ถูกจดจำในข้อมูลเซ็นเซอร์ มีการคำนวณหลายอย่างที่ต้องดำเนินการกับข้อมูลของเท้า ตอนนี้ API ตัวไหนจะดีกว่า: class Foot : public RecognizedObject { MaxPressureFrame getMaxPressureFrame(); FootAxis getFootAxis(); AnatomicalZones getAnatomicalZones(); // + similar getters for other calculations // ... } หรือ: class Foot : public RecognizedObject { virtual CalculationBase getCalculation(QString aName); // ... } ตอนนี้มีโปรและคอนแสตนท์จำนวนมากที่ฉันสามารถหาได้ แต่ฉันก็ไม่สามารถตัดสินใจได้ว่าอะไรคือสิ่งที่สำคัญที่สุด หมายเหตุนี่เป็นแอปพลิเคชั่นสำหรับผู้ใช้ไม่ใช่ไลบรารี่ซอฟต์แวร์ที่เราขาย คำแนะนำใด ๆ? โปรบางตัวสำหรับวิธีแรกอาจเป็น: …

15 design  c++  object-oriented  programming-practices  language-agnostic 

ฉันมีสถานการณ์ที่พ่อแม่ของฉันรู้ว่ามันเป็นลูก (duh) แต่ฉันต้องการให้เด็กสามารถอ้างอิงผู้ปกครองได้ เหตุผลสำหรับเรื่องนี้คือฉันต้องการให้เด็กมีความสามารถในการกำหนดตัวเองว่าสำคัญที่สุดหรือสำคัญที่สุดเมื่อรู้สึกเช่นนั้น เมื่อเด็กทำสิ่งนี้มันจะย้ายไปที่ด้านบนหรือด้านล่างของลูกของผู้ปกครอง ในอดีตที่ผ่านมาฉันเคยใช้คุณสมบัติ WeakReference กับเด็กเพื่ออ้างอิงย้อนกลับทีโอทีพ่อแม่ แต่ฉันรู้สึกว่ามันเพิ่มค่าใช้จ่ายที่น่ารำคาญ แต่บางทีมันอาจเป็นวิธีที่ดีที่สุดที่จะทำ นี่เป็นความคิดที่ไม่ดีใช่ไหม คุณจะใช้ความสามารถนี้แตกต่างกันอย่างไร อัปเดต 1: การเพิ่มบริบทเพิ่มเติม นี่คือระบบการแสดงผลดังนั้นคอนเทนเนอร์พาเรนต์คือรายการของ windows ที่จัดกลุ่มเข้าด้วยกัน รายการย่อย (หน้าต่าง) ที่ระบุว่า "ฉันสำคัญที่สุด!" ต้องการแสดงผลโดยทั่วไปที่ด้านบนของหน้าต่างที่เหลือ พาเรนต์เป็นเพียงคอนเทนเนอร์โลจิคัลเพื่อจัดกลุ่มเด็กเหล่านี้เข้าด้วยกัน ฉันสามารถดูว่าการเพิ่มกิจกรรมเพื่อส่งสัญญาณคำขอให้อยู่ด้านบนเป็นความคิดที่ดี แต่การนำไปปฏิบัติ (สิ่งที่เด็กต้องการทำกับผู้ปกครอง) ทำไมคุณไม่ต้องการให้มีการเชื่อมโยงกับผู้ปกครอง? รายการที่เชื่อมโยงเป็นทวีคูณทำเช่นนี้เพื่อให้ผู้คนสามารถท่องไปและกลับจากบางสิ่งได้

15 c#  programming-practices 

ในอีกด้านหนึ่งมีคำแนะนำที่บอกว่า "สร้างหนึ่งทิ้ง" หลังจากเสร็จสิ้นระบบซอฟต์แวร์และการเห็นผลิตภัณฑ์สุดท้ายเรารู้ว่ามีอะไรผิดพลาดในขั้นตอนการออกแบบและเข้าใจว่าเราควรทำอย่างไร ในทางกลับกันมี "เอฟเฟ็กต์ระบบที่สอง" ซึ่งบอกว่าระบบที่สองในรูปแบบเดียวกันที่ออกแบบมามักจะแย่กว่าระบบแรก มีคุณสมบัติหลายอย่างที่ไม่เหมาะสมในโครงการแรกและถูกผลักเข้าไปในรุ่นที่สองซึ่งมักจะนำไปสู่ความซับซ้อนและการออกแบบมากเกินไป นี่ขัดแย้งกับหลักการเหล่านี้หรือไม่? อะไรคือมุมมองที่ถูกต้องเกี่ยวกับปัญหาและพรมแดนระหว่างสองสิ่งนี้อยู่ที่ไหน ฉันเชื่อว่า "แนวทางปฏิบัติที่ดี" เหล่านี้ได้รับการส่งเสริมเป็นครั้งแรกในหนังสือน้ำเชื้อThe Mythical Man-Monthโดย Fred Brooks ฉันรู้ว่าปัญหาเหล่านี้บางอย่างได้รับการแก้ไขโดยวิธีการ Agile แต่ลึกลงไปปัญหายังคงเป็นหลักการที่ยังคงอยู่ ตัวอย่างเช่นเราจะไม่เปลี่ยนแปลงการออกแบบที่สำคัญ 3 sprint ก่อนที่จะเผยแพร่

15 design  project-management  programming-practices  project  principles 

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

15 programming-practices  coding-style  code-quality 

เป็นที่ยอมรับหรือไม่ที่จะส่งคืนรหัสออกที่ไม่ใช่ศูนย์หากโปรแกรมที่เป็นปัญหารันได้อย่างถูกต้องหรือไม่? ตัวอย่างเช่นสมมติว่าฉันมีโปรแกรมอย่างง่าย ๆ ที่ (เท่านั้น) ทำสิ่งต่อไปนี้: โปรแกรมรับอาร์กิวเมนต์ N มันจะส่งคืนรหัสทางออกของนาที (N, 255) โปรดทราบว่า N ใด ๆ ที่ถูกต้องสำหรับโปรแกรม โปรแกรมที่สมจริงยิ่งขึ้นอาจส่งคืนรหัสที่แตกต่างกันสำหรับการรันโปรแกรมที่ประสบความสำเร็จซึ่งมีความหมายต่างกัน โปรแกรมเหล่านี้ควรเขียนข้อมูลนี้ไปยังสตรีมแทนเช่น stdout หรือไม่

15 programming-practices  exit-strategy 

ฉันได้รับความประทับใจแล้วการจับลิงนั้นเป็นประเภทแฮ็คที่รวดเร็วและสกปรกมากกว่าการฝึกเขียนโปรแกรมมาตรฐานที่ดี ในขณะที่ฉันใช้เป็นครั้งคราวเพื่อแก้ไขปัญหาเล็กน้อยกับ libs ของบุคคลที่สามฉันคิดว่าเป็นการแก้ไขชั่วคราวและฉันจะส่งปะที่เหมาะสมให้กับโครงการของบุคคลที่สาม แต่ผมเคยเห็นเทคนิคนี้มาใช้เป็น "วิธีปกติ" ในโครงการหลักเช่นใน Gevent ของโมดูลgevent.monkey การฝึกลิงกลายเป็นกระแสหลักปกติการฝึกเขียนโปรแกรมที่ยอมรับได้หรือไม่? ดูเพิ่มเติม: "Monkeypatching เพื่อมนุษย์"โดย Jeff Atwood

15 python  programming-practices  ruby  meta-programming  monkey-patch