วิศวกรรมซอฟต์แวร์

มีเหตุผลมากมายว่าทำไมคนรอบข้างจึงชั่วร้ายใน OOP หากจำนวนหรือขนาดของวัตถุที่ต้องการแบ่งปันมีขนาดใหญ่เกินไปที่จะส่งผ่านอย่างมีประสิทธิภาพในพารามิเตอร์ฟังก์ชั่นมักจะทุกคนแนะนำพึ่งพาการฉีดแทนวัตถุทั่วโลก อย่างไรก็ตามในกรณีที่เกือบทุกคนจำเป็นต้องรู้เกี่ยวกับโครงสร้างข้อมูลบางอย่างทำไมการพึ่งพาการฉีดจึงดีกว่าวัตถุระดับโลก ตัวอย่าง (ตัวย่อที่เรียบง่ายเพื่อแสดงจุดโดยทั่วไปโดยไม่ต้องเจาะลึกในแอปพลิเคชันเฉพาะ) มีรถยนต์เสมือนจำนวนมากที่มีคุณสมบัติและสถานะจำนวนมากตั้งแต่ประเภทชื่อสีไปจนถึงความเร็วตำแหน่ง ฯลฯ ผู้ใช้จำนวนมากสามารถควบคุมจากระยะไกลและเหตุการณ์จำนวนมาก (ทั้งผู้ใช้ - เริ่มต้นและอัตโนมัติ) สามารถเปลี่ยนสถานะหรือคุณสมบัติได้มากมาย วิธีการแก้ปัญหาที่ไร้เดียงสาคือการสร้างภาชนะใส่ของโลกเช่น vector<Vehicle> vehicles; ซึ่งสามารถเข้าถึงได้จากทุกที่ วิธีแก้ปัญหาที่เป็นมิตรกับ OOP ก็คือให้มีคอนเทนเนอร์เป็นสมาชิกของคลาสที่จัดการห่วงเหตุการณ์หลักและถูกสร้างอินสแตนซ์ในตัวสร้าง ทุกคลาสที่ต้องการมันและเป็นสมาชิกของเธรดหลักจะได้รับการเข้าถึงคอนเทนเนอร์ผ่านตัวชี้ในตัวสร้างของพวกเขา ตัวอย่างเช่นหากข้อความภายนอกเข้ามาผ่านการเชื่อมต่อเครือข่ายคลาส (หนึ่งสำหรับแต่ละการเชื่อมต่อ) การจัดการการแยกจะใช้เวลามากกว่าและ parser จะเข้าถึงคอนเทนเนอร์ผ่านตัวชี้หรือการอ้างอิง ตอนนี้ถ้าข้อความที่วิเคราะห์คำส่งผลให้เกิดการเปลี่ยนแปลงในองค์ประกอบของคอนเทนเนอร์หรือต้องการข้อมูลบางส่วนเพื่อดำเนินการก็สามารถจัดการได้โดยไม่จำเป็นต้องสลับตัวแปรหลายพันตัวผ่านสัญญาณและช่องเสียบ (หรือแย่กว่านั้น เก็บไว้ใน parser ที่จะเรียกคืนในภายหลังโดยผู้ที่เรียกว่า parser) แน่นอนว่าคลาสทั้งหมดที่ได้รับการเข้าถึงคอนเทนเนอร์ผ่านการฉีดเป็นส่วนหนึ่งของเธรดเดียวกัน เธรดที่แตกต่างกันจะไม่สามารถเข้าถึงได้โดยตรง แต่ทำงานของพวกเขาแล้วส่งสัญญาณไปยังเธรดหลักและสล็อตในเธรดหลักจะอัพเดตคอนเทนเนอร์ อย่างไรก็ตามถ้าส่วนใหญ่ของคลาสจะเข้าถึงคอนเทนเนอร์สิ่งที่ทำให้แตกต่างจากส่วนกลาง หากคลาสจำนวนมากต้องการข้อมูลในคอนเทนเนอร์ไม่ใช่ "วิธีการฉีดพึ่งพา" เป็นเพียงระบบปลอมทั่วโลกใช่หรือไม่ คำตอบหนึ่งก็คือความปลอดภัยของเธรด: แม้ว่าฉันจะระวังไม่ให้ใช้ภาชนะที่ไม่เหมาะสมกับผู้ใช้ทั่วโลกบางทีผู้พัฒนารายอื่นในอนาคตภายใต้แรงกดดันของเส้นตายที่ใกล้จะถึงกระนั้นก็ตาม กรณีการปะทะกัน อย่างไรก็ตามแม้ในกรณีของการฉีดพึ่งพาใครสามารถชี้ให้คนที่ทำงานในหัวข้ออื่นที่นำไปสู่ปัญหาเดียวกัน

20 design-patterns  object-oriented  dependency-injection 

เมื่อใช้ภาษาที่สนับสนุนอาร์กิวเมนต์ที่ตั้งชื่อและเป็นตัวเลือกรูปแบบตัวสร้างจะไม่มีประโยชน์ในทางปฏิบัติอีกต่อไปหรือไม่ ผู้สร้าง: new Builder(requiredA, requiredB).setOptionalA("optional").Build(); อาร์กิวเมนต์ตัวเลือก / ชื่อ: new Object(requiredA, requiredB, optionalA: "optional");

20 design-patterns  builder-pattern 

ฉันกำลังทำงานในโปรเจ็กต์ที่เกี่ยวข้องกับอุปกรณ์ทางกายภาพและฉันสับสนว่าจะตั้งชื่อคลาสบางคลาสในโครงการนี้ได้อย่างไร เมื่อพิจารณาถึงอุปกรณ์จริง (เซ็นเซอร์และตัวรับสัญญาณ) เป็นสิ่งหนึ่งและการเป็นตัวแทนของพวกเขาในซอฟต์แวร์นั้นเป็นอีกสิ่งหนึ่ง ตัวอย่างเช่นในขณะที่Sensorคลาสจะเป็นตัวแทนของเซ็นเซอร์จริง (เมื่อเชื่อมต่อกับอุปกรณ์ที่ใช้งานจริง) SensorInfoจะถูกใช้เพื่อแสดงเฉพาะคุณสมบัติของเซ็นเซอร์ดังกล่าว ตัวอย่างเช่นเมื่อบันทึกไฟล์ฉันจะทำให้เป็น a SensorInfoถึงส่วนหัวของไฟล์แทนการทำให้เป็นอันดับ a Sensorซึ่งเรียงลำดับของจะไม่ทำให้รู้สึก แต่ตอนนี้ฉันสับสนเพราะมีวงจรกลางในวงจรชีวิตของวัตถุที่ฉันไม่สามารถตัดสินใจได้ว่าฉันควรใช้อย่างใดอย่างหนึ่งหรืออื่นหรือวิธีการได้รับอย่างใดอย่างหนึ่งหรือแม้กระทั่งว่าตัวแปรทั้งสองควรจะยุบลงในชั้นเดียวเท่านั้น นอกจากนี้Employeeคลาสตัวอย่างที่ธรรมดาเกินไปก็ชัดเจนว่าเป็นเพียงตัวแทนของบุคคลจริง แต่ไม่มีใครแนะนำให้ตั้งชื่อชั้นเรียนEmployeeInfoแทนเท่าที่ฉันรู้ ภาษาที่ฉันทำงานด้วยคือ. NET และรูปแบบการตั้งชื่อนี้ดูเหมือนจะเป็นเรื่องทั่วไปตลอดทั้งเฟรมเวิร์กสำหรับตัวอย่างของคลาสเหล่านี้: DirectoryและDirectoryInfoชั้นเรียน FileและFileInfoชั้นเรียน ConnectionInfoชั้นเรียน (ไม่มีConnectionชั้นเรียนผู้สื่อข่าว); DeviceInfoชั้นเรียน (ไม่มีDeviceชั้นเรียนผู้สื่อข่าว); ดังนั้นคำถามของฉันคือ: มีเหตุผลทั่วไปเกี่ยวกับการใช้รูปแบบการตั้งชื่อนี้หรือไม่? มีกรณีที่เหมาะสมหรือไม่ที่จะมีชื่อคู่ ( ThingและThingInfo) และกรณีอื่น ๆ ที่ควรมีอยู่เฉพาะThingInfoคลาสหรือThingคลาสโดยไม่มีคู่

20 c#  .net  naming  class-design  naming-standards 

เป็นที่รู้จักกันดีสำหรับผู้ที่คุ้นเคยกับประวัติที่ C # และ. NET Framework เริ่มต้นจากการที่ "Delphi เขียนใหม่เพื่อให้รู้สึกเหมือน Java" ได้รับการออกแบบโดยหัวหน้าผู้พัฒนาที่อยู่เบื้องหลัง Delphi, Anders Hejlsberg สิ่งต่าง ๆ ได้เบี่ยงเบนไปเล็กน้อยตั้งแต่นั้นมา แต่ในช่วงต้นของความคล้ายคลึงกันได้ชัดเจนว่ามีการเก็งกำไรร้ายแรงบางอย่างที่. NET เป็นผลิตภัณฑ์ดั้งเดิมของ Borland แต่ฉันได้ดูบางสิ่ง. NET เมื่อเร็ว ๆ นี้และหนึ่งในคุณสมบัติที่น่าสนใจและมีประโยชน์ที่สุดจาก Delphi ดูเหมือนจะหายไปโดยสิ้นเชิง: แนวคิดของคลาสเป็นประเภทข้อมูลชั้นหนึ่ง สำหรับผู้ที่ไม่คุ้นเคยกับมันประเภทTClassแสดงถึงการอ้างอิงถึงระดับคล้ายกับTypeประเภทใน. NET แต่ที่. NET ใช้Typeในการสะท้อนเดลฟีใช้TClassเป็นส่วนสำคัญในตัวของภาษา มันช่วยให้สำนวนที่เป็นประโยชน์ต่าง ๆ ที่ไม่มีและไม่มีอยู่จริงเช่นตัวแปรคลาสย่อยและวิธีคลาสเสมือน ทุกภาษา OO มีวิธีการเสมือนซึ่งคลาสที่แตกต่างกันใช้แนวคิดพื้นฐานเดียวกันของวิธีการในวิธีที่ต่างกันและจากนั้นวิธีการที่เหมาะสมจะได้รับการเรียกใช้ที่รันไทม์ตามชนิดที่แท้จริงของอินสแตนซ์วัตถุที่เรียกว่า Delphi ขยายแนวคิดนี้ไปยังคลาส: ถ้าคุณมีการอ้างอิง TClass ที่กำหนดเป็นคลาสย่อยเฉพาะ (เช่นclass of TMyClassหมายความว่าตัวแปรสามารถรับการอ้างอิงคลาสใด ๆ ที่สืบทอดมาTMyClassแต่ไม่ใช่สิ่งใดนอก …

20 architecture  .net  history  delphi 

พื้นหลัง เมื่อปีที่แล้วฉันถูกขอให้สร้างเครื่องมือที่จะใช้สำหรับการวางแผนธุรกิจสำหรับผู้ใช้ประมาณ 10 คน สิ่งนี้ทำในนามของทีมงานไอทีอีกคนที่ "ทำสัญญาย่อย" ทำงานให้ฉันและเนื่องจากกำหนดเวลาโครงการไม่ได้วางแผนมาก่อนที่ด้านข้างของพวกเขาฉันจึงต้องดำเนินการอย่างเร่งด่วน ในเวลานั้นเราตัดสินใจว่าวิธีที่เร็วที่สุดคือการสร้างเวิร์กบุ๊ก Excel ด้วย VBA จากนั้นให้ผู้ใช้ดาวน์โหลดเวิร์กบุ๊กที่ปรับปรุงด้วย VBA นี้จากอินทราเน็ตเพื่อใช้บนพีซีของพวกเขา Excel เป็นข้อ จำกัด ในกรณีนี้เนื่องจากระบบการวางแผน (เช่นฐานข้อมูล) ที่เราใช้สามารถโต้ตอบผ่านทาง Add-in ของ Excel เท่านั้นซึ่งจะต้องโหลดในเวลาเดียวกันเมื่อสมุดงานการวางแผนเปิดอยู่ อย่างไรก็ตาม VBA ไม่ใช่ข้อ จำกัด ในเวลานั้น สมุดงานที่ฉันสร้างขึ้นประมาณ 4,000 บรรทัดของรหัส VBA และในขณะที่ฉันพยายามแยกข้อมูลและเลเยอร์การนำเสนอฉันไม่สามารถทำได้ในทุกกรณีเนื่องจากกำหนดเวลาโครงการ จริงๆแล้วในขณะที่ฉันภูมิใจในการสร้างเวิร์กบุคนี้ฉันก็รู้สึกผิดหวังเล็กน้อยที่มันสามารถทำได้ดีกว่าทั้งในแง่ของการเข้ารหัสและการปรับใช้กับผู้ใช้ ในวันนี้ ย้อนกลับไปวันนี้และทีมไอทีได้มาหาฉันอีกครั้งเพื่อขอสมุดงานที่คล้ายกัน (ดังนั้นฉันจึงสามารถใช้ซ้ำบางส่วนของสมุดงานอื่นด้านบนได้) แต่คราวนี้มันซับซ้อนมากขึ้นและจะมีผู้ใช้จำนวนมากขึ้น ( ประมาณ 200) อย่างไรก็ตามในครั้งนี้มันเป็นการวางแผนที่ดีขึ้นเล็กน้อยและฉันเห็นว่าเรามีเวลาอีกเล็กน้อยในการวางแผนสิ่งต่าง ๆ จากนี้ฉันคิดเกี่ยวกับโซลูชันและโครงสร้างพื้นฐานเนื่องจากการเขียนโปรแกรมสำหรับผู้ใช้ 100 คนมีผลกระทบมากกว่าผู้ใช้ 10 คน ดังนั้นฉันแนะนำทีมว่าบางทีเราควรพิจารณาย้ายรหัสที่มีอยู่ไปยังโซลูชัน …

20 c#  projects-and-solutions  excel  vba 

สมมติว่าฉันต้องการเขียนไลบรารีที่เกี่ยวข้องกับเวกเตอร์และเมทริกซ์ เป็นไปได้หรือไม่ที่จะอบมิติข้อมูลให้เป็นประเภทเพื่อให้การดำเนินการของมิติที่เข้ากันไม่ได้สร้างข้อผิดพลาดในเวลารวบรวม ตัวอย่างเช่นฉันต้องการให้ลายเซ็นของผลิตภัณฑ์ดอทเป็นแบบนี้ dotprod :: Num a, VecDim d => Vector a d -> Vector a d -> a โดยที่dtype นั้นมีค่าจำนวนเต็มเดียว (แสดงถึงมิติของเวกเตอร์เหล่านี้) ฉันคิดว่านี้สามารถทำได้โดยการกำหนด (ด้วยมือ) VecDimเป็นชนิดที่แยกต่างหากสำหรับแต่ละจำนวนเต็มและกลุ่มพวกเขาในระดับชนิดที่เรียกว่า มีกลไกในการ "สร้าง" ประเภทดังกล่าวหรือไม่? หรือบางทีวิธีที่ดีกว่า / ง่ายกว่าในการบรรลุสิ่งเดียวกัน?

20 haskell  type-systems  type-safety 

เมื่อเร็ว ๆ นี้ฉันได้พัฒนา API ของตัวเองและด้วยความสนใจลงทุนในการออกแบบ API ฉันมีความสนใจอย่างมากว่าฉันจะปรับปรุงการออกแบบ API ได้อย่างไร แง่มุมหนึ่งที่เกิดขึ้นสองสามครั้งคือ (ไม่ใช่โดยผู้ใช้ API ของฉัน แต่ในการสังเกตการอภิปรายเกี่ยวกับหัวข้อ): สิ่งหนึ่งที่ควรรู้เพียงแค่ดูรหัสที่เรียก API ว่ามันกำลังทำอะไรอยู่ ตัวอย่างเช่นดูการสนทนานี้ใน GitHub สำหรับวาทกรรมวาทกรรมมันมีลักษณะดังนี้: foo.update_pinned(true, true); เพียงแค่มองไปที่โค้ด (โดยไม่รู้ชื่อพารามิเตอร์เอกสาร ฯลฯ ) เราไม่สามารถเดาได้ว่ามันจะทำอะไร - อาร์กิวเมนต์ที่ 2 หมายถึงอะไร การปรับปรุงที่แนะนำคือการมี: foo.pin() foo.unpin() foo.pin_globally() และนั่นก็เป็นการล้างสิ่งต่าง ๆ (ข้อโต้แย้งที่สองคือว่าจะตรึง foo ทั่วโลกฉันเดา) และฉันเห็นด้วยในกรณีนี้ภายหลังจะเป็นการปรับปรุงอย่างแน่นอน แต่ผมเชื่อว่าอาจจะมีกรณีที่วิธีการในการตั้งค่าสถานะที่แตกต่างกัน แต่ที่เกี่ยวข้องเหตุผลจะได้รับการสัมผัสที่ดีกว่าเรียกวิธีหนึ่งมากกว่าคนแยกเป็นสัดส่วนถึงแม้คุณจะไม่ทราบว่าสิ่งที่ทำเพียงแค่มองรหัส (ดังนั้นคุณจะต้องหันไปดูที่ชื่อพารามิเตอร์และเอกสารประกอบเพื่อค้นหา - ซึ่งโดยส่วนตัวแล้วฉันจะทำทุกอย่างไม่ว่าฉันจะไม่คุ้นเคยกับ API) ตัวอย่างเช่นฉันเปิดเผยหนึ่งวิธีSetVisibility(bool, string, bool)ในFalconPeerและฉันรับทราบเพียงแค่ดูที่บรรทัด: …

20 programming-practices  naming  api  api-design 

ฉันกำลังใช้บอต IRC ที่ได้รับข้อความและฉันกำลังตรวจสอบข้อความนั้นเพื่อพิจารณาว่าจะเรียกใช้ฟังก์ชันใด มีวิธีที่ฉลาดกว่านี้ในการทำเช่นนี้? ดูเหมือนว่ามันจะออกจากมือได้อย่างรวดเร็วหลังจากที่ฉันได้รับคำสั่งถึง 20 คำสั่ง บางทีอาจมีวิธีที่ดีกว่าที่จะสรุปสิ่งนี้ใช่ไหม public void onMessage(String channel, String sender, String login, String hostname, String message){ if (message.equalsIgnoreCase(".np")){ // TODO: Use Last.fm API to find the now playing } else if (message.toLowerCase().startsWith(".register")) { cmd.registerLastNick(channel, sender, message); } else if (message.toLowerCase().startsWith("give us a countdown")) { cmd.countdown(channel, message); …

20 java  design  abstraction 

ฉันพบปัญหาทางทฤษฎีที่น่าสนใจเมื่อหลายปีก่อน ฉันไม่เคยพบวิธีแก้ปัญหาและยังคงหลอกหลอนฉันเมื่อฉันนอนหลับ สมมติว่าคุณมีแอปพลิเคชัน (C #) ที่มีตัวเลขอยู่ใน int ที่เรียกว่า x (ค่าของ x ไม่ได้รับการแก้ไข) เมื่อโปรแกรมทำงาน x จะถูกคูณด้วย 33 แล้วเขียนลงในไฟล์ ซอร์สโค้ดพื้นฐานมีลักษณะดังนี้: int x = getSomeInt(); x = x * 33; file.WriteLine(x); // Writes x to the file in decimal format หลายปีต่อมาคุณค้นพบว่าคุณต้องการค่าดั้งเดิมของ X ย้อนกลับ การคำนวณบางอย่างง่าย: เพียงแค่หารจำนวนในไฟล์ด้วย 33 อย่างไรก็ตามในกรณีอื่น X มีขนาดใหญ่พอที่การคูณจะทำให้เกิดการล้นจำนวนเต็ม ตามเอกสาร , C # …

20 c# 

ปิด คำถามนี้จะต้องมีมากขึ้นมุ่งเน้น ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้มุ่งเน้นที่ปัญหาเดียวโดยแก้ไขโพสต์นี้ ปิดให้บริการใน4 ปีที่แล้ว ฉันคือ Elvis พยายามอย่างหนักที่จะเรียนรู้ที่จะเป็น Einstein ฉันทำงานให้มอร์ท คนบ้านี้มันบ้าอะไรกันเนี่ย!?!? (คุณจะต้องอ่านสองสามย่อหน้าแรก) หากคุณไม่รู้สึกว่ากำลังอ่านลิงค์นั้นโดยพื้นฐานแล้วฉันเป็นโปรแกรมเมอร์มืออาชีพและเจ้านายของฉันคือ โปรแกรมเมอร์สายธุรกิจมืออาชีพที่ขาดวุฒิด้านวิทยาศาสตร์คอมพิวเตอร์ แต่มีความคุ้นเคยกับ Office และ VBA เป็นอย่างมากและโดยทั่วไปแล้วผู้เขียนแอปพลิเคชั่นการผลิตร่วมกันระหว่างเพื่อนร่วมงานของเขา ทั้งหมดที่กล่าวมาส่วนใหญ่ของงานของฉันคือการปูด้วยก้อนกรวดของเขารหัสและทำให้การผลิตพร้อม อย่างไรก็ตามรูปแบบที่ไม่ดีและลัทธิขนส่งสินค้าทำให้ยาก สิ่งนี้ประกอบไปด้วยข้อเท็จจริงที่ว่าเขาไม่เต็มใจที่จะอ่านหนังสือเขียนโปรแกรมหรืออนุญาตให้ฉันช่วยเขาสร้างรหัสใหม่อีกครั้ง มีกลวิธีอื่น ๆ ที่จะช่วยคนที่ไม่ใช่โปรแกรมเมอร์มืออาชีพหรือไม่จะเป็นโปรแกรมเมอร์มืออาชีพที่เขียนโค้ดไปข้างหน้าซึ่งมีความชัดเจนและใช้งานได้ง่ายกว่าสำหรับฉันที่จะใช้และตีความ?

20 development-environment  teamwork  maintenance 

เพื่อให้คุณมีพื้นฐานเล็กน้อย: ฉันทำงานให้กับ บริษัท ที่มีผู้พัฒนา Ruby on Rails ประมาณสิบสองคน (+/- ฝึกงาน) การทำงานระยะไกลเป็นเรื่องปกติ ผลิตภัณฑ์ของเราทำจากสองส่วนคือแกนที่ค่อนข้างอ้วนและบางขึ้นกับโครงการขนาดใหญ่ที่ลูกค้าสร้างขึ้น โครงการของลูกค้ามักจะขยายหลัก การเขียนทับคุณสมบัติหลักไม่ได้เกิดขึ้น ฉันอาจเพิ่มว่าแกนกลางมีบางส่วนที่ไม่ดีซึ่งต้องการการรีแฟคเตอร์ด่วน มีสเปค แต่ส่วนใหญ่สำหรับโครงการของลูกค้า ส่วนที่แย่ที่สุดของแกนนั้นยังไม่ได้ทดสอบ (ไม่ใช่อย่างที่ควรจะเป็น ... ) ผู้พัฒนาแบ่งออกเป็นสองทีมโดยทำงานร่วมกับ PO หนึ่งหรือสองตัวสำหรับการวิ่งแต่ละครั้ง โดยปกติโครงการของลูกค้าหนึ่งโครงการจะเชื่อมโยงกับหนึ่งในทีมและ POs อย่างเคร่งครัด ตอนนี้ปัญหาของเรา: ค่อนข้างบ่อยเราแบ่งเนื้อหาของกันและกัน บางคนจากทีม A ขยายหรือสร้างคุณลักษณะหลัก Y อีกครั้งทำให้เกิดข้อผิดพลาดที่ไม่คาดคิดสำหรับโครงการลูกค้าของทีม B ส่วนใหญ่การเปลี่ยนแปลงจะไม่ถูกประกาศในทีมดังนั้นข้อบกพร่องที่เกิดขึ้นแทบจะไม่คาดคิดเสมอไป ทีม B รวมถึง PO คิดเกี่ยวกับคุณสมบัติ Y ว่าเสถียรและไม่ได้ทดสอบก่อนปล่อยโดยไม่ทราบการเปลี่ยนแปลง จะกำจัดปัญหาเหล่านั้นได้อย่างไร? 'เทคนิคการประกาศ' แบบไหนที่คุณสามารถแนะนำฉันได้บ้าง

20 teamwork  communication  customer-relations  errors 

พื้นหลัง การทดสอบพัฒนาการขับเคลื่อนได้รับความนิยมหลังจากเรียนจบแล้วและในอุตสาหกรรม ฉันพยายามที่จะเรียนรู้ แต่สิ่งสำคัญบางอย่างยังคงหลบหนีฉัน ผู้เสนอ TDD พูดหลายสิ่งหลายอย่างเช่น (ต่อไปนี้เรียกว่า "หลักการยืนยันเดียว" หรือSAP ): บางครั้งฉันก็คิดว่าการทดสอบ TDD นั้นเรียบง่ายมีความหมายและสง่างามเท่าที่จะทำได้ บทความนี้สำรวจเล็กน้อยเกี่ยวกับสิ่งที่ต้องการทำแบบทดสอบที่ง่ายและย่อยสลายได้มากที่สุด: มีเป้าหมายสำหรับการยืนยันเดียวในแต่ละการทดสอบ ที่มา: http://www.artima.com/weblogs/viewpost.jsp?thread=35578 พวกเขายังพูดแบบนี้ (ซึ่งต่อไปจะเรียกว่า "หลักการวิธีการส่วนตัว" หรือPMP ): โดยทั่วไปคุณไม่ได้ทดสอบหน่วยวิธีการส่วนตัวโดยตรง เนื่องจากเป็นข้อมูลส่วนบุคคลให้พิจารณารายละเอียดการใช้งาน ไม่มีใครเคยเรียกหนึ่งในพวกเขาและคาดหวังว่ามันจะทำงานในรูปแบบเฉพาะ คุณควรทดสอบส่วนต่อประสานสาธารณะแทน หากวิธีการที่เรียกวิธีการส่วนตัวของคุณทำงานได้ตามที่คุณคาดไว้คุณจะถือว่าส่วนขยายนั้นวิธีส่วนตัวของคุณทำงานอย่างถูกต้อง ที่มา: คุณทำการทดสอบวิธีการส่วนตัวอย่างไร สถานการณ์ ฉันพยายามทดสอบระบบการประมวลผลข้อมูลที่เป็นรัฐ ระบบสามารถทำสิ่งที่แตกต่างกันสำหรับข้อมูลชิ้นเดียวกันที่ได้รับจากสถานะก่อนที่จะรับข้อมูลนั้น พิจารณาการทดสอบที่ตรงไปตรงมาที่สร้างสถานะขึ้นในระบบจากนั้นทดสอบพฤติกรรมที่วิธีการที่กำหนดไว้มีวัตถุประสงค์เพื่อทดสอบ SAP แนะนำว่าฉันไม่ควรทดสอบ "ขั้นตอนการสร้างรัฐ" ฉันควรสมมติว่าสถานะเป็นสิ่งที่ฉันคาดหวังจากรหัสการสะสมแล้วทดสอบการเปลี่ยนสถานะเดียวที่ฉันพยายามทดสอบ PMP แนะนำว่าฉันไม่สามารถข้ามขั้นตอน "state build up" นี้ได้และเพียงทดสอบวิธีการที่ควบคุมการทำงานนั้นอย่างอิสระ ผลลัพธ์ในรหัสจริงของฉันคือการทดสอบที่มีการป่องซับซ้อนซับซ้อนยาวและยากที่จะเขียน และหากการเปลี่ยนสถานะเปลี่ยนไปการทดสอบจะต้องเปลี่ยน ... ซึ่งจะดีกับการทดสอบขนาดเล็กที่มีประสิทธิภาพ แต่ใช้เวลานานมากและสับสนกับการทดสอบแบบป่องยาวเหล่านี้ ปกติแล้วจะทำอย่างไร?

20 design  unit-testing  tdd 

ฉันจะใช้คำอธิบายภาษาที่ไม่เชื่อเรื่องพระเจ้าของ monads เช่นนี้ก่อนอธิบาย monoids: หนังสือคือ ( ๆ ) ชุดของฟังก์ชั่นที่ใช้บางชนิดเป็นพารามิเตอร์และส่งกลับชนิดเดียวกัน monadเป็น ( ๆ ) ชุดของฟังก์ชั่นที่ใช้เป็นกระดาษห่อประเภทเป็นพารามิเตอร์และส่งกลับชนิดกระดาษห่อเดียว หมายเหตุเหล่านั้นคือคำอธิบายไม่ใช่คำจำกัดความ รู้สึกอิสระที่จะโจมตีคำอธิบายนั้น! ดังนั้นในภาษา OO monad อนุญาตให้มีองค์ประกอบการดำเนินการเช่น: Flier<Duck> m = new Flier<Duck>(duck).takeOff().flyAround().land() โปรดทราบว่า monad กำหนดและควบคุมซีแมนทิกส์ของการดำเนินการเหล่านั้นมากกว่าคลาสที่มีอยู่ ตามเนื้อผ้าในภาษา OO เราจะใช้ลำดับชั้นและการสืบทอดเพื่อให้ความหมายเหล่านั้น ดังนั้นเราจึงต้องการมีBirdระดับด้วยวิธีการtakeOff(), flyAround()และland()และเป็ดจะได้รับมรดกเหล่านั้น แต่แล้วเราก็มีปัญหากับนกที่บินไม่ได้เพราะpenguin.takeOff()ล้มเหลว เราต้องหันไปใช้ข้อยกเว้นในการขว้างและจัดการ นอกจากนี้เมื่อเราบอกว่าเพนกวินเป็นเราทำงานเป็นปัญหากับมรดกหลายตัวอย่างเช่นถ้าเรายังมีลำดับชั้นของBirdSwimmer โดยพื้นฐานแล้วเรากำลังพยายามที่จะใส่คลาสเป็นหมวดหมู่ (ด้วยการขอโทษกับหมวดหมู่ทฤษฎีพวก) และกำหนดความหมายตามหมวดหมู่มากกว่าในแต่ละชั้นเรียน แต่พระสงฆ์ดูเหมือนจะเป็นกลไกที่ชัดเจนกว่าสำหรับการทำเช่นนั้นมากกว่าลำดับชั้น ดังนั้นในกรณีนี้เราจะมีFlier<T>monad เหมือนตัวอย่างด้านบน: Flier<Duck> m = new Flier<Duck>(duck).takeOff().flyAround().land() ... Flier<Penguin>และเราจะไม่ยกตัวอย่าง เราสามารถใช้การพิมพ์แบบคงที่เพื่อป้องกันสิ่งนั้นไม่ให้เกิดขึ้นด้วยอินเทอร์เฟซของตัวทำเครื่องหมาย …

20 object-oriented  monad 

สมมติว่าคุณทำงานให้กับ บริษัท และสิ่งที่คุณทำคือการพัฒนาซอฟต์แวร์สำหรับพวกเขา คุณไม่มีความคิดในภาพรวมหรืออาจจะเล็กน้อย สิ่งที่คุณมีคืองานที่มอบหมายให้คุณผ่านระบบติดตามปัญหา คุณได้รับงานคุณทำให้งานเป็นไปตามที่งานอธิบายคุณส่งงานกลับมา ชอบเพิ่ม 2 จำนวนเต็ม: function add(a,b){return a + b;} แต่ต่อมาเมื่อโครงการดำเนินไปข้างหน้าคุณจะสังเกตเห็นว่าในขณะที่addมีความซับซ้อนมากขึ้นคุณรู้ว่ามันควรจะต้องมีรูปแบบของสถาปัตยกรรมมากกว่าฟังก์ชั่นที่เพิ่มพารามิเตอร์และส่งกลับค่า อย่างไรก็ตามคุณไม่ทราบว่า addในสถานที่แรกทั้งหมดที่พวกเขาต้องการก็คือง่ายๆที่ คุณไม่ได้คาดหวังว่าการเพิ่มจะซับซ้อนนัก โครงการดำเนินไปด้วยคุณสมบัติที่มากขึ้นซึ่งคุณไม่ได้คาดหวังไว้ตั้งแต่แรก และในที่สุดคุณก็เก็บซ้อนแฮ็คและเลเยอร์ตามเลเยอร์ของฟังก์ชั่นเพื่อหลีกเลี่ยงการทำลาย / เขียนรหัสที่มีอยู่ใหม่ คุณรับมือกับสถานการณ์เหล่านี้อย่างไร? คุณต่อสู้กับหนี้ทางเทคนิคในฐานะ "ผู้พัฒนาที่ต่ำที่สุด" ได้อย่างไร? ชี้แจง: คุณคือ "implementer" ซึ่งต่ำที่สุดในลำดับชั้น คุณเห็นปัญหา แต่ไม่ได้พูดกับเรื่องนี้ ฉันไม่ได้ระบุปริมาณหนี้ทางเทคนิคหรือมองหาเครื่องมือ เกี่ยวกับ"ซ้ำ" ที่สาม การ Refactoring & Rewrite - คุณถูกล็อคในงานของคุณ คุณไม่ได้รับค่าตอบแทนในการทำสิ่งพิเศษ ภาพรวมสถาปัตยกรรม - คุณรู้ระบบโดยรวม แต่ไม่มีแนวคิดเกี่ยวกับสถาปัตยกรรม Code Freeze - ไม่ใช่การโทรของคุณ …

20 architecture  software  scalability  maintainability  technical-debt 

ฉันกำลังทำงานกับซอฟต์แวร์บางอย่างในขณะนี้และฉันไม่แน่ใจว่าจะใช้เส้นทางนี้กับอะไร ฉันมีข้อมูลบางอย่างเพื่อเก็บไว้ที่ไหนสักแห่งบนอุปกรณ์มือถือ ข้อมูลจะไม่เปลี่ยนแปลงและมีความสัมพันธ์แบบลำดับชั้นและจะใช้ในการเติมการแสดงผล ข้อมูลนี้มีจำนวนพอสมควร ฉันมีตัวเลือกดังต่อไปนี้: ชุดของ enums / วัตถุ ไฟล์ XML ฐานข้อมูล SQLite แบบฝัง ในกรณีพิเศษนี้ฉันคิดว่าตัวเลือก enums นั้นใช้งานได้น้อยที่สุด แต่ฉันได้กลิ่นจากข้อมูลที่ฝังอยู่ในโค้ดเช่นนั้น ไฟล์ XML เหมาะสมที่สุดที่ฉันคิด แต่การแยกวิเคราะห์จะเป็นแหล่งข้อมูลที่ดูเหมือนว่าเสียเพราะจะไม่มีการเปลี่ยนแปลง ฐานข้อมูลควรให้ประสิทธิภาพการทำงานน้อยลง แต่ดูเหมือนว่า overkill สำหรับข้อมูลคงที่ เส้นทางการออกแบบที่ถูกต้องที่นี่คืออะไร? หมายเหตุ:การเปลี่ยนแปลง 'ไม่' ฉันหมายถึงว่ามันจะไม่ค่อยเปลี่ยนแปลง ข้อมูลที่เป็นปัญหานั้นเป็นแบบจำลองของมาตรฐานรัฐบาลดังนั้นอาจมีการเปลี่ยนแปลงในบางจุดในอนาคต แต่จะไม่เป็นประจำและจะไม่อัปเดตซอฟต์แวร์ของเราโดยอัตโนมัติเมื่อการเปลี่ยนแปลงมาตรฐานทำได้ดี ก่อให้เกิดการเปลี่ยนแปลงในข้อกำหนดของเรา

20 design