تقدير المشروع
← كل المقالات

المبادئ الأساسية لبناء التطبيقات بلغة Scala

بضعة مبادئ تستحق أن تبقى حاضرة في ذهنك عند كتابة الشيفرة بلغة Scala والبرمجة الوظيفية.

8 دقائق قراءة
ScalaJavaالبرمجة الوظيفيةالتزامنMacrosعدم القابلية للتغيير

مرّت قرابة 20 عامًا على ظهور Scala، وهي لغة برمجة وظيفية ذات كتابة ساكنة (static typing). وخلال تلك الفترة تشكلت عدة طرق شائعة لكتابة شيفرة Scala. ومنها العمل مع أنظمة التأثيرات (effect systems)، وتقنيات متنوعة لتشغيل الشيفرة بشكل غير متزامن، والاعتماد على مجموعة من المكتبات وأطر العمل.

ورغم أن هذه المقاربات تختلف كثيرًا، فإنها تتشارك مجموعة من المبادئ. وبعبارة أخرى، أيًّا كانت الحزمة التقنية التي تفضلها عند بناء التطبيقات بلغة Scala، فهناك أمور تفعلها دائمًا، وأمور لا تفعلها أبدًا.

وتنبع هذه المبادئ من ثلاث ركائز: اللغة نفسها، والمكتبة القياسية، والمجتمع. لنتفحص بعض هذه الممارسات عن كثب، مع مقارنة مقاربة Scala أحيانًا بالطريقة التي تُبنى بها التطبيقات في منظومة Java.

بنى البيانات غير القابلة للتغيير

من أبسط خصائص شيفرة Scala وأبعدها أثرًا أن بنى البيانات فيها غير قابلة للتغيير افتراضيًا. وتجلب هذه المقاربة عدة مزايا (إلى جانب بعض العيوب):

  • لا يستطيع أي طرف “آخر” تغيير البيانات “في مكان آخر”
  • بما أن الحالة خارج الدالة لا يمكن أن تتغير، تصبح الشيفرة أسهل في المتابعة؛ ويُعرف هذا أيضًا بـ الاستدلال المحلي (local reasoning)
  • تُحمى البيانات من التلف، لأن التعديل المتزامن مستحيل
  • أمان أفضل للخيوط (thread-safety) وبرمجة متزامنة أبسط عمومًا

تفضل منصات برمجية أخرى أيضًا بنى البيانات غير القابلة للتغيير في البرمجة المتزامنة. وكون Scala تجعلها الخيار الافتراضي قد يكون أحد أسباب تحول البرمجة المتزامنة إلى أحد مجالاتها المتخصصة.

تدعم Scala بنى البيانات غير القابلة للتغيير على مستويات عديدة. فأولًا، توفر اللغة نفسها تراكيب مثل case classes، وحقول الفئات التي تكون vals (وليس vars) افتراضيًا، وenums (في Scala 3)، و ADTs (عائلات مغلقة من الفئات). ومن الأهمية نفسها سهولة إنشاء نسخ معدّلة من بنى البيانات بفضل دوال copy التي تُولَّد تلقائيًا.

وربما الأهم من ذلك أن المكتبة القياسية مصممة حول بنى البيانات غير القابلة للتغيير – فكلما لجأت إلى Set أو List أو Map حصلت افتراضيًا على النسخة غير القابلة للتغيير.

وأخيرًا، تقبل غالبية مكتبات Scala بنى بيانات غير قابلة للتغيير وتعيدها. إنها ببساطة الطريقة المعتمدة للتعامل مع البيانات في Scala. وبطبيعة الحال، تظل بنى البيانات القابلة للتغيير متاحة عند الحاجة. لكن ذلك استثناء أكثر منه قاعدة.

لا شيء يمنعك من استخدام بنى البيانات غير القابلة للتغيير على منصات أخرى، مثل node.js أو Java أو .NET. لكن اللغة في تلك الحالات تقدم دعمًا محدودًا فقط. والأهم أن المكتبات القياسية ومكتبات المجتمع الشائعة مبنية على بنى بيانات قابلة للتغيير. وحتى حيث يمكن تحقيق عدم القابلية للتغيير، قد يتضح أنه غير عملي إطلاقًا.

فمثلًا، تعتمد جميع مكتبات Java تقريبًا على واجهات المجموعات القابلة للتغيير من المكتبة القياسية. وأيًّا كانت مكتبة Java التي تستخدمها، فمن شبه المؤكد أنها ستعمل مع المجموعات القياسية القابلة للتغيير. ومن المستحيل عمليًا تغيير ذلك: ستبقى Java لغة تضع قابلية التغيير أولًا.

التعبيرات والقيم

من ميزات Scala التي قد لا تلفت انتباهك في البداية، لكنها سرعان ما تصبح شيئًا لا تستطيع العيش من دونه، أن كل شيء في Scala تعبير (expression). وبعد الاعتياد على ذلك، تبدو البرمجة بلغة تفصل بين العبارات والتعبيرات متثاقلة ومقيِّدة بلا داعٍ.

ويُظهر هذا مدى مرونة صياغة Scala وتنوعها. وبالنظر إلى الركائز الثلاث التي وصفناها في البداية، فإن كون اللغة موجّهة بالتعبيرات سمة تعود إلى اللغة وحدها.

ومن الممارسات المتصلة بذلك في Scala نمذجة مفاهيم متنوعة على أنها قيم. لنأخذ الدوال أولًا: تعريف دالة-قيمة يتطلب صياغة خفيفة جدًا. في Scala يأتي ذلك بشكل طبيعي. وتعزز المكتبة القياسية ذلك بالاعتماد على الدوال عالية المستوى (higher-order functions) (أي الدوال التي تقبل دوالَّ أخرى معاملات أو تعيد دوالَّ). وكذلك المنظومة بأكملها، التي تتبع النهج نفسه.

لكن الأمر يتجاوز الدوال. فإحدى المزايا الكبرى لـ Scala هي مرونة تعريف التجريدات. وهذا يعني عمليًا في كثير من الأحيان القدرة على نمذجة مفاهيم متنوعة كقيم. وربما على غير المتوقع، فإن إدخال هذه الطبقة الإضافية من الالتفاف يفتح إمكانيات جديدة مثيرة.

ومن الأمثلة البارزة أنظمة التأثيرات الوظيفية مثل ZIO أو cats-effect. ففيها تُنمذج الحسابات بأكملها كقيمة. وهذا يمنحنا تقييمًا كسولًا ومضبوطًا للشيفرة ذات التأثيرات. وبالاقتران مع وقت تشغيل مخصص، يجعل ذلك التزامن التصريحي ممكنًا، إلى جانب خيوط خفيفة تدعم المقاطعات المنضبطة، أو إعادة هيكلة الشيفرة من دون خوف.

ومثال آخر يأتي من مكتبات HTTP، حيث تبدأ غالبًا بإنشاء قيمة تصف نقطة نهاية أو طلب HTTP. وبطبيعة الحال، هذه القيمة غير قابلة للتغيير، مما يتيح صقلها خطوة بخطوة وفصل الاهتمامات: طبقة الشبكة عن طبقة المجال.

Macros بدلًا من الانعكاس (reflection)

يتبع المبدأ الثالث مباشرة تشديد Scala على الصحة من خلال الأنواع المفحوصة ساكنًا. ومرة أخرى سنقارن أساسًا “مقاربة Scala” بما توفره Java.

تمنحك Scala مرونة كبيرة في تعريف التجريدات، لكن ذلك لا يوصلك إلا إلى حد معين. فعاجلًا أم آجلًا، سيتعين عليك إما كتابة كتل كبيرة من الشيفرة المتكررة (boilerplate) أو إيجاد طريقة لتوليد الشيفرة لك. ومن الحالات النموذجية توليد مشفّرات/مفكّكات JSON، وربط شبكة الكائنات بحقن الاعتمادية، أو ربط الفئات بجداول قواعد البيانات.

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

في Java يتم ذلك عادةً بالتعليقات التوضيحية (annotations)، التي يقرؤها إطار عمل مثل Spring عبر الانعكاس وقت التشغيل. ثم يعمل إطار العمل كـ مفسّر (interpreter)، فينتج bytecode أو ينشئ نسخًا من فئات محددة مسبقًا. لطالما رأيت أن Java تفرط في استخدام التعليقات التوضيحية وأنها تشكل فعليًا لغة برمجة موازية ومحدودة وغير آمنة بمفسّرات غير محددة المواصفات وعشوائية.

فما البديل؟ إجابة Scala هي توليد الشيفرة وقت الترجمة. وأكثر أشكالها انتشارًا، وهو الاشتقاق الموجّه بالنوع للحدود (type-directed term derivation)، يُعرف بـ implicits (في Scala 2) أو givens (في Scala 3). وكما تستطيع بيئة التطوير (IDE) في كثير من الأحيان استنتاج أنواع جزء من الشيفرة، يستطيع مترجم Scala استنتاج الشيفرة من نوع. وقد حسّنت Scala 3 “تجربة المطور” لهذه الميزة.

لكن Scala تذهب أبعد من ذلك – إذ تحل inlines و macros مباشرةً محل توليد الشيفرة القائم على التعليقات التوضيحية. فهي تتيح توليد شيفرة Scala وقت الترجمة بطريقة آمنة من حيث الأنواع، مستخدمةً لغة Scala بأكملها لوصف العملية، ومنسجمة بسلاسة مع بقية ميزات Scala.

وما زال بإمكان التعليقات التوضيحية توجيه macro وتوفير بيانات وصفية إضافية – لكن ذلك احتمال واحد فقط؛ وفحص الأنواع والحدود الممررة إلى macro احتمال آخر. وتوفر Scala أمثلة كثيرة لاستخدام macros، مثل مكتبة jsoniter-scala أو macwire لحقن الاعتمادية وقت الترجمة.

كثيرًا ما توصف macros بأنها صعبة الفهم. ورغم أن كتابة macro قد تكون بالفعل أبعد ما تكون عن البساطة، فإن الأمر نفسه صحيح – وأزعم أنه أصح بكثير – على كتابة معالجات التعليقات التوضيحية أو مولّدات bytecode.

أما استخدام macros فمسألة مختلفة تمامًا؛ فهو لا يختلف عادةً عن استدعاء دالة. وكون رسائل الخطأ ليست مثالية دائمًا مشكلة، لكنها ترجع إلى نضج المنظومة، لا إلى عيب جوهري في المقاربة كلها.

ورغم أن توليد الشيفرة المدفوع بالتعليقات التوضيحية والقائم على الانعكاس ما زال مهيمنًا على منظومة Java، فهناك إشارات إلى أنها تتجه هي الأخرى نحو التوليد وقت الترجمة. ومن الأمثلة النموذج الوصفي في Hibernate (الذي يعتمد على معالجات التعليقات التوضيحية). ومع ذلك، تظل محدودية التعبير في التعليقات التوضيحية بوصفها لغة فرعية مشكلة. وإضافة التسلسل في Kotlin (https://github.com/Kotlin/kotlinx.serialization) مثال آخر.

صريح عند الضرورة، ضمني عند عدمها

المبدأ الأخير ليس نتيجة مباشرة لتصميم Scala أو مكتبتها القياسية، بل لـ“ثقافة” البرمجة الوظيفية ككل، ولمجتمع Scala على وجه الخصوص.

على كل منصة تقريبًا يوجد إغراء بإضافة نوع من “السحر”. والدافع جيد: نريد أن تكون الأمور آلية وتحدث من تلقاء نفسها. لكن المشكلة تبدأ عندما لا نستطيع، نحن مستخدمي هذا “السحر”، تحديد وفهم ما سيحدث، ومتى، ولأي سبب. وهذا يتعارض مع قابلية التنبؤ وقابلية الاستكشاف في قواعد شيفرتنا، وهما تؤديان دورًا كبيرًا في تقديم برمجيات قابلة للصيانة.

مثال نموذجي على هذا “السحر” هو مسح classpath و“الاكتشاف التلقائي”، الذي يفعّل مكونات معينة بشروط، لمجرد أنها موجودة على classpath. وفي شيفرة Scala يغيب هذا تقريبًا بالكامل.

هل تريد أن يغيّر نظام التشغيل لديك سلوكه لمجرد أنك نزّلت شيئًا من الإنترنت؟ ومع ذلك فإن سحر مسح classpath والتجهيز التلقائي (auto-instrumentation) يفعل ذلك تمامًا. تفضل Scala أن تُفعَّل الميزات بشكل صريح، ولو بكلفة ثلاثة أسطر إضافية من الشيفرة.

ومثال آخر أن تطبيقات Scala تعرّف دائمًا دوال main الخاصة بها بشكل صريح. ولسبب ما، تفتقر شيفرة Java كثيرًا إلى نقطة دخول واضحة كهذه، وتعتمد بدلًا من ذلك على رفيقينا القديمين الموثوقين: التعليقات التوضيحية والانعكاس. ربما تكون Java هي الشاذة هنا، أو ربما تُدخل Scala قدرًا من العقلانية على الأمور – لا أستطيع الجزم. المؤكد أنه لا داعي لتخشى الدالة main.

ما أصل هذا؟ عندما نكتب شيفرة Scala، أو نتبع الأسلوب “الوظيفي” عمومًا، نتعامل مع دوال يمكنها أخذ دوال أخرى معاملات وإعادة قيم نمررها بعد ذلك إلى دوال أخرى. وهذا، في نهاية المطاف، جوهر البرمجة الوظيفية: دوال تُعامل كقيم من الدرجة الأولى.

ونتيجة لذلك، يمكننا تتبع مسارات الشيفرة مباشرة – باستخدام ميزة “go-to definition” البسيطة والفعالة جدًا في بيئات التطوير لدينا.

الخلاصة

لا شيء من الخصائص أعلاه حكر على Scala وحدها. وما يجعل المزيج جيدًا إلى هذا الحد هو الطريقة التي تتكامل بها. فتصميم اللغة ليس كل شيء؛ والقيم الافتراضية مهمة أيضًا، كما تُظهر بنى البيانات والمجموعات غير القابلة للتغيير في المكتبة القياسية.

ونحو منتظم وصغير بشكل مدهش في لغة موجّهة بالتعبيرات يجلب إمكانيات جديدة – مثل التمثيل الموجز للمفاهيم كقيم.

وتوسيع الترجمة بتوليد شيفرة آمن من حيث الأنواع أكثر كفاءة وأمانًا وقابلية للتنبؤ من معالجة التعليقات التوضيحية وقت التشغيل.

وأخيرًا، فإن الوضوح فيما يحدث في شيفرتك، ومتى ولماذا، يجعل قواعد شيفرتنا أسهل في الاستكشاف والفهم، حتى عندما يتعين علينا شق طريقنا عبر شيفرة البنية التحتية التي توفرها المكتبات.

كل هذا يقوم على ثلاث ركائز: لغة Scala، ومكتبتها القياسية، والمكتبات وأطر العمل التي يوفرها المجتمع. فما المبادئ التي ستضيفها إلى هذه القائمة عند تطوير الشيفرة بالبرمجة الوظيفية ولغة Scala؟