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

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

12 database  concurrency  microservices  data-integrity 

ทีมการต่อสู้ 3 x นักพัฒนา 2 x ผู้ทดสอบ 1 x นักวิเคราะห์ทดสอบอัตโนมัติ เราไม่ใช่ทีมอเนกประสงค์ที่ผู้พัฒนาไม่ทำการทดสอบและผู้ทดสอบไม่ได้พัฒนา ฉันเชื่อว่านี่เป็นสาเหตุของปัญหา ขณะนี้เราดำเนินการสองสัปดาห์ ในช่วงเริ่มต้นของการวิ่งทุกคนไม่ว่างนักพัฒนากำลังเริ่มงานพัฒนาและผู้ทดสอบกำลังเตรียมการทดสอบ (การเขียนกรณีทดสอบ ฯลฯ ) เมื่อผู้ทดสอบเสร็จสิ้นการเตรียมการพวกเขากำลังรอให้งานพัฒนาเสร็จสมบูรณ์หรืองานพัฒนาเสร็จสมบูรณ์และผู้พัฒนากำลังรอข้อเสนอแนะ / ข้อบกพร่อง นักพัฒนาได้รับเท้าที่นี่และเริ่มทำงานกับรายการใน backlog ซึ่งอยู่นอกการวิ่งปัจจุบัน สิ่งนี้สร้างผลกระทบแปลก ๆ โดยที่เรามักจะพัฒนา sprints ถัดไปทำงานใน sprint ปัจจุบัน สำหรับฉันมันไม่ถูกต้อง จากมุมมองของผู้บริหารพวกเขาอยากให้นักพัฒนาทำงานมากกว่านั่งที่โต๊ะทำงานโดยไม่ทำอะไรเลย แต่ในเวลาเดียวกันฉันรู้สึกว่าเป้าหมายของทีมการต่อสู้ ฉันหวังว่าทีมของเราจะใช้งานได้หลากหลาย แต่น่าเสียดายที่มันไม่สามารถทำได้ ผู้ทดสอบไม่มีทักษะที่จำเป็นในการทำงานด้านการพัฒนาและนักพัฒนาส่วนใหญ่มีความเห็นว่าการทดสอบนั้นอยู่ด้านล่าง นี่ถือว่าเป็นปัญหาในการต่อสู้หรือไม่? มีวิธีแก้ปัญหานี้หรือไม่? การต่อสู้กับทีมมัลติฟังก์ชั่นเท่านั้นหรือไม่ ฉันอยากจะรู้ว่าคนอื่นมีประสบการณ์กับสิ่งนี้ถ้าเป็นไปได้ :)

12 agile  scrum 

สถานการณ์ปัจจุบัน เรากำลังดำเนินการ (และตอนนี้ยังคงรักษา) เว็บแอปพลิเคชันการช็อปปิ้งออนไลน์ในสถาปัตยกรรม microservice หนึ่งในความต้องการก็คือธุรกิจจะต้องสามารถใช้กฎกับสิ่งที่ลูกค้าของเราเพิ่มลงในรถเข็นของพวกเขาเพื่อปรับแต่งประสบการณ์ของพวกเขาและลำดับท้ายที่สุด เห็นได้ชัดว่าต้องวางเอ็นจิ้นกฎทางธุรกิจและเราได้ใช้ "บริการไมโคร" ที่เฉพาะเจาะจงสำหรับสิ่งนี้ (ถ้าเรายังคงเรียกมันได้) ในช่วงหนึ่งปีที่ผ่านมาเอ็นจินกฎนี้มีความซับซ้อนมากขึ้นเรื่อย ๆ ต้องการข้อมูลมากขึ้น (เช่นเนื้อหาของรถเข็น แต่ยังรวมถึงข้อมูลผู้ใช้บทบาทของเขาบริการที่มีอยู่ของเขาข้อมูลการเรียกเก็บเงินบางอย่างเป็นต้น) เพื่อให้สามารถ คำนวณกฎเหล่านั้น ในขณะนี้shopping-cartmicroservice ของเรากำลังรวบรวมข้อมูลทั้งหมดจาก microservices อื่น ๆ แม้ว่าส่วนหนึ่งของข้อมูลนี้จะถูกใช้งานโดยshopping-cartส่วนใหญ่จะใช้เพื่อป้อนกฎของเครื่องมือเป็นส่วนใหญ่ ข้อกำหนดใหม่ ตอนนี้มาถึงความต้องการแอปพลิเคชั่น / ไมโครไซต์อื่นเพื่อนำเอ็นจินกฎกลับมาใช้ใหม่สำหรับข้อกำหนดที่คล้ายกัน ในสถานการณ์ปัจจุบันพวกเขาจะต้องส่งข้อมูลชนิดเดียวกันเรียกไมโครไซต์เดียวกันและสร้าง (เกือบ) ทรัพยากรเดียวกันเพื่อให้สามารถเรียกเครื่องมือกฎ ดำเนินการต่อตามที่เป็นอยู่เราจะเผชิญกับปัญหาหลายประการ: ทุกคน (เรียกเครื่องมือกฎ) ต้องนำการดึงข้อมูลกลับมาใช้ใหม่แม้ว่าพวกเขาจะไม่ต้องการมัน การร้องขอไปยังเอ็นจินกฎมีความซับซ้อน ต่อไปในทิศทางนี้เราจะต้องขนส่งข้อมูลนี้ไปทั่วเครือข่ายสำหรับคำขอจำนวนมาก (คิดว่าμs A μsโทรμs B เรียกเครื่องมือกฎ แต่ A มีข้อมูลที่ต้องการกฎเครื่องยนต์อยู่แล้ว); shopping-cart ได้กลายเป็นใหญ่เนื่องจากการดึงข้อมูลทั้งหมด ฉันอาจลืม ... เราจะทำอย่างไรเพื่อหลีกเลี่ยงปัญหาเหล่านี้ เป็นการดีที่เราจะหลีกเลี่ยงการเพิ่มความซับซ้อนมากขึ้นในเครื่องมือกฎ …

12 design  architecture  enterprise-architecture  microservices  business-rules 

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

12 uml  sequence-diagram 

ฉันค่อนข้างใหม่ในแง่ของทักษะการพัฒนาเว็บ Java ฉันมีโครงการที่ฉันคิดว่าจะทำให้ผู้สมัครที่ดีสำหรับบริการ RESTful จากสิ่งที่ฉันเข้าใจเกี่ยวกับ API น้อย ฉันพยายามที่จะดูรายละเอียดว่ามันควรจะมีโครงสร้างอย่างไร แต่ไม่ได้ไปที่ใดก็ได้ในแง่ของการค้นหาของ google และอ่านเนื้อหาที่ฉันมีอยู่แล้ว ฉันหวังว่าโพสต์นี้จะให้การตรวจสอบและ / หรือการเปลี่ยนเส้นทางในแง่ของความรู้และสมมติฐานของฉันในหัวข้อนี้ ข้อสันนิษฐานปัจจุบันของฉันคือการให้บริการที่สงบของฉันจะมีโครงสร้างดังต่อไปนี้: ข้อมูลฐานข้อมูล (SQL) ORM (ฉันใช้ ORM ที่ค่อนข้างไม่เป็นที่นิยมเรียกว่า CPO แต่สิ่งนี้จะถูกแทนที่ด้วย Hibernate กับคนส่วนใหญ่) คลาสผู้จัดการ Java ด้วยวิธีการที่พูดคุยกับ ORM เพื่อรับข้อมูล คลาสตัวควบคุม Java / คลาสที่จัดการการแมปคำขอและใช้@ResponseBodyเพื่อกำหนด / จัดการ URL และการกระทำของวิธีการจัดการข้อมูลผ่านทางคำกริยา HTTP ( http://mysite.com/computers/dellอาจมีการGETร้องขอด้วยคำว่า "dell" ใน URL เป็นพารามิเตอร์ที่จะส่งคืนอาร์เรย์ของข้อมูล JSON เกี่ยวกับคอมพิวเตอร์เดลล์) บริการนี้ควรทำด้วย Spring Boot …

12 java  web-applications  rest  api  spring 

ฉันอ่านเอกสารSpring Cloud Netflixเมื่อฉันค้นพบวิธีแชร์อินเทอร์เฟซระหว่างเซิร์ฟเวอร์ HTTP และไคลเอนต์ พวกเขาใช้ตัวอย่างนี้สำหรับ microservices แม้ว่าจะไม่มีเหตุผลว่าทำไมมันถึงขยายไปยังการสื่อสาร HTTP ทั่วไปไม่ได้: // The shared interface, in a common library public interface UserService { @RequestMapping(method = GET, value = "/users/{id}") User getUser(@PathVariable long id); } // The controller, on the server @RestController public class UserResource implements UserService { } // The same …

12 spring  microservices 

ฉันเพิ่งอ่านข้อโต้แย้งจำนวนมากต่อต้านการใช้รูปแบบพื้นที่เก็บข้อมูลกับ Entity Framework ORM ที่ทรงพลังเนื่องจากมีการรวมฟังก์ชั่นที่คล้ายกับพื้นที่เก็บข้อมูลพร้อมกับฟังก์ชั่นหน่วยการทำงานเช่นกัน อีกข้อโต้แย้งต่อการใช้รูปแบบสำหรับสถานการณ์เช่นการทดสอบหน่วยคือรูปแบบที่เก็บเป็นสิ่งที่เป็นนามธรรมเนื่องจากการใช้งานทั่วไปมีประโยชน์มากขึ้น IQueryable ข้อโต้แย้งเกี่ยวกับการใช้รูปแบบพื้นที่เก็บข้อมูลมีเหตุผลสำหรับฉัน แต่วิธีการทางเลือกของ abstractions ที่แนะนำมักทำให้เกิดความสับสนมากขึ้นและดูเหมือนจะเกินความเป็นปัญหาเช่นกัน วิธีการแก้ปัญหาของ Jimmy Bogards ดูเหมือนจะเป็นการผสมผสานของนามธรรมที่ออกไป แต่ยังแนะนำสถาปัตยกรรมของเขาเอง https://lostechies.com/jimmybogard/2012/10/08/favor-query-objects-over-repositories/ อีกตัวอย่างของที่เก็บที่ไม่จำเป็น .... แต่ใช้สถาปัตยกรรมของฉัน! http://blog.gauffin.org/2012/10/22/griffin-decoupled-the-queries/ อื่น ... http://www.thereformedprogrammer.net/is-the-repository-pattern-useful-with-entity-framework ฉันไม่พบวิธีการแทนที่ที่ชัดเจนหรือทางเลือกแทนวิธีการเก็บข้อมูลแบบ "ซับซ้อนมากเกินไป" ซึ่งไม่ได้มีการออกแบบตัวเองมากกว่า

12 domain-driven-design  entity-framework  orm  nhibernate  repository-pattern 

ฉันยังใหม่กับการเขียนโปรแกรมและสับสนเล็กน้อยจากการอ่าน \ ฟังการประชุมต่าง ๆ จากแหล่งต่าง ๆ : การโปรแกรมเชิงวัตถุมีแนวคิด 4 หรือ 5 หรือไม่? ในฐานะผู้มาใหม่ฉันเข้าใจว่านี่คือแนวคิด 5 ประการ: สิ่งที่เป็นนามธรรม มรดก encapsulation ความแตกต่าง modularity เหตุใดฉันจึงไม่พบคำจำกัดความที่ "เข้มงวดมากขึ้น" และดูเหมือนจะมีการจัดการแนวคิดเหล่านี้หลายอย่าง

12 object-oriented 

ตอนนี้ฉันใช้ GitHub มาระยะหนึ่งแล้วฉันมักจะใช้ฟีเจอร์ - สาขาแล้วก็เริ่มคำขอดึงซึ่งตัวฉันเองรวมเข้าด้วยกัน ฉันพบว่ามันช่วยฉันติดตามว่าฉันรวมสาขาที่ไหน แต่เมื่อเร็ว ๆ นี้ฉันได้อ่านมากขึ้นเกี่ยวกับวิธีการทำงานของ Git และฉันก็ตระหนักว่าฉันสามารถใช้การผสานที่มุ่งมั่นในการอ้างถึงเมื่อฉันรวมสาขา ดังนั้นฉันควรทำอย่างไรเมื่อรวมฟีเจอร์บรานช์เข้ากับมาสเตอร์: ทำการผสานคอมมิชชันบนมาสเตอร์จากนั้นดันต้นน้ำหรือดันสาขาท้องถิ่นและเริ่มคำขอดึง? ฉันได้อ่านIntroducing Pull Requests สำหรับทีม 2 คนแล้วรวมคำขอของฉันเองหรือ และขั้นตอนการทำงานกับ 2 คนในโครงการคืออะไรและฉันควรจะเปิดคำขอดึงจากสาขาใน repo อย่างเป็นทางการหรือทางแยกของฉัน? แต่ดูเหมือนว่าไม่มีใครตอบคำถามที่ฉันต้องการ

12 git  github  merging  pull-requests 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน4 ปีที่แล้ว ฉันเห็นในหลาย ๆ ที่ที่ใช้คำResolveนี้ใน Dependency Injection (แก้ไขการใช้งานอินเทอร์เฟซ), Package Managers (เช่น: แก้ไขการพึ่งพาแพ็คเกจ), เว็บ (เช่น: แก้ไขชื่อโฮสต์) ดังนั้นสิ่งที่จะทำให้ตรรกะของรหัสพิเศษที่ทำให้คนเลือกคำResolveมากกว่าง่ายConvertหรือTransformหรือแม้กระทั่งGet?

12 programming-practices  naming  dependency-injection  packages 

มีคำถามที่คล้ายกันอยู่สองสามข้อ 1 ,2 ,3 ,4แต่ดูเหมือนว่าไม่ใช่ในกรณีของคำถามนี้และการแก้ปัญหาก็ดูดีที่สุด นี่เป็นคำถามทั่วไปของ OOP โดยสมมติว่ามีหลายรูปแบบชื่อสามัญและมิกซ์อินมีอยู่ ภาษาจริงที่ใช้คือ OOP Javascript (Typescript) แต่เป็นปัญหาเดียวกันใน Java หรือ C ++ ฉันมีลำดับชั้นของชั้นเรียนแบบขนานซึ่งบางครั้งก็มีพฤติกรรมที่เหมือนกัน (ส่วนต่อประสานและการใช้งาน) แต่บางครั้งก็มีพฤติกรรมที่ 'ได้รับการป้องกัน' ของตัวเอง ภาพประกอบดังนี้: นี้สำหรับวัตถุประสงค์ในการประกอบการอธิบายเท่านั้น ; มันไม่ใช่แผนภาพคลาสที่แท้จริง หากต้องการอ่าน: สิ่งใดก็ตามในลำดับชั้นทั่วไป (กลาง) จะแชร์กันระหว่างทั้ง Canvas (ซ้าย) และ SVG (ขวา) ด้วยการแบ่งปันฉันหมายถึงทั้งอินเทอร์เฟซและการใช้งาน สิ่งใดก็ตามที่อยู่บนคอลัมน์ซ้ายหรือขวาหมายถึงพฤติกรรม (วิธีการและสมาชิก) เฉพาะสำหรับลำดับชั้นนั้น ตัวอย่างเช่น: ทั้งลำดับชั้นซ้ายและขวาใช้กลไกการตรวจสอบความถูกต้องเดียวกันแสดงเป็นวิธีการเดียว ( Viewee.validate()) ในลำดับชั้นทั่วไป paint()เพียงลำดับชั้นของผ้าใบมีวิธีการ วิธีนี้เรียกวิธีการทาสีบนเด็กทุกคน ลำดับชั้น SVG จำเป็นต้องแทนที่addChild()วิธีการCompositeแต่ไม่ได้เป็นกรณีที่มีลำดับชั้นของผืนผ้าใบ โครงสร้างจากลำดับชั้นทั้งสองไม่สามารถผสมกันได้ …

12 design-patterns  object-oriented  inheritance  multiple-inheritance  mixins 

ฉันมีโครงร่างการใช้งานเช่นเดียวกับข้อ 18 จาก Effective Java (การอภิปรายเพิ่มเติมที่นี่ ) มันเป็นคลาสนามธรรมที่มีวิธีการสาธารณะ 2 วิธี methodA () และ methodB () ที่เรียกวิธีการ subclasses เพื่อ "เติมช่องว่าง" ที่ฉันไม่สามารถกำหนดในลักษณะที่เป็นนามธรรม ฉันพัฒนาก่อนโดยการสร้างคลาสที่เป็นรูปธรรมและเขียนการทดสอบหน่วยสำหรับมัน เมื่อชั้นสองมาฉันสามารถแยกพฤติกรรมทั่วไปใช้ "ช่องว่างที่หายไป" ในชั้นสองและมันก็พร้อม (แน่นอนการทดสอบหน่วยถูกสร้างขึ้นสำหรับคลาสย่อยที่สอง) เวลาผ่านไปและตอนนี้ฉันมี 4 คลาสย่อยแต่ละการใช้งาน 3 วิธีการป้องกันแบบสั้นที่เฉพาะเจาะจงกับการใช้งานที่เป็นรูปธรรมของพวกเขาในขณะที่การใช้โครงร่างทำหน้าที่ทั่วไปทั้งหมด ปัญหาของฉันคือเมื่อฉันสร้างการใช้งานใหม่ฉันเขียนการทดสอบอีกครั้ง: คลาสย่อยเรียกวิธีตามที่กำหนดหรือไม่? วิธีการที่กำหนดมีคำอธิบายประกอบที่กำหนดหรือไม่ ฉันจะได้รับผลลัพธ์ที่คาดหวังจากวิธีการ A หรือไม่ ฉันจะได้รับผลลัพธ์ที่คาดหวังจากวิธีการ B หรือไม่ ในขณะที่เห็นข้อดีด้วยวิธีนี้: เป็นเอกสารข้อกำหนดของคลาสย่อยผ่านการทดสอบ มันอาจล้มเหลวอย่างรวดเร็วในกรณีที่มีการปรับโครงสร้างที่มีปัญหา ทดสอบคลาสย่อยโดยรวมและสาธารณะ API ("methodA () ทำงานอย่างไร" และไม่ "วิธีนี้ได้รับการป้องกันหรือไม่") ปัญหาที่ฉันมีคือการทดสอบสำหรับคลาสย่อยใหม่นั้นไม่ใช่เกมง่ายๆ: …

12 java  unit-testing  testing 

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

12 scrum  communication  product-owner 

ฉันเป็นนักพัฒนาซอฟต์แวร์ในทีมเปรียวขนาดใหญ่พอสมควร (เรามีนักพัฒนาแปดคนทำการเปลี่ยนแปลงที่เก็บรหัสเดียว) ทุกสองสัปดาห์เราจะผลักดันซอฟต์แวร์เวอร์ชันใหม่ให้ผลิต นี่คือขั้นตอนการทำงานปัจจุบันของเรา: เมื่อเริ่มงานใหม่นักพัฒนาจะสร้าง "ฟีเจอร์บรานช์" จากสาขาการพัฒนาหลัก (เราใช้คอมไพล์ ) และทำงานนอกสาขาใหม่นี้ เมื่อนักพัฒนาซอฟต์แวร์ทำงานเสร็จแล้วพวกเขาจะรวมสาขาฟีเจอร์ของพวกเขากลับเข้าไปในสาขาการพัฒนา ผู้พัฒนาผสานสาขาการพัฒนาเข้ากับสาขา QA บิลด์จะถูกทริกเกอร์จากสาขา QA ผลลัพธ์ของโครงสร้างนี้ถูกปรับใช้ในสภาพแวดล้อม QA ของเราเพื่อให้ผู้ทดสอบเริ่มการทดสอบ เป็นเรื่องปกติที่ผู้ทดสอบของเราจะพบปัญหาเกี่ยวกับคุณสมบัติใหม่เหล่านี้ซึ่งได้รวมเข้ากับสาขา QA ซึ่งหมายความว่าในเวลาใดก็ตามสภาพแวดล้อม QA อาจมีคุณสมบัติใหม่หลายประการ - บางส่วนผ่านการทดสอบและปราศจากข้อบกพร่องและบางส่วนเสีย สิ่งนี้ทำให้การปล่อยทำได้ยากเพราะหายากที่ QA build อยู่ในสถานะพร้อมใช้งานการผลิต เพื่อบรรเทาปัญหานี้เราได้พยายามเริ่มต้น "การหยุด QA" ซึ่งหมายความว่านักพัฒนาไม่รวมสาขาการพัฒนาของเราเข้ากับสาขา QA สองสามวันก่อนการเปิดตัว การแก้ไขข้อบกพร่องของสภาพแวดล้อม QA นั้นเกิดขึ้นโดยตรงกับสาขา QA และรวมเข้ากับสาขาการพัฒนา ในทางทฤษฎีสิ่งนี้ทำให้คุณสมบัติใหม่แตกออกจาก QA ในขณะที่ยังช่วยให้เราสามารถแก้ไขปัญหาที่มีอยู่แล้วใน QA ในขณะที่แนวคิด "QA freeze" ประสบความสำเร็จเพียงบางส่วน แต่ก็ยากที่จะประสานงานและผู้คนมักสับสนว่าพวกเขาได้รับอนุญาตให้รวมกับ QA …

12 agile  version-control  development-process  branching  release-management 

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

12 async  io