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

ฉันมีโครงสร้างโครงการเช่นนี้: My Project - Other Team's Project -Third Party Dependency My Projectต้องการOther Team's Projectฟังก์ชั่นและทั้งสองMy ProjectและOther Team's Projectจำเป็นต้องมีThird Party Dependencyฟังก์ชั่น เรากำลังใช้ระบบการจัดการการพึ่งพาเพื่อจัดการสิ่งเหล่านี้ จากมุมมองการออกแบบจะดีกว่าที่จะMy Projectพึ่งพาการขนส่งThird Party Dependencyหรือไม่ หรือมันจะดีกว่าสำหรับทั้งสองMy ProjectและOther Team's Projectทั้งสองอย่างชัดเจนประกาศว่าพวกเขาใช้Third Party Dependency? สิ่งอื่น ๆ : Third Party Dependencyทั้งสองโครงการจะต้องมีรุ่นเดียวกัน ไม่รับประกันว่าหากOther Team's Projectได้รับการปรับปรุงที่My Projectจะถูกทดสอบเพื่อให้แน่ใจว่าไม่มีอะไรแตกเพราะได้รับการจัดการโดยทีมที่แตกต่างกัน

11 dependency-management 

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

11 refactoring  code-quality  branching 

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

11 business-rules 

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

11 language-design 

เมื่อฉันทำงานในสาขาฟีเจอร์ฉันมักจะต้องการล้างคอมมิชชันในสาขาโดยใช้การรีบูตแบบโต้ตอบก่อนที่งานของฉันจะได้รับการตรวจสอบและบูรณาการในสาขาหลัก ในระหว่างการพัฒนาคุณลักษณะฉันต้องการผลักดันงานกลางของฉันไปยังที่เก็บข้อมูลระยะไกลเพื่อเป็นการสำรองข้อมูล เช่นเมื่อฮาร์ดไดรฟ์ล่มฉันไม่ต้องการให้ฟีเจอร์สาขาของฉันหาย อย่างไรก็ตามสิ่งนี้นำไปสู่ความจริงที่ว่าฉันมักจะต้องทำgit push --forceกับที่เก็บระยะไกลหลังจาก rebase การกระทำที่ขมวดคิ้วโดยทั่วไป หรือเป็นหน้า GitHub ที่เชื่อมโยงพูดว่า: เนื่องจากการเปลี่ยนประวัติการกระทำของคุณอาจทำให้ทุกคนยากลำบากในการใช้พื้นที่เก็บข้อมูลจึงถือว่าเป็นการปฏิบัติที่ไม่ถูกต้องในการรีบูตคอมมิทเมื่อคุณส่งไปยังพื้นที่เก็บข้อมูลแล้ว มีนโยบาย (ที่ยอมรับกันโดยทั่วไป) ที่แก้ไขข้อขัดแย้งนี้หรือไม่? ทำไมสิ่งนี้จึงไม่ซ้ำซ้อนกับ git "Golden Rule of Rebasing" จำเป็นหรือไม่ คำถามของฉันที่นี่ถามถึงนโยบายในการแก้ปัญหาความขัดแย้งระหว่างต้องการสำรองข้อมูลงานของคุณในที่เก็บระยะไกลและการรีบูตงานของคุณในขณะที่คำถามอื่นพยายามปฏิเสธว่ามีข้อขัดแย้งและถามว่าทำไมบางคนคิดว่าความขัดแย้งมีอยู่จริง และจึงถามว่าทำไม "สำคัญมาก" ที่จะไม่ผลักดันการแย่งชิงกำลัง

11 git 

ฉันกำลังแก้ไขคำถามอัลกอริทึมและการวิเคราะห์ของฉันคือมันจะทำงานบน O (2 ^ sqrt (n)) มันใหญ่แค่ไหน? มันเท่ากับ O (2 ^ n) หรือไม่? มันยังเป็นเวลาที่ไม่ใช่พหุนามหรือไม่?

11 big-o  algorithm-analysis 

ฉันกำลังเรียนรู้ Haskell และฉันกำลังมองหาเครื่องมือการเยื้องอัตโนมัติ ฉันไม่ได้ดูมากนักและเรียนรู้ว่าใน Haskell (เช่นเดียวกับใน Python) การเยื้องนั้นหมายถึงบล็อก ด้วยเหตุนี้ฉันเดาว่าเป็นไปไม่ได้ที่จะสร้างเครื่องมือการจัดรูปแบบอัตโนมัติที่แข็งแกร่งเช่นเดียวกับในภาษาอื่น ๆ ในตระกูล C ที่ใช้ตัวระบุที่ชัดเจนเช่น {} (เครื่องหมายปีกกา) หรือbegin endคำหลัก ฉันไม่สนใจภาษาที่บังคับให้ย่อหน้าเพื่อให้อ่านได้ แต่ฉันไม่สามารถเข้าใจถึงประโยชน์ของทั้งการบังคับใช้การเยื้องและมีเครื่องหมายระบุชัดเจนเพื่อให้เครื่องมืออัตโนมัติสามารถเข้าใจสิ่งที่อยู่ในบล็อกนั้น หากการตั้งค่าการเยื้องเป็นตัวทำเครื่องหมายบล็อกเป็นเพื่อให้รหัสดูดีขึ้นแล้วฉันยังไม่เข้าใจความได้เปรียบ เนื่องจากแท็บและช่องว่างมีการแสดงแตกต่างกันในเครื่องมือแก้ไขและแบบอักษรที่แตกต่างกัน (แบบอักษรช่องว่างเดียวเช่น look tidier) จึงไม่สามารถคาดหวังว่าโปรแกรมเมอร์จะแสดงรหัสอย่างเหมาะสม เครื่องมือที่สามารถพิจารณาโปรแกรมแก้ไขข้อความปัจจุบันจะเหมาะสมกว่าในการจัดรูปแบบรหัสอย่างถูกต้อง เหตุใดนักออกแบบภาษาจึงเลือกการเยื้องผ่านตัวทำเครื่องหมายบล็อกอย่างชัดเจน

11 programming-languages  language-agnostic  language-design 

มีการเขียนโปรแกรมใด ๆ (หรือสคริปต์) ภาษา (หรือบางภาษาเฉพาะโดเมน) มีสองผู้ประกอบการไบนารีoplและoprของเดียวกันความสำคัญกับoplการถูกทิ้ง-เชื่อมโยงและoprเป็นขวาเชื่อมโยง? (ฉันไม่สามารถหาตัวอย่างได้ แต่ฉันพยายามที่จะเขียนโค้ดตัวแยกวิเคราะห์ทั่วไปพอที่จะจัดการกับกรณีแปลก ๆ นั้น) จะแยกนิพจน์ของรูปแบบx opl y opr zหรือx opr y opl zได้อย่างไร และโดยทั่วไปกับตัวถูกดำเนินการมากขึ้น?

11 language-design  parsing 

ขณะนี้ฉันกำลังทำงานกับ webapp ซึ่งเรามักจะต้องกำหนดเงื่อนไขของเซิร์ฟเวอร์บางอย่างโดยอิงจากหน้าเว็บที่จะถูกส่งคืนให้กับผู้ใช้ แต่ละหน้าจะได้รับรหัสหน้า 4 ตัวอักษรและรหัสหน้าเหล่านี้มีการระบุไว้ในชั้นเรียนเป็นสตริงคงที่: public class PageCodes { public static final String FOFP = "FOFP"; public static final String FOMS = "FOMS"; public static final String BKGD = "BKGD"; public static final String ITCO = "ITCO"; public static final String PURF = "PURF"; // etc.. } และบ่อยครั้งที่ในโค้ดเราเห็นโค้ดลักษณะนี้ ( …

11 java  design  enum 

ฉันเคยได้ยินมาโคร Clojure นั้นเขียนได้ง่ายกว่า แต่ไม่น่าเชื่อถือเท่ากับแมโครที่ถูกสุขอนามัยของ Racket คำถามของฉันมี 2 ส่วน: วิธีการที่ไม่gensymแตกต่างจากแมโครที่ถูกสุขอนามัย? มาโคร Racket ให้อะไรที่ Clojure ทำไม่ได้? (ไม่ว่าจะเป็นความปลอดภัยการประกอบหรืออะไรก็ได้)

11 lisp  clojure  macros  meta-programming  racket 

ฉันกำลังสร้างเกม 2d สำหรับเว็บไซต์ที่มีขนาดใหญ่มาก (โดยทั่วไปมีขนาดใหญ่มาก) เริ่มแรกจักรวาลประกอบด้วยดาว 6 ดวงที่อยู่ห่างจากจุดกำเนิดเท่ากัน (0, 0) งานของฉันคือการสร้างดาวให้มากขึ้นซึ่งจะมี "เส้นทาง" (ขอบ) ที่เชื่อมต่อซึ่งกันและกัน ฉันจะออกแบบอัลกอริทึมที่ตรงตามข้อ จำกัด เหล่านี้ได้อย่างไร: ดวงดาวถูกสร้างแบบสุ่มออกไปด้านนอก (เช่น (x, y) พิกัดสำหรับดาวดวงใหม่จะค่อยๆออกไปด้านนอกจาก (0, 0) ในทุกทิศทางโดยเฉพาะในรูปแบบเกลียว ขอบจะไม่ข้าม แม้ว่าจะมีความแตกต่างบ้าง แต่ดาวดวงใหม่ไม่ควรอยู่ไกลหรืออยู่ใกล้ดาวดวงอื่นมากเกินไป (เช่นต้องมีรัศมีต่ำสุด) ไม่มีดาว / จุดควรมีหลายหลากมากกว่า 3 ระบุว่าทั้งหมดนี้จะถูกเก็บไว้ในฐานข้อมูลอัลกอริทึมไม่สามารถมีราคาแพงเกินไป กล่าวอีกนัยหนึ่งฉันชอบที่จะได้รับสิ่งที่ซับซ้อน O (n) (ฉันไม่รู้ว่าสิ่งนี้เป็นไปได้หรือไม่) โดยพื้นฐานแล้วสิ่งที่ฉันกำลังมองหาคือกาแลคซีที่มีลักษณะเป็นดาวหางโดยที่ดวงดาวเป็นจุดบนกราฟและการเดินทางระหว่างดวงดาวจะถูกแสดงด้วยขอบระหว่างดาวเหล่านั้น ขั้นตอนเฉพาะที่ฉันต้องแก้ไขคือ: สร้างจุดในบริเวณใกล้เคียงกับดวงดาวอื่นที่ยังไม่ได้เป็น 3 เท่า ค้นหาดาวดวงแรกที่ยังไม่มีพหุคูณเท่ากับ 3 ซึ่งจะไม่สร้างความขัดแย้งให้กับขอบ หากดาวอยู่ห่างจากหน่วย x อย่างน้อยที่สุดให้สร้างขอบระหว่างจุดสองจุด ฉันพยายามหาวิธีแก้ปัญหา แต่ทักษะคณิตศาสตร์ของฉัน …

11 php  algorithms  mysql  graph  graph-databases 

ตามที่ฉันเข้าใจใน DDD มีความเหมาะสมที่จะใช้รูปแบบพื้นที่เก็บข้อมูลที่มีรูทรวม คำถามของฉันคือฉันควรส่งคืนข้อมูลเป็นนิติบุคคลหรือวัตถุโดเมน / DTO หรือไม่ บางทีรหัสบางอย่างจะอธิบายคำถามของฉันเพิ่มเติม: เอกลักษณ์ public class Customer { public Guid Id { get; set; } public string FirstName { get; set; } public string LastName { get; set; } } ฉันควรทำอะไรแบบนี้ public Customer GetCustomerByName(string name) { /*some code*/ } หรืออะไรแบบนี้ public class CustomerDTO { public …

11 c#  domain-driven-design  repository-pattern 

ถาม: วิธีใดที่ดีที่สุดในการย้าย บริษัท ขนาดใหญ่ไปยัง Cucumber ด้วยความต้องการซอฟต์แวร์รุ่นเก่าอย่างน้อย 15 ปีในฐานข้อมูลความต้องการ กำลังพิจารณา: 1) โยกย้ายทุกอย่าง ข้อเสีย: เราไม่มีเวลา / งบประมาณไม่ จำกัด เราต้องเดินหน้าต่อไปเพื่อความอยู่รอดเราไม่สามารถหยุดทุกสิ่งได้และ GC 100% ของข้อกำหนดดั้งเดิมและชุดทดสอบแบบดั้งเดิม 2) กฎลูกเสือ ปล่อยให้ทุกสิ่งทุกอย่างดีกว่าที่คุณพบ หากคุณสัมผัสข้อกำหนดหรือเปลี่ยนแปลงเขียน / อัปเดตคุณสมบัติแตงกวา ข้อเสีย: เราจะมีระบบการบันทึกสองระบบ (แตงกวามรดกความต้องการฐานข้อมูล) ซึ่งอาจเป็นไปได้ว่าสมมติว่ามีมุมของแอปพลิเคชันที่ให้มาซึ่งไม่ได้สัมผัสเป็นเวลานาน 3) กฎลูกเสือพลัส เหมือนกับ # 2 แต่วางข้อกำหนดซึ่งเราไม่ได้ย้ายไปที่แตงกวาในคุณลักษณะด้วยสถานการณ์ที่รอดำเนินการเดียวและคัดลอก / วางข้อกำหนดดั้งเดิมลงในส่วนคำอธิบาย วิธีนี้เราจะได้รับตัวชี้วัด (ผ่านสถานการณ์ที่รอดำเนินการ) ว่า "ครอบคลุม" เราเป็นอย่างไรโดย Cucumber และทำให้เรามีความต้องการที่จะรักษาระบบข้อกำหนดเก่า ฉันไม่สามารถหาข้อเสียอื่น ๆ นอกเหนือจากนี้อาจเป็นเรื่องใหญ่ใน Cucumber 4) …

11 bdd  cucumber 

ฉันรู้ว่าจาวาสคริปต์ใช้การพิมพ์เป็ดและตอนแรกฉันคิดว่านี่จะทำให้ความแตกต่างง่ายเมื่อเทียบกับภาษาที่พิมพ์อย่างยิ่งเช่น C # แต่ตอนนี้ฟังก์ชั่นของฉันที่รับการโต้แย้งจะเกลื่อนไปด้วยสิ่งต่าง ๆ เช่น: if(myObj.hasSomeProperty()) หรือ if(myObj.hasSomeMethod()) หรือ if(isNumber(myParam)) เป็นต้น นี่มันน่าเกลียดสำหรับฉันจริงๆ ฉันมาจากพื้นหลัง C # และฉันพบว่าอินเตอร์เฟสที่กำหนดไว้นั้นดีกว่ามาก ฉันสงสัยว่าฉันพยายามใช้กลยุทธ์ที่มีประสิทธิภาพในภาษาที่พิมพ์แบบคงที่หรือไม่และมีวิธีที่ดีกว่าในการทำเช่นนี้ใน javascript หรือไม่ ฉันรู้ว่าฉันไม่สามารถตรวจสอบได้ แต่การติดตามข้อผิดพลาดรันไทม์ของจาวาสคริปต์อาจเป็นฝันร้ายเพราะพวกเขามักจะไม่เกิดขึ้นเมื่อเกิดข้อผิดพลาดในรหัส

11 javascript  polymorphism  duck-typing 

บางครั้งผู้ใช้เริ่มการดำเนินการด้านเทคนิคเพิ่มเติมซึ่งใช้เวลาสักครู่ในการดำเนินการ ในกรณีเหล่านี้มักจะแสดงแถบความคืบหน้าพร้อมกับข้อมูลเกี่ยวกับงานที่กำลังดำเนินการอยู่ในขณะนี้ เพื่อหลีกเลี่ยงการมีเพศสัมพันธ์อย่างใกล้ชิดกับ UI และเลเยอร์ตรรกะมันเป็นการดีที่สุดที่จะเกิดการสื่อสารผ่านพร็อกซีบางประเภท นั่นคือแบ็คเอนด์ไม่ควรจัดการองค์ประกอบ UI ของตัวเองหรือแม้กระทั่งโต้ตอบกับเลเยอร์ตัวกลางโดยตรง เห็นได้ชัดว่าจะต้องมีการโทรกลับบางแห่งเพื่อให้งานนี้ ฉันได้นำไปใช้โดยทั่วไปด้วยหนึ่งในสองวิธี: ส่งผ่านวัตถุที่ไม่แน่นอนไปยังส่วนหลังและให้ส่วนหลังเปลี่ยนแปลงอยู่ระหว่างดำเนินการ วัตถุแจ้ง Front-end เมื่อมีการเปลี่ยนแปลงเกิดขึ้น ผ่านฟังก์ชั่นโทรกลับของแบบฟอร์มvoid f(ProgressObject)หรือProgressObject -> unitว่าส่วนหลังเรียกใช้ ในกรณีนี้ back-end สร้างProgressObjectและมันแฝงอย่างสมบูรณ์ มันจะต้องสร้างวัตถุใหม่ทุกครั้งที่ต้องการรายงานความคืบหน้าฉันถือว่า ข้อเสียและข้อดีของวิธีการเหล่านี้คืออะไร? มีวิธีใช้ที่ดีที่สุดตามที่ตกลงกันไว้หรือไม่? มีสถานการณ์ที่แตกต่างกันสำหรับการใช้งานของพวกเขา? มีเทคนิคที่แตกต่างอย่างสิ้นเชิงจากการรายงานความก้าวหน้าที่ฉันมองข้ามไปหรือไม่?

11 design  object-oriented  gui