لا تترجم أداة rust-anything الكود من بايثون إلى Rust تلقائياً. تسجّل الأداة سلوك التطبيق الأصلي، ثم يكتب المهندس أو وكيل البرمجة كود Rust قطعةً قطعةً. تتحقق كل قطعة من مطابقتها للتسجيل قبل الانتقال إلى التالية، وإذا لم تتطابق لا تُدمج. وما لم يُنقل بعد يعود تنفيذه إلى النسخة الأصلية.
لنفترض أن فريق تقنية في شركة توزيع متوسطة في الرياض يملك أداة داخلية بلغة Python، تحسب أسعار الشحن وتصدّر ملفاً يومياً إلى نظام المحاسبة (مثال توضيحي). يسأل المدير: هل نعيد كتابة الأداة كلها بلغة Rust دفعة واحدة؟ الجواب المختصر أن ذلك ممكن، لكن تنفيذه دفعة واحدة يخفي سبب أي فرق في النتائج.
يشرح هذا الدليل كيف تتم ترجمة تطبيق من بايثون إلى رست على مراحل، مع مقارنة السلوك في كل خطوة. سنتناول تسجيل ما يفعله التطبيق اليوم، وكتابة الوحدة الأولى، ومقارنة نتائجها بالتسجيل، ومن يقرر عند الاختلاف، ومتى لا يكون التحويل قراراً مناسباً.
هل يمكن تحويل تطبيق بايثون كله إلى Rust دفعة واحدة؟
الجواب المختصر: يمكن تحويل التطبيق إلى Rust، لكن تحويله كله دفعة واحدة يجعل معرفة سبب أي فرق أصعب كثيراً. فإذا اختلف الناتج بعد إعادة كتابة كل شيء، لن تعرف أي جزء أحدثه.
التحويل على مراحل يعالج هذه المشكلة، لأن كل جزء يُختبر على حدة قبل الانتقال إلى التالي. وما لم يُنقل بعد يبقى في النسخة الأصلية.
لماذا يصعب قياس تطابق مشروع كامل دفعة واحدة؟
التطابق يعني أن النسخة الجديدة تعطي النتيجة نفسها للمدخلات نفسها. في مشروع كامل تتعدد الحالات: ملفات ناقصة، وقيم فارغة، وأخطاء شبكة، وترتيب تنفيذ غير متوقع. وعند فشل المقارنة يصعب تحديد الجزء المسؤول عنه.
إذا كان الكود يكتب ملفات أو يتصل بقاعدة بيانات أو بالشبكة، فإن ناتج الدالة وحده لا يكفي. تذكر صفحة المستودع أن الخيار --effects في الأمر app record يسجّل أيضاً ما يرسله التطبيق، وتضرب مثلاً ببريد يُرسل مرتين بعد تحديث النسخة الجديدة.
الفرق قد يأتي من تفاصيل صغيرة، مثل:
- تقريب الأرقام العشرية
- ترتيب النتائج عند تكرار القيم
- نص رسالة الخطأ أو رمز الخروج
- ما يرسله التطبيق: يُسجَّل عند استخدام الخيار --effects
ما الذي يعنيه التحويل على مراحل عملياً؟
يعني اختيار وحدة صغيرة لها مدخلات ومخرجات واضحة، مثل دالة تحسب تكلفة الشحن أو محلل ملفات CSV، وكتابة نسخة Rust لها. قبل الانتقال إلى الوحدة التالية، تُقارن النسختان بالسجل المأخوذ من التطبيق الأصلي، ولا يُدمج أي جزء قبل أن يطابق سجله.
بهذا النهج يُفحص كل تغيير على حدة، ويستطيع الفريق أن يراجع بعد كل وحدة هل ما زالت الفائدة تستحق الكلفة، وهذا قرار يعود إليه لا إلى الأداة. أما تشغيل الخدمة الحية أثناء هذه المراحل، فلا تغطيه صفحة المستودع، ويحتاج الفريق إلى تخطيطه بشكل منفصل حسب طريقة النشر لديه.
مثال من خارج Python: تذكر صفحة المستودع أن Prettier، وهي أداة تنسيق للكود، نُقلت إلى Rust جزئياً. تعمل النسخة المنقولة بالكامل على 15,837 من أصل 17,224 تشغيلاً مسجلاً، ويطابق الناتج النسخة الأصلية بايتاً ببايت في كل الحالات المسجلة. لكن هذه النتائج تنطبق على ما سُجّل فقط، ولا تحكم على أي سلوك لم تغطه التسجيلات.
للفكرة نفسها من زاوية أوسع، راجع تحديث النظام القديم دون تعطيل ما يعمل جيداً. وقبل تشغيل أي تسجيل، اعزل المشروع: نسخة منه، وقاعدة بيانات تجريبية، ولا بيانات اعتماد إنتاجية.
ما الذي تفعله أداة rust-anything، وما الذي لا تفعله؟
تقدّم صفحة المستودع الأداة على أنها أداة إعادة كتابة التطبيقات بلغة Rust مع مقارنة سلوك النسخة الجديدة مع النسخة الأصلية. تسجّل الأداة ما يفعله التطبيق اليوم، ثم يكتب المساعد البرمجي أو المطور كود Rust قطعةً بعد قطعة، وتُقارن كل قطعة بالتسجيل قبل الانتقال إلى التي تليها.
لنفترض أداة داخلية بلغة Python يعتمد عليها فريق آخر في حساب قيم يومية. الأداة لا تترجم الكود تلقائياً. ما تفعله أنها تشغّل التطبيق الأصلي على حالات كثيرة، ثم تتحقق من أن النسخة الجديدة تعطي النتيجة نفسها في كل حالة مسجّلة.
النتيجة العملية للفريق: الأداة تجيب عن سؤال «هل تغيّر السلوك؟»، أما سؤال «هل يستحق النقل الجهد؟» فيبقى للفريق وهو يقيّم الأداة.
ما معنى تسجيل السلوك الأصلي؟
التسجيل خطوة تحفظ فيها الأداة سلوك التطبيق الأصلي. تُشغَّل الدالة أو التطبيق على مدخلات مولّدة تلقائياً وحالات حدّية ومدخلات تختارها أنت، ثم يُحفظ ما يعيده الكود أو الاستثناء الذي يرميه.
إذا كان التطبيق يكتب ملفات أو يتصل بقاعدة بيانات أو بالشبكة، فالقيمة المعادة وحدها لا تكفي. يذكر المستودع أن أمر app record مع الخيار --effects يسجّل كذلك ما يرسله التطبيق، ويضرب مثالاً ببريد يُرسل مرتين في نسخة جديدة. وتُشغَّل هذه الأوامر على نسخة تجريبية من المشروع.
- المدخلات: حالات مولّدة، وحالات حدّية، ومدخلات تختارها أنت.
- المخرجات: القيمة المعادة أو الاستثناء المرمي.
- ما يرسله التطبيق: يُسجَّل عند استخدام الخيار --effects، كما يوضح المستودع.
لماذا لا تُعد الأداة مترجماً للكود؟
يكتب كود Rust المساعد البرمجي، مثل Claude Code أو Codex، أو المطور نفسه. أما الأداة فتقدّم ما لا يستطيع المساعد تحديده بثقة، مثل أين يقع الوقت في التنفيذ، وأي وحدة تُحوَّل أولاً، والسلوك الدقيق الذي يجب أن تطابقه النسخة الجديدة، وبوابة تحدد متى تكون الوحدة منتهية.
لذلك تبقى حدود واضحة يجب أن يعرفها الفريق قبل البدء:
- الأداة تختبر ما سُجّل فقط. أي مسار لم يُسجَّل لا يُختبر.
- لا تُعد الوحدة منتهية قبل نجاح أمر gate، ولا يُدمج التطبيق بلغة Rust قبل اجتياز كل الحالات المسجّلة.
- يولّد الأمر bridge غلافاً يُبقي الواجهة الأصلية كما هي للمستدعين، فلا تتغير طريقة استخدام الكود.
دورة العمل الأساسية لكل وحدة
- تسجيل السلوكتشغيل الأصل على حالات كثيرة وحفظ ما يعيده أو يرميه
- كتابة الوحدةيكتب المساعد البرمجي أو المطور قطعة Rust واحدة
- المقارنةأمر diff يعيد تشغيل كل الحالات المسجّلة على النسخة الجديدة
- بوابة الاكتماللا تُعد الوحدة منتهية قبل نجاح أمر gate
كيف أتحقق أن النسخة المكتوبة بلغة Rust تعطي النتائج نفسها؟
التحقق يسبق الانتقال ولا يأتي بعده. تُسجَّل أولاً ما تفعله النسخة الأصلية بلغة Python، ثم تُكتب النسخة الجديدة وتُقارن بهذا التسجيل جزءاً بعد جزء. هذه هي مقارنة سلوك النسخة الجديدة مع النسخة الأصلية، وهي التي تجعل تحويل مشروع Python إلى Rust خطوة بخطوة قابلاً للمراجعة.
بحسب صفحة مستودع rust-anything، تسجّل الأداة ما تُعيده الدالة أو ما تطلقه من خطأ، ثم تعيد تشغيل كل حالة على النسخة الجديدة. الأداة لا تترجم الكود، فالنسخة بلغة Rust يكتبها وكيل برمجي أو المطوّر نفسه. ولفهم دور الوكيل البرمجي، راجع ما هو الوكيل الذكي المستقل؟.
ماذا يُقارن بالضبط في كل حالة؟
في الدالة المنفردة تُقارن القيمة المُعادة أو الخطأ الذي تطلقه. أما في التطبيق كاملاً فالقيمة المُعادة قد لا تكفي. إذا كان الكود يكتب ملفات أو يرسل بريداً أو يتصل بقاعدة بيانات، فالناتج وحده لا يكشف كل فرق.
يذكر المستودع أن الخيار app record --effects يسجّل أيضاً ما يرسله التطبيق، ومثاله رسالة بريد تُرسل مرتين بعد إعادة الكتابة. لذلك يحتاج الفريق إلى مقارنة الآثار الجانبية إلى جانب الناتج.
لنفترض فريقاً يحوّل أداة داخلية (مثال توضيحي) تولّد تقريراً يومياً وترسله إلى الإدارة. إذا أعادت النسخة الجديدة التقرير نفسه لكنها أرسلته مرتين، فمقارنة القيم المُعادة وحدها لن تكشف الخطأ.
متى يُعتبر الجزء المحوّل منتهياً؟
لا يُعد الجزء منتهياً لأن الكود يبدو صحيحاً، ولا لأن تجربة يدوية نجحت. ينتهي عندما تطابق النسخة الجديدة كل الحالات المسجّلة، وتنجح البوابة gate. ووفق المستودع، نجاح البوابة هو ما يعني أن الجزء منتهٍ.
الأداة لا تكشف إلا ما سُجّل. إذا لم تغطِّ التسجيلات حالة معينة، فلا يمكن ضمان تطابقها. لذلك يبقى اختيار الحالات جزءاً من عمل الفريق، ويشمل ذلك الحالات الحدّية والمدخلات التي يضيفها الفريق بنفسه.
خطوات التحقق من جزء واحد
سجّل السلوك الأصلي
شغّل rust-anything record على الجزء الأصلي بلغة Python. تُحفظ النتائج والأخطاء لكل حالة مولّدة، وكل حالة حدّية، وكل مدخل يضيفه الفريق. وإذا كان التطبيق يرسل رسائل أو يكتب ملفات، فأضف app record --effects.
ابنِ النسخة بلغة Rust
يُنشئ أمر bridge الغلاف الذي يحافظ على واجهة الاستدعاء الأصلية، فيبقى الكود الذي يستدعي الجزء دون تغيير. في Python تُبنى الوحدة عبر PyO3. ثم شغّل rust-anything build على المجلد. الكتابة نفسها يقوم بها المطوّر أو الوكيل البرمجي.
تقسيم المشروع إلى وحدات صغيرة يسهّل مراجعة كل وحدة على حدة. شغّل البوابة
شغّل rust-anything gate. عند نجاحها يُعد الجزء منتهياً. وإن فشلت، فالجزء لم ينتهِ بعد، ويبحث الفريق عن سبب الفرق قبل المتابعة.
ما اللغات التي يمكن نقلها تدريجياً، وما الفرق بين نقل CLI وخادم HTTP ومكتبة؟
تغطي الأداة TypeScript وJavaScript وPython وC وGo وRuby وJava. وبما أن موضوعنا نقل مشروع من Python إلى Rust، فسنركّز على Python ونذكر اللغات الأخرى بقدر ما يوضح الفكرة. اللغة وحدها لا تحدد صعوبة النقل، بل يحدده نوع المدخل: أداة سطر أوامر، أم خادم HTTP، أم مكتبة يستدعيها كود آخر. أما C وGo فلهما طرق ربط مختلفة، ومن يرحّل الكود من C أو Go إلى Rust يحتاج إلى مراجعة وثائقهما الخاصة.
الفرق بين نقل أداة سطر الأوامر ونقل خادم HTTP
أداة سطر الأوامر تستقبل مدخلات محددة وتنتج مخرجات، فيمكن تسجيل تشغيلها كاملة ثم إعادته على النسخة الجديدة. تسمي الأداة ذلك على مستوى التطبيق: app record للتسجيل وapp replay لإعادة التشغيل.
أما خادم HTTP فيُعامَل كل طلب مسجّل كحالة تُقارَن بالنسخة الجديدة. في مثال json-server، طابقت النسخة الخالصة بلغة Rust 514 من 514 حالة HTTP مسجّلة، وفق ما يذكره المستودع. ومع ذلك، تذكر الوثائق أن الأداة لا تكتشف إلا ما يغطيه التسجيل، لذلك يجب مراجعة ما لم تشمله الحالات المسجّلة.
ماذا يتغير عند نقل مكتبة؟
المكتبة لا تُشغَّل وحدها، بل يستدعيها كود آخر، لذلك يكون الهدف الأول ألا يلاحظ المستدعي أي تغيير. يولّد الجسر حزمة Rust وغلافاً يحافظ على واجهة الأصل، ثم يكتب المطوّر أو وكيل البرمجة كود Rust الداخلي.
مثال توضيحي: فريق في الدمام لديه مكتبة Python لحساب خصومات الموردين، وتستدعيها ثلاث أدوات داخلية لا يريد تعديلها. يُنقل الجزء الساخن فقط، وتبقى أسماء الدوال وتوقيعاتها كما هي، وتُقارن كل دالة بتسجيلها قبل الانتقال إلى الخطوة التالية. بهذه الطريقة لا تحتاج الأدوات الثلاث إلى تعديل.
وتذكر الوثائق أن استدعاء Rust عدة مرات لدالة صغيرة يكون عادة أبطأ، لذلك توفر اللغات كلها ما عدا C صيغة الدفعات (--batch)، حيث تنتقل العناصر مرة واحدة وتبقى داخل Rust.
الاستدعاء قبل النقل وبعده
قبل النقل
- الكود المستدعي يستورد المكتبة بأسمائها الأصلية
- الدوال تُنفَّذ داخل Python
- التسجيل يُؤخذ من المكتبة الأصلية
بعد النقل عبر الجسر
- الأسماء والتوقيعات تبقى كما هي
- الدوال المنقولة تُنفَّذ في Rust عبر الجسر
- كل دالة منقولة تُقارن بتسجيلها قبل الانتقال
ما الوحدة التي يجب تحويلها أولاً في المشروع؟
لا يبدأ نقل مشروع من Python إلى Rust بأكبر ملف فيه، ولا بأصعب جزء. الأفضل أن تختار وحدة صغيرة لها مدخلات ومخرجات واضحة، ويمكن تسجيل سلوكها بدرجة كافية. نجاح هذه الخطوة الأولى يمنح الفريق خبرة عملية في طريقة العمل قبل الانتقال إلى أجزاء أكبر.
مثال عام: دالة تحسب سعر الشحن من الوزن والوجهة وفئة العميل مرشح جيد، لأن مدخلاتها واضحة ومخرجها رقم محدد. أما تصدير ملف يومي إلى نظام محاسبي فيعتمد على الوقت وصيغة الملف وأنظمة خارجية، ويحتاج تسجيلاً أوسع، لذلك يأتي لاحقاً.
تبدأ الخطوة بسؤال: أين يقضي البرنامج وقته؟ يعرض أمر profile ما هو ساخن ومن يستدعيه، وتساعد هذه المعلومة في ترتيب الأولويات. لكن القرار النهائي يبقى للفريق بعد مراجعة النتائج.
معايير اختيار الوحدة الأولى
قبل أن تختار الوحدة، راجع القائمة التالية. إذا تحقق معظم بنودها، فالوحدة مناسبة للبدء. وإذا لم تتحقق بنود التسجيل، فالأفضل تأجيل النقل حتى يكتمل التسجيل.
متى تكون الدالة الساخنة هي الأولى؟
الدالة الساخنة هي التي تُستدعى كثيراً أو تستغرق جزءاً كبيراً من الزمن. إذا أظهر التحليل أن دالة واحدة تتصدر الزمن، وكانت مدخلاتها ومخرجاتها قابلة للتسجيل، فهي مرشح قوي للبدء.
لكن كونها ساخنة لا يعني أنها الأسهل. تذكر صفحة المشروع أن نداء Rust لكل دالة صغيرة يكون عادة أبطأ من محرك JIT، لذلك تبحث الأداة عن الحلقة التي تستحق النقل، وتبقى المفاضلة النهائية للفريق. وينطبق الأمر نفسه عند تحويل مشروع Node.js إلى Rust خطوة بخطوة، لأن الأداة تغطي TypeScript وJavaScript.
وإذا كانت الدالة تعتمد على قاعدة بيانات أو ملفات أو شبكة، فيلزم تسجيلها في بيئة منفصلة. تنص الصفحة على أن أوامر التسجيل والتشغيل تنفّذ الكود الأصلي على حالات كثيرة، لذلك تُشغَّل على نسخة من المشروع، مع قاعدة بيانات تجريبية وبلا بيانات اعتماد إنتاجية.
قائمة تحقق لاختيار الوحدة الأولى
كيف يعمل النظامان معاً أثناء الانتقال؟ ومن يقرر عند الاختلاف؟
خلال الانتقال يبقى الكود الأصلي بلغة Python هو المرجع. تسجّل الأداة ما يعيده الأصل على حالات مولّدة ومدخلات يحددها الفريق، ثم تعيد الحالات نفسها على الجزء المكتوب بلغة Rust. لا يُستبدل جزء قبل أن تطابق كل حالاته المسجّلة، وهكذا تصبح إعادة كتابة التطبيق بلغة Rust تدريجياً ممكنة.
الأجزاء التي لم تُحوَّل بعد تبقى على الأصل. ويمثّل Prettier في المستودع هذا المبدأ، إذ يعود إلى الأصل ما لم يُنقل بعد. والمنهج نفسه يصلح لتحويل مشروع Node.js إلى Rust خطوة بخطوة. أما نشر الخدمة الحية في فترة النقل فلا يغطيه المستودع، ويضعه الفريق في خطته.
لا يُعد التطبيق خالصاً بلغة Rust إلا إذا مرت إعادة التشغيل (app replay) دون رجوع إلى الأصل، ونجحت كل وحدة في الفحص gate. عندها فقط ينفّذ الفريق app lift، ولا يُعدَّل الكود الأصلي.
التطابق في المخرجات وحده لا يكفي، لذلك يسجّل الخيار --effects ما يرسله التطبيق أيضاً. ففي التطبيق الذي يرسل بريداً، تفشل إعادة الكتابة التي ترسله مرتين.
ما المخاطر على الأداء والصيانة خلال فترة التشغيل معاً؟
الخطر الأول على الأداء هو كلفة العبور بين اللغتين. تنبّه الأداة إلى أن استدعاء Rust لكل دالة صغيرة يكون عادة أبطأ من JIT، لذلك يبحث الفريق عن الحلقة التي تستحق النقل. ويمكن في Python استخدام الدفعات (--batch)، فتعبر العناصر مرة واحدة وتبقى داخل Rust. القرار النهائي فيما يُنقل يبقى للفريق.
الخطر الثاني على الصيانة. خلال فترة التشغيل المشترك يعمل الفريق على نسختين، فمن المفيد أن يتفق مسبقاً على طريقة التعامل مع أي تغيير مقصود في السلوك الأصلي (تقدير عملي من فريق التحرير، لا من المستودع). كما أن الفحص لا يغطي إلا ما سُجّل فعلاً، فالسلوك الذي لم يدخل في التسجيل لا يُحمى.
كيف يُدار الاختلاف بين النسختين؟
عند ظهور اختلاف، لا يُدمج الجزء. يقارن الفريق ما أعاده الأصل بما أعادته نسخة Rust، ثم يحدد السبب.
القرار يحتاج إلى صاحب واضح قبل بدء التنفيذ، لا بعد أول اختلاف. نقترح أن تُكتب في خطة الانتقال جهة القرار لكل نوع اختلاف. فالأداة تُظهر الفرق، أما الحكم عليه فيبقى للإنسان.
- خطأ في الوحدة المحوّلة: يصلحه مطوّر الوحدة ويراجعه زميل من الفريق.
- تسجيل قديم: يقرره مالك النظام، لأنه صاحب السلوك المقصود.
- سلوك غير مسجّل: يضيف المسؤول التقني الحالة إلى التسجيل.
- خلل في الأصل: قرار مشترك بين الإدارة التقنية ومالك النظام.
خطوات التعامل مع اختلاف في النتيجة
تحديد السبب
يحدد الفريق هل الخلل في الوحدة المحوّلة أم في التسجيل أم في الأصل نفسه.
إعادة الفحص
بعد الإصلاح تُعاد الحالات كلها، ولا يُعتمد الإصلاح قبل نجاح الفحص.
متى لا يكون تحويل المشروع إلى Rust قراراً مناسباً؟
لا تصلح كل مشاريع ترحيل الكود من C أو Go إلى Rust بالطريقة نفسها، ولا يحتاج كل مشروع إلى هذا النوع من الفحص. الأداة تثبت أن النسخة الجديدة تطابق ما سُجّل من سلوك النسخة الأصلية، ولا تثبت أكثر من ذلك. وينطبق الحد نفسه على مشروع Python الذي نتناوله هنا.
كتابة Rust نفسها تحتاج جهداً بشرياً حقيقياً، لأن الأداة لا تترجم الكود، بل تتحقق من النسخة التي يكتبها المهندس أو وكيل البرمجة. قدّر هذا الجهد قبل الالتزام بالمشروع، وحدّد من سيكتب الكود ومن سيراجعه.
ما الذي لا يلتقطه الفحص؟
الفحص لا يرى إلا الحالات التي سُجّلت. إذا لم يغطِّ التسجيل مدخلاً نادراً، مثل ملف شحن فيه رمز منطقة غير معتاد، فلن تكشف المقارنة الفرق فيه. هذا مثال توضيحي لفريق افتراضي يحسب رسوم الشحن بلغة Python.
وتوضح الأداة هذا الحد بنفسها، إذ تقول إنها لا تلتقط إلا ما يغطيه التسجيل. لذلك فإن جودة الحالات المسجلة لا تقل أهمية عن عددها.
- سلوك لم تُدخل له حالة في التسجيل.
- أخطاء لا تظهر إلا مع بيانات حقيقية لم تشملها الحالات المولّدة.
- اختلافات تعتمد على خدمات خارجية لم تُسجَّل بوضوح.
ما الآثار الجانبية التي تحتاج إلى حماية خاصة أثناء التسجيل؟
الكود الذي يرسل رسالة أو يكتب ملفاً يفعل ذلك مع كل تشغيل. وتذكر الأداة أن app record يشغّل كل حالة مرتين، ثم تعيد diff وgate وapp replay تشغيل الحالات نفسها على النسخة الجديدة أو الأصلية. فالأثر الجانبي قد يتكرر أكثر مما يتوقعه الفريق.
لهذا تتيح الأداة الخيار --effects في app record لتسجيل ما يرسله التطبيق مع نتائجه. فالنتائج وحدها لا تكفي، لأن رسالة مرسلة مرتين قد لا تظهر في الناتج المعاد. اقرأ الكود قبل التسجيل، وحدد ما يرسله أو يكتبه، ثم قرر كيف تعزله.
هل يلزم أن يكون فريقنا خبيراً في Rust قبل أن يبدأ التحويل؟
الجواب المختصر أن الفريق لا يحتاج إلى خبراء Rust في كل مستوى، لكنه يحتاج إلى أشخاص يكتبون الكود ويفهمونه، وإلى من يراجع النتائج ويقرر متى يُقبل الجزء المنقول.
تُقدَّر الجدوى والتكلفة البشرية والمخاطر قبل أي تنفيذ، لأن الأداة لا تكشف إلا ما يغطيه التسجيل. كلما ضاقت التغطية، زادت الحاجة إلى مراجعة بشرية.
من يكتب كود Rust فعلياً؟
أداة rust-anything لا تترجم الكود. بحسب توثيقها في المستودع، يكتب الكود بلغة Rust وكيل البرمجة الذي تستخدمه، أو المطوّر نفسه. دور الأداة أن تحدد ما يجب مطابقته، وأين يذهب الوقت، وأي وحدة تُنقل أولاً، ثم تقارن النسخة الجديدة بالتسجيل.
في مثال توضيحي لشركة توزيع، قد يكتب مطوّر Python الذي يعرف منطق الشحن الجزء المنقول بمساعدة وكيل برمجة، ثم يراجعه زميل لديه خبرة في Rust. بهذا الشكل يعمل الفريق بمهاراته الحالية، ويضيف مهارة Rust عند نقاط المراجعة. ويحتاج الأمر إلى ثلاثة أدوار على الأقل:
- مطوّر يعرف الوحدة ومدخلاتها ومخرجاتها.
- مراجع له خبرة في Rust يتحقق من الأنواع ومعالجة الأخطاء.
- مسؤول تقني يحدد ما الذي يُعتبر تطابقاً مقبولاً في المقارنة.
ما الذي يحتاجه الفريق قبل البدء؟
قبل كتابة أول سطر بلغة Rust، يحتاج الفريق إلى مهارات تشغيل واختبار. عليه أن يعرف كيف يشغّل التطبيق الأصلي بمدخلات حقيقية، وأن يفهم شكل مخرجاته، وأن يجهّز بيئة منفصلة لا تحتوي على بيانات إنتاجية.
توصي الأداة بتشغيل أوامر التسجيل والمقارنة على نسخة من المشروع، مع قاعدة بيانات تجريبية وبدون بيانات اعتماد إنتاجية في متغيرات البيئة. لذلك يحتاج الفريق إلى شخص مسؤول عن هذه البيئة، وإلى من يتأكد أن الاتصالات بالشبكة والملفات لا تؤثر على الأنظمة الحية.
أما أدوات البناء، فتحتاج أجهزة المطوّرين إلى بيئة Rust مثبتة. وإذا لم تكن لدى الفريق خبرة سابقة، يمكنه البدء بكتاب The Rust Programming Language الرسمي، المتاح عبر الإنترنت ومع تثبيت Rust عبر rustup. ومن الأفضل أن يبدأ الفريق بوحدة صغيرة مع مراجع يتابع الكود، بدلاً من تحويل المشروع كله دفعة واحدة، فذلك أقل كلفة وأوضح في المخاطر.
أسئلة شائعة
هل تترجم أداة rust-anything الكود من بايثون إلى Rust تلقائياً؟
لا. تقول الأداة إنها لا تترجم الكود، بل تثبت أن النسخة الجديدة تطابق السلوك المسجّل. كود Rust يكتبه المهندس أو وكيل برمجة، ثم تتولى الأداة التسجيل والمقارنة والتحقق من كل وحدة. لذلك يبقى الجهد البشري في الكتابة والمراجعة حقيقياً، ويجب تقديره قبل بدء المشروع.
هل يلزم أن يكون الفريق خبيراً في Rust قبل بدء التحويل؟
لا يلزم وجود خبراء Rust في كل مستوى، لكن يحتاج الفريق إلى أشخاص يكتبون الكود ويفهمونه، وإلى من يراجع النتائج ويقرر متى يُقبل الجزء المنقول. تُقدَّر الجدوى والتكلفة البشرية والمخاطر قبل أي تنفيذ، لأن الأداة لا تكشف إلا ما يغطيه التسجيل. وكلما ضاقت التغطية، زادت الحاجة إلى مراجعة بشرية.
هل يمكن نقل مشروع بايثون إلى Rust على مراحل؟
نعم، فهذا هو النمط الذي تصفه الأداة: قطعة بعد قطعة. يبقى التطبيق الأصلي هو المرجع، والأجزاء التي لم تُنقل بعد تبقى على الأصل، ولا يُدمج جزء لم يطابق تسجيله. أما طريقة نشر الخدمة الحية أثناء النقل فلا يتناولها المستودع، لذلك يخطط لها الفريق بشكل منفصل. ويبقى القرار النهائي عند الفريق بعد مراجعة النتائج.
ماذا يحدث عندما يكتب التطبيق ملفات أو يتصل بالشبكة أثناء التسجيل؟
تحذّر الأداة من أن التسجيل يشغّل الكود الأصلي على حالات كثيرة، وأن الكود الذي يكتب ملفات أو يتصل بقاعدة بيانات أو بالشبكة ينفّذ ذلك في كل تشغيل. لذلك يُنصح بتشغيل الفحوص على نسخة من المشروع، مع قاعدة بيانات تجريبية ودون بيانات اعتماد إنتاجية. ويمكن تسجيل ما يرسله التطبيق أيضاً، لأن تطابق المخرجات وحده لا يكفي.
متى يكون تحويل المشروع إلى Rust قراراً غير مناسب؟
لا يناسب كل مشروع هذا التحويل، ولا يحتاج كل مشروع إلى هذا النوع من الفحص. إذا كان التسجيل لا يغطي الحالات التي تهم العمل، فالأداة لا تثبت أكثر مما سُجّل. وإذا كان الجهد البشري في كتابة Rust أكبر من الفائدة المتوقعة، فالأفضل تأجيل القرار. ويجب تقدير ذلك قبل الالتزام بالمشروع.
خطوة عملية
خطوتك العملية التالية
ابدأ بوحدة صغيرة في مشروعك، لها مدخلات ومخرجات واضحة، وسجّل سلوكها الحالي قبل كتابة أي سطر بلغة Rust. ثم راجع هل يغطي التسجيل الحالات التي تهم العمل فعلاً، لأن الأداة لا تكشف إلا ما سُجّل. وقبل الالتزام بالمشروع كله، قدّر مع فريقك جهد كتابة Rust ومراجعته على هذه الوحدة الأولى. تواصل معنا إذا أردت مساعدة في تبنّي هذه الأداة.
إذا كان هذا التحدي قريباً من واقع عملك، اكتب لنا ما تحتاجه.
تحدث مع الريتاج





