การเพิ่มประสิทธิภาพ Feedback Vector ของ JavaScript V8: เจาะลึกการเรียนรู้รูปแบบการเข้าถึง Property

เอนจิ้น V8 JavaScript ซึ่งเป็นขุมพลังของ Chrome และ Node.js มีชื่อเสียงด้านประสิทธิภาพ ส่วนประกอบที่สำคัญของประสิทธิภาพนี้คือไปป์ไลน์การเพิ่มประสิทธิภาพที่ซับซ้อน ซึ่งอาศัย feedback vectors เป็นอย่างมาก เวคเตอร์เหล่านี้เป็นหัวใจสำคัญของความสามารถของ V8 ในการเรียนรู้และปรับตัวเข้ากับพฤติกรรมการทำงานของโค้ด JavaScript ของคุณ ซึ่งช่วยให้สามารถปรับปรุงความเร็วได้อย่างมาก โดยเฉพาะอย่างยิ่งในการเข้าถึง property บทความนี้จะเจาะลึกถึงวิธีที่ V8 ใช้ feedback vectors เพื่อเพิ่มประสิทธิภาพรูปแบบการเข้าถึง property โดยใช้ประโยชน์จาก inline caching และ hidden classes

ทำความเข้าใจแนวคิดหลัก

Feedback Vectors คืออะไร?

Feedback vectors คือโครงสร้างข้อมูลที่ V8 ใช้เพื่อรวบรวมข้อมูลขณะรันไทม์เกี่ยวกับการดำเนินการที่เกิดขึ้นในโค้ด JavaScript ข้อมูลนี้รวมถึงประเภทของอ็อบเจกต์ที่ถูกจัดการ, property ที่ถูกเข้าถึง และความถี่ของการดำเนินการต่างๆ ลองนึกว่ามันเป็นวิธีการของ V8 ในการสังเกตและเรียนรู้จากพฤติกรรมของโค้ดของคุณแบบเรียลไทม์

โดยเฉพาะอย่างยิ่ง feedback vectors จะเชื่อมโยงกับคำสั่ง bytecode ที่เฉพาะเจาะจง แต่ละคำสั่งสามารถมีหลายช่อง (slot) ใน feedback vector ของมันได้ แต่ละช่องจะเก็บข้อมูลที่เกี่ยวข้องกับการทำงานของคำสั่งนั้นๆ

Hidden Classes: รากฐานของการเข้าถึง Property ที่มีประสิทธิภาพ

JavaScript เป็นภาษาแบบ dynamic typed ซึ่งหมายความว่าประเภทของตัวแปรสามารถเปลี่ยนแปลงได้ในขณะรันไทม์ สิ่งนี้ก่อให้เกิดความท้าทายในการเพิ่มประสิทธิภาพ เนื่องจากเอนจิ้นไม่ทราบโครงสร้างของอ็อบเจกต์ในขณะคอมไพล์ เพื่อแก้ไขปัญหานี้ V8 ใช้ hidden classes (บางครั้งเรียกว่า maps หรือ shapes) hidden class จะอธิบายโครงสร้าง (properties และตำแหน่ง offset ของมัน) ของอ็อบเจกต์ เมื่อใดก็ตามที่อ็อบเจกต์ใหม่ถูกสร้างขึ้น V8 จะกำหนด hidden class ให้กับมัน หากอ็อบเจกต์สองตัวมีชื่อ property เหมือนกันและอยู่ในลำดับเดียวกัน พวกมันจะใช้ hidden class เดียวกัน

พิจารณาอ็อบเจกต์ JavaScript เหล่านี้:

const obj1 = { x: 10, y: 20 };
const obj2 = { x: 5, y: 15 };

ทั้ง obj1 และ obj2 มีแนวโน้มที่จะใช้ hidden class เดียวกัน เพราะพวกมันมี property เหมือนกันและอยู่ในลำดับเดียวกัน อย่างไรก็ตาม ถ้าเราเพิ่ม property ให้กับ obj1 หลังจากที่สร้างขึ้นแล้ว:

obj1.z = 30;

ตอนนี้ obj1 จะเปลี่ยนไปใช้ hidden class ใหม่ การเปลี่ยนแปลงนี้สำคัญมากเพราะ V8 จำเป็นต้องอัปเดตความเข้าใจเกี่ยวกับโครงสร้างของอ็อบเจกต์

Inline Caches (ICs): การเร่งความเร็วในการค้นหา Property

Inline caches (ICs) เป็นเทคนิคการเพิ่มประสิทธิภาพที่สำคัญซึ่งใช้ประโยชน์จาก hidden classes เพื่อเร่งความเร็วในการเข้าถึง property เมื่อ V8 พบการเข้าถึง property มันไม่จำเป็นต้องทำการค้นหาแบบทั่วไปที่ช้า แต่สามารถใช้ hidden class ที่เชื่อมโยงกับอ็อบเจกต์เพื่อเข้าถึง property โดยตรงที่ตำแหน่ง offset ที่ทราบในหน่วยความจำ

ในครั้งแรกที่เข้าถึง property ตัว IC จะยังไม่ถูก uninitialized V8 จะทำการค้นหา property และเก็บ hidden class และ offset ไว้ใน IC การเข้าถึง property เดียวกันในครั้งถัดไปบนอ็อบเจกต์ที่มี hidden class เดียวกัน จะสามารถใช้ offset ที่แคชไว้ได้ ซึ่งหลีกเลี่ยงกระบวนการค้นหาที่มีค่าใช้จ่ายสูง นี่คือการเพิ่มประสิทธิภาพอย่างมหาศาล

นี่คือภาพประกอบอย่างง่าย:

1. การเข้าถึงครั้งแรก: V8 พบ obj.x IC ยังไม่ถูกเริ่มต้น
2. การค้นหา: V8 หาตำแหน่ง offset ของ x ใน hidden class ของ obj
3. การแคช: V8 เก็บ hidden class และ offset ไว้ใน IC
4. การเข้าถึงครั้งถัดๆ ไป: ถ้า obj (หรืออ็อบเจกต์อื่น) มี hidden class เดียวกัน V8 จะใช้ offset ที่แคชไว้เพื่อเข้าถึง x โดยตรง

Feedback Vectors และ Hidden Classes ทำงานร่วมกันอย่างไร

Feedback vectors มีบทบาทสำคัญในการจัดการ hidden classes และ inline caches พวกมันจะบันทึก hidden classes ที่สังเกตได้ระหว่างการเข้าถึง property ข้อมูลนี้จะถูกใช้เพื่อ:

• กระตุ้นการเปลี่ยน Hidden Class: เมื่อ V8 สังเกตเห็นการเปลี่ยนแปลงโครงสร้างของอ็อบเจกต์ (เช่น การเพิ่ม property ใหม่) feedback vector จะช่วยเริ่มต้นการเปลี่ยนไปสู่ hidden class ใหม่
• เพิ่มประสิทธิภาพ ICs: feedback vector จะแจ้งให้ระบบ IC ทราบเกี่ยวกับ hidden classes ที่พบบ่อยสำหรับการเข้าถึง property ที่กำหนด ซึ่งช่วยให้ V8 สามารถเพิ่มประสิทธิภาพ IC สำหรับกรณีที่พบบ่อยที่สุดได้
• Deoptimize Code: หาก hidden classes ที่สังเกตได้เบี่ยงเบนไปจากสิ่งที่ IC คาดหวังอย่างมาก V8 อาจทำการ deoptimize โค้ดและกลับไปใช้กลไกการค้นหา property ที่ช้าและทั่วไปมากขึ้น เพราะ IC ไม่ได้ผลอีกต่อไปและกำลังสร้างผลเสียมากกว่าผลดี

สถานการณ์ตัวอย่าง: การเพิ่ม Properties แบบไดนามิก

ลองกลับไปดูตัวอย่างก่อนหน้านี้และดูว่า feedback vectors เข้ามาเกี่ยวข้องอย่างไร:

function Point(x, y) {
 this.x = x;
 this.y = y;
}

const p1 = new Point(10, 20);
const p2 = new Point(5, 15);

// เข้าถึง properties
console.log(p1.x + p1.y);
console.log(p2.x + p2.y);

// ตอนนี้ เพิ่ม property ให้กับ p1
p1.z = 30;

// เข้าถึง properties อีกครั้ง
console.log(p1.x + p1.y + p1.z);
console.log(p2.x + p2.y);

นี่คือสิ่งที่เกิดขึ้นเบื้องหลัง:

1. Hidden Class เริ่มต้น: เมื่อ p1 และ p2 ถูกสร้างขึ้น พวกมันจะใช้ hidden class เริ่มต้นเดียวกัน (ซึ่งมี x และ y)
2. การเข้าถึง Property (ครั้งแรก): ครั้งแรกที่ p1.x และ p1.y ถูกเข้าถึง feedback vectors ของคำสั่ง bytecode ที่เกี่ยวข้องจะว่างเปล่า V8 จะทำการค้นหา property และเติม ICs ด้วย hidden class และ offsets
3. การเข้าถึง Property (ครั้งถัดๆ ไป): ครั้งที่สองที่ p2.x และ p2.y ถูกเข้าถึง ICs จะถูกใช้งาน (hit) และการเข้าถึง property จะเร็วขึ้นมาก
4. การเพิ่ม Property z: การเพิ่ม p1.z ทำให้ p1 เปลี่ยนไปใช้ hidden class ใหม่ feedback vector ที่เชื่อมโยงกับการกำหนดค่า property นี้จะบันทึกการเปลี่ยนแปลงนี้ไว้
5. Deoptimization (อาจเกิดขึ้น): เมื่อ p1.x และ p1.y ถูกเข้าถึงอีกครั้ง *หลังจาก* เพิ่ม p1.z แล้ว ICs อาจถูกทำให้ใช้งานไม่ได้ (ขึ้นอยู่กับ heuristics ของ V8) เนื่องจาก hidden class ของ p1 ตอนนี้แตกต่างจากที่ ICs คาดหวัง ในกรณีที่ง่ายกว่า V8 อาจสามารถสร้าง transition tree ที่เชื่อมโยง hidden class เก่ากับอันใหม่ เพื่อรักษาระดับการเพิ่มประสิทธิภาพไว้ได้บ้าง ในสถานการณ์ที่ซับซ้อนกว่านั้น อาจเกิด deoptimization ขึ้น
6. Optimization (ในที่สุด): เมื่อเวลาผ่านไป หาก p1 ถูกเข้าถึงบ่อยครั้งด้วย hidden class ใหม่ V8 จะเรียนรู้รูปแบบการเข้าถึงใหม่และเพิ่มประสิทธิภาพตามนั้น ซึ่งอาจสร้าง ICs ใหม่ที่เชี่ยวชาญสำหรับ hidden class ที่อัปเดตแล้ว

กลยุทธ์การเพิ่มประสิทธิภาพเชิงปฏิบัติ

การทำความเข้าใจว่า V8 เพิ่มประสิทธิภาพรูปแบบการเข้าถึง property อย่างไร ช่วยให้คุณสามารถเขียนโค้ด JavaScript ที่มีประสิทธิภาพมากขึ้นได้ นี่คือกลยุทธ์เชิงปฏิบัติบางประการ:

1. กำหนดค่าเริ่มต้นให้กับ Property ทั้งหมดใน Constructor

ควรกำหนดค่าเริ่มต้นให้กับ property ทั้งหมดของอ็อบเจกต์ใน constructor หรือ object literal เสมอ เพื่อให้แน่ใจว่าอ็อบเจกต์ทั้งหมดที่มี "ประเภท" เดียวกันจะมี hidden class เดียวกัน นี่เป็นสิ่งสำคัญอย่างยิ่งในโค้ดที่ต้องการประสิทธิภาพสูง

// ไม่ดี: การเพิ่ม properties นอก constructor
function BadPoint(x, y) {
 this.x = x;
 this.y = y;
}

const badPoint = new BadPoint(1, 2);
badPoint.z = 3; // หลีกเลี่ยงสิ่งนี้!

// ดี: การกำหนดค่าเริ่มต้นให้ property ทั้งหมดใน constructor
function GoodPoint(x, y, z) {
 this.x = x;
 this.y = y;
 this.z = z !== undefined ? z : 0; // ค่าเริ่มต้น
}

const goodPoint = new GoodPoint(1, 2, 3);

constructor ของ GoodPoint ช่วยให้แน่ใจว่าอ็อบเจกต์ GoodPoint ทั้งหมดมี property เหมือนกัน ไม่ว่าค่า z จะถูกส่งมาหรือไม่ก็ตาม แม้ว่า z จะไม่ได้ถูกใช้เสมอไป การจัดสรรล่วงหน้าด้วยค่าเริ่มต้นมักจะมีประสิทธิภาพดีกว่าการเพิ่มในภายหลัง

2. เพิ่ม Properties ในลำดับเดียวกัน

ลำดับการเพิ่ม property ให้กับอ็อบเจกต์ส่งผลต่อ hidden class ของมัน เพื่อให้เกิดการใช้ hidden class ร่วมกันได้สูงสุด ควรเพิ่ม property ในลำดับเดียวกันสำหรับอ็อบเจกต์ทั้งหมดที่มี "ประเภท" เดียวกัน

// ลำดับ property ไม่สอดคล้องกัน (ไม่ดี)
const objA = { a: 1, b: 2 };
const objB = { b: 2, a: 1 }; // ลำดับต่างกัน

// ลำดับ property สอดคล้องกัน (ดี)
const objC = { a: 1, b: 2 };
const objD = { a: 1, b: 2 }; // ลำดับเดียวกัน

แม้ว่า objA และ objB จะมี property เหมือนกัน แต่พวกมันมักจะมี hidden class ที่แตกต่างกันเนื่องจากลำดับ property ที่ต่างกัน ซึ่งนำไปสู่การเข้าถึง property ที่มีประสิทธิภาพน้อยลง

3. หลีกเลี่ยงการลบ Properties แบบไดนามิก

การลบ property ออกจากอ็อบเจกต์อาจทำให้ hidden class ของมันใช้งานไม่ได้และบังคับให้ V8 กลับไปใช้กลไกการค้นหา property ที่ช้ากว่า หลีกเลี่ยงการลบ property เว้นแต่จะจำเป็นจริงๆ

// หลีกเลี่ยงการลบ properties (ไม่ดี)
const obj = { a: 1, b: 2, c: 3 };
delete obj.b; // หลีกเลี่ยง!

// ใช้ null หรือ undefined แทน (ดี)
const obj2 = { a: 1, b: 2, c: 3 };
obj2.b = null; // หรือ undefined

การตั้งค่า property เป็น null หรือ undefined โดยทั่วไปมีประสิทธิภาพดีกว่าการลบออก เนื่องจากยังคงรักษา hidden class ของอ็อบเจกต์ไว้

4. ใช้ Typed Arrays สำหรับข้อมูลตัวเลข

เมื่อทำงานกับข้อมูลตัวเลขจำนวนมาก ควรพิจารณาใช้ Typed Arrays ซึ่งเป็นวิธีแสดงอาร์เรย์ของข้อมูลประเภทเฉพาะ (เช่น Int32Array, Float64Array) ในลักษณะที่มีประสิทธิภาพมากกว่าอาร์เรย์ JavaScript ทั่วไป V8 มักจะสามารถเพิ่มประสิทธิภาพการดำเนินการบน Typed Arrays ได้ดีกว่า

// อาร์เรย์ JavaScript ทั่วไป
const arr = [1, 2, 3, 4, 5];

// Typed Array (Int32Array)
const typedArr = new Int32Array([1, 2, 3, 4, 5]);

// ดำเนินการ (เช่น การบวก)
let sum = 0;
for (let i = 0; i < arr.length; i++) {
 sum += arr[i];
}

let typedSum = 0;
for (let i = 0; i < typedArr.length; i++) {
 typedSum += typedArr[i];
}

Typed Arrays มีประโยชน์อย่างยิ่งเมื่อทำการคำนวณเชิงตัวเลข การประมวลผลภาพ หรือภารกิจที่ต้องใช้ข้อมูลจำนวนมาก

5. โปรไฟล์โค้ดของคุณ

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

1. เปิด Chrome DevTools: คลิกขวาบนหน้าเว็บแล้วเลือก "Inspect" จากนั้นไปที่แท็บ "Performance"
2. บันทึก (Record): คลิกปุ่มบันทึกและดำเนินการที่คุณต้องการโปรไฟล์
3. วิเคราะห์ (Analyze): หยุดการบันทึกและวิเคราะห์ผลลัพธ์ มองหาฟังก์ชันที่ใช้เวลานานในการทำงานหรือทำให้เกิด garbage collection บ่อยครั้ง

ข้อควรพิจารณาขั้นสูง

Polymorphic Inline Caches

บางครั้ง property อาจถูกเข้าถึงบนอ็อบเจกต์ที่มี hidden classes ที่แตกต่างกัน ในกรณีเหล่านี้ V8 จะใช้ polymorphic inline caches (PICs) ซึ่ง PIC สามารถแคชข้อมูลสำหรับ hidden classes หลายอันได้ ทำให้สามารถจัดการกับ polymorphism ในระดับที่จำกัดได้ อย่างไรก็ตาม หากจำนวน hidden classes ที่แตกต่างกันมีมากเกินไป PIC อาจไม่มีประสิทธิภาพ และ V8 อาจต้องหันไปใช้การค้นหาแบบ megamorphic (ซึ่งเป็นเส้นทางที่ช้าที่สุด)

Transition Trees

ดังที่ได้กล่าวไว้ก่อนหน้านี้ เมื่อมีการเพิ่ม property ให้กับอ็อบเจกต์ V8 อาจสร้าง transition tree เพื่อเชื่อมโยง hidden class เก่ากับอันใหม่ สิ่งนี้ช่วยให้ V8 สามารถรักษาระดับการเพิ่มประสิทธิภาพไว้ได้แม้ว่าอ็อบเจกต์จะเปลี่ยนไปใช้ hidden classes ที่แตกต่างกัน อย่างไรก็ตาม การเปลี่ยนที่มากเกินไปก็ยังสามารถทำให้ประสิทธิภาพลดลงได้

Deoptimization

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

ตัวอย่างในโลกแห่งความจริงและข้อควรพิจารณาด้าน Internationalization

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

• แอปพลิเคชันที่ใช้ข้อมูลจำนวนมาก (เช่น การสร้างแบบจำลองทางการเงิน, การจำลองทางวิทยาศาสตร์): แอปพลิเคชันเหล่านี้มักได้รับประโยชน์จากการใช้ Typed Arrays และการจัดการหน่วยความจำอย่างระมัดระวัง โค้ดที่เขียนโดยทีมในอินเดีย สหรัฐอเมริกา และยุโรปที่ทำงานกับแอปพลิเคชันดังกล่าวจะต้องได้รับการปรับให้เหมาะสมเพื่อจัดการกับข้อมูลจำนวนมหาศาล
• เว็บแอปพลิเคชันที่มีเนื้อหาแบบไดนามิก (เช่น เว็บไซต์อีคอมเมิร์ซ, แพลตฟอร์มโซเชียลมีเดีย): แอปพลิเคชันเหล่านี้มักเกี่ยวข้องกับการสร้างและจัดการอ็อบเจกต์บ่อยครั้ง การเพิ่มประสิทธิภาพรูปแบบการเข้าถึง property สามารถปรับปรุงการตอบสนองของแอปพลิเคชันเหล่านี้ได้อย่างมาก ซึ่งเป็นประโยชน์ต่อผู้ใช้ทั่วโลก ลองนึกภาพการเพิ่มประสิทธิภาพเวลาในการโหลดสำหรับเว็บไซต์อีคอมเมิร์ซในญี่ปุ่นเพื่อลดอัตราการละทิ้งตะกร้าสินค้า
• แอปพลิเคชันบนมือถือ: อุปกรณ์มือถือมีทรัพยากรจำกัด ดังนั้นการเพิ่มประสิทธิภาพโค้ด JavaScript จึงมีความสำคัญมากยิ่งขึ้น เทคนิคต่างๆ เช่น การหลีกเลี่ยงการสร้างอ็อบเจกต์ที่ไม่จำเป็น และการใช้ Typed Arrays สามารถช่วยลดการใช้แบตเตอรี่และปรับปรุงประสิทธิภาพได้ ตัวอย่างเช่น แอปพลิเคชันแผนที่ที่ใช้กันอย่างแพร่หลายในแอฟริกาใต้สะฮาราจำเป็นต้องมีประสิทธิภาพบนอุปกรณ์ระดับล่างที่มีการเชื่อมต่อเครือข่ายที่ช้ากว่า

นอกจากนี้ เมื่อพัฒนาแอปพลิเคชันสำหรับผู้ชมทั่วโลก สิ่งสำคัญคือต้องพิจารณาแนวทางปฏิบัติที่ดีที่สุดสำหรับ internationalization (i18n) และ localization (l10n) แม้ว่าสิ่งเหล่านี้จะเป็นข้อกังวลที่แยกต่างหากจากการเพิ่มประสิทธิภาพของ V8 แต่ก็สามารถส่งผลกระทบต่อประสิทธิภาพทางอ้อมได้ ตัวอย่างเช่น การจัดการสตริงที่ซับซ้อนหรือการจัดรูปแบบวันที่อาจเป็นงานที่ใช้ประสิทธิภาพสูง ดังนั้น การใช้ไลบรารี i18n ที่ได้รับการปรับให้เหมาะสมและหลีกเลี่ยงการดำเนินการที่ไม่จำเป็นสามารถช่วยปรับปรุงประสิทธิภาพโดยรวมของแอปพลิเคชันของคุณได้อีกด้วย

สรุป

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

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

ด้วยการยึดมั่นในหลักการเหล่านี้ นักพัฒนาทั่วโลกสามารถมีส่วนร่วมในการสร้างประสบการณ์เว็บที่รวดเร็วขึ้น มีประสิทธิภาพมากขึ้น และตอบสนองได้ดีขึ้นสำหรับทุกคน