NinjaEvan Martin Ninja is a build s

Ninja
Evan Martin

Ninja is a build system similar to Make. As input you describe the commands necessary to process source files into target files. Ninja uses these commands to bring targets up to date. Unlike many other build systems, Ninja’s main design goal was speed.
I wrote Ninja while working on Google Chrome. I started Ninja as an experiment to find out if Chrome’s build could be made faster. To successfully build Chrome, Ninja’s other main design goal followed: Ninja needed to be easily embedded within a larger build system.
Ninja has been quietly successful, gradually replacing the other build systems used by Chrome. After Ninja was made public others contributed code to make the popular CMake build system generate Ninja files–now Ninja is also used to develop CMake-based projects like LLVM and ReactOS. Other projects, like TextMate, target Ninja directly from their custom build.
I worked on Chrome from 2007 to 2012, and started Ninja in 2010. There are many factors contributing to the build performance of a project as large as Chrome (today around 40,000 files of C++ code generating an output binary around 90 MB in size). During my time I touched many of them, from distributing compilation across multiple machines to tricks in linking. Ninja primarily targets only one piece–the front of a build. This is the wait between starting the build and the time the first compile starts to run. To understand why that is important it is necessary to understand how we thought about performance in Chrome itself.
A Small History of Chrome
Discussion of all of Chrome’s goals is out of scope here, but one of the defining goals of the project was speed. Performance is a broad goal that spans all of computer science, and Chrome uses nearly every trick available, from caching to parallelization to just-in-time compilation. Then there was startup speed–how long it the program took to show up on the screen after clicking the icon–which seems a bit frivolous in comparison.
Why care about startup speed? For a browser, a quick startup conveys a feeling of lightness, that doing something on the web is as trival an action as opening a text file. Further, the impact of latency on your happiness and on losing your train of thought is well-studied in human-computer interaction. Latency is especially a focus of web companies like Google or Amazon, who are in a good position to measure and experiment on the effect of latency–and who have done experiments that show that delays of even milliseconds have measurable effects on how frequently people use the site or make purchases. It’s a small frustration that adds up subconsciously.
Chrome’s approach to starting quickly was a clever trick by one of the first engineers on Chrome. As soon as they got their skeleton application to the point where it showed a window on the screen, they created a benchmark measuring that speed along with a continuous build that tracked it. Then, in Brett Wilson’s words, “a very simple rule: this test can never get any slower.”1 As code was added to Chrome, maintenance of this benchmark demanded extra engineering effort2–in some cases work was delayed until it was truly needed, or data used during startup was precomputed–but the primary “trick” to performance, and the one that made the greatest impression on me, was simply to do less work.
I joined the Chrome team without any intention of working on build tools. My background and platform of choice was Linux, and I wanted to be the Linux guy. To limit scope the project was initially Windows-only; I took it as my role to help finish the Windows implementation so that I could then make it run on Linux.
When starting work on other platforms, the first hurdle was sorting out the build system. By that point Chrome was already large (complete, in fact–Chrome for Windows was released in 2008 before any ports had started), so efforts to switch even the Visual Studio-based Windows build to a different build system wholesale were conflicting with ongoing development. It felt like replacing the foundation of a building while it was in use.
Members of the Chrome team came up with an incremental solution called GYP3 which could be used to generate, one subcomponent at a time, the Visual Studio build files already used by Chrome in addition to the build files that would be used on other platforms.
The input to GYP is simple: the desired name of the output accompanied by plain text lists of source files, the occasional custom rule like “process each IDL file to generate an additional source file”, and some conditional behaviors (e.g., only use certain files on certain platforms). GYP then takes this high-level description and generates platform-native build files.4
On the Mac “native build files” meant Xcode project files. On Linux, however, there was no obvious single choice. The initial attempt used the Scons build system, but I was dismayed to discover that a GYP-generated Scons build could take 30 seconds to start

ผลลัพธ์ (ไทย) 1:

นินจาEvan Martin นินจาเป็นระบบโครงสร้างคล้าย ๆ กันทำให้ เป็นการป้อนข้อมูล คุณอธิบายคำสั่งที่จำเป็นในการกระบวนการแฟ้มต้นฉบับลงในไฟล์เป้าหมาย นินจาใช้คำสั่งเหล่านี้จะนำเป้าหมายเสมอ ซึ่งแตกต่างจากหลายสร้างระบบอื่น ๆ เป้าหมายหลักของนินจาคือ ความเร็วผมเขียนนินจาขณะทำงานบน Google Chrome ผมเริ่มนินจาเป็นการทดลองเพื่อค้นหาถ้าโครงสร้างของ Chrome สามารถทำได้เร็วขึ้น การประสบความสำเร็จสร้างโครเมี่ยม นินจาของเป้าหมายหลักอื่น ๆ ตาม: นินจาต้องฝังภายในโครงสร้างระบบขนาดใหญ่ได้อย่างง่ายดายนินจาประสบความสำเร็จอย่างเงียบ ๆ ค่อย ๆ เปลี่ยนระบบโครงสร้างอื่นใช้ Chrome หลังจากนินจาทำสาธารณะ อื่น ๆ ส่วนรหัสเพื่อให้ระบบสร้าง CMake นิยมสร้างไฟล์นินจา – ตอนนี้นินจายังใช้ในการพัฒนาโครงการ CMake LLVM และ ReactOS โครงการอื่น ๆ เช่น TextMate เป้าหมายนินจาจากโครงสร้างของตนเองโดยตรงฉันทำงานบน Chrome จาก 2007 2012 และเริ่มต้นนินจาใน 2010 มีหลายปัจจัยที่เอื้อต่อการสร้างประสิทธิภาพการทำงานของโครงการใหญ่ Chrome (ไฟล์ประมาณ 40,000 ใน c ++รหัสสร้างไบนารีมีผลผลิตประมาณ 90 MB ในขนาดวันนี้) ในช่วงเวลาของฉัน ฉันสัมผัสหลาย จากการรวบรวมการกระจายทั่วไปเทคนิคในการเชื่อมโยงหลายเครื่อง นินจาเป็นหลักเป้าหมายเพียงหนึ่งชิ้น – ในหน้าของการสร้าง นี่คือการรอคอยระหว่างการเริ่มต้นสร้างและเวลาการคอมไพล์แรกเริ่มเพื่อเรียกใช้ เข้าใจ เหตุที่เป็นสิ่งสำคัญจำเป็นต้องเข้าใจว่าเราคิดเกี่ยวกับประสิทธิภาพใน Chrome เองประวัติเล็กน้อยของโครเมียมสนทนาทั้งหมดของเป้าหมายของ Chrome อยู่นอกขอบเขตที่นี่ แต่หนึ่งในการกำหนดเป้าหมายของโครงการเป็นความเร็ว ประสิทธิภาพการทำงานคือ เป้าหมายสิ่งที่ครอบคลุมทั้งหมดของวิทยาการคอมพิวเตอร์ และ Chrome ใช้เกือบทุกเทคนิคมี แค parallelization การคอมไพล์เพียงในเวลา แล้วก็ความเร็วเริ่มต้น – นานโปรแกรมเอาไปแสดงบนหน้าจอหลังจากคลิกไอคอน – ซึ่งดูเหมือนไม่สำคัญในการเปรียบเทียบบิตทำไมดูแลเกี่ยวกับความเร็วเริ่มต้น สำหรับเบราว์เซอร์ การเริ่มต้นระบบอย่างรวดเร็วถ่ายทอดความรู้สึกของความสว่าง ที่ทำอะไรบนเว็บเป็น trival การกระทำเป็นการเปิดแฟ้มข้อความ เพิ่มเติม ผลกระทบของเวลาแฝง บนความสุขของคุณ และการสูญเสียของกระแสความคิดดีศึกษาในปฏิสัมพันธ์ของมนุษย์กับคอมพิวเตอร์ เวลาแฝงอยู่โดยเฉพาะโฟกัสของบริษัทเว็บเช่น Google หรือ Amazon ที่อยู่ในตำแหน่งที่ดีในการวัด และทดลองเกี่ยวกับผลกระทบของเวลาแฝง – และที่ได้ทำการทดลองที่แสดงว่า ความล่าช้าของมิลลิวินาทีแม้มีถี่คนใช้เว็บไซต์ หรือทำการซื้อสินค้าสามารถวัดผล มันเป็นเสียงเล็กที่เพิ่มขึ้นไม่รู้ตัววิธีการของ chrome เพื่อเริ่มต้นได้อย่างรวดเร็วได้เคล็ดลับฉลาด โดยวิศวกรแรกบน Chrome อย่างใดอย่างหนึ่ง ทันทีที่พวกเขามีโปรแกรมโครงกระดูกของพวกเขาไปยังจุดที่แสดงให้เห็นหน้าต่างบนหน้าจอ พวกเขาสร้างเกณฑ์มาตรฐานวัดความเร็วพร้อมกับสร้างความต่อเนื่องที่ติดตามมัน แล้ว ในคำ Brett วิลสัน, "กฎง่ายมาก: การทดสอบนี้ไม่เคยได้รับใด ๆ ช้าได้" 1 เป็นรหัสถูกเพิ่มลงใน Chrome การบำรุงรักษาของเกณฑ์มาตรฐานนี้เรียกร้องวิศวกรรมเสริม effort2 ในบางกรณีงานล่าช้าจนกระทั่งมันถูกจำเป็นอย่างแท้จริง หรือข้อมูลที่ใช้ระหว่างการเริ่มต้นคือ precomputed – แต่หลัก "เคล็ดลับ" การปฏิบัติงาน และที่ทำความประทับใจที่สุดกับฉัน เป็นเพียงการ ทำงานน้อยลงผมเข้าร่วมทีม Chrome ไม่ต้องตั้งใจทำงานบนเครื่องมือ พื้นหลังของฉันและแพลตฟอร์มเลือก Linux และอยากจะเป็นผู้ชาย Linux การจำกัดขอบเขตโครงการถูกเริ่ม Windows เท่านั้น เอามันเป็นบทบาทของฉันเพื่อช่วยทำการใช้งาน Windows เพื่อให้ฉันแล้วจะทำให้มันรันบน Linuxเมื่อเริ่มทำงานบนแพลตฟอร์มอื่น ๆ รั้วกระโดดข้ามแรกคือการเรียงลำดับออกระบบสร้าง โดยที่ จุด Chrome ได้แล้วใหญ่ (สมบูรณ์ ในความเป็นจริง – Chrome สำหรับ Windows ถูกนำออกใช้ใน 2008 ก่อนพอร์ตใด ๆ ได้เริ่มต้น), ดังนั้นความพยายามที่จะเปลี่ยนแม้แต่ Windows ที่ใช้ Visual Studio สร้างระบบโครงสร้างต่าง ๆ ขายส่งก็ขัดแย้งกับการพัฒนาอย่างต่อเนื่อง มันรู้สึกเหมือนแทนรากฐานของอาคารในขณะที่มันใช้สมาชิกของทีม Chrome มาพร้อมกับโซลูชั่นเพิ่มขึ้นเรียกว่า GYP3 ซึ่งสามารถใช้เพื่อสร้าง ส่วนประกอบหนึ่งในเวลา Visual Studio สร้างแฟ้มแล้วใช้ Chrome นอกจากการสร้างแฟ้มที่ใช้บนแพลตฟอร์มอื่น ๆการ GYP ง่าย: ชื่อที่ต้องการของผลผลิตที่มาพร้อมกับรายการข้อความธรรมดาของแฟ้มต้นฉบับ กฎที่กำหนดเองเป็นครั้งคราวเช่น "ประมวลผลแต่ละแฟ้ม IDL เพื่อสร้างไฟล์เพิ่ม" และพฤติกรรมแบบมีเงื่อนไขบางอย่าง (เช่น ใช้เฉพาะแฟ้มบางแฟ้มบนแพลตฟอร์มบาง) GYP แล้วใช้คำนี้อธิบายพื้นฐาน และสร้างสร้างแพลตฟอร์มพื้นเมือง files.4บน Mac ดั้งเดิมสร้างแฟ้ม"หมายถึง แฟ้มโครงการ Xcode บน Linux อย่างไรก็ตาม ก็ไม่มีทางเลือกเดียวที่ชัดเจน ความพยายามในการเริ่มต้นใช้ระบบสร้าง Scons แต่ฉันก็จะค้นพบว่า การสร้างสร้าง GYP Scons อาจใช้เวลา 30 วินาทีเริ่มอนาถใจ

ผลลัพธ์ (ไทย) 2:

นินจา
อีวานมาร์ติน

นินจาเป็นสร้างระบบที่คล้ายกันในการสร้าง เป็นข้อมูลที่คุณอธิบายคำสั่งที่จำเป็นในการประมวลผลไฟล์ที่มาเป็นไฟล์เป้าหมาย นินจาใช้คำสั่งเหล่านี้จะนำเป้าหมายได้ถึงวันที่ ซึ่งแตกต่างจากระบบอื่น ๆ การสร้างเป้าหมายในการออกแบบหลักของนินจาเป็นความเร็ว.
ผมเขียนนินจาขณะที่ทำงานกับ Google Chrome ผมเริ่มนินจาขณะที่การทดลองเพื่อดูว่าของ Chrome สร้างอาจจะทำให้เร็วขึ้น จะประสบความสำเร็จสร้าง Chrome, เป้าหมายการออกแบบหลักอื่น ๆ ของนินจาตาม: นินจาจำเป็นต้องได้รับการฝังตัวได้อย่างง่ายดายภายในการสร้างระบบที่มีขนาดใหญ่.
นินจาได้รับความสำเร็จอย่างเงียบ ๆ ค่อยๆเปลี่ยนระบบการสร้างอื่น ๆ ใช้โดย Chrome หลังจากนินจาได้ถูกทำให้ประชาชนคนอื่น ๆ ที่มีส่วนรหัสที่จะทำให้ได้รับความนิยม CMake สร้างระบบสร้างไฟล์ตอนนี้นินจายังใช้ในการพัฒนาโครงการ CMake-based เช่น LLVM และ ReactOS โครงการอื่น ๆ เช่น TextMate เป้าหมายนินจาโดยตรงจากการสร้างของพวกเขาเอง.
ผมทำงานบน Chrome 2007-2012 และเริ่มนินจาในปี 2010 มีหลายปัจจัยที่เอื้อต่อการสร้างประสิทธิภาพการทำงานของโครงการที่มีขนาดใหญ่เป็นโครเมี่ยมมี (วันนี้ประมาณ 40,000 ไฟล์ ของรหัส c ++ สร้างไบนารีการส่งออกประมาณ 90 ล้านบาทในขนาด) ในช่วงเวลาของฉันฉันสัมผัสมากของพวกเขาจากการรวบรวมกระจายทั่วหลายเครื่องเพื่อเทคนิคในการเชื่อมโยง นินจาหลักเป้าหมายเพียงหนึ่งชิ้นด้านหน้าของการสร้าง นี่คือการรอคอยระหว่างการเริ่มสร้างและเวลาที่รวบรวมครั้งแรกเริ่มที่จะเรียกใช้ จะเข้าใจว่าทำไมที่สำคัญมันเป็นสิ่งจำเป็นที่จะเข้าใจว่าเราคิดเกี่ยวกับประสิทธิภาพใน Chrome ตัวเอง.
ประวัติเล็ก ๆ ของ Chrome
อภิปรายทั้งหมดของเป้าหมายของ Chrome อยู่นอกขอบเขตที่นี่ แต่หนึ่งในการกำหนดเป้าหมายของโครงการคือความเร็ว ผลการดำเนินงานเป็นเป้าหมายในวงกว้างที่ครอบคลุมทุกสาขาวิชาวิทยาการคอมพิวเตอร์และ Chrome ใช้เกือบทุกเคล็ดลับที่มีอยู่จากการแคชแบบขนานที่จะเพียงแค่ในเวลารวบรวม จากนั้นก็มีความเร็ววิธีการเริ่มต้นนานโปรแกรมเอาไปปรากฏขึ้นบนหน้าจอหลังจากคลิกที่ไอคอนซึ่งดูเหมือนว่าบิตเล็ก ๆ น้อย ๆ ในการเปรียบเทียบ.
ทำไมดูแลเกี่ยวกับความเร็วเริ่มต้น? สำหรับเบราว์เซอร์เริ่มต้นอย่างรวดเร็วบ่งบอกถึงความรู้สึกของความสว่างที่ทำบางสิ่งบางอย่างในเว็บเป็น trival การดำเนินการเปิดแฟ้มข้อความ นอกจากนี้ผลกระทบจากความล่าช้าในความสุขของคุณและในการสูญเสียรถไฟของความคิดเป็นอย่างดีในการศึกษาปฏิสัมพันธ์ระหว่างมนุษย์และคอมพิวเตอร์ แฝงโดยเฉพาะอย่างยิ่งการให้ความสำคัญของ บริษัท เว็บเช่น Google หรือ Amazon ที่อยู่ในตำแหน่งที่ดีในการวัดและการทดสอบเกี่ยวกับผลกระทบของการล่าช้าและผู้ที่ได้กระทำการทดลองที่แสดงให้เห็นว่าความล่าช้าของมิลลิวินาทีแม้จะมีผลกระทบที่วัดกับความถี่ที่คนใช้ ไซต์หรือทำการสั่งซื้อ มันเป็นความยุ่งยากขนาดเล็กที่เพิ่มขึ้นโดยไม่รู้ตัว.
วิธีการของ Chrome เพื่อเริ่มต้นได้อย่างรวดเร็วเป็นเคล็ดลับฉลาดโดยหนึ่งในวิศวกรแรกบน Chrome เร็วที่สุดเท่าที่พวกเขาได้รับการประยุกต์ใช้โครงกระดูกของพวกเขาไปยังจุดที่มันแสดงให้เห็นหน้าต่างบนหน้าจอให้พวกเขาสร้างวัดมาตรฐานว่าความเร็วพร้อมกับการสร้างต่อเนื่องที่ติดตามมัน จากนั้นในคำพูดของเบรตต์วิลสัน "กฎง่ายมาก:. การทดสอบนี้ไม่สามารถรับได้ช้าลง" 1 เป็นรหัสที่ถูกเพิ่มเข้ามาใน Chrome, การบำรุงรักษามาตรฐานนี้เรียกร้องวิศวกรรมพิเศษ effort2 ในการทำงานบางอย่างกรณีถูกเลื่อนออกไปจนกว่ามันจะเป็นสิ่งที่จำเป็นอย่างแท้จริง หรือข้อมูลที่ใช้ระหว่างการเริ่มต้นถูก precomputed แต่หลัก "เคล็ดลับ" ผลการดำเนินงานและหนึ่งที่ทำให้การแสดงผลที่ยิ่งใหญ่ที่สุดในฉันเป็นเพียงที่จะทำงานน้อยลง.
ผมได้เข้าร่วมทีมงาน Chrome โดยไม่ตั้งใจในการทำงานเกี่ยวกับการสร้างเครื่องมือใด ๆ พื้นหลังและแพลตฟอร์มของทางเลือกของฉันคือ Linux และฉันอยากจะเป็นคนที่แต่งตัวประหลาดลินุกซ์ เพื่อ จำกัด ขอบเขตของโครงการเป็นคนแรกที่ใช้ Windows เท่านั้น ฉันเอามันเป็นบทบาทของฉันที่จะช่วยให้เสร็จสิ้นการใช้งาน Windows เพื่อให้จากนั้นผมก็จะทำให้มันทำงานบนลินุกซ์.
เมื่อเริ่มต้นการทำงานบนแพลตฟอร์มอื่น ๆ ที่กีดขวางแรกถูกคัดแยกออกมาสร้างระบบ โดยจุดที่ Chrome มีขนาดใหญ่อยู่แล้ว (เสร็จสมบูรณ์ในความเป็นจริง-Chrome สำหรับ Windows ได้รับการปล่อยตัวในปี 2008 ก่อนที่จะพอร์ตใด ๆ ได้เริ่มต้น) ดังนั้นความพยายามที่จะเปลี่ยนแม้กระทั่งของ Windows Visual Studio ที่ใช้สร้างการสร้างระบบที่แตกต่างกันขายส่งถูกขัดแย้งกับการพัฒนาอย่างต่อเนื่อง . มันรู้สึกเหมือนการเปลี่ยนรากฐานของอาคารขณะที่มันเป็นในการใช้งาน.
สมาชิกของทีมงาน Chrome ขึ้นมาด้วยวิธีการแก้ปัญหาที่เพิ่มขึ้นเรียกว่า GYP3 ซึ่งสามารถนำมาใช้ในการสร้างหนึ่งย่อยที่เวลาของ Visual Studio สร้างไฟล์ที่ใช้แล้วโดยโครเมี่ยม . นอกเหนือจากการสร้างไฟล์ที่จะนำมาใช้บนแพลตฟอร์มอื่น ๆ
อินพุต GYP ง่าย: ชื่อที่ต้องการของการส่งออกพร้อมด้วยรายชื่อข้อความธรรมดาของไฟล์ที่มาของกฎที่กำหนดเองเป็นครั้งคราวเช่น "กระบวนการไฟล์ IDL แต่ละคนที่จะสร้างเพิ่มเติม แฟ้มแหล่งที่มา "และบางพฤติกรรมเงื่อนไข (เช่นใช้เฉพาะบางไฟล์บนแพลตฟอร์มบางอย่าง) GYP แล้วจะใช้เวลาคำอธิบายระดับสูงนี้และสร้างแพลตฟอร์มพื้นเมืองสร้าง files.4
บน Mac "แม่สร้างไฟล์" หมายถึงไฟล์โครงการ Xcode บน Linux แต่ก็ไม่มีทางเลือกเดียวที่เห็นได้ชัด ความพยายามครั้งแรกที่ใช้ scons สร้างระบบ แต่ผมก็ใจหายที่จะค้นพบว่า GYP สร้าง scons สร้างอาจจะใช้เวลา 30 วินาทีที่จะเริ่มต้น

ผลลัพธ์ (ไทย) 3:

นินจาอีวาน มาร์ตินนินจาคือ สร้างระบบที่คล้ายกันเพื่อให้ เป็นการป้อนข้อมูลที่คุณอธิบายคำสั่งที่จำเป็นกระบวนการไฟล์ที่มาลงในแฟ้มเป้าหมาย นินจาใช้คำสั่งเหล่านี้เพื่อให้เป้าหมายได้ถึงวันที่ ซึ่งแตกต่างจากหลายอื่น ๆสร้างระบบ นินจาเป็นหลักออกแบบ เป้าหมายคือความเร็วผมเขียนนินจาในขณะที่ทำงานบน Google Chrome . ผมเริ่มนินจาเป็นทดสอบเพื่อดูว่า Chrome ก็สร้างได้เร็วขึ้น ไปเรียบร้อยแล้วสร้าง Chrome นินจาเป็นหลักอื่น ๆการออกแบบเป้าหมายตาม : นินจาต้องสามารถฝังตัวภายในขนาดใหญ่สร้างระบบนินจาที่ได้รับความสำเร็จอย่างเงียบๆ ค่อยๆแทนที่อื่น ๆ สร้างระบบที่ใช้โดยโครเมี่ยม หลังจากนินจาทำสาธารณะอื่นๆส่วนรหัสเพื่อให้เป็นที่นิยมแฟ้ม CMakeLanguage สร้างระบบสร้างไฟล์นินจานินจา ) ตอนนี้ยังใช้พัฒนาแฟ้ม CMakeLanguage ตามโครงการและชอบ llvm reactos . โครงการอื่นๆ เช่น สำหรับเป้าหมายของนินจาโดยตรงจากพวกเขาเองสร้างผมทำงานในเบราว์เซอร์จาก 2007 ถึง 2012 , นินจา และเริ่มต้นใน 2010 . มีหลายปัจจัยในการสร้างประสิทธิภาพของโครงการขนาดใหญ่เป็นโครเมี่ยม ( วันนี้ประมาณ 40 , 000 ไฟล์ของ C + + รหัสการสร้างผลผลิตไบนารีประมาณ 90 MB ในขนาด ) เวลาที่ผมประทับใจมากของพวกเขาจากการรวบรวมข้ามเครื่องหลายเทคนิคในการเชื่อมโยง นินจาเป็นหลักเป้าหมายเพียงหนึ่งชิ้นสำหรับหน้าของการสร้าง นี่รอระหว่างการเริ่มต้นสร้างและเวลาก่อนรวบรวมเริ่มวิ่ง ที่จะเข้าใจ ว่าทำไม ที่สำคัญมันเป็นสิ่งจำเป็นที่จะเข้าใจวิธีการที่เราคิดเกี่ยวกับการทำงานใน Chrome นั่นเองประวัติเล็กน้อยของโครเมี่ยมการอภิปรายของ Chrome ของเป้าหมายคือออกจากขอบเขตตรงนี้ แต่หนึ่งในการกำหนดเป้าหมายของโครงการ คือ ความเร็ว ประสิทธิภาพเป็นเป้าหมายที่กว้างครอบคลุมทั้งหมดของคอมพิวเตอร์ และโครเมี่ยม ใช้เกือบทุกเคล็ดลับใช้ได้จากแคชเพื่อ parallelization ไปแค่รวบรวมเวลา จากนั้นก็มีการเริ่มต้นเร็วและนานแค่ไหน โปรแกรมก็จะแสดงขึ้นบนหน้าจอหลังจากคลิกที่ไอคอน ( ซึ่งดูเหมือนว่าบิตไม่เอาจริงเอาจังในการเปรียบเทียบทำไมต้องสนใจเรื่องความเร็วเริ่มต้น สำหรับเบราว์เซอร์เริ่มต้นอย่างรวดเร็วบ่งบอกถึงความรู้สึกของความสว่างนั้นทำอะไร บนเว็บเป็น trival การเปิดเป็นแฟ้มข้อความ นอกจากนี้ ผลกระทบจากความล่าช้าในความสุขของคุณและสูญเสียรถไฟของคุณคิดว่าเป็นอย่างดีใช้ในการปฏิสัมพันธ์ระหว่างมนุษย์และคอมพิวเตอร์ ศักยภาพโดยเน้นเว็บของ บริษัท เช่น Google และ Amazon ที่อยู่ในตำแหน่งที่ดีในการวัดและการทดลองผลของความล่าช้า–และผู้ทำการทดลองที่แสดงให้เห็นว่า ความล่าช้าของมิลลิวินาทีได้ผลการวัดในบ่อยครั้งที่ผู้ใช้เว็บไซต์หรือให้ซื้อ มันมีขนาดเล็กเสียงที่เพิ่มขึ้นจากจิตใต้สำนึกวิธีการเริ่มต้นของ Chrome ได้อย่างรวดเร็วเป็นวิธีที่ฉลาดโดยหนึ่งในวิศวกรแรกบนโครเมี่ยม ทันทีที่พวกเขามีโปรแกรมโครงกระดูกของพวกเขาไปยังจุดที่พบหน้าต่างบนหน้าจอ พวกเขาได้สร้างมาตรฐานการวัดความเร็วที่พร้อมกับอย่างต่อเนื่องสร้างติดตามมัน แล้วในเบร็ทวิลสันคำ " กฎง่ายมาก : การทดสอบนี้สามารถไม่เคยได้รับช้า . " 1 เป็นรหัสที่ถูกเพิ่มเข้าไปใน Chrome , รักษามาตรฐานนี้เรียกร้อง– effort2 วิศวกรรมพิเศษในบางกรณีทำงานล่าช้าจนอย่างแท้จริง ต้องการ หรือข้อมูลที่ใช้ในการเริ่มต้นคือ precomputed –แต่หลัก " เคล็ดลับ " ผลงาน และทำให้ความประทับใจมากที่สุดที่ฉันได้เพียงแค่การทํางานน้อยลงผมเข้าร่วมกับทีม Chrome ไม่มีความตั้งใจทำงาน สร้างเครื่องมือ พื้นหลังของฉันและแพลตฟอร์มของทางเลือกที่เป็น Linux , และฉันต้องการที่จะเป็น Linux นะ เพื่อจำกัดขอบเขตโครงการที่เริ่มต้น Windows เท่านั้น ฉันจึงเป็นบทบาทของฉันเพื่อช่วยให้เสร็จหน้าต่างการใช้งานเพื่อให้ฉันสามารถทำให้มันรันบนลินุกซ์เมื่อเริ่มทำงานบนแพลตฟอร์มอื่น ๆอุปสรรค์แรกก็คัดสร้างระบบ โดยจุดที่ Chrome ก็ใหญ่ ( สมบูรณ์ในความเป็นจริง– Chrome สำหรับ Windows เผยแพร่ในปี 2008 ก่อนที่พอร์ตใดได้เริ่มต้น ) เพื่อให้ความพยายามที่จะเปลี่ยนแม้แต่ Visual Studio ใช้ Windows สร้างเพื่อสร้างระบบที่แตกต่างกันขายส่งเป็นความขัดแย้งกับการพัฒนาอย่างต่อเนื่อง มันรู้สึกเหมือนการเปลี่ยนรากฐานของอาคาร ขณะถูกใช้สมาชิกของทีม Chrome ขึ้นมาด้วยโซลูชั่นที่เพิ่มขึ้น เรียกว่า gyp3 ซึ่งสามารถใช้เพื่อสร้างหนึ่ง subcomponent ครั้ง สตูดิโอของ Visual สร้างไฟล์แล้วใช้ Chrome ในการสร้างไฟล์ที่สามารถใช้ในแพลตฟอร์มอื่น ๆใส่เพื่อต้มตุ๋นง่าย : ต้องการชื่อของผลผลิตพร้อมด้วยข้อความธรรมดาของรายการแฟ้มแหล่งที่มา , บางครั้งเองกฎเหมือน " กระบวนการไฟล์ IDL แต่ละคนเพื่อสร้างแหล่งแฟ้มเพิ่มเติม " และบางเงื่อนไขพฤติกรรม ( เช่น ใช้เฉพาะไฟล์บางอย่างในบางแพลตฟอร์ม ) โกงแล้วจะอธิบายพื้นฐานนี้และสร้างแพลตฟอร์มดั้งเดิมสร้างไฟล์ 4 .บน Mac พื้นเมือง " สร้างไฟล์ " หมายถึงไฟล์ Xcode โครงการ บน linux แต่ไม่มีชัดเจนทางเลือกเดียว ความพยายามครั้งแรกที่ใช้ scons สร้างระบบ แต่ผมขยาดที่จะค้นพบว่าโกง GENERAT