คำถามติดแท็ก anti-patterns

เมื่อเร็ว ๆ นี้ฉันเคยติดนิสัยคอลเลกชัน Java "กำบัง" ที่มีชื่อคลาสที่เป็นมิตรกับมนุษย์ ตัวอย่างง่ายๆ: // Facade class that makes code more readable and understandable. public class WidgetCache extends Map<String, Widget> { } หรือ: // If you saw a ArrayList<ArrayList<?>> being passed around in the code, would you // run away screaming, or would you actually understand what …

46 java  anti-patterns  generics  collections 

ฉันต้องขยายโมดูลที่มีอยู่ของโครงการ ฉันไม่ชอบวิธีที่เคยทำ (มีรูปแบบการต่อต้านจำนวนมากที่เกี่ยวข้องเช่นคัดลอก / วางโค้ด) ฉันไม่ต้องการดำเนินการ refactor แบบสมบูรณ์ด้วยเหตุผลหลายประการ ฉันควร: สร้างวิธีการใหม่โดยใช้การประชุมที่มีอยู่แม้ว่าฉันจะรู้สึกผิดเพื่อหลีกเลี่ยงความสับสนสำหรับผู้ดูแลต่อไปและสอดคล้องกับรหัสฐานหรือไม่ หรือ ลองใช้สิ่งที่ฉันรู้สึกดีขึ้นแม้ว่าจะมีการแนะนำรูปแบบอื่นในรหัสหรือไม่ Precison แก้ไขหลังจากคำตอบแรก: รหัสที่มีอยู่ไม่เป็นระเบียบ มันง่ายที่จะติดตามและทำความเข้าใจ แต่มันก็แนะนำรหัสสำเร็จรูปจำนวนมากที่สามารถหลีกเลี่ยงได้ด้วยการออกแบบที่ดี (รหัสผลลัพธ์อาจกลายเป็นเรื่องยากที่จะปฏิบัติตามแล้ว) ในกรณีปัจจุบันของฉันมันเป็นโมดูล DAO เก่าแก่ของ JDBC (บอร์ดเทมเพลตสปริง) แต่ฉันได้พบปัญหานี้แล้วและฉันกำลังมองหาความคิดเห็น dev อื่น ๆ ฉันไม่ต้องการ refactor เพราะฉันไม่มีเวลา และถึงเวลาจะยากที่จะพิสูจน์ว่าโมดูลที่ทำงานได้อย่างสมบูรณ์แบบนั้นต้องการการปรับโครงสร้างใหม่ ต้นทุนการปรับโครงสร้างจะหนักกว่าประโยชน์ของมัน จำเอาไว้: รหัสไม่ยุ่งหรือซับซ้อนเกิน ฉันไม่สามารถแยกวิธีการไม่กี่ที่นั่นและแนะนำคลาสนามธรรมที่นี่ มันเป็นข้อบกพร่องในการออกแบบมากขึ้น (เพราะ 'Keep It Stupid Simple' สุดขีดฉันคิดว่า) ดังนั้นคำถามที่สามารถถามได้เช่น: คุณในฐานะนักพัฒนาคุณต้องการที่จะรักษาโค้ดที่น่าเบื่องี่เง่าที่ง่ายหรือจะมีผู้ช่วยบางคนที่จะทำโค้ดที่น่าเบื่อแบบโง่ในที่ของคุณหรือไม่? ข้อเสียของความเป็นไปได้ครั้งสุดท้ายที่คุณจะต้องเรียนรู้บางสิ่งและบางทีคุณอาจจะต้องรักษารหัสที่น่าเบื่ออย่างง่าย ๆ ไว้เช่นกันจนกว่าจะทำการรีแฟคเตอร์เสร็จสมบูรณ์)

45 refactoring  coding  maintenance  anti-patterns 

เพื่อจัดการข้อผิดพลาดที่เป็นไปได้หลายอย่างที่ไม่ควรหยุดการทำงานฉันมีerrorตัวแปรที่ลูกค้าสามารถตรวจสอบและใช้เพื่อโยนข้อยกเว้น นี่เป็น Anti-Pattern หรือไม่ มีวิธีที่ดีกว่าในการจัดการกับเรื่องนี้? ตัวอย่างของสิ่งนี้คุณสามารถดูmysqli API ของ PHP สมมติว่าปัญหาการมองเห็น (ผู้เข้าถึงขอบเขตสาธารณะและส่วนตัวเป็นตัวแปรในคลาสหรือระดับโลกหรือไม่) ได้รับการจัดการอย่างถูกต้อง

44 design-patterns  object-oriented  exceptions  patterns-and-practices  anti-patterns 

เพื่อนร่วมงานของฉันชอบพูดว่า "การบันทึก / การแคช / ฯลฯ เป็นข้อกังวลข้าม" จากนั้นดำเนินการใช้ซิงเกิลที่เกี่ยวข้องทุกที่ พวกเขารัก IoC และ DI มันเป็นข้อแก้ตัวที่ถูกต้องหรือไม่ที่จะทำลายหลักการของ SOLI D ?

43 dependency-injection  solid  anti-patterns  singleton 

ในขณะที่เขียนห้องสมุดสำหรับโครงการขนาดใหญ่ที่ฉันกำลังทำงานอยู่มีปัญหาเกิดขึ้นซึ่งต้องใช้โทเค็นเพื่อส่งไปยังที่อยู่อีเมลจากนั้นส่งกลับไปยังรหัสที่สามารถใช้เพื่อการใช้งานต่อไป เพื่อนร่วมงานของฉันบอกว่าให้อ่านจาก STDIN (โดยใช้ Python:) code = input("Enter code: ")จากนั้นให้ผู้ใช้ส่งมันมาให้ฉัน แต่สำหรับฉันนี่เป็นวิธีปฏิบัติที่ไม่ดีเนื่องจากห้องสมุดอาจใช้ (ในกรณีนี้จะ) ใช้ในงานแบ็คกราวน์บนเซิร์ฟเวอร์ . ฉันสงสัยว่าสิ่งนี้ถือเป็นรูปแบบการต่อต้านหรือไม่

39 programming-practices  libraries  anti-patterns 

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

39 c++  design-patterns  anti-patterns 

ฉันมีการพูดคุยกับเพื่อนร่วมงานและท้ายที่สุดเราก็มีสัญชาติญาณที่ขัดแย้งกันเกี่ยวกับวัตถุประสงค์ของการทำคลาสย่อย สัญชาตญาณของฉันคือถ้าฟังก์ชั่นหลักของคลาสย่อยแสดงค่าที่เป็นไปได้ที่ จำกัด ของพาเรนต์มันก็คงไม่ควรเป็นคลาสย่อย เขาแย้งกับสัญชาตญาณตรงข้ามว่าคลาสย่อยหมายถึงวัตถุที่เป็น "เฉพาะ" มากกว่าดังนั้นความสัมพันธ์คลาสย่อยจึงเหมาะสมกว่า เพื่อให้สัญชาตญาณของฉันเป็นรูปธรรมมากขึ้นฉันคิดว่าถ้าฉันมี subclass ที่ขยายคลาสแม่ แต่รหัสเดียวที่แทนที่ subclass เป็นตัวสร้าง (ใช่ฉันรู้ว่าตัวสร้างไม่ได้โดยทั่วไป "แทนที่", ทนกับฉัน) แล้ว สิ่งที่จำเป็นจริงๆคือวิธีการช่วยเหลือ ตัวอย่างเช่นลองพิจารณาชั้นเรียนชีวิตจริงนี้: public class DataHelperBuilder { public string DatabaseEngine { get; set; } public string ConnectionString { get; set; } public DataHelperBuilder(string databaseEngine, string connectionString) { DatabaseEngine = databaseEngine; ConnectionString = connectionString; } …

37 design-patterns  object-oriented  inheritance  anti-patterns 

พิจารณาการออกแบบดังต่อไปนี้ public class Person { public virtual string Name { get; } public Person (string name) { this.Name = name; } } public class Karl : Person { public override string Name { get { return "Karl"; } } } public class John : Person { public override string Name …

37 programming-practices  inheritance  class-design  anti-patterns 

สมมติว่าฉันมีกระแสของสิ่งต่าง ๆ และฉันต้องการ "เพิ่มคุณค่า" พวกเขาให้อยู่กลางกระแสฉันสามารถใช้peek()ทำสิ่งนี้ได้เช่น: streamOfThings.peek(this::thingMutator).forEach(this::someConsumer); สมมติว่าการกลายพันธุ์สิ่งต่าง ๆ ณ จุดนี้ในรหัสเป็นการทำงานที่ถูกต้องตัวอย่างเช่นthingMutatorวิธีการอาจตั้งค่าฟิลด์ "lastProcessed" เป็นเวลาปัจจุบัน อย่างไรก็ตามpeek()ในบริบทส่วนใหญ่หมายถึง "มอง แต่ไม่ได้สัมผัส" ใช้peek()เพื่อเปลี่ยนแปลงองค์ประกอบของกระแสข้อมูลที่เป็น antipattern หรือไม่เหมาะสมหรือไม่? แก้ไข: ทางเลือกที่ธรรมดากว่าคือการเปลี่ยนผู้บริโภค: private void thingMutator(Thing thing) { thing.setLastProcessed(System.currentTimeMillis()); } ไปที่ฟังก์ชันที่คืนค่าพารามิเตอร์: private Thing thingMutator(Thing thing) { thing.setLastProcessed(currentTimeMillis()); return thing; } และใช้map()แทน: stream.map(this::thingMutator)... แต่ที่แนะนำรหัสลวก ๆ (คนreturn) และฉันไม่ได้เชื่อว่ามันเป็นที่ชัดเจนเพราะคุณรู้ว่าpeek()ผลตอบแทนที่วัตถุเดียวกัน แต่map()มันไม่ได้ล้างได้อย่างรวดเร็วว่ามันเป็นเดียวกันระดับของวัตถุ นอกจากนี้peek()คุณยังสามารถมีแลมบ์ดาที่กลายพันธุ์ได้ แต่map()คุณต้องสร้างซากรถไฟ เปรียบเทียบ: stream.peek(t -> t.setLastProcessed(currentTimeMillis())).forEach(...) …

36 java  anti-patterns  java8  stream-processing  mutable 

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

35 naming  anti-patterns 

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

35 programming-practices  anti-patterns 

ฉันเพิ่งพูดคุยเกี่ยวกับตัวเลือกการออกแบบหลังจากการตรวจสอบโค้ด ฉันสงสัยว่าความคิดเห็นของคุณคืออะไร มีPreferencesคลาสนี้ซึ่งเป็นที่เก็บข้อมูลสำหรับคู่คีย์ - ค่า ค่า Null นั้นถูกกฎหมาย (สำคัญมาก) เราคาดหวังว่าค่าบางอย่างอาจยังไม่ถูกบันทึกและเราต้องการจัดการกับกรณีเหล่านี้โดยอัตโนมัติโดยเริ่มต้นด้วยค่าเริ่มต้นที่กำหนดไว้ล่วงหน้าเมื่อมีการร้องขอ วิธีแก้ปัญหาที่กล่าวถึงใช้รูปแบบต่อไปนี้ (หมายเหตุ: นี่ไม่ใช่รหัสจริงแน่นอน - มันง่ายสำหรับจุดประสงค์ในการอธิบาย): public class Preferences { // null values are legal private Map<String, String> valuesFromDatabase; private static Map<String, String> defaultValues; class KeyNotFoundException extends Exception { } public String getByKey(String key) { try { return getValueByKey(key); } catch …

33 java  programming-practices  coding-style  exceptions  anti-patterns 

ฉันเพิ่งมาข้ามบทความ MSDN เกี่ยวกับการแยกทางและการผสานและ SCM: การแตกแขนงและผสานรองพื้น - คริส Birmele ในบทความพวกเขาบอกว่า 'บิ๊กแบงผสาน' เป็นปฏิปักษ์ต่อการรวม: Big Bang Merge - ชะลอการรวมสาขาเพื่อสิ้นสุดความพยายามในการพัฒนาและพยายามรวมสาขาทั้งหมดพร้อมกัน ฉันรู้ว่านี่คล้ายกับสิ่งที่ บริษัท ของฉันทำกับสาขาการพัฒนาทั้งหมดที่ผลิต ฉันทำงานที่ บริษัท ขนาดเล็กมากโดยมีคนคนหนึ่งทำหน้าที่เป็นผู้ตรวจสอบขั้นสุดท้าย + มีอำนาจในการรวมลำตัว เรามีนักพัฒนา 5 คน (รวมถึงฉันด้วย) เราแต่ละคนจะได้รับมอบหมายภารกิจ / ข้อบกพร่อง / โครงการแยกจากกันและเราจะแยกแต่ละสาขาออกจากเส้นทางปัจจุบัน (การโค่นล้ม) จากนั้นทำการพัฒนาในสาขาของเราทดสอบผลลัพธ์เขียนเอกสาร หากจำเป็นให้ดำเนินการตรวจสอบแบบเพียร์และข้อเสนอแนะกับนักพัฒนาอื่น ๆ แล้วส่งสาขาสำหรับความคิดเห็น + ผสานในซอฟต์แวร์การจัดการโครงการของเรา เจ้านายของฉันซึ่งเป็นผู้มีอำนาจ แต่เพียงผู้เดียวในที่เก็บ trunk จะทำการตรวจสอบความคิดเห็นทั้งหมดของสาขาจนกว่าจะถึงจุดเดียวในเวลาที่เขาจะแสดงความคิดเห็นให้มากที่สุดเท่าที่จะทำได้บางสาขาจะถูกโยนทิ้งเพื่อปรับปรุง / แก้ไข กิ่งไม้จะถูกรวมเข้ากับลำต้นบางสาขาจะถูกโยนกลับเนื่องจากความขัดแย้ง ฯลฯ ไม่ใช่เรื่องแปลกที่เราจะมีสาขาที่ใช้งานอยู่ 10-20 …

28 svn  anti-patterns  merging  scm 

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

28 design  terminology  anti-patterns  technical-debt  legacy-code 

ในช่วงสองสามเดือนที่ผ่านมาฉันสะดุดเทคนิค / รูปแบบต่อไปนี้สองสามครั้ง อย่างไรก็ตามฉันไม่สามารถหาชื่อเฉพาะได้และฉันก็ไม่แน่ใจ 100% เกี่ยวกับข้อดีและข้อเสียทั้งหมด รูปแบบไปดังนี้: ภายในอินเตอร์เฟส Java ชุดของวิธีการทั่วไปจะถูกกำหนดตามปกติ อย่างไรก็ตามการใช้คลาสภายในอินสแตนซ์เริ่มต้นจะถูกปล่อยออกมาผ่านส่วนต่อประสาน public interface Vehicle { public void accelerate(); public void decelerate(); public static class Default { public static Vehicle getInstance() { return new Car(); // or use Spring to retrieve an instance } } } สำหรับฉันดูเหมือนว่าข้อได้เปรียบที่ใหญ่ที่สุดคือความจริงที่ว่าผู้พัฒนาต้องการทราบเกี่ยวกับอินเทอร์เฟซไม่ใช่การใช้งานเช่นในกรณีที่เขาต้องการสร้างอินสแตนซ์อย่างรวดเร็ว Vehicle someVehicle = Vehicle.Default.getInstance(); …

28 java  interfaces  anti-patterns  technique