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

การใช้ Zero Downtime Deploymentประสบปัญหาเดียวกัน แต่ฉันต้องการคำแนะนำเกี่ยวกับกลยุทธ์ที่ฉันกำลังพิจารณา บริบท แอปพลิเคชันบนเว็บพร้อม Apache / PHP สำหรับการประมวลผลฝั่งเซิร์ฟเวอร์และฐานข้อมูล MySQL / ระบบไฟล์เพื่อการคงอยู่ ขณะนี้เรากำลังสร้างโครงสร้างพื้นฐาน ฮาร์ดแวร์ระบบเครือข่ายทั้งหมดจะมีความซ้ำซ้อนและสายเคเบิลเครือข่ายหลักทั้งหมดจะถูกใช้ในคู่ที่ถูกผูกมัดสำหรับการป้องกันความผิดพลาด เซิร์ฟเวอร์กำลังได้รับการกำหนดค่าให้เป็นคู่ที่มีความพร้อมใช้งานสูงสำหรับความทนทานต่อข้อผิดพลาดของฮาร์ดแวร์และจะมีความสมดุลของโหลดสำหรับทั้งการยอมรับข้อบกพร่องของเครื่องเสมือนและประสิทธิภาพทั่วไป มันเป็นความตั้งใจของฉันที่เราสามารถใช้การปรับปรุงกับแอปพลิเคชันโดยไม่ต้องหยุดทำงาน ฉันใช้ความเจ็บปวดอย่างมากเมื่อออกแบบโครงสร้างพื้นฐานเพื่อให้แน่ใจว่าฉันสามารถให้เวลาได้ 100% มันน่าผิดหวังอย่างยิ่งที่มีเวลาหยุดทำงาน 10-15 นาทีทุกครั้งที่มีการอัปเดต สิ่งนี้มีความสำคัญอย่างยิ่งเนื่องจากเราตั้งใจที่จะมีวงจรการเผยแพร่ที่รวดเร็วมาก (บางครั้งอาจถึงหนึ่งหรือมากกว่านั้นต่อวัน โครงสร้างเครือข่าย นี่เป็นบทสรุปของเครือข่าย: Load Balancer |----------------------------| / / \ \ / / \ \ | Web Server | DB Server | Web Server | DB Server …

14 deployment  schema  strategy  downtime 

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

14 documentation  domain-driven-design 

อัปเดต / ชี้แจงลูกค้าของฉันเข้าใจถึงความจำเป็นในการทดสอบภายในและพวกเขา / พวกเขาสาบานเสมอว่าพวกเขาจะ "ทำได้ดีกว่า" (เช่นทำอะไร) แต่มันก็ไม่ได้เกิดขึ้น พวกเขาไม่มีงบประมาณสำหรับการทดสอบภายนอก ฉันเดาว่าฉันกำลังถาม (ราง ๆ ฉันยอมรับ) เกี่ยวกับสิ่งที่สามารถปลูกฝัง "การทดสอบก่อนการทดสอบบ่อยทดสอบบนร๊อคของเครื่องเป้าหมาย? คำถาม:วิธีการกระตุ้นให้ผู้ใช้ใช้เวลาในการทดสอบและรายงานปัญหาเกี่ยวกับการออกรุ่นใหม่อย่างชัดเจนไม่ใช่ "test-as-They-go" ในโครงการผลิต พื้นหลัง:ฉันมีลูกค้ารายย่อยซึ่งฉันได้เขียนชุดเครื่องมือนำเสนอมัลติมีเดีย พวกเขาเป็นลูกค้าที่ดีและเรามีความสัมพันธ์ที่ดี โครงการกำลังดำเนินการอยู่เพิ่มคุณสมบัติตามที่เราไปด้วย ฉันมีสองประเด็น: คำจำกัดความของคุณสมบัติกระทำได้ตามปกติบ่อยครั้งที่โทรศัพท์การเปลี่ยนแปลงการแก้ไขการพลิกกลับ (นิดหน่อยเหมือนของ Kennedy "เราจะไปยังดวงจันทร์และทำสิ่งอื่น ๆ " - ฉันมักจะถูกขบขันโดย "สิ่งอื่น ๆ " ส่วนหนึ่งของที่) การทดสอบ QA แทบจะไม่เสร็จสิ้น ฉันสามารถจัดการกับ # 1 มากหรือน้อย นี่ไม่ใช่ไคลเอนต์ที่จะอ่านข้อกำหนดก่อนการประชุม ฉันคุ้นเคยกับมัน มันเป็นรายการ # 2 ที่ฉันมีปัญหากับ: พวกเขาไม่ได้หรือจะไม่ทดสอบรุ่นใหม่ สิ่งที่พวกเขาทำคือการใช้พวกมันในการผลิตดังนั้นเมื่อเกิดข้อบกพร่องขึ้นพวกเขาจะหาวิธีแก้ปัญหาและไม่รายงานหรือไม่ก็รีบเข้าโครงการด้วยรายงานข้อผิดพลาดที่คลุมเครือ เรามีการพูดคุยมากมายเกี่ยวกับสิ่งนี้ …

14 client-relations  qa 

ขณะนี้ทีมของฉันใช้กระบวนการแยก / ปรับใช้ที่ค่อนข้างง่ายซึ่งมีลักษณะดังนี้: ┌────────┐ ┌────┐ ┌──────┐ Environments: │ DEV │ │ QA │ │ PROD │ └────────┘ └────┘ └──────┘ ▲ ▲ ▲ │ │ │ ┌────────┐ ┌────┐ ┌──────┐ Builds: │ DEV │ │ QA │ │ PROD │ └────────┘ └────┘ └──────┘ ▲ ▲ ▲ │ │ │ ┌────────┐ ┌────┐ ┌──────┐ …

14 version-control  git  development-process  deployment  development-environment 

ในกระบวนการ Agile ของเราเรามี Sprints 2 สัปดาห์ งานจะถูกส่งเป็นรายวัน (งานสร้างรายวัน) และทีมทดสอบจะทำการทดสอบเสร็จในวันถัดไปหรือในวันเดียวกัน นอกจากนี้เรายังมีบทวิจารณ์รหัส Dev ซึ่งต้องใช้เวลา (1-2 ชั่วโมง) ดังนั้นจึงมีกำหนด 3 ครั้งต่อสัปดาห์: จันทร์ - ศุกร์ นักพัฒนามารวมกันและแนะนำวิธีปรับปรุง / สร้างรหัสใหม่ ปัญหาของเราคือเมื่อรายการการดำเนินการเกิดขึ้นหลังจากการตรวจสอบโค้ดงานส่วนใหญ่ได้รับการทดสอบแล้ว ผู้ทดสอบไม่ต้องการทดสอบสิ่งที่ผ่านการทดสอบแล้ว พวกเขาไม่สนใจเกี่ยวกับการเปลี่ยนแปลง dev ภายใน เราเข้าใจผิดเกี่ยวกับกระบวนการเปรียวหรือไม่? การตรวจสอบโค้ดไม่เข้ากันกับรอบการเปิดตัว / ทดสอบรายวันหรือไม่ เราไม่สามารถตรวจสอบโค้ดได้ทุกวันเนื่องจากใช้เวลาของทุกคน

14 project-management  agile  teamwork  code-reviews  sdlc 

ยกตัวอย่างของแอพพลิเคชั่น Ruby on Rails แบบง่าย ๆ มันสร้างLoggerวัตถุในระหว่างกระบวนการโหลดแอปพลิเคชัน: # in environment.rb config.logger = Logger.new(<STDOUT | file | whatever>) # and in our application we use this object logger.warn "This process is taking too long to process. Optimization needed." คำถามของฉันคือทำไมเราไม่ใช้วิธีการเรียน (หรือวิธีการคงที่) สำหรับการเข้าสู่ระบบ? จะไม่Logger.warnขยายมากกว่าLogger.new.warn? หรืออย่างน้อยดูเหมือนว่าใช้งานง่ายกว่าLogger.warnLogger.new.warn แม้ว่าLogger.newจะเป็นวัตถุซิงเกิลตันมันมีข้อดีอะไรบ้าง?

14 development-process  logging 

ถ้าคุณไปที่ Eg: http://www.forbes.com/sites/adrianbridgwater/2015/06/12/why-technology-has-to-be-continuous/ หรือ http://www.zdnet.com/article/if-you-want-those-cool-ios-9-features-its-time-to-buy-a-new-ipad/ เมื่อคุณไปถึงด้านล่างของหน้าเรื่องใหม่จะโหลดและ URL ในอินเทอร์เน็ตเบราว์เซอร์ของฉันเปลี่ยนเป็น URL ของเรื่องข่าวถัดไปนี้ ดังนั้นฉันจึงสงสัยว่าหน้าเว็บใดที่จะสามารถโหลดหน้าเว็บถัดไปได้ในทันทีโดยมีความล่าช้าเล็กน้อยระหว่างหน้าเว็บ พวกเขาเป็นตัวอย่างก่อนการดาวน์โหลดเว็บเพจของเรื่องข่าวถัดไปแล้วโหลดหน้าเว็บอย่างรวดเร็วจริง ๆ ?

14 javascript  web-development  web-applications  html  websites 

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

14 data-structures 

ฉันออกแบบอินเทอร์เฟซด้วยสองวิธีที่เกี่ยวข้องคล้ายกับสิ่งนี้: public interface ThingComputer { default Thing computeFirstThing() { return computeAllThings().get(0); } default List<Thing> computeAllThings() { return ImmutableList.of(computeFirstThing()); } } การใช้งานประมาณครึ่งหนึ่งจะคำนวณสิ่งหนึ่งเท่านั้นในขณะที่อีกครึ่งหนึ่งอาจคำนวณเพิ่มเติมได้ สิ่งนี้มีแบบอย่างใด ๆ ในโค้ด Java 8 ที่ใช้กันอย่างแพร่หลายหรือไม่? ฉันรู้ว่า Haskell ทำสิ่งที่คล้ายกันในบางประเภทEqของตัวอย่าง( เช่น) ข้อเสียคือฉันต้องเขียนโค้ดน้อยกว่าอย่างมากถ้าฉันมีบทคัดย่อสองคลาส ( SingleThingComputerและMultipleThingComputer) ข้อเสียก็คือการคอมไพล์การดำเนินงานที่ว่างเปล่า StackOverflowErrorแต่พัดขึ้นที่รันไทม์กับ เป็นไปได้ที่จะตรวจสอบการเรียกซ้ำซึ่งกันและกันด้วย a ThreadLocalและให้ข้อผิดพลาดที่ดีกว่า แต่นั่นเป็นการเพิ่มโอเวอร์เฮดให้กับโค้ดที่ไม่ใช่บั๊ก

14 java  design  interfaces  java8 

ใน C # เราสามารถโอเวอร์โหลดตัวดำเนินการแปลงโดยนัยเช่นนี้ (ตัวอย่างจากMSDN ): struct Digit { /* ... */ public static implicit operator byte(Digit d) // implicit digit to byte conversion operator { /* ... */ } } ดังนั้นเราจึงสามารถมีประเภทเป็นประเภทค่าที่กำหนดเอง , น่าอัศจรรย์แปลงตัวเองไปอีก (ไม่เกี่ยวข้อง) ประเภทออกจากผู้ชมในความสับสน (จนกว่าพวกเขาจะมองเข้าไปหลังเวทีและเห็นผู้ประกอบการแปลงนัยที่มี) ฉันไม่ชอบปล่อยให้ใครก็ตามที่อ่านรหัสของฉันในความสับสน ฉันไม่คิดว่าหลายคนทำ คำถามคือกรณีใช้งานของโอเปอเรเตอร์การแปลงประเภทโดยนัยคืออะไรจะไม่ทำให้โค้ดของฉันเข้าใจยากขึ้น?

14 c#  operators 

กำลังทำงานกับ API ในขณะนี้และต้องการรวบรวมความคิดเห็นเกี่ยวกับตำแหน่งที่ดีที่สุดในการส่งคีย์ API ฉันรู้ว่าไม่ควรเข้าไปใน URL สิ่งนี้ทำให้ส่วนหัวคำขอหรือเนื้อหาข้อความ หากฉันใส่ไว้ในส่วนหัวฉันสามารถสร้างวิธีทั่วไปสำหรับดึงมันออกมาซึ่งสามารถใช้ได้กับทุกบริการอย่างไรก็ตามข้อมูลจำเพาะที่ฉันส่งมานั้นต้องการในร่างกาย (เช่นในสตริง JSON ที่รวมเป็นส่วนหนึ่งของ วัตถุที่ทำให้เป็นอนุกรมในเนื้อหาของ POST)

14 api 

Optionalมีประโยชน์ในวิธีที่ชัดเจนในภาษาที่พิมพ์แบบคงที่ แต่ฉันสงสัยว่ามันยังมีประโยชน์ในภาษาแบบไดนามิก โดยปกติจะไม่มีคอมไพเลอร์บอกคุณว่า "เฮ้คุณใช้สิ่งนี้Optional<String>เป็นString" ดังนั้นคุณยังต้องค้นพบข้อผิดพลาดของคุณที่รันไทม์ ฉันมีพื้นหลังการพิมพ์แบบสแตติกและจากมุมมองของฉันฉันไม่เห็นประโยชน์ของOptionalประเภทในภาษาแบบไดนามิก

14 dynamic-typing  static-typing 

ฉันเพิ่งเสร็จสิ้นlearnyouahaskellวันอื่น ๆ และผมก็พยายามที่จะทำให้ความรู้สึกของข้อ จำกัด Monomorphism, ตามที่อธิบายไว้โดย Haskell วิกิพีเดีย ฉันคิดว่าฉันเข้าใจว่า MR สามารถป้องกันการประเมินซ้ำ ๆ ได้อย่างไร แต่ฉันล้มเหลวที่จะดูว่าทำไมการประเมินซ้ำ ๆ เหล่านั้นไม่สามารถหลีกเลี่ยงได้โดยวิธีที่ตรงไปตรงมามากขึ้น ตัวอย่างที่ฉันมีอยู่ในใจคือตัวอย่างที่ใช้โดยวิกิ: f xs = (len,len) where len = genericLength xs ที่เป็นประเภทgenericLengthNum a => [b] -> a เห็นได้ชัดว่าgenericLength xsต้องมีการคำนวณเพียงครั้งเดียวเพื่อประเมิน(len,len)เนื่องจากเป็นฟังก์ชันเดียวกันกับอาร์กิวเมนต์ที่เหมือนกัน และเราไม่จำเป็นต้องเห็นการเรียกร้องใด ๆfให้รู้ ดังนั้นทำไม Haskell ไม่สามารถทำการเพิ่มประสิทธิภาพนี้โดยไม่แนะนำกฎเช่น MR? การอภิปรายในหน้าวิกินั้นบอกฉันว่ามีบางอย่างเกี่ยวกับความจริงที่ว่าNumเป็น typeclass มากกว่าประเภทที่เป็นรูปธรรม แต่ถึงกระนั้นก็ไม่ควรที่จะรวบรวมไว้ในเวลาที่ฟังก์ชั่น pure จะคืนค่าเดิม - - และดังนั้นประเภทคอนกรีตเดียวกันของ Num …

14 optimization  haskell  type-systems 

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

14 scrum  user-story  sprint  scrum-master 

ฉันขายสวยในรุ่น react.js เพราะมันทำให้การจัดการ DOM เป็นไปอย่างราบรื่นและเข้าใจง่าย แต่ฉันสงสัยว่ามันสามารถใช้ประโยชน์อย่างไรกับไซต์ที่ส่วนใหญ่คงที่ด้วยบล็อกข้อความและรูปภาพขนาดใหญ่ที่ไม่เคลื่อนไหว มันจะเข้าไปขวางทางหรือไม่? ดูเหมือนว่าอึดอัดใจที่จะมีส่วนประกอบที่มีข้อความ KB ในสถานะของพวกเขา

14 javascript  web-development  html