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

ฉันกำลังพยายามเลือกเวิร์กโฟลว์ Git ที่เหมาะสมที่สุดสำหรับผลิตภัณฑ์ของเรา นี่คือพารามิเตอร์: เรามีการเปิดตัวรุ่นใหญ่สองสามครั้งต่อปีสมมติว่ามากที่สุด 10 รายการ เรามีผลิตภัณฑ์หลายเวอร์ชันที่ใช้งานอยู่ในเวลาเดียวกัน (บางคนอยู่ใน v10.1, บางคนใน v11.2 ฯลฯ ) เราต้องสามารถทำงานกับหลาย ๆ รุ่นได้ในเวลาเดียวกัน (ดังนั้นเราจึงสามารถทำงานกับ v12.1 ได้ แต่เมื่อเราถึงจุดสิ้นสุดของการวางจำหน่ายเราจะเริ่มทำงานกับ v12.2 ในเวลาเดียวกัน) เราจำเป็นต้องสามารถเผยแพร่โปรแกรมแก้ไขด่วนเมื่อพบข้อบกพร่องที่สำคัญ จนถึงตอนนี้เป็นวิธีที่ฉันคิดว่าสามารถใช้งานได้: ใช้ repo ระยะไกลเดียว สร้างสาขา 12.1 จากต้นแบบ สร้างฟีเจอร์ย่อยตาม 12.1, คอมมิชชันเหล่านั้นและรวมกลับเป็น 12.1, กด เมื่อเราต้องการเริ่มทำงานในรุ่นอนาคตให้สร้างสาขาใหม่ 12.2 จาก 12.1 จากนั้นเมื่อทำงานกับคุณลักษณะสำหรับ 12.1 สร้างสาขาจาก 12.1 กระทำการเปลี่ยนแปลงและรวมเข้ากับทั้ง 12.1 และ 12.2 กด หากทำงานกับคุณลักษณะสำหรับ …

30 version-control  git 

ใน C ไม่จำเป็นต้องส่ง a void *ไปยังชนิดพอยน์เตอร์ใด ๆ มันได้รับการเลื่อนอย่างปลอดภัยเสมอ อย่างไรก็ตามใน C ++ นี่ไม่ใช่กรณี เช่น, int *a = malloc(sizeof(int)); ทำงานใน C แต่ไม่ใช่ใน C ++ (หมายเหตุ: ฉันรู้ว่าคุณไม่ควรใช้mallocใน C ++ หรือสำหรับเรื่องnewนั้นและควรเลือกสมาร์ทพอยน์เตอร์และ / หรือ STL แทนที่จะถามสิ่งนี้เพราะความอยากรู้อยากเห็น) ทำไมมาตรฐาน C ++ จึงไม่อนุญาตให้ใช้แบบจำลองนี้ ในขณะที่มาตรฐาน C ทำอะไร

30 c++  language-features 

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

30 c  pointers 

โดยเฉพาะฉันเขียนใน JavaScript สมมติว่าฟังก์ชั่นหลักของฉันคือฟังก์ชั่น A ถ้าฟังก์ชั่น A ทำการโทรไปยังฟังก์ชั่น B หลายครั้ง แต่ฟังก์ชั่น B นั้นไม่ได้ใช้ที่อื่นฉันควรวางฟังก์ชั่น B ไว้ในฟังก์ชั่น A หรือไม่ เป็นการปฏิบัติที่ดีหรือไม่? หรือฉันควรจะวาง Function B ในขอบเขตเดียวกับ Function A หรือไม่

30 javascript  programming-practices  patterns-and-practices  encapsulation  scope 

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

30 architecture  database  webforms 

ฉันกำลังทำงานบนฐานรหัสที่มีหลายคลาสที่ใช้วิธีการเริ่มต้น ดูเหมือนว่าการก่อสร้างแบบสองเฟสสำหรับฉันซึ่งฉันถือว่าเป็นการปฏิบัติที่ไม่ดีอยู่เสมอ ฉันไม่สามารถบอกความแตกต่างระหว่างสิ่งนี้กับตัวสร้างได้ เมื่อใดจึงเหมาะสมที่จะใช้วิธีการเริ่มต้นแทนการสร้างวัตถุปกติ เมื่อใดฉันจึงควรใช้ตัวสร้าง แก้ไข: ฉันไม่คิดว่ามันเป็นสิ่งที่เกี่ยวข้อง แต่ภาษาการเขียนโปรแกรมคือ C # ซึ่งสามารถนำไปใช้กับ Java หรือ C ++ ได้อย่างเท่าเทียมกัน

30 object-oriented-design  construction  constructors 

ฉันสงสัยว่าฉันควรป้องกันค่าตอบแทนการโทรด้วยวิธีการโดยตรวจสอบว่าพวกเขาตอบสนองความคาดหวังของฉันแม้ว่าฉันรู้ว่าวิธีการที่ฉันโทรจะตอบสนองความคาดหวังดังกล่าว GIVEN User getUser(Int id) { User temp = new User(id); temp.setName("John"); return temp; } ฉันควรทำหรือไม่ void myMethod() { User user = getUser(1234); System.out.println(user.getName()); } หรือ void myMethod() { User user = getUser(1234); // Validating Preconditions.checkNotNull(user, "User can not be null."); Preconditions.checkNotNull(user.getName(), "User's name can not be null."); System.out.println(user.getName()); } …

30 java  validation  null  return-type  defensive-programming 

ฉันทำงานที่ บริษัท ขนาดกลาง (พนักงาน 150 คน, ทีมวิศวกรขนาด 10 ~ คน) และโครงการส่วนใหญ่ของฉันเกี่ยวข้องกับการเชื่อมต่อกับอุปกรณ์ห้องปฏิบัติการ (oscilloscopes, เครื่องวิเคราะห์สเปกตรัมแบบออปติคอล ฯลฯ ) เพื่อวัตถุประสงค์ในการทดสอบแบบกึ่งอัตโนมัติ ฉันพบสถานการณ์ที่แตกต่างกันสองสามอย่างซึ่งฉันไม่สามารถแก้ไขปัญหาหรือทดสอบรหัสใหม่ได้อย่างมีประสิทธิภาพเพราะฉันไม่ได้ตั้งค่าฮาร์ดแวร์ให้ฉันอีกต่อไป ตัวอย่าง 1:การตั้งค่าที่กระบวนการ 10-20 "เบิร์นอิน" ทำงานอย่างอิสระโดยใช้เซ็นเซอร์ประเภทท็อปบัลลังก์ - ฉันสามารถรับเซ็นเซอร์หนึ่งตัวสำหรับการทดสอบและสามารถขโมยวินาทีในการจำลองการเชื่อมต่อทั้งหมดเพื่อจำลอง อุปกรณ์หลายอย่าง (การค้นหาการเชื่อมต่อการสตรีม ฯลฯ ) ในที่สุดข้อผิดพลาดปรากฏขึ้น (และในที่สุดก็ลงเอยอยู่ในอุปกรณ์เฟิร์มแวร์ & ไดรเวอร์) ที่ยากมากที่จะทำซ้ำอย่างถูกต้องด้วยหน่วยเดียว แต่เข้าใกล้ระดับ "โชว์จุก" เมื่อ 10-20 ของอุปกรณ์เหล่านี้ถูกใช้พร้อมกัน สิ่งนี้ยังคงไม่ได้รับการแก้ไขและกำลังดำเนินการอยู่ ตัวอย่างที่ 2:การทดสอบที่ต้องใช้เครื่องวิเคราะห์สเปกตรัมแสงที่มีราคาแพงเป็นองค์ประกอบหลักของมัน อุปกรณ์นั้นค่อนข้างเก่าล้าสมัยตามผู้ผลิตที่ได้รับมาจาก บริษัท ขนาดใหญ่และถูกทำลายโดยทั่วไปและเอกสารเพียงอย่างเดียวคือเอกสารที่ยืดยาว (และไม่เป็นทางการ) ที่ดูเหมือนจะแปลไม่ดี ในระหว่างการพัฒนาเริ่มต้นฉันสามารถเก็บอุปกรณ์ไว้ที่โต๊ะทำงานของฉันได้ แต่ตอนนี้มันเชื่อมโยงกันทั้งทางร่างกายและตามกำหนดเวลาในระหว่างการทดสอบตลอด 24 ชั่วโมงทุกวัน …

30 programming-practices  testing  hardware  test-automation 

ฉันมักจะอ่านว่านักพัฒนาจะต้องเขียนโค้ดที่สวยงาม แต่สำหรับผู้เริ่มต้นในขณะที่ฉันยังคงคลุมเครือของรหัสที่สวยงามและคุณจำได้อย่างไร คำถามที่ควันหลงคือ: จะเขียนโค้ดที่สวยงามได้อย่างไรและอะไรคือนิสัยในการปฏิบัติเพื่อปรับปรุงคุณภาพของโค้ดของคุณ? สิ่งที่ฉันควรสนใจเกี่ยวกับการทำให้รหัสที่ฉันเขียนสวยงาม (และสิ่งที่ shoud ฉันเรียนรู้)

30 algorithms  source-code 

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

30 programming-languages  language-design  compiler 

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

30 tdd  integration-tests 

ฉันได้อ่านนิดหน่อยเกี่ยวกับdenotational semantics (DS) และฉันก็รู้สึกทึ่งมากเกี่ยวกับกระบวนการออกแบบโปรแกรมคอมพิวเตอร์ที่ประเภทและฟังก์ชั่นมีการแมปที่แข็งแกร่งและชัดเจนกับคณิตศาสตร์ มีทรัพยากรใดบ้างที่พูดถึงการออกแบบโปรแกรมโดยยึด DS เป็นรายละเอียดหรือไม่? ฉันเคยเห็นการรักษาผิวเผินบางอย่างของเรื่อง ฉันคุ้นเคยกับ Haskell, Scala, Common LISP และ Scheme เล็กน้อยดังนั้นทรัพยากรใด ๆ ที่ใช้ภาษาเหล่านั้นจะได้รับการชื่นชมอย่างมาก

30 scala  haskell  scheme 

ดูเหมือนว่าList<T>ใน C # สามารถทำทุกอย่างที่อาเรย์สามารถทำได้และอื่น ๆ อีกมากมายและดูเหมือนว่าในหน่วยความจำและประสิทธิภาพก็มีประสิทธิภาพเช่นเดียวกับอาเรย์ เหตุใดฉันจึงต้องการใช้อาร์เรย์ เห็นได้ชัดว่าฉันไม่ได้ถามเกี่ยวกับกรณีที่ API หรือข้อ จำกัด ภายนอกอื่น ๆ (เช่นฟังก์ชั่นหลัก) ต้องการให้ฉันใช้อาร์เรย์ ... ฉันแค่ถามเกี่ยวกับการสร้างโครงสร้างข้อมูลใหม่ในรหัสของฉันเอง

30 c#  data-types 

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

30 multithreading  bug  features 

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

30 git  workflows  branching  gitflow