SYS.ONLINE
[ ASK_ME ↗ ]
INDEX / DOC // SPEC
2591 words
•
13 minutes

المتغير مش زي س في المعادلة… حكاية الـ Mutation ولغز x = x + 1 (سلسلة أصل البرمجة — 6)

المتغير مش زي س في المعادلة… حكاية الـ Mutation ولغز x = x + 1 (سلسلة أصل البرمجة — 6)

المتغير مش زي س في المعادلة… حكاية الـ Mutation ولغز x = x + 1#

فاكر أول أسبوع في حياتك وأنت بتتعلم برمجة؟

غالباً كلنا مرينا بنفس اللحظة دي: شفت سطر زي ده مكتوب في الكود:

x=x+1x = x + 1

مخك اللي اتعود على سنين المدرسة وقف ثانية وتنّح. لو فكرت فيها بالمنطق الرياضي اللي درسناه، هتحس إن فيه حاجة غلط تماماً؛ لأنك لو طرحت xx من الطرفين، هتوصل لكارثة:

0=10 = 1

في الرياضيات، مستحيل أي رقم يساوي نفسه مجموعاً عليه واحد. دي بديهية مفيش عليها نقاش؛ لأن السبورة معندهاش مفهوم لمرور الوقت، والمعادلة بتعبّر عن «حقيقة أبدية» ثابتة في كل مكان.

لكن في نفس اللحظة، لو فتحت المتصفح وكتبت في الـ Console:

let x = 5;
x = x + 1; // أو الاختصار اللي كلنا بنحبه: x++

console.log(x); // 6

الكمبيوتر هينفذ السطر ده في رمشة عين، ويطلعلك 6 بمنتهى الهدوء، ولا كأنه كسر أي قاعدة في الكون!

السؤال اللي لازم نسأله لنفسنا كمهندسين:
ليه السطر اللي يجيب جلطة لمدرس الرياضيات، هو أكتر سطر بنكتبه في شغلنا كل يوم؟ وإيه اللي بيحصل بجد جوا خلايا الرام والمعالج أول ما بتدوس على زرار اليساوي = في الكيبورد؟

تعال نحكي القصة من أولها، لأن فهم الحتة دي هو اللي بيفرّق بين مبرمج حافظ كود، ومهندس فاهم السيستم شغال إزاي تحت الغطاء.


الفارق الجوهري: التساوي الرياضي مقابل أمر النسخ الفيزيائي#

الحكاية كلها بدأت من «استسهال» تاريخي حصل سنة 1957.
وقتها، الفريق اللي كان بيعمل لغة FORTRAN بقيادة جون باكوس، حبوا يخلوا لغة البرمجة سهلة ومألوفة للعلماء، فاستلفوا نفس الرموز اللي كلنا عارفينها من الجبر: الحرف (xx) وعلامة التساوي (==).

الحركة دي سهّلت الدنيا وقتها فعلاً، بس ورّطت أجيال من المبرمجين في سوء تفاهم كبير:

في الرياضيات:   x = 5       ──► إعلان حقيقة أبدية (Equivalence)
                                x هي 5 دايماً، مفيش ساعة بتدق، ومفيش حاجة هتتغير كمان شوية.

في البرمجة:     let x = 5;  ──► أمر تشغيل فيزيائي مع الزمن (Assignment)
                                احجز مكان في الرام، وحطلي جواه الشحنات دي دلوقتي حالا!

الفرق هنا جوهري جداً بين فكرتين:

  1. في الرياضيات (xx): المتغير هو رمز تجريدي لحقيقة ثابتة. لما نقول في مسألة إن x=5x = 5، الـ xx هنا هي الـ 5 على طول، ومفيش حاجة في الرياضيات اسمها «كمان سطرين في المسألة هنعدل الـ xx ونخليها 6».
  2. في البرمجة (let x): المتغير مش رمز؛ ده اسم دلع (Label) لعنوان حقيقي في شريحة الرام. عامل بالظبط زي ما تلزق ستيكر باسمك على صندوق أمانات في بنك أو خزانة في الجيم.
  3. علامة = في الكود: دي مش ميزان تكافؤ خالص؛ دي أمر نقل وكتابة بيانات (Assignment Operator). معناها الحرفي للمعالج: «هات القيمة اللي على اليمين دي، وروح اكتبها بقوة جوا العنوان اللي على الشمال وامسح أي حاجة كانت موجودة قبله».

إيه اللي بيحصل جوا المعالج (CPU) لما ينفّذ x = x + 1؟#

المعالج ميعرفش جبر ولا معادلات؛ هو آلة صماء بتنفذ 3 خطوات عتادية ورا بعض:

[1] LOAD  R1, [0x7FFD]  ──► روح لعنوان x في الرام، اقرأ القيمة (5)، وشيلها في مسجل داخلي (R1).
[2] ADD   R1, 1         ──► وحدة الحساب والمنطق (ALU) تزود 1 على الرقم اللي في المسجل، فيبقى 6.
[3] STORE [0x7FFD], R1  ──► ارجع لنفس العنوان في الرام، واكتب الـ 6 وامسح الـ 5 القديمة للأبد!

عشان كده زمان، لغات زي Pascal و Ada كانت صريحة ومحترمة جداً مع المبرمج؛ مكنتش بتسيبك تكتب =، بل كانت بتجبرك تكتب نقطتين ويساوي := عشان تفكرك دايماً إن ده أمر تحويل وكتابة، مش علاقة تكافؤ:

x := x + 1;  {اقرأ من الذاكرة، اجمع، واكتب فوق نفس العنوان}

تشبيه الكاش والمحفظة مقابل الحساب البنكي المشترك#

عشان تفهم الكود بتاعك بيتصرف إزاي في الذاكرة وماتقعش في مشاكل غريبة، محتاج ترسم في خيالك النموذج ده:

1. الأنواع البدائية (Primitives): كاش في محفظتك (Pass by Value)#

الأنواع البدائية زي الأرقام (number) والقيم المنطقية (boolean) حجمها صغير وثابت وبتعيش مباشرة في الـ Stack. ومعاهم النصوص (string) اللي بتتصرف دايماً كقيمة مستقلة وغير قابلة للتعديل (Immutable) حتى لو محرك التشغيل بيحط محتواها الفعلي في الـ Heap.

تخيل إن معاك ورقة بـ 100 جنيه في محفظتك. جه صاحبك طلب منك نفس المبلغ، فقمت مطلع مكنة تصوير، وطبعتله ورقة تانية بـ 100 جنيه مطابقة وحطيتها في محفظته:

  • لو صاحبك قرر يمسك ورقته ويقطعها أو يصرفها كلها، هل محفظتك أنت هيحصلها حاجة؟ مستحيل.
  • كل واحد فيكم معاه نسخته المستقلة في جيبه، واللي حصل وقت الإسناد هو نسخ كامل للقيمة (Copy by Value).
let a = 100;
let b = a; // اتنسخت القيمة 100 بالكامل في خانة جديدة ومستقلة تماماً

b = 50; // عدلنا b براحتنا

console.log(a); // 100 (الأصل في أمان تام وميعرفش أي حاجة عن b)

2. الكائنات والمصفوفات (Objects & Arrays): حساب بنكي مشترك#

الكائنات والمصفوفات بيانات مركبة حجمها مش ثابت وممكن يوصل لآلاف العناصر؛ عشان كده المحرك (زي V8) مبيحشرهاش في الـ Stack، بل بيخصص لها مساحة في الخزانة الكبيرة: The Heap.

طب والمتغير اللي كتبته في كودك؟
المتغير في الـ Stack مبيشلش الكائن أصلاً! هو بيشيل بس كارت عليه عنوان الشقة في الـ Heap (64-bit Memory Address)!

الموقف هنا بالظبط زي حساب بنكي مشترك معاه كارتين فيزا:

  • كارت في جيبك (user).
  • وكارت في جيب شريكك (partner).
  • الكارتين مبيشيلوش فلوس؛ الاتنين مربوطين بنفس الخزنة في البنك (الـ Heap).

لو شريكك نزل الشارع وسحب 500 جنيه بكارته:
أنت أول ما تفتح أبلكيشن البنك على موبايلك هتلاقي الرصيد نقص عندك أنت كمان، لأن الحساب في الرام واحد!

const user = { name: "أحمد", balance: 1000 };
const partner = user; // انتبه: أنت نسخت عنوان الكارت بس، منسختش الحساب!

partner.balance -= 500; // شريكك عدّل في نفس مكان الكائن بالذاكرة

console.log(user.balance); // 500! (رصيد أحمد طار لأن المتغيرين بيشاوروا على نفس العنوان)

العملية دي بنسميها في هندسة البرمجيات: التحوير في نفس المكان (In-place Mutation) — وهي الباب الملكي لأكتر أخطاء خبيثة بنشوفها في الشغل.

تصحيح مهم عن Pass by Reference

كتير بنسمع في الشغل والإنترفيوهات إن JavaScript شغالة بـ Pass-by-Reference مع الكائنات.
الحقيقة الدقيقة: JavaScript دايماً Pass-by-Value في كل الحالات وبلا استثناء.
الفرق الوحيد: «القيمة» اللي بتتنقل في حالة الكائنات هي قيمة العنوان الفيزيائي (Pointer Value)، مش الكائن نفسه.
عشان كده لو عملت جوه أي دالة: partner = {}، هتلاقي المتغير الأصلي برة الدالة سليم زي ما هو وماتأثرش، لأنك غيّرت اتجاه الكارت المحلي بتاعك لعنوان جديد، وملمستش الحساب المشترك.


تحت الغطاء: خريطة الـ Stack والـ Heap في الذاكرة#

تعال نبص بصه على شكل الـ RAM في اللحظة دي بصورة معمارية واضحة عشان تشوف اللي بيحصل بعينك:

توزيع الذاكرة بين الـ Stack والـ Heap ومؤشرات المراجع وعملية التحوير في نفس المكان

تأمل المسارات في الرسم التوضيحي:

  • في الـ Stack، المتغير user شايل العنوان 0x7FFE4A، والمتغير partner شايل نفس العنوان 0x7FFE4A.
  • السهمين طالعين من المتغيرين وبيصبوا في نفس الكائن المشترك المقيم جوه الـ Heap.
  • لما ننفّذ partner.balance -= 500، التعديل بيحصل مباشرة على بيانات الكائن في العنوان 0x7FFE4A؛ فلما user يقرأ من نفس العنوان طبيعي هيلاقي القيمة اتغيرت.
  • في المقابل، بص على المتغيرات البدائية a و b فوق على الشمال: كل واحدة فيهم حاجزة خانة مقفولة على نفسها في الـ Stack، وتعديل واحدة منهم ملوش أي علاقة بالتانية.
نموذج توضيحي مش خريطة V8 بالحرف

الرسمة دي نموذج ذهني عملي: هدفها تفهمك ليه تعديل كائن مشترك بيأثر على باقي الكود.
محركات حقيقية زي V8 بتعمل تفاصيل أعقد ورا الستار (زي إن الـ strings الكبيرة بتعيش في الـ Heap، وفيه تقنيات زي inline caching و pointer tagging). اللي يهمك كل يوم وأنت بتبني سيستم هو السلوك المنطقي: إمتى الداتا بتستقل، وإمتى بتتشارك.


اللغز الشائع: ليه {} مش بيساوي {} في JavaScript؟#

كتير من المطورين بيقفوا مستغربين قدام النتيجة دي:

console.log(10 === 10);             // true
console.log("hello" === "hello");   // true

console.log({} === {});             // false!
console.log([] === []);             // false!

السؤال البديهي اللي بيخطر على بال أي حد: «طب ما الكائنين فاضيين زي بعض بالمللي، إزاي مش متساويين؟!».

السر هنا في طبيعة السؤال اللي بيسأله عامل المقارنة ===:

  1. مع الأنواع البدائية (10 === 10): المعالج بيفحص محتوى القيمة نفسها (Value Equality)؛ هل 10 تطابق 10؟ أيوة، فيرجع true.
  2. مع الكائنات والمصفوفات ({} === {}): المعالج مبيدخلش يفتش جوه الكائن خالص، هو بيسأل سؤال واحد بس:

    «هل الطرفين دول ماسكين نفس عنوان الذاكرة بالمللي في الـ Heap؟ (Same Memory Reference)»

وكل مرة بتكتب فيها القوسين {} في كودك، أنت بتطلب صراحة من محرك التشغيل:
«احجزلي شقة جديدة في عمارة الـ Heap بعنوان مستقل!»:

const obj1 = {}; // اتحجزت شقة في العنوان: 0x1111
const obj2 = {}; // اتحجزت شقة تانية خالص في العنوان: 0x2222

console.log(obj1 === obj2); // false لأن العنوان 0x1111 مختلف تماماً عن 0x2222!

الشقتين فاضيين أه، بس دي في عمارة ودي في عمارة تانية خالص.
عشان كده لو كتبت:

const a = { name: "عمر" };
const b = a; // هنا اتنسخ عنوان الشقة بس

console.log(a === b); // true! لأن الاتنين بيشاوروا على نفس العنوان بالظبط

طبيعة الكلمة المحجوزة const#

من أكتر الحاجات اللي بتلخبط الناس في البداية، إنهم فاكرين كلمة const بتخلي الكائن صخرة مابتتحركش ومستحيل يتعدل:

const cart = ["قميص", "حذاء"];
cart.push("ساعة"); // الكود هيشتغل وهيضيف العنصر في هدوء تام!

console.log(cart); // ["قميص", "حذاء", "ساعة"]

إزاي المتصفح بيسمح بتعديل مصفوفة متعرفة بـ const؟ هي const دي بتعمل إيه بالظبط؟

السر بيرجع للنموذج اللي لسه شارحينه في الذاكرة:

  • كلمة const ملهاش أي سلطان على الـ Heap ولا على محتويات الكائن! هي بتحمي الخانة بتاعة المتغير في الـ Stack بس من إعادة الإسناد (Re-assignment).
  • يعني بتقول للمترجم: «ممنوع حد يغيّر العنوان المكتوب على الاستيكر ده ويوجهه لعنوان تاني». لكن محتويات الشقة اللي العنوان بيشاور عليها في الـ Heap؟ مسموح تعديلها وإضافة وحذف عناصر منها براحتك!
const cart = ["قميص", "حذاء"];

cart.push("ساعة");   // مسموح: البيانات جوه الـ Heap اتغيرت، لكن العنوان في الـ Stack ثابت
cart = ["جاكيت"];    // Error صريح (TypeError): أنت هنا بتحاول تغير العنوان المحمي بالـ Stack!

القاعدة اللي متنسهاش:
const بتحمي المؤشر من إعادة التوجيه (Re-assignment)، لكنها مبتمنعش التعديل الداخلي (Mutation).


كوارث الإنتاج الحقيقية: أخطار الـ Mutation غير المنضبط#

الـ Mutation العشوائي مش مجرد موضوع فلسفي في هندسة البرمجيات؛ ده بيعمل مصايب حقيقية في الـ Production صعب جداً تكتشفها (Bugs صامتة بتجنن فرق الصيانة):

1. كارثة الـ Backend: ثغرة الخصم المشترك#

في سيستم تجارة إلكترونية مبني بـ Node.js، مطور حب يسهّل على نفسه وينظم كوده، فجه فوق في أول ملف الموديول وعمل كائن إعدادات افتراضي:

interface Cart {
  userId: string;
  items: string[];
  discount: number;
}

// كائن افتراضي مقيم في ذاكرة السيرفر المشتركة:
const defaultCartConfig = {
  items: [],
  discount: 0,
};

function initUserCart(userId: string, couponCode?: string): Cart {
  // استخدام نفس المرجع المشترك لكل العملاء
  const cart: Cart = {
    userId,
    items: defaultCartConfig.items, // فخ: مرجع مشترك لنفس المصفوفة في الذاكرة!
    discount: defaultCartConfig.discount,
  };

  if (couponCode === "VIP50") {
    // تعديل الكائن الافتراضي العام مباشرة في الرام!
    defaultCartConfig.discount = 50;
    cart.discount = 50;
  }

  return cart;
}

الكود ده على جهازك شغال مية مية ومفيهوش أي غلطة.. المشكلة ظهرت أول ما السيستم طلع Production وجاله ضغط حقيقي:

  1. جه عميل مميز معاه كوبون “VIP50”، فنفّذ السطر: defaultCartConfig.discount = 50.
  2. في نفس اللحظة دي، دخل مئات المستخدمين العاديين من غير أي كوبونات يطلبوا أوردراتهم.
  3. لأن Node.js بيحمل الموديول مرة واحدة في الذاكرة (Module Singleton)، الكائن defaultCartConfig هو كائن واحد مشترك في رام السيرفر للناس كلها!
  4. النتيجة؟ كل المستخدمين اللي بعده خدوا خصم 50% مجاناً على حساب المتجر من غير ما يدخلوا أي كوبون!
  5. والأسوأ من كده: items كمان مصفوفة مشتركة، فلو عميل ضاف منتج في سلته، المنتجات بتظهر فجأة في سلال ناس تانية!

2. كارثة الـ Frontend: الشاشة المتجمدة في React (The Frozen UI Bug)#

أما بقى في الـ Frontend ومع React، فدي أشهر غلطة بنشوفها في الـ Code Reviews:

import { useState } from "react";

function ProfileOld() {
  const [user, setUser] = useState({ name: "أحمد", score: 10 });

  const handleLevelUp = () => {
    // الغلطة الشائعة: تعديل مباشر لنفس الكائن في الذاكرة
    user.score += 10;
    setUser(user);
  };

  return (
    <div>
      <p>النقاط: {user.score}</p>
      <button onClick={handleLevelUp}>زيادة النقاط</button>
    </div>
  );
}

المطور يدوس على الزرار.. ومفيش أي حاجة بتتغير على الشاشة!
يفتح الـ console يلاقي user.score بقت 20 فعلاً.. طب ليه الـ Component مبيعملش Re-render؟!

السبب في قلب محرك React وطريقة مقارنته للبيانات:

  1. عشان React تحقق أداء سريع جداً وماتضيعش وقت في فحص كل خصائص الكائن واحدة واحدة في كل نقرة زرار (O(N)O(N))، هي بتعمل فحص مرجعي فائق السرعة في سطر واحد:
    Object.is(prevUser, nextUser); // فحص تطابق العنوان الفيزيائي في الرام
    
  2. وبما إنك عدلت الخاصية جوه نفس الكائن في مكانه، فعنوان الكائن في الـ Heap ماتغيرش بربع ملي (0x7FFE4A === 0x7FFE4A).
  3. محرك React بيبص يلاقي نفس العنوان هو هو، فيفترض فوراً إن مفيش أي جديد حصل في الداتا، ويتجاهل إعادة رسم الشاشة تماماً! فتلاقي الـ UI متجمد قدامك.

الحل المعماري: مبدأ اللاتغير (Immutability)#

عشان نقفل باب المشاكل دي نهائياً، هندسة البرمجيات الحديثة بتعتمد على مبدأ بسيط وعبقري: مبدأ اللاتغير (Immutability):

«ماتعدّلش في الكائن القديم في مكانه أبداً؛ بل طلّع نسخة (Snapshot) جديدة كلياً بعنوان جديد في الذاكرة شايلة التعديل المطلوب.»

تعال نصلح كود React اللي فوق بالطريقة النظيفة:

import { useState } from "react";

function ProfileClean() {
  const [user, setUser] = useState({ name: "أحمد", score: 10 });

  const handleLevelUp = () => {
    // إنتاج كائن جديد كلياً بعنوان مستقل في الـ Heap
    setUser((prev) => ({
      ...prev,
      score: prev.score + 10,
    }));
  };

  return (
    <div>
      <p>النقاط: {user.score}</p>
      <button onClick={handleLevelUp}>زيادة النقاط</button>
    </div>
  );
}

شوف الجمال والراحة في اللي حصل هنا:

  • مشغّل الـ Spread ...prev بينشئ كائن جديد في عنوان مختلف بالكامل في الـ Heap (مثلاً 0x9999)، بينسخ فيه الخصائص القديمة ويحط القيمة الجديدة لـ score.
  • لما محرك React يقارن العناوين (Object.is(0x7FFE4A, 0x9999))، بيلاحظ فوراً إن العنوان اتغير في زمن O(1)O(1)!
  • الشاشة بتترسم من جديد في نفس اللحظة بكل سلاسة وأمان.
أهمية الـ Immutability في أداء أطر العمل الحديثة

الـ Immutability مش مجرد شياكة كود؛ ده سر الأداء الخارق لمكتبات زي React و Redux و Zustand.
بفضله، الأدوات دي بتقدر تكتشف أي تعديل في شجرة بيانات ضخمة فيها آلاف الحقول بمجرد سطر واحد لمقارنة عناوين الذاكرة في زمن O(1)O(1)، بدل ما تضطر تلف وتفحص كل حقل وتخنق جهاز اليوزر.


فخ النسخ السطحي (Shallow Copy vs Deep Copy)#

لكن هنا فيه مطب معماري مشهور بيقع فيه مطورين كتير:
الـ Spread Operator (...) بيعمل نسخ سطحي (Shallow Copy)؛ يعني بينسخ المستوى الأول بس من الكائن:

const order = {
  id: "ORD-101",
  customer: { name: "عمر", address: "القاهرة" },
};

// نسخ سطحي بالـ Spread Operator:
const updatedOrder = { ...order };

// تعديل خاصية من المستوى الأول: آمن ومستقل تماماً
updatedOrder.id = "ORD-102";
console.log(order.id); // "ORD-101" (الأصل سليم وملمسناهوش)

// تعديل كائن متداخل (Nested Object): هنا الفخ اشتغل!
updatedOrder.customer.address = "الإسكندرية";

console.log(order.customer.address); 
// النتيجة: "الإسكندرية"! لأن customer كان مجرد مؤشر مشترك لنفس الشقة في الرام!

فخ النسخ السطحي في الذاكرة وكيف يؤدي لتعديل الكائنات المتداخلة في الرام دون علمك

اللي حصل إن الـ Spread نسخ الحاوية الخارجية بس في عنوان جديد (0x2222)، لكنه مسك المؤشر الداخلي بتاع customer ونقله زي ما هو (0x5555)؛ فبقى الكائنين بيشاوروا على نفس كائن العميل في الـ Heap!

إزاي نهرب من فخ النسخ السطحي؟#

  1. في JavaScript الحديثة: استخدم الدالة القياسية المدمجة:
    const safeClone = structuredClone(order);
    
    الدالة دي بتلف على كل المستويات المتداخلة وتعمل نسخ كاملة ومستقلة لكل شقة في الرام.
    (ملحوظة عملية: structuredClone بترمي Exception لو الكائن جواه Functions أو DOM Nodes).
  2. في التطبيقات الكبيرة وإدارة الحالة: استخدم مكتبات بتعتمد على المشاركة الهيكلية (Structural Sharing) زي Immer: المكتبة دي بتستخدم الـ Proxy عشان تنسخ بس الفروع اللي أنت عدلتها، وتسيب باقي الفروع المشتركة في الذاكرة بأمان، فتوفر استهلاك الرام وتضمن أقصى حماية ممكنة.

المقارنة الشاملة: المفهوم الرياضي مقابل الواقع البرمجي#

عشان تثبت الصورة الكاملة في دماغك وماتنساهاش، جمعنالك الفروق الجوهرية بين عالم الرياضيات النظري وعالم فيزياء العتاد في المصفوفة دي:

المقارنة الشاملة بين المفهوم الرياضي المجرد والواقع الفيزيائي في الرام والعتاد

ملاحظة سريعة على صف === في الجدول:
في البرمجة المقارنة مش دايماً Pointer Equality.
للأنواع البدائية زي 10 === 10 دي مقارنة قيمة (Value Equality)، وللكائنات زي {} === {} دي مقارنة عنوان ومرجع فيزيائي (Reference Equality). الجدول بيلخص الفكرة للكائنات؛ والشرح اللي فوق هو المرجع الكامل.


الخلاصة الهندسية لليوم السادس#

  1. المتغير في الكود مش زي المتغير في الرياضيات: في الرياضيات رمز مجرد لحقيقة ثابتة؛ في البرمجة عنوان فيزيائي لخلايا شحن كهربائية في الرام بتتغير مع الوقت.
  2. الـ In-Place Mutation فخ صامت: تعديل الكائنات في مكانها بيبوّظ مراجع أجزاء تانية في السيستم بتشترك في نفس العنوان.
  3. const بتحمي المؤشر مش المحتوى: بتمنعك تعيد توجيه العنوان في الـ Stack، لكنها مبتمنعش تعديل البيانات جوه الـ Heap.
  4. الـ Immutability هي سر السرعة في أطر العمل: بتخلي React وأخواتها يكتشفوا التغيير في زمن O(1)O(1) بمجرد مقارنة سريعة لعناوين الذاكرة.
  5. خلي بالك من الـ Shallow Copy: الـ Spread Operator بينسخ القشرة الخارجية بس؛ وللكائنات المتداخلة استخدم structuredClone أو مكتبات الـ Structural Sharing.

في المقال القادم من المرحلة التانية:#

بعد ما فهمنا طبيعة المتغيرات وحجز الذاكرة، هنروح لسؤال هندسي تأسيسي عجيب جداً:
الكمبيوتر ده جهاز إلكتروني مبيدخلش جواه غير شحنات كهربائية (صفر أو واحد).. إزاي فيزيائياً بيعمل عمليات الطرح وبيمثّل الأرقام السالبة من غير ما يكون في الرام أي خانة اسمها «سالب» أصلاً؟

موعدنا في المقال القادم مع:
«الأرقام السالبة… ونظام المتمم الثنائي (Two’s Complement)»!

TERMINAL.COLOPHON // CORE v2.5
LAST.DISPATCH: 2026.11.12
guest@ag-coding:~ (interactive-zsh)
LIVE CLI
RUN //
01 // ISSUES ●
59
Published Articles
02 // CORPUS ≈ 7.6H
91.3K
Total Words Written
03 // SECTORS #
3/43
Categories & Tags
04 // UPTIME 99.9%
ONLINE
Static Edge Node
QUANTUM TELEPORTER // ROULETTE 1-CLICK JUMP
TARGET DESTINATION:
TELEPORT NOW ↗
© 2026 Abdoelaziz Gamal // ALL RIGHTS RESERVED.
30.0444° N, 31.2357° E ■ DESIGNED & ENGINEERED IN CAIRO
OPERATOR // RADAR.HUD
SCROLL.PROGRESS
00% LIVE
Abdoelaziz Gamal
LIVE
// CHIEF ARCHITECT
Abdoelaziz Gamal
REACT.JS NEXT.JS SYS.ARCH
root@ag-coding:~# cat dossier.log ● UTF-8

Full-stack engineer from Mansoura. 5+ years shipping TypeScript / Next.js products — dashboards, multi-tenant apps, CRM, LMS, e-commerce. Behind AG Coding.