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

ฉันมีความสนุกสนานเมื่อเร็ว ๆ นี้สำรวจการพัฒนาของ parsers ภาษาในบริบทของวิธีที่พวกเขาเหมาะสมกับลำดับชั้น Chomsky ตัวอย่างของไวยากรณ์ที่ไวต่อบริบทคืออะไรในโลกแห่งความจริง (เช่นไม่ใช่ทางทฤษฎี)

9 language-design  parsing  grammar 

นี่เป็นปัญหาเล็กน้อย มีเอนทิตีที่มีค่าวัตถุ ไม่ใช่ปัญหา. ฉันแทนที่วัตถุค่าสำหรับวัตถุใหม่จากนั้น nhibernate จะแทรกค่าใหม่และกำพร้าของเก่าแล้วลบทิ้ง ตกลงนั่นเป็นปัญหา ผู้ประกันตนเป็นนิติบุคคลของฉันในโดเมนของฉัน เขามีชุดของที่อยู่ (วัตถุค่า) หนึ่งในที่อยู่คือ MailingAddress เมื่อเราต้องการอัพเดทที่อยู่ทางไปรษณีย์สมมติว่ารหัสไปรษณีย์ผิดตามหลักคำสอนของ Mr. Evans เราต้องแทนที่วัตถุเก่าสำหรับที่อยู่ใหม่เนื่องจากมันไม่เปลี่ยนรูป แต่เราไม่ต้องการลบแถวเจ้าเนื่องจาก PK ของที่อยู่นั้นเป็น FK ในตาราง MailingHistory ดังนั้นตามหลักคำสอนของนายอีแวนส์เรารู้สึกเมามากที่นี่ เว้นแต่ฉันจะทำให้ที่อยู่ของฉันเป็นรายการดังนั้นฉันไม่จำเป็นต้อง "แทนที่" มันและเพียงอัปเดตสมาชิกรหัสไปรษณีย์เช่นวันที่ดีเก่า ๆ คุณจะแนะนำอะไรให้ฉันในกรณีนี้ วิธีที่ฉันเห็นมัน ValueObjects จะมีประโยชน์ก็ต่อเมื่อคุณต้องการสรุปแค็ปซูลกลุ่มของคอลัมน์ของตารางฐานข้อมูล (คอมโพเนนต์ใน nhibernate) ทุกอย่างที่มีรหัสการคงอยู่ในฐานข้อมูลจะดีกว่าถ้าจะให้เป็น Entity (ไม่จำเป็นต้องเป็น root รวม) เพื่อให้คุณสามารถอัปเดตสมาชิกโดยไม่ต้องสร้างกราฟวัตถุทั้งหมดใหม่โดยเฉพาะหากเป็นวัตถุที่ซ้อนกันลึก คุณเห็นด้วยไหม นายอีแวนส์ได้รับอนุญาตให้มีวัตถุค่าที่ไม่แน่นอนหรือไม่? หรือเป็นค่าที่ไม่แน่นอนวัตถุผู้สมัครสำหรับนิติบุคคลหรือไม่ ขอบคุณ

9 domain-driven-design 

ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้เป็นหัวข้อสำหรับ Software Engineering Stack Exchange ปิดให้บริการใน7 ปีที่ผ่านมา เพื่อนของฉัน (เรียกเขาว่าโจ ) กำลังทำงานในโครงการที่มีแนวโน้มและขอความช่วยเหลือจากฉัน เป็นเรื่องของมิตรภาพฉันเห็นด้วย (ปากเปล่า) ที่จะไม่หารือเกี่ยวกับรายละเอียด แต่ตอนนี้เขามีนักลงทุนที่มีศักยภาพที่ต้องการให้ฉันลงนามข้อตกลงที่ไม่เปิดเผย (NDA) เนื่องจากงานของฉันทั้งหมดเป็นมืออาชีพฉันบอกโจว่าฉันไม่สบายใจที่จะต้องรับผิดชอบเอกสารทางกฎหมายโดยไม่มีการชดเชยความเสี่ยง (ไม่จำเป็นต้องเป็นการเงินอย่างเคร่งครัดฉันจะยอมรับสัดส่วนการถือหุ้นเพียงเล็กน้อยหรืออาจรับประกันเครดิตในรหัสและเอกสาร) คำขอของฉันสมเหตุสมผลหรือไม่หรือฉันเพิ่งแนะนำความซับซ้อนที่ไม่จำเป็น

9 legal  contract  non-disclosure-agreement 

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

9 design-patterns  delegates  observer-pattern 

ฉันรู้ว่าเป็นไปได้ที่จะขายรหัส GPL แต่ฉันต้องการทราบว่าเป็นไปได้ที่จะขายรหัส GPL ที่แยกและแก้ไขแล้วหรือไม่ รหัสที่แยกและแก้ไขจะยังคงพร้อมใช้งานแก้ไขและแจกจ่ายต่อ

9 licensing  gpl 

อยากรู้อยากเห็นมีภาษาที่ช่วยให้คุณสามารถตั้งค่าทางคณิตศาสตร์ในประเภทที่จะสร้างประเภทใหม่ได้หรือไม่ สิ่งที่ต้องการ: interface A { void a(); void b(); } interface B { void b(); void c(); } interface C = A & B; // has b() interface D = A | B; // has a(), b() and c() interface E = (A & B) ^ B; // has c() …

9 programming-languages  type-systems 

ฉันได้อ่านบทความเกี่ยวกับการเขียนโปรแกรมฟังก์ชั่นทุกวันและพยายามที่จะใช้แนวทางปฏิบัติบางอย่างให้มากที่สุด แต่ฉันไม่เข้าใจสิ่งที่เป็นเอกลักษณ์ในการประยุกต์ใช้การ currying หรือบางส่วน ใช้โค้ด Groovy นี้เป็นตัวอย่าง: def mul = { a, b -> a * b } def tripler1 = mul.curry(3) def tripler2 = { mul(3, it) } ฉันไม่เข้าใจความแตกต่างระหว่างtripler1และtripler2คืออะไร พวกเขาทั้งคู่ไม่เหมือนกันหรือ 'การแกง' ได้รับการสนับสนุนในภาษาที่ใช้งานได้จริงหรือบางส่วนเช่น Groovy, Scala, Haskell เป็นต้น แต่ฉันสามารถทำสิ่งเดียวกันได้ (แกงเผ็ดซ้าย, แกงกะหรี่ขวา, แกงกะหรี่หรือแอปพลิเคชั่นบางส่วน) เพียงแค่สร้างชื่อหรือไม่ระบุชื่อ ฟังก์ชั่นหรือการปิดที่จะส่งต่อพารามิเตอร์ไปยังฟังก์ชั่นเดิม (เช่นtripler2) ในภาษาส่วนใหญ่ (แม้ C. ) ฉันทำอะไรบางอย่างหายไปหรือเปล่า มีสถานที่ที่ฉันสามารถใช้แอปพลิเคชั่นการแกงและบางส่วนในแอปพลิเคชัน …

9 functional-programming  groovy  higher-order-functions  currying 

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

9 java  c#  c++  exceptions 

ฉันกำลังทำงานกับโมดูลการซิงโครไนซ์เนื้อหาสำหรับ Drupal มีโมดูลเซิร์ฟเวอร์ซึ่งตั้งอยู่บนเว็บไซต์ ona และแสดงเนื้อหาผ่านบริการเว็บ นอกจากนี้ยังมีโมดูลไคลเอนต์ซึ่งตั้งอยู่บนเว็บไซต์ที่แตกต่างกันและดึงข้อมูลและนำเข้าเนื้อหาในช่วงเวลาปกติ เซิร์ฟเวอร์ถูกสร้างใน Drupal 6 ไคลเอนต์ถูกสร้างขึ้นใน Drupal 7 จะต้องมีเซิร์ฟเวอร์รุ่น Druapl 7 และจากนั้นจะต้องใช้ Drupal 8 ทั้งไคลเอนต์และเซิร์ฟเวอร์เมื่อเปิดตัวในปีหน้า ฉันค่อนข้างใหม่กับ git และ source control ดังนั้นฉันจึงสงสัยว่าวิธีที่ดีที่สุดในการตั้งค่าที่เก็บ git คืออะไร? มันจะเป็นกรณีของการมีพื้นที่เก็บข้อมูลแยกต่างหากสำหรับแต่ละตัวอย่างเช่น: Drupal 6 server = 1 repository Drupal 6 client = 1 repository Drupal 7 server = 1 repository Drupal 7 client = …

9 version-control  git  drupal 

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

9 testing  version-control  development-methodologies  branching 

วันนี้เราพยายามแนะนำ BDD ในกระบวนการพัฒนาซอฟต์แวร์ของเราโดยมีเวิร์กช็อปสเปค สำหรับเวิร์คช็อปนี้เรามีนักพัฒนา 2 คนผู้ทดสอบ 1 คนและนักวิเคราะห์ธุรกิจ 1 คน การประชุมเชิงปฏิบัติการใช้เวลา 1h30 และในตอนท้ายเราได้จัดการกับสถานการณ์ BDD บางอย่างสำหรับคุณสมบัติใหม่ของเรา เราพยายามที่จะมุ่งเน้นไปที่การค้นหาสถานการณ์ที่เราอาจพลาดและสิ่งที่ยากลำบาก ในตอนท้ายของการประชุมเชิงปฏิบัติการบางคนไม่พอใจกับการประชุมเชิงปฏิบัติการ นักพัฒนาคนหนึ่งรู้สึกว่าเขาเสียเวลาขณะที่เขาคุ้นเคยกับการอธิบายสถานการณ์โดยตรงจากนักวิเคราะห์ธุรกิจและตรวจสอบกับเธอ นักวิเคราะห์ธุรกิจไม่รู้สึกมั่นใจกับการครอบคลุมสถานการณ์ของเรา (มีความรู้สึกว่าเราสามารถพลาดสิ่งสำคัญอื่น ๆ ได้) แต่ที่สำคัญกว่านั้นรู้สึกว่าการประชุมเชิงปฏิบัติการนี้เป็นการเสียเวลาเพราะเธอสามารถเข้าใจสถานการณ์เหล่านี้ทั้งหมดด้วยตัวเอง และในช่วงเวลาอันสั้น การประชุมเชิงปฏิบัติการทดลองนี้ใช้เวลา 1h30 และในตอนท้ายเราไม่รู้สึกมั่นใจเพียงพอเกี่ยวกับสิ่งที่เราทำ ... แน่ใจว่าเราสามารถใช้เวลากับมันได้ แต่คนส่วนใหญ่หมดแรงหลังจากการระดมสมองใน 1h30 เพื่อดึงธุรกิจออกมา กฎจากสมองของ BA ดังนั้นคำถามของฉันคือวิธีการประชุมเชิงปฏิบัติการประเภทนั้นสามารถทำงานได้จริง ในทางทฤษฎีเมื่อคุณมีคุณสมบัติใหม่ในการพัฒนาคุณวางต้นไม้ 'amigos' (dev / tester / ba) ในห้องเดียวกันเพื่อให้พวกเขาสามารถทำงานร่วมกันในการเขียนข้อกำหนด differents สำหรับคุณลักษณะใหม่โดยใช้ตัวอย่าง ฉันเห็นประโยชน์ทั้งหมดจากสิ่งนั้น พิเศษในแง่ของการแบ่งปันความรู้และผลิตภัณฑ์ทั่วไป / เป้าหมายสุดท้าย / …

9 bdd 

ภาษาโปรแกรมสมัยใหม่จำนวนมากสนับสนุนแนวคิดเรื่องการปิดบางอย่างเช่นโค้ด (บล็อกหรือฟังก์ชัน) ที่ สามารถถือเป็นค่าและเก็บไว้ในตัวแปรส่งผ่านไปยังส่วนต่าง ๆ ของรหัสที่กำหนดไว้ในส่วนหนึ่งของโปรแกรมและเรียกใช้ในส่วนที่แตกต่างกันโดยสิ้นเชิงของโปรแกรมเดียวกัน สามารถจับตัวแปรจากบริบทที่มันถูกกำหนดและเข้าถึงพวกมันเมื่อมันถูกเรียกใช้ในภายหลัง (อาจเป็นในบริบทที่แตกต่างกันโดยสิ้นเชิง) นี่คือตัวอย่างของการปิดที่เขียนใน Scala: def filterList(xs: List[Int], lowerBound: Int): List[Int] = xs.filter(x => x >= lowerBound) ฟังก์ชั่นตัวอักษรx => x >= lowerBoundมีตัวแปรอิสระlowerBoundซึ่งถูกปิด (ผูกพัน) โดยอาร์กิวเมนต์ของฟังก์ชั่นfilterListที่มีชื่อเดียวกัน การปิดจะถูกส่งไปยังวิธีการของไลบรารีfilterซึ่งสามารถเรียกใช้ซ้ำได้ตามฟังก์ชั่นปกติ ฉันได้อ่านคำถามและคำตอบมากมายในเว็บไซต์นี้และเท่าที่ฉันเข้าใจการปิดเทอมมักจะเกี่ยวข้องกับการเขียนโปรแกรมฟังก์ชั่นและรูปแบบการเขียนโปรแกรมการทำงานโดยอัตโนมัติ คำนิยามของฟังก์ชั่นการเขียนโปรแกรมบนวิกิพีเดียอ่าน: ในวิทยาการคอมพิวเตอร์การเขียนโปรแกรมเชิงการทำงานเป็นกระบวนทัศน์การเขียนโปรแกรมที่ปฏิบัติกับการคำนวณเป็นการประเมินฟังก์ชั่นทางคณิตศาสตร์และหลีกเลี่ยงข้อมูลสถานะและไม่แน่นอน มันเน้นการประยุกต์ใช้ฟังก์ชั่นในทางตรงกันข้ามกับรูปแบบการเขียนโปรแกรมจำเป็นซึ่งเน้นการเปลี่ยนแปลงในรัฐ และเพิ่มเติมเกี่ยวกับ [... ] ในโค้ดการทำงานค่าเอาต์พุตของฟังก์ชันขึ้นอยู่กับอาร์กิวเมนต์ที่ป้อนเข้ากับฟังก์ชัน [... ] เท่านั้น การกำจัดผลข้างเคียงสามารถทำให้เข้าใจและคาดการณ์พฤติกรรมของโปรแกรมได้ง่ายขึ้นซึ่งเป็นหนึ่งในแรงจูงใจหลักสำหรับการพัฒนาโปรแกรมเชิงฟังก์ชัน ในทางตรงกันข้ามการปิดโครงสร้างจำนวนมากที่จัดทำโดยภาษาการเขียนโปรแกรมช่วยให้การปิดการจับตัวแปรที่ไม่ใช่ท้องถิ่นและเปลี่ยนแปลงพวกเขาเมื่อปิดการเรียกจึงทำให้เกิดผลข้างเคียงกับสภาพแวดล้อมที่พวกเขาถูกกำหนดไว้ ในกรณีนี้การปิดใช้ความคิดแรกของการเขียนโปรแกรมเชิงฟังก์ชัน (ฟังก์ชั่นเป็นเอนทิตีชั้นหนึ่งที่สามารถเคลื่อนย้ายไปมาเหมือนค่าอื่น ๆ ) แต่ไม่สนใจความคิดที่สอง (หลีกเลี่ยงผลข้างเคียง) การใช้การปิดด้วยผลข้างเคียงนี้ถือเป็นลักษณะการใช้งานหรือเป็นการปิดซึ่งเป็นการสร้างทั่วไปที่สามารถใช้งานได้ทั้งการใช้งานและการเขียนโปรแกรมแบบไม่ทำงาน? …

9 programming-languages  closures 

ขณะนี้ฉันกำลังพยายามสร้างกรณีสำหรับการใช้การจัดการการพึ่งพาสำหรับการสร้าง (ala Maven, Ivy, NuGet) และสร้างที่เก็บภายในสำหรับโมดูลที่ใช้ร่วมกันซึ่งเรามีองค์กรมากกว่าโหล จุดขายหลักของเทคนิคการสร้างนี้คืออะไร? สิ่งที่ฉันมี: ทำให้กระบวนการแจกจ่ายและนำเข้าโมดูลที่ใช้ร่วมกันโดยเฉพาะการอัพเกรดเวอร์ชั่น ต้องมีการขึ้นต่อกันของโมดูลที่ใช้ร่วมกัน ลบที่ใช้ร่วมกันโมดูลจากการควบคุมแหล่งเร่งและลดความซับซ้อนจ่ายเงิน / เช็คอิน(เมื่อคุณมีการใช้งานกับ 20 + ห้องสมุดนี้เป็นปัจจัยที่แท้จริง) อนุญาตให้ควบคุมหรือรับรู้ถึงสิ่งที่ libs ของบุคคลที่สามที่ใช้ในองค์กรของคุณ มีจุดขายใดที่ฉันขาดหายไปหรือไม่? มีการศึกษาหรือบทความใดบ้างที่ให้ตัวชี้วัดการปรับปรุง?

9 dependency-management 

บางโปรเจ็กต์ชนเวอร์ชันก่อนที่จะเริ่มการพัฒนาใหม่ในขณะที่โปรเจ็กต์อื่น ๆ ชนเวอร์ชันเมื่อแท็กการปล่อย วิธีไหนดีกว่ากัน หากหมายเลขเวอร์ชั่นไม่เปลี่ยนแปลงในช่วงเริ่มต้นของเฟสใหม่ผู้พัฒนาอาจลืมที่จะเปลี่ยนแปลงและเพียงแค่ปล่อยโปรแกรม หากหมายเลขเวอร์ชันเปลี่ยนไปก่อนการแท็กปล่อยดังนั้น 2 หมายเลขเวอร์ชัน (แท็กและ Makefile / AssemblyInfo.cs) จะไม่ตรงกัน git describe อาจให้คุณ v1.2.3.4-15-g1234567 หากการแก้ไขปัจจุบันหลังจาก v1.2.3.4 แต่คุณได้เปลี่ยนไฟล์ไปเป็น v1.2.3.5 แล้ว

9 version-control  versioning 

ฉันต้องการสร้างแอปพลิเคชันที่เรียบง่ายและพิสูจน์ความคิดรวบยอด (REPL) ที่ใช้ตัวเลขแล้วประมวลผลคำสั่งกับหมายเลขนั้น ตัวอย่าง: ฉันเริ่มต้นด้วย 1 จากนั้นฉันเขียน " add 2" มันให้ฉัน 3. จากนั้นฉันเขียน " multiply 7" มันให้ 21 ฉันแล้วฉันต้องการทราบว่ามันเป็นนายกฉันเขียน " is prime" (ในจำนวนปัจจุบัน - 21) มันทำให้ฉันเป็นเท็จ " is odd" จะให้ฉันจริง และอื่น ๆ ตอนนี้สำหรับแอ็พพลิเคชันแบบง่ายที่มีคำสั่งไม่กี่อย่างแม้แต่แบบธรรมดาswitchก็สามารถทำได้เพื่อประมวลผลคำสั่ง แต่ถ้าฉันต้องการความสามารถในการขยายฉันจะต้องใช้ฟังก์ชันนี้อย่างไร ฉันใช้รูปแบบคำสั่งหรือไม่ ฉันจะสร้าง parser / interpreter ง่าย ๆ สำหรับภาษาได้หรือไม่? ถ้าฉันต้องการคำสั่งที่ซับซ้อนมากขึ้นเช่น " multiply 5 until >200" สิ่งที่จะเป็นวิธีที่ง่ายในการขยาย (เพิ่มคำสั่งใหม่) …

9 parsing  text-processing