คำถามติดแท็ก builds

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

410 unit-testing  tdd  builds 

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

181 continuous-integration  builds  release 

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

131 version-control  git  svn  builds  versioning 

สำหรับอาชีพการเขียนโปรแกรมส่วนใหญ่ของฉันฉันได้ใช้คำสั่ง "build / compile / run" ในทุก ๆ IDE ที่ฉันทำงานด้วยเพื่อสร้างโปรแกรมที่รันได้ นี่คือปุ่มเดียวค่อนข้างง่าย ในขณะที่ฉันเรียนรู้เพิ่มเติมเกี่ยวกับภาษาและกรอบงานต่าง ๆ ฉันเห็นการพูดถึง "build script" มากขึ้นเรื่อย ๆ (ANT, Maven, Gradle และอื่น ๆ ) เพื่อให้โครงการทำงาน ความเข้าใจของฉันเกี่ยวกับสิ่งเหล่านี้คือพวกเขาเป็นคำแนะนำสำหรับคอมไพเลอร์ / ลิงเกอร์ / ผู้เขียนโปรแกรมที่ระบุรายละเอียดการกำหนดค่า - minutiae ฉันจำได้ว่าการเขียน makefiles กลับไปโรงเรียน แต่ฉันไม่เห็นข้อได้เปรียบพิเศษใด ๆ เลย (เราจะใช้มันเฉพาะเมื่อเขียนในเทอร์มินัล Unix ที่ IDE ไม่มีปุ่ม "สร้าง" ที่มีประโยชน์) นอกเหนือจากนั้นผมเคยเห็นคำถามอื่น ๆ ที่นี่ที่หารือถึงวิธีการสร้างสคริปต์สามารถทำได้มากกว่าเพียงแค่สร้างโปรแกรมของคุณ - พวกเขาสามารถเรียกใช้การทดสอบหน่วยเช่นเดียวกับแหล่งข้อมูลที่เชื่อถือได้โดยไม่คำนึงถึงเครื่องโฮสต์ …

97 development-process  builds 

มีภาษาการเขียนโปรแกรมบางอย่างซึ่งมีอยู่ในระบบการจัดการบรรจุภัณฑ์: CTANสำหรับ TeX CPANสำหรับ Perl Pip & Eggsสำหรับ Python Mavenสำหรับ Java พันธมิตรสำหรับ Haskell อัญมณีสำหรับทับทิม npmสำหรับ NodeJS bowerสำหรับ Javascript & CSS ส่วนหน้า นักเก็ตสำหรับ C # นักแต่งเพลงสำหรับ PHP มีภาษาอื่นที่ใช้ระบบดังกล่าวหรือไม่? แล้ว C และ C ++ ล่ะ? (นั่นเป็นคำถามหลัก!) ทำไมไม่มีระบบดังกล่าวสำหรับพวกเขา? และไม่ได้มีการสร้างแพคเกจสำหรับyum, apt-getหรือระบบการจัดการแพคเกจอื่น ๆ ทั่วไปดีขึ้นหรือไม่

78 c++  c  builds  packages 

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

75 deployment  builds 

สิ่งที่ฉันคิดเกี่ยวกับ Build Numbers คือเมื่อใดก็ตามที่สร้างบิลด์ใหม่ทุกคืนบิลด์ใหม่จะถูกสร้างและกำหนดให้กับบิลด์นั้น ดังนั้นสำหรับแอปพลิเคชันเวอร์ชัน 7.0 ของฉันบิลด์บิลด์ต่อคืนจะเป็น 7.0.1, 7.0.2 เป็นต้น มันเป็นอย่างนั้นเหรอ? ถ้าเช่นนั้นการใช้ REVISION หลังจากหมายเลขบิลด์คืออะไร? หรือว่าส่วนการปรับปรุงจะเพิ่มขึ้นหลังจากการสร้างทุกคืน? ฉันสับสนเล็กน้อยที่นี่ ... เราจะอ้างถึงยามค่ำคืนสร้างแต่ละเป็นBUILD ? รูปแบบที่กล่าวถึงที่นี่: AssemblyVersion - MSDN

55 builds  versioning 

ผมได้อธิบายที่เสนอสร้างระบบ (Gradle / Artifactory / เจนกินส์ / Chef) ให้เป็นหนึ่งในสถาปนิกอาวุโสของเราและเขาได้แสดงความคิดเห็นกับฉันว่าฉันเรียงลำดับของการไม่เห็นด้วย แต่ผมไม่ได้มีประสบการณ์มากพอที่จะจริงๆชั่งน้ำหนักใน โครงการนี้สร้างไลบรารี Java (JAR) เป็นสิ่งประดิษฐ์ที่ทีมอื่นนำมาใช้ซ้ำ สำหรับการกำหนดเวอร์ชันฉันต้องการใช้ความหมายของ: <major>.<minor>.<patch> โดยที่patchระบุถึงการแก้ไขบั๊ก / ฉุกเฉินminorระบุรีลีสที่เข้ากันได้แบบย้อนหลังและmajorบ่งชี้ถึงการปรับเปลี่ยนขนาดใหญ่ของ API และ / หรือการเปลี่ยนแปลงที่เข้ากันไม่ได้ด้านหลัง ตราบใดที่การส่งมอบตรงนี้คือสิ่งที่ฉันต้องการ: นักพัฒนาให้รหัสบางส่วน; สิ่งนี้ทริกเกอร์การสร้างสภาพแวดล้อม QA / TEST การทดสอบบางอย่างถูกเรียกใช้ (บางแบบอัตโนมัติและแบบทดสอบด้วยตนเอง) หากการทดสอบทั้งหมดผ่านไปแล้วบิลด์โปรดักชั่นจะเผยแพร่ JAR ไปยัง repo ภายในองค์กรของเรา ณ จุดนี้ JAR ควรได้รับการกำหนดเวอร์ชันอย่างถูกต้องและความคิดของฉันคือการใช้สิ่งbuild.numberที่สร้างขึ้นโดยอัตโนมัติและจัดทำโดยเครื่องมือ CI ของเราเพื่อทำหน้าที่เป็นหมายเลขโปรแกรมแก้ไข ดังนั้นการกำหนดเวอร์ชันจะเป็น: <major>.<minor>.<build.number> อีกครั้งที่build.numberมีให้โดยเครื่องมือ CI สถาปนิกปฏิเสธสิ่งนี้โดยบอกว่าการใช้หมายเลขการสร้าง CI นั้นเป็น "การละเมิด" …

35 continuous-integration  versioning  builds  continuous-delivery  semantic-versioning 

ดังนั้นฉันจึงเจอหลายความคิดเห็น / โพสต์ / อื่น ๆ เกี่ยวกับการสร้าง makefiles โดยตรงและมันเป็นเรื่องโง่ที่ต้องทำในปี 2015 ฉันรู้เครื่องมือต่าง ๆ เช่น CMake และฉันใช้ CMake บ่อยครั้งมาก CMake กำลังสร้าง Makefile ให้คุณและช่วยในการลบความน่าเบื่อของการทำมันด้วยตัวคุณเอง แน่นอนว่ามันเพิ่มคุณสมบัติที่ยอดเยี่ยมอื่น ๆ อีกมากมาย ... แต่มันก็ยังเป็น Makefile ในที่สุด ดังนั้นคำถามของฉันคือการพูดคุย 'ล้าสมัย' เกี่ยวกับการอ้างอิงถึงยูทิลิตี้ Make ทั้งหมดหรือเพียงแค่ความคิดในการเขียน Makefiles ของคุณเองหรือไม่ ฉันไม่ได้ใช้ IDE สำหรับการพัฒนา C / C ++ เลย (แค่ emacs) ดังนั้นฉันจึงเขียน Makefiles เสมอ ถ้า Make …

31 c++  c  builds  make  cmake 

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

25 version-control  teamwork  continuous-integration  builds  branching 

ต้องการปรับปรุงโพสต์นี้หรือไม่? ให้คำตอบโดยละเอียดสำหรับคำถามนี้รวมถึงการอ้างอิงและคำอธิบายว่าทำไมคำตอบของคุณถึงถูกต้อง คำตอบที่ไม่มีรายละเอียดเพียงพออาจแก้ไขหรือลบออกได้ หาก Java เป็นภาษาที่ใช้โดยทั่วไปและการสร้างโปรแกรมเป็นสิ่งที่สามารถอธิบายได้โดยใช้ภาษา Java ทำไมจึงไม่ใช่วิธีที่ดีที่สุดในการเขียนไฟล์บิลด์และเราใช้เครื่องมือเช่น Ant, Maven และ Gradle แทน มันจะไม่ตรงไปตรงมามากกว่านี้และยังไม่จำเป็นต้องเรียนรู้ภาษาการเขียนโปรแกรมอีกด้วย (BTW - คำถามนี้สามารถใช้ได้กับภาษาอื่นเช่น C #)

24 java  c#  builds  build-system 

คำถามนี้ถูกโยกย้ายจาก Stack Overflow เพราะสามารถตอบได้ใน Software Engineering Stack Exchange อพยพ 7 ปีที่ผ่านมา ในช่วงเวลาหลายปีของการเขียนโปรแกรม Java และ Scala เมื่อเร็ว ๆ นี้ฉันไม่เคยใช้ Ant, Maven, Gradle หรือเครื่องมือสร้างเหล่านี้สำหรับ Java ทุกที่ที่ฉันทำงานมีผู้จัดการสร้างที่ดูแลทุกอย่าง - ฉันรวบรวมภายในเครื่องด้วย IDE สำหรับการพัฒนาและทดสอบหน่วยจากนั้นตรวจสอบในซอร์สโค้ดและแจ้งผู้จัดการสร้างที่ทำสิ่งที่จำเป็น รวบรวมไฟล์ของทุกคนสำหรับสภาพแวดล้อมที่ใช้ร่วมกัน ตอนนี้ฉันอยู่ระหว่างสัญญาฉันได้ทำงานในโครงการที่ได้รับทุนของตัวเองแล้วและถึงจุดที่มันจะดีพอที่จะทำเงินได้จริง ฉันยังมีนักลงทุนที่คาดหวังและวางแผนที่จะแสดงให้พวกเขาเห็นเป็นรุ่นเบต้าในไม่กี่สัปดาห์ แต่ตลอดฉันคลิกปุ่มสร้างบน IDE และสร้างไฟล์ Jar และใช้งานได้ดี แน่นอนว่าภูมิปัญญาดั้งเดิมแสดงให้เห็นว่าฉัน "ควร" เขียนสคริปต์ Ant / Maven / Gradle ของตัวเองและใช้สิ่งนั้นแทน IDE แต่อะไรคือข้อดีที่เป็นรูปธรรมในสถานการณ์ของฉัน (ทำงานคนเดียว)? ฉันได้อ่านเกี่ยวกับวิธีการใช้เครื่องมือสร้างเหล่านั้นและดูเหมือนว่าฉันจะเขียน XML …

22 builds  continuous-integration  maven  ant 

หนึ่งในบทบาทของผมในทีมงานของฉันคือคนที่สร้าง ฉันรับผิดชอบในการดูแลรักษา / ปรับปรุงสคริปต์การสร้างของเราและทำให้แน่ใจว่าเรากำลังสร้าง 'ราบรื่น' บนเซิร์ฟเวอร์การรวมอย่างต่อเนื่อง ฉันมักจะไม่รังเกียจงานนี้ แต่บ่อยครั้งที่รู้สึกว่าฉันดูแลเซิร์ฟเวอร์ CI อยู่ตลอดเวลา งานนี้อาจสร้างความรำคาญในบางครั้งเพราะหากงานสร้างฉันต้องทิ้งเรื่องราวที่ฉันกำลังทำอยู่และตรวจสอบความล้มเหลวของงานสร้าง การสร้างความล้มเหลวเกิดขึ้นทุกวันในทีมของเรา บางครั้งผู้พัฒนาก็ไม่ได้สร้างแบบโลคัลก่อนที่จะส่งข้อมูลดังนั้นการทดสอบล้มเหลวบนเซิร์ฟเวอร์ CI ในสถานการณ์เช่นนี้ฉันต้องการไปยังผู้ที่มี 'ความมุ่งมั่นที่ไม่ดี' อย่างรวดเร็วเพื่อให้การสร้างไม่ได้พักนานเกินไป บางครั้ง (บ่อยครั้งมาก) มีเงื่อนไขแปลก ๆ อยู่บนเซิร์ฟเวอร์ CI ที่ต้องทำการดีบั๊ก ฉันรู้ว่าหลาย ๆ ทีมที่เป็นผู้ใหญ่ใช้การผสมผสานอย่างต่อเนื่อง แต่ไม่มีเนื้อหาสาระเกี่ยวกับแนวทางปฏิบัติที่ดี ปัญหาของฉันชี้ให้เห็นว่าการรวมกลุ่มอย่างต่อเนื่องของเราไม่ได้เป็นผู้ใหญ่มากหรือเป็นเพียงส่วนหนึ่งของงานหรือไม่ แนวทางปฏิบัติที่ดีในการปฏิบัติตามคืออะไร? อะไรคือลักษณะของการบูรณาการอย่างต่อเนื่องเป็นผู้ใหญ่ ? ปรับปรุง แทนที่จะตอบความคิดเห็นฉันจะทำการอัปเดตแทน เรามีคำสั่งเดียวที่เรียบง่ายที่ทำสิ่งที่เซิร์ฟเวอร์การสร้างจะทำเมื่อสร้างแอป มันจะรวบรวมเรียกใช้หน่วย / การรวมและการทดสอบตาม UI อย่างรวดเร็ว การอ่านคำตอบของทุกคนรู้สึกว่าเราอาจมีปัญหาสองอย่าง CI Server ไม่บ่นดังพอเมื่อการสร้างล้มเหลว นักพัฒนาไม่รู้สึกว่าเป็นความรับผิดชอบของทุกคนในการทำให้แน่ใจว่าการกระทำของพวกเขาประสบความสำเร็จ สิ่งที่ทำให้ทีมของฉันลำบากยิ่งขึ้นคือเรามีทีมขนาดใหญ่ (นักพัฒนามากกว่า 10 คน) และเรามีสมาชิกในทีมนอกชายฝั่งสองคนที่กระทำเมื่อเราไม่ได้ทำงาน …

22 builds  continuous-integration 

ปิด คำถามนี้จะต้องมีมากขึ้นมุ่งเน้น ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้มุ่งเน้นที่ปัญหาเดียวโดยแก้ไขโพสต์นี้ ปิดให้บริการใน6 ปีที่ผ่านมา มีกรอบการทำงานร่วมกันอย่างต่อเนื่อง (CI) ที่แตกต่างกันออกไปเล็กน้อยและฉันสงสัยว่าสิ่งใดที่ได้รับความนิยมมากที่สุด กรอบการทำงานแบบใดที่คุณใช้ใน บริษัท ที่คุณทำงาน มีเหตุผลใดที่กรอบหนึ่งของ CI ได้รับความนิยมมากกว่ากรอบอื่น ๆ บางทีนี่อาจจะเกี่ยวกับคุณสมบัติที่มีให้สิ่งต่าง ๆ ที่รวมเข้ากับมันหรืออาจเป็นเพียงการตลาด ดูเหมือนว่ามีการใช้การรวมอย่างต่อเนื่องในโลก Java และ. net มากกว่าการพูดว่า ruby ​​หรือ python ทำไมนี้

21 java  c#  development-process  builds 

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

20 joel-test  version-control  builds