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

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

11 unit-testing  tdd  code-smell  anti-patterns 

ฉันกำลังทำงานในจุดขายใหม่สำหรับ บริษัท ที่ผลิตภัณฑ์ในราคาที่แตกต่างกันขึ้นอยู่กับส่วนผสมของผลิตภัณฑ์ ผลิตภัณฑ์ทั้งหมดมีราคาฐาน เพื่ออธิบายปัญหาของฉันฉันจะใช้ข้อมูลต่อไปนี้: Product Category Price A 1 45 B 1 70 Q 2 20 R 2 27 S 2 15 X 3 17 Y 3 22 Z 3 16 บริษัท มีแพ็คเกจเช่นแพ็คเกจ "Combo": สำหรับผลิตภัณฑ์ A หรือ B หากคุณเลือก 1 จาก Q หรือ R และ 1 จาก X, Y …

11 web-development  database  database-design  schema  relationships 

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

11 licensing  mit-license 

ฉันได้รับการสำรวจคุณสมบัติใหม่ใน JDK8 เช่นการแสดงออกแลมบ์ดาวิธีการขยายและสตรีม API ใหม่ เห็นได้ชัดว่าไม่มีคุณสมบัติเหล่านี้ใหม่ในโลกการเขียนโปรแกรมและทำให้สงสัยว่าทำไมสิ่งเหล่านี้ได้รับใน Java จนถึงปัจจุบัน เรามีการแสดงออกแลมบ์ดาใน Lisp (1958), SML (1973), Haskell (1990), Python (1991), JavaScript (1994), Ruby (1995), Ruby (1995), Scala (2003), C # (2007) และ 55 ปีหลังจาก Lisp และ แทบทุกคนใน Java (2013) และฉันได้อ่านเกี่ยวกับสตรีมในSIC (1996) ฉันสงสัยว่าทำไมตอนนี้ หลักฐานแสดงให้เห็นว่าการแข่งขันกับภาษาอื่นไม่ใช่แรงจูงใจ ดูเหมือนว่าคุณสมบัติใหม่ ๆ ที่ยอดเยี่ยมใน Java รุ่นนี้เป็นเพียงผลพลอยได้จากการใช้งานแบบคู่ขนาน เรามี lambdas เพราะทำให้การเขียนอัลกอริทึมแบบขนานง่ายขึ้นและเรามีวิธีการขยายเนื่องจากเราต้องการให้พวกเขาให้การสนับสนุนการเปลี่ยนแปลงที่แสดงออกแลมบ์ดาที่ต้องการ ฯลฯ ฯลฯ …

11 java  parallelism  lambda  extension-method 

ถือว่าเป็นแนวปฏิบัติที่ดีที่จะมีสาขาระยะไกลสำหรับนักพัฒนาแต่ละคนในโครงการหรือไม่ เรากำลังใช้ Git กับสาขาดังต่อไปนี้: เจ้านาย ปล่อย พัฒนา หากนักพัฒนาซอฟต์แวร์แต่ละคนมีสาขาของตนเองพวกเขาสามารถกดรหัสลงในสาขาของตนเองและผู้อื่นสามารถรวมการเปลี่ยนแปลงเหล่านี้เข้ากับสาขาของตนเอง

11 version-control  git  branching 

เมื่อเร็ว ๆ นี้ฉันได้เห็นปัญหาที่คล้ายกับปัญหาที่อธิบายไว้ในบทความนี้มากขึ้นเรื่อย ๆ อีกคำสำหรับมันคือสายผลิตภัณฑ์แม้ว่าฉันมักจะเชื่อว่าสิ่งเหล่านี้กับผลิตภัณฑ์ที่แตกต่างกันจริงในขณะที่ฉันมักจะพบปัญหาเหล่านี้ในรูปแบบของการกำหนดค่าผลิตภัณฑ์ที่เป็นไปได้ แนวคิดพื้นฐานของปัญหาประเภทนี้ง่ายมาก: คุณเพิ่มคุณสมบัติให้กับผลิตภัณฑ์ แต่อย่างใดสิ่งที่ซับซ้อนเนื่องจากการรวมกันของคุณสมบัติที่มีอยู่อื่น ๆ ในที่สุด QA พบปัญหากับชุดค่าผสมที่หายากซึ่งไม่มีใครคิดมาก่อนและสิ่งที่ควรเป็นตัวแก้ไขข้อบกพร่องอย่างง่าย ๆ ก็อาจกลายเป็นการต้องการการเปลี่ยนแปลงการออกแบบที่สำคัญ มิติของปัญหาการแยกคุณลักษณะนี้มีความซับซ้อนที่เหลือเชื่อ สมมติว่าเวอร์ชันซอฟต์แวร์ปัจจุบันมีNคุณสมบัติและคุณเพิ่มคุณสมบัติใหม่หนึ่งรายการ นอกจากนี้เราจะทำให้สิ่งต่าง ๆ ง่ายขึ้นด้วยการบอกว่าคุณลักษณะแต่ละอย่างสามารถเปิดหรือปิดได้เท่านั้นจากนั้นคุณ2^(N+1)มีการผสมผสานคุณสมบัติที่เป็นไปได้ที่จะต้องพิจารณา เนื่องจากการขาดการใช้ถ้อยคำที่ดีกว่า / คำค้นหา, ผมหมายถึงการดำรงอยู่ของชุดเหล่านี้เป็นปัญหาคุณลักษณะที่สี่แยก (คะแนนโบนัสสำหรับคำตอบรวมถึงการอ้างอิงสำหรับคำที่กำหนดขึ้น) ตอนนี้คำถามที่ฉันต่อสู้คือวิธีจัดการกับปัญหาความซับซ้อนนี้ในแต่ละระดับของกระบวนการพัฒนา สำหรับเหตุผลด้านราคาที่ชัดเจนมันเป็นไปไม่ได้จนถึงจุดที่เป็นอุดมคติที่ต้องการแยกแต่ละชุดค่าผสม ท้ายที่สุดเราพยายามหลีกเลี่ยงอัลกอริธึมที่ซับซ้อนแบบเอกซ์โปเนนเชียลเพื่อเหตุผลที่ดี แต่เพื่อเปลี่ยนกระบวนการพัฒนาให้กลายเป็นสัตว์ประหลาดขนาดเอ็กซ์โพเนนเชียล ดังนั้นคุณจะได้รับผลลัพธ์ที่ดีที่สุดในแบบที่เป็นระบบที่ไม่ระเบิดงบประมาณใด ๆ และเสร็จสมบูรณ์ในวิธีที่เหมาะสมมีประโยชน์และเป็นที่ยอมรับอย่างมืออาชีพ ข้อมูลจำเพาะ: เมื่อคุณระบุคุณลักษณะใหม่ - คุณจะมั่นใจได้อย่างไรว่ามันเล่นได้ดีกับเด็กคนอื่น ๆ ทั้งหมด? ฉันสามารถเห็นได้ว่ามีใครสามารถตรวจสอบแต่ละคุณลักษณะที่มีอยู่ร่วมกับคุณลักษณะใหม่อย่างเป็นระบบ แต่จะแยกคุณลักษณะอื่น ๆ เมื่อพิจารณาถึงลักษณะที่ซับซ้อนของคุณลักษณะบางอย่างมุมมองที่แยกได้นี้มักเกี่ยวข้องกันอยู่แล้วเพื่อให้ต้องการแนวทางแบบมีโครงสร้างในตัวเองโดยไม่คำนึงถึง2^(N-1)ปัจจัยที่เกิดจากคุณสมบัติอื่น ๆ ที่เราไม่สนใจ การติดตั้งใช้งาน: เมื่อคุณติดตั้งฟีเจอร์ - คุณจะมั่นใจได้อย่างไรว่าโค้ดของคุณโต้ตอบ / ตัดกันอย่างถูกต้องในทุกกรณี อีกครั้งฉันสงสัยเกี่ยวกับความซับซ้อนที่แท้จริง …

11 complexity  product-features 

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

11 browser  fonts  rendering 

แค่อ่านนี้ในREST API กฎหมาย : GET และ POST จะต้องไม่ถูกนำมาใช้เพื่ออุโมงค์วิธีคำขออื่น Tunneling หมายถึงการใช้ HTTP ในทางที่ผิดหรือปิดบังเจตนาของข้อความผิด ๆ และทำลายความโปร่งใสของโปรโตคอล ส่วนที่เหลือ API ต้องไม่ประนีประนอมการออกแบบโดยวัตถุประสงค์ของ HTTP วิธีการร้องขอในความพยายามไปสู่การรองรับลูกค้าที่มี จำกัด HTTP คำศัพท์ ใช้วิธีการ HTTP อย่างเหมาะสมตามกฎที่ระบุไว้ในส่วนนี้เสมอ [ไฮไลท์โดยฉัน] แต่แล้วจำนวนมากของกรอบการใช้อุโมงค์เพื่อแสดงการเชื่อมต่อผ่านทาง REST รูปแบบ HTML, ตั้งแต่<form>เท่านั้นที่รู้เกี่ยวกับและGET POSTตัวอย่างล่าสุดของฉันเป็นMethodRewriteMiddlewareสำหรับขวด (ส่งโดยผู้เขียนของกรอบ): http://flask.pocoo.org/snippets/38/ มีวิธีใดบ้างที่จะปฏิบัติตาม "กฎ" โดยไม่มีแฮ็กหรือส่วนเสริมในเว็บเฟรมเวิร์ก

11 api  rest  web-framework  http 

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

11 binary  compilation 

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

11 language-agnostic  statistics 

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

11 design  design-patterns  object-oriented  refactoring  single-responsibility 

ฉันเห็นสิ่งนี้: เรียนรู้การเขียนโปรแกรมบนบัตรชกมวย และฉันได้เห็นสิ่งนี้แล้ว: http://en.wikipedia.org/wiki/Computer_programming_in_the_punched_card_era แต่พวกเขาปล่อยให้เป็นที่ต้องการ ทุกคนสามารถอธิบายให้ฉันรู้ได้อย่างไรว่าโปรแกรมเมอร์โปรแกรมเมื่อพวกเขาใช้บัตรคำศัพท์? โดยเฉพาะอย่างยิ่งระบบของคอมพิวเตอร์อินพุตที่ใช้ในการรับคำสั่งจากการ์ดที่ถูกเจาะ ฉันไม่รู้มากเกี่ยวกับคอมพิวเตอร์ย้อนยุคดังนั้นระบบอินพุตใด ๆ ที่คุณคุ้นเคยก็น่าจะดี คำตอบทั่วไปเพิ่มเติมก็ชื่นชมเช่นกัน

11 history 

ฉันเขียนใหม่บางส่วนของMercurial (ซึ่งได้รับอนุญาตภายใต้ GNU GPL v2) ใน C # โดยปกติฉันดูรหัส Python ดั้งเดิมมากและบางส่วนเป็นการแปลโดยตรงจาก Python เป็น C # เป็นไปได้หรือไม่ที่ "รหัสของฉัน" ได้รับอนุญาตภายใต้ข้อกำหนดที่แตกต่างกันหรือแม้กระทั่งเป็นส่วนหนึ่งของแอปพลิเคชันเชิงพาณิชย์แบบโอเพ่นซอร์ส ถ้าไม่ฉันจะอนุญาต "my-code" ภายใต้ LGPL อีกครั้งให้เปิดโอเพนซอร์สแล้วใช้ไลบรารี่ C # แบบโอเพนซอร์สในแอปพลิเคชันเชิงพาณิชย์แบบโอเพ่นซอร์สของฉันได้ไหม

11 licensing  gpl 

สรุป: มีรูปแบบการปฏิบัติที่ดีที่สุดบางอย่างที่ฉันสามารถติดตามเพื่อให้โค้ดของฉันสามารถอ่านได้แม้จะใช้รหัสอะซิงโครนัสและการโทรกลับหรือไม่ ฉันใช้ไลบรารี JavaScript ที่ทำสิ่งต่างๆมากมายแบบอะซิงโครนัสและอาศัยการโทรกลับอย่างหนัก ดูเหมือนว่าการเขียนวิธี "โหลด A, โหลด B, ... " ง่าย ๆ นั้นค่อนข้างซับซ้อนและยากที่จะติดตามโดยใช้รูปแบบนี้ ขอยกตัวอย่าง (contrived) สมมติว่าฉันต้องการโหลดรูปภาพจำนวนมาก (แบบอะซิงโครนัส) จากเว็บเซิร์ฟเวอร์ระยะไกล ใน C # / async ฉันจะเขียนสิ่งนี้: disableStartButton(); foreach (myData in myRepository) { var result = await LoadImageAsync("http://my/server/GetImage?" + myData.Id); if (result.Success) { myData.Image = result.Data; } else { write("error loading …

11 javascript  coding-style  async  continuation 

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

11 logging