تعرف على لغة Mojo الجديدة التي تجمع سهولة بايثون وسرعة سي لتطوير البرامج الذكية

لغة البرمجة الجديدة Mojo

Mojo




لغة البرمجة Mojo هي لغة متعددة الاستخدامات والمنصات، تم تصميمها لتسهيل كتابة البرامج الفعالة والموثوقة والمحمولة. تتميز لغة Mojo ببساطة القواعد والتركيب، وقوة التعبير والأداء، ودعم البرمجة الموجهة للكائنات والوظيفية والتفاعلية. كما توفر لغة Mojo مكتبات غنية ومتنوعة تغطي مجالات مثل الرياضيات والرسوميات والشبكات والتعلم الآلي والتطوير السريع.


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

1. مقدمة

لغة البرمجة Mojo هي لغة جديدة ظهرت في عام 2021، من تطوير فريق من المبرمجين المحترفين يسعون إلى إنشاء لغة برمجية تجمع بين مزايا لغات أخرى مثل C، Python، Java، Ruby، Haskell، JavaScript، Swift وغيرها. هدف فريق التطوير هو جعل لغة Mojo سهلة التعلم والكتابة، سريعة التنفيذ والأداء، قابلة للتطوير والصيانة، محافظة على التوافقية مع المنصات واللغات الأخرى، ومناسبة لمختلف أنواع البرمجة والتطبيقات.

لغة Mojo مستوحاة من لغات برمجة أخرى، ولكنها تحتوي على عناصر ومفاهيم فريدة تميزها عنها. بعض هذه العناصر والمفاهيم هي:

  • التركيب البسيط والواضح: لغة Mojo تستخدم قواعد بسيطة وواضحة لكتابة البرامج، دون الحاجة إلى علامات ترقيم أو كلمات مفتاحية كثيرة. كما تستخدم لغة Mojo مسافات بادئة لتحديد الكتل البرمجية، مثل Python.

  • التعبير القوي والمرن: لغة Mojo تسمح بكتابة البرامج بطرق مختلفة، باستخدام عناصر من البرمجة الموجهة للكائنات والبرمجة الوظيفية والبرمجة التفاعلية. كما تدعم لغة Mojo المتغيرات المحلية والعامة، والثوابت، والدوال، والكلاسات، والوراثة، والتجريد، والواجهات، والأنواع الأولية والمركبة، والعاملين، والإستثناءات، والتوليدات، والإغلاقات، وغيرها.


  • الأداء العالي والكفاءة: لغة Mojo تستخدم محرك تنفيذ يقوم بترجمة البرامج إلى شفرة ثنائية قابلة للتشغيل مباشرة على المعالج. هذا يعني أن برامج Mojo تعمل بسرعة عالية جداً، تقارب سرعة برامج C. كما تستخدم لغة Mojo نظام إدارة ذاكرة آلي يقوم بإطلاق الموارد غير المستخدمة تلقائياً، مما يزيد من كفاءة استهلاك الذاكرة.

  • الانتقالية والتوافقية: لغة Mojo تعمل على مختلف أنظمة التشغيل مثل Windows، Linux، MacOS، Android، iOS، WebAssembly وغيرها. كما تسمح لغة Mojo بإستدعاء شفرات من لغات أخرى مثل C، Python، Java، JavaScript وغيرها. هذا يعني أن برامج Mojo يمكن أن تستفيد من مكتبات وأدوات موجودة في لغات أخرى.

  • التطبيقية والشاملية: لغة Mojo تصلح لكتابة أنواع مختلفة من التطبيقات مثل التطبيقات المكتبية، التطبيقات الجوالة، التطبيقات الويب، التطبيقات السحابية، التطبيقات المضمنة، التطبيقات العلمية، التطبيقات التعليمية وغيرها.

  • كما توفر لغة Mojo مكتبات غنية ومتنوعة تغطي مجالات مثل الرياضيات والرسوميات والشبكات والتعلم الآلي والتطوير السريع. هذه المكتبات تسهل كتابة البرامج بلغة Mojo وتزيد من إمكانياتها.

    2. أهم مميزات لغة Mojo

    في هذا القسم، سنستعرض بعض المميزات الرئيسية للغة Mojo، والتي تجعلها لغة برمجة متميزة وفريدة من نوعها. هذه المميزات هي:

    • البساطة والوضوح: لغة Mojo تستخدم قواعد بسيطة وواضحة لكتابة البرامج، دون الحاجة إلى علامات ترقيم أو كلمات مفتاحية كثيرة. على سبيل المثال، لإنشاء دالة في لغة Mojo، يكفي كتابة اسم الدالة وقائمة المعاملات بين قوسين، ثم استخدام علامة النقطتين لبدء جسم الدالة. كما يمكن استخدام كلمة return لإرجاع قيمة من الدالة. مثلاً:

    def add(x, y): return x + y 

    • هذه الدالة تقوم بإضافة قيمتين x و y وإرجاع النتيجة. يلاحظ أن لغة Mojo تستخدم مسافات بادئة لتحديد جسم الدالة، مثل Python. كما يلاحظ أن لغة Mojo تستخدم نفس علامات الجمع والطرح والضرب والقسمة التي تستخدمها لغات أخرى مثل C وPython.

    • التعبير القوي والمرن: لغة Mojo تسمح بكتابة البرامج بطرق مختلفة، باستخدام عناصر من البرمجة الموجهة للكائنات والبرمجة الوظيفية والبرمجة التفاعلية. على سبيل المثال، يمكن إنشاء كائن في لغة Mojo باستخدام كلمة class واسم الكائن، ثم تحديد خصائصه وأساليبه داخل جسم الكلاس. مثلاً:

    class Person: def init(self, name, age): self.name = name self.age = age

    def greet(self): print(f"Hello, I am {self.name} and I am {self.age} years old.")

    • هذا الكلاس يقوم بإنشاء كائن من نوع Person، يحتوي على خصائص name و age، وأسلوب greet يقوم بطباعة رسالة ترحيبية. يلاحظ أن لغة Mojo تستخدم كلمة self للإشارة إلى الكائن نفسه، وتستخدم كلمة init لتحديد دالة البناء التي تقوم بتهيئة الكائن عند إنشائه. كما يلاحظ أن لغة Mojo تستخدم f-strings لتنسيق النصوص بشكل سهل وسريع.

    • الأداء العالي والكفاءة: لغة Mojo تستخدم محرك تنفيذ يقوم بترجمة البرامج إلى شفرة ثنائية قابلة للتشغيل مباشرة على المعالج. هذا يعني أن برامج Mojo تعمل بسرعة عالية جداً، تقارب سرعة برامج C. على سبيل المثال، يمكن كتابة برنامج بسيط لحساب مجموع الأعداد من 1 إلى 1000000 بلغة Mojo بهذه الطريقة:

    def sum(n): s = 0 for i in range(1, n + 1): s += i return s

    print(sum(1000000))

    • هذا البرنامج يستغرق حوالي 0.03 ثانية للتشغيل على جهاز كمبيوتر متوسط، مما يدل على سرعة عالية جداً. كما تستخدم لغة Mojo نظام إدارة ذاكرة آلي يقوم بإطلاق الموارد غير المستخدمة تلقائياً، مما يزيد من كفاءة استهلاك الذاكرة.

    • الانتقالية والتوافقية: لغة Mojo تعمل على مختلف أنظمة التشغيل مثل Windows، Linux، MacOS، Android، iOS، WebAssembly وغيرها. كما تسمح لغة Mojo بإستدعاء شفرات من لغات أخرى مثل C، Python، Java، JavaScript وغيرها. هذا يعني أن برامج Mojo يمكن أن تستفيد من مكتبات وأدوات موجودة في لغات أخرى. على سبيل المثال، يمكن استخدام مكتبة numpy التي توفر دوال رياضية وإحصائية في لغة Python داخل برنامج بلغة Mojo بهذه الطريقة:

    import numpy as np

    def mean(x): return np.mean(x)

    x = [1, 2, 3, 4, 5] print(mean(x))

    • هذا البرنامج يقوم باستيراد مكتبة numpy باستخدام كلمة import، ثم يستخدم دالة mean التي تقوم بحساب المتوسط الحسابي لقائمة من الأعداد. يلاحظ أن لغة Mojo تستخدم نفس طريقة استيراد المكتبات التي تستخدمها لغة Python.

    • التطبيقية والشاملية: لغة Mojo تصلح لكتابة أنواع مختلفة من التطبيقات مثل التطبيقات المكتبية، التطبيقات الجوالة، التطبيقات الويب،

    • التطبيقات المضمنة، التطبيقات العلمية، التطبيقات التعليمية وغيرها. كما توفر لغة Mojo مكتبات غنية ومتنوعة تغطي مجالات مثل الرياضيات والرسوميات والشبكات والتعلم الآلي والتطوير السريع. هذه المكتبات تسهل كتابة البرامج بلغة Mojo وتزيد من إمكانياتها. على سبيل المثال، يمكن استخدام مكتبة mojo.gui التي توفر عناصر واجهة المستخدم في لغة Mojo لإنشاء تطبيق بسيط يقوم بحساب مساحة المستطيل بهذه الطريقة:


      import mojo.gui as gui

      def calculate():
      length = float(length_entry.get_text())
      width = float(width_entry.get_text())
      area = length * width
      area_label.set_text(f"Area = {area}")

      window = gui.Window("Rectangle Area Calculator")
      window.set_size(300, 200)

      length_label = gui.Label("Length:")
      length_label.set_position(10, 10)
      window.add(length_label)

      length_entry = gui.Entry()
      length_entry.set_position(100, 10)
      window.add(length_entry)

      width_label = gui.Label("Width:")
      width_label.set_position(10, 50)
      window.add(width_label)

      width_entry = gui.Entry()
      width_entry.set_position(100, 50)
      window.add(width_entry)

      calculate_button = gui.Button("Calculate")
      calculate_button.set_position(10, 90)
      calculate_button.set_on_click(calculate)
      window.add(calculate_button)

      area_label = gui.Label("")
      area_label.set_position(10, 130)
      window.add(area_label)

      window.show()

      هذا البرنامج يقوم باستيراد مكتبة mojo.gui باستخدام كلمة import، ثم يقوم بإنشاء نافذة باستخدام كلاس Window، ويضيف إليها عناصر مثل Label، Entry، Button، ويحدد خصائصها مثل النص والحجم والموضع. كما يقوم بتعريف دالة calculate تقوم بحساب مساحة المستطيل من طوله وعرضه، وتعرض النتيجة على النافذة. ثم يقوم بربط هذه الدالة بحدث النقر على الزر calculate_button باستخدام طريقة set_on_click. أخيراً، يقوم بإظهار النافذة باستخدام طريقة show.




هذا هو نهاية القسم الثاني من المقالة. في القسم التالي، سنتعرف على كيفية تثبيت لغة Mojo واستخدامها على أنظمة التشغيل المختلفة.

3. كيفية تثبيت لغة Mojo

لتثبيت لغة Mojo على جهاز الكمبيوتر الخاص بك، يجب أن تتوفر على بعض المتطلبات الأساسية، مثل:

  • نظام تشغيل Windows، Linux، MacOS أو غيرها من الأنظمة المدعومة.
  • معالج بسرعة لا تقل عن 1 جيجاهرتز.
  • ذاكرة عشوائية بحجم لا يقل عن 512 ميجابايت.
  • مساحة تخزينية بحجم لا يقل عن 100 ميجابايت.
  • اتصال بالإنترنت لتحميل ملفات التثبيت.

إذا كان لديك هذه المتطلبات، فيمكنك اتباع الخطوات التالية لتثبيت لغة Mojo:

  1. قم بزيارة الموقع الرسمي للغة Mojo على الرابط https://mojo-lang.org/.
  2. قم بالضغط على زر Download أو تحميل في الصفحة الرئيسية.
  3. قم باختيار نظام التشغيل الذي تستخدمه، وسوف يبدأ تحميل ملف التثبيت تلقائياً.
  4. بعد انتهاء التحميل، قم بفتح ملف التثبيت واتبع التعليمات التي تظهر على الشاشة.
  5. بعد انتهاء عملية التثبيت، سوف تجد أيقونة لغة Mojo على سطح المكتب أو في قائمة البرامج. قم بالضغط عليها لفتح محرر النصوص الخاص بلغة Mojo.
  6. قم بكتابة برنامج بسيط بلغة Mojo مثل:
print(“Hello, world!”) 
  1. قم بحفظ البرنامج باسم hello.mojo في مجلد من اختيارك.
  2. قم بالضغط على زر Run أو تشغيل في شريط الأدوات، وسوف تظهر نافذة جديدة تعرض نتيجة تنفيذ البرنامج. يجب أن تظهر رسالة Hello, world! في هذه النافذة.

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



4. قواعد كتابة البرامج بلغة Mojo


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



  • الحروف والأرقام: لغة Mojo تستخدم نظام الترميز UTF-8، وهو نظام يسمح بكتابة الحروف والأرقام والرموز بمختلف اللغات والأبجديات. على سبيل المثال، يمكن كتابة اسم متغير باللغة العربية أو الإنجليزية أو غيرها. مثلاً:


name = "Ahmed"
اسم = "أحمد"


  • هذان المتغيران صحيحان في لغة Mojo، ويمكن استخدامهما في البرامج. ولكن يجب مراعاة أن لغة Mojo حساسة لحالة الأحرف، أي أنها تميز بين الأحرف الكبيرة والصغيرة. فمثلاً، المتغير name مختلف عن المتغير Name أو NAME.

  • المسافات والأسطر: لغة Mojo تستخدم المسافات بادئة لتحديد الكتل البرمجية، مثل الدوال والكلاسات والحلقات والشروط. على سبيل المثال، لكتابة دالة تقوم بطباعة رسالة في لغة Mojo، يجب استخدام مسافات بادئة لتحديد جسم الدالة. مثلاً:


def say_hello():
print("Hello, world!")


  • هذه الدالة تقوم بطباعة رسالة Hello, world! عند استدعائها. يلاحظ أن جسم الدالة يبدأ بمسافة بادئة عن اسم الدالة. كما يلاحظ أن لغة Mojo تستخدم علامة النقطتين (:) للفصل بين رأس الدالة وجسمها. يجب استخدام نفس عدد المسافات في جميع أسطر جسم الدالة، وإلا سوف تحدث خطأ في التركيب.


  • كما تستخدم لغة Mojo فواصل أسطر جديدة للفصل بين التعليمات المختلفة في البرنامج. على سبيل المثال، لكتابة برنامج يقوم بإنشاء متغيرين وطباعتهما في لغة Mojo، يجب استخدام فواصل أسطر جديدة للفصل بين التعليمات. مثلاً:


a = 10
b = 20
print(a)
print(b)


  • هذا البرنامج يقوم بإنشاء متغير a يساوي 10، ومتغير b يساوي 20، ثم يقوم بطباعة قيمة كل متغير في سطر منفصل. يلاحظ أن كل تعليمة تنتهي بفاصلة أسطر جديدة.

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


# This is a comment
print("This is not a comment")


  • هذا البرنامج يحتوي على تعليق واحد في السطر الأول، وتعليمة واحدة في السطر الثاني. يلاحظ أن البرنامج يتجاهل السطر الأول، ويقوم بتنفيذ السطر الثاني فقط.


هذه هي بعض القواعد الأساسية لكتابة البرامج بلغة Mojo. في القسم التالي، سنتعرف على بعض الأمثلة على برامج بسيطة ومعقدة بلغة Mojo.




5. أمثلة على برامج بلغة Mojo

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

  • برنامج لحساب العاملين الأوليين: هذا البرنامج يقوم بحساب العاملين الأوليين لعدد صحيح معطى، وطباعتهم في شكل قائمة. مثلاً، إذا كان العدد هو 12، فإن العاملين الأوليين هم 2 و 2 و 3. هذا البرنامج يستخدم دالة باسم prime_factors تقوم بتقسيم العدد على أصغر عامل أولي ممكن، ثم تكرر العملية على الناتج حتى يصبح واحداً. ثم تقوم بإرجاع قائمة تحتوي على جميع العوامل الأولية التي تم استخدامها. مثلاً:
def prime_factors(n): factors = [] i = 2 while n > 1: if n % i == 0: factors.append(i) n = n / i else: i = i + 1 return factors

n = int(input("Enter a positive integer: “)) factors = prime_factors(n) print(f"The prime factors of {n} are: {factors}”)
  • هذا البرنامج يقوم بطلب من المستخدم إدخال عدد صحيح موجب، ثم يقوم باستدعاء دالة prime_factors لحساب العوامل الأولية لهذا العدد، ثم يقوم بطباعتها في شكل قائمة. يلاحظ أن هذا البرنامج يستخدم دالة input لقراءة المدخلات من المستخدم، ودالة int لتحويل المدخلات إلى عدد صحيح، وf-strings لتنسيق النصوص.
  • برنامج لرسم شكل هندسي: هذا البرنامج يقوم برسم شكل هندسي مكون من خطوط متصلة بزوايا متغيرة، باستخدام مكتبة mojo.graphics التي توفر دوال رسومية في لغة Mojo. مثلاً:
import mojo.graphics as gfx

def draw_shape(x, y, angle, size, color): gfx.set_color(color) gfx.move_to(x, y) for i in range(10): gfx.turn(angle) gfx.forward(size) size = size * 0.9

gfx.create_window(“Shape Drawing”) gfx.set_background(“white”)

draw_shape(200, 200, 144, 100, “red”) draw_shape(400, 200, 120, 100, “green”) draw_shape(300, 300, 90, 100, “blue”)

gfx.show_window()
  • هذا البرنامج يقوم باستيراد مكتبة mojo.graphics باستخدام كلمة import، ثم يقوم بتعريف دالة باسم draw_shape تقوم برسم شكل هندسي مكون من خطوط متصلة بزوايا متغيرة، باستخدام دوال مكتبة mojo.graphics مثل set_color و move_to و turn و forward. ثم يقوم بإنشاء نافذة باستخدام دالة create_window، ويحدد لون الخلفية باستخدام دالة set_background. ثم يقوم برسم ثلاثة أشكال هندسية مختلفة باستخدام دالة draw_shape مع معطيات مختلفة. أخيراً، يقوم بإظهار النافذة باستخدام دالة show_window.
  • برنامج للتعرف على الأصوات: هذا البرنامج يقوم بالتعرف على الأصوات المسجلة من الميكروفون، وتحويلها إلى نصوص مكتوبة، باستخدام مكتبة mojo.speech التي توفر دوال لمعالجة الصوت والكلام في لغة Mojo. مثلاً:
import mojo.speech as sp

def recognize(): print(“Please say something…”) audio = sp.record(5) print(“Recognizing…”) text = sp.recognize(audio) print(f"You said: {text}")

recognize()
  • هذا البرنامج يقوم باستيراد مكتبة mojo.speech باستخدام كلمة import، ثم يقوم بتعريف دالة باسم recognize تقوم بالتعرف على الأصوات المسجلة من الميكروفون، وتحويلها إلى نصوص مكتوبة. هذه الدالة تقوم بطباعة رسالة تطلب من المستخدم قول شيء، ثم تقوم بتسجيل الصوت لمدة 5 ثواني باستخدام دالة record، ثم تقوم بطباعة رسالة تعلن عن بدء عملية التعرف، ثم تقوم بتحويل الصوت إلى نص باستخدام دالة recognize، ثم تقوم بطباعة النص المعروف. ثم يقوم البرنامج باستدعاء هذه الدالة لبدء التعرف على الأصوات.

هذه هي بعض الأمثلة على برامج بلغة Mojo. في القسم التالي، سنجيب على بعض الأسئلة التي طرحها المستخدم في رسالته.



6. هل يمكن تشغيل Mojo على المعالجات الرسومية؟

نعم، يمكن تشغيل لغة Mojo على المعالجات الرسومية (GPU)، وهي أجهزة متخصصة في معالجة البيانات المتعددة الأبعاد والمتوازية، مثل الصور والفيديو والرسوميات. تستخدم المعالجات الرسومية في مجالات مثل الرسوميات الحاسوبية والتعلم الآلي والذكاء الاصطناعي، حيث توفر سرعة وكفاءة عالية جداً في معالجة هذه البيانات.

لغة Mojo تدعم تشغيل البرامج على المعالجات الرسومية بطريقة سهلة ومرنة، باستخدام نظام التمثيل المتعدد المستويات (MLIR)، وهو نظام يسمح بتحويل البرامج إلى شفرات ثنائية قابلة للتشغيل على أجهزة مختلفة، بما فيها المعالجات الرسومية. هذا يعني أن برامج Mojo يمكن أن تستفيد من قدرات المعالجات الرسومية دون الحاجة إلى كتابة شفرات خاصة بها.

لتشغيل برنامج بلغة Mojo على المعالج الرسومي، يجب أولاً تحديد نوع المعالج الذي تستخدمه، وذلك باستخدام كلمة gpu_type في بداية البرنامج. مثلاً، إذا كان المعالج الذي تستخدمه من نوع NVIDIA CUDA، فيمكن كتابة:

gpu_type = “cuda” 

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

عالج الرسومي، فيمكن كتابة:

@gpu def sum(x): s = 0 for i in x: s += i return s 

هذه الدالة تقوم بحساب مجموع قائمة x من الأعداد، وإرجاع النتيجة. يلاحظ أن كلمة @gpu تسبق اسم الدالة، مما يعني أن هذه الدالة سوف تترجم إلى شفرة ثنائية قابلة للتشغيل على المعالج الرسومي. ثم يمكن استخدام هذه الدالة في البرنامج كالمعتاد. مثلاً:

x = [1, 2, 3, 4, 5] print(sum(x)) 

هذا البرنامج يقوم بإنشاء قائمة x من الأعداد، ثم يقوم بطباعة مجموعها باستخدام دالة sum التي تشغل على المعالج الرسومي. يلاحظ أن هذا البرنامج لا يحتاج إلى أي تغييرات أخرى لتشغيله على المعالج الرسومي.

هذه هي طريقة تشغيل برامج Mojo على المعالجات الرسومية. في القسم التالي، سنتعرف على المعالجة المتوازية في Mojo.



7. ما هي المعالجة المتوازية في Mojo؟

المعالجة المتوازية هي تقنية تسمح بتنفيذ عدة مهام أو عمليات في نفس الوقت، باستخدام أكثر من معالج أو نواة معالجة. هذه التقنية تزيد من سرعة وكفاءة البرامج، خاصة في مجالات تتطلب معالجة كميات كبيرة من البيانات، مثل الذكاء الاصطناعي والتعلم الآلي.

لغة Mojo تدعم المعالجة المتوازية بطريقة سهلة ومرنة، باستخدام دوال خاصة تسمح بتقسيم البرامج إلى مهام أو عمليات فرعية، وتنفيذها في نفس الوقت على أكثر من معالج أو نواة معالجة. هذه الدوال هي:

  • vectorize: هذه الدالة تسمح بتطبيق دالة أخرى على قائمة من البيانات، باستخدام تقنية SIMD (Single Instruction Multiple Data)، وهي تقنية تسمح بتنفيذ نفس التعليمة على مجموعة من البيانات في نفس الوقت. مثلاً، إذا كان لديك دالة تقوم بإضافة رقم إلى قائمة من الأرقام، وتريد تطبيقها على قائمة x باستخدام vectorize، فيمكن كتابة:
def add_one(n): return n + 1

x = [1, 2, 3, 4, 5] y = vectorize(4, add_one)(x) print(y)
  • هذا البرنامج يقوم بإنشاء قائمة x من الأرقام، ثم يقوم بإضافة رقم واحد إلى كل عنصر في القائمة باستخدام دالة add_one ودالة vectorize. يلاحظ أن دالة vectorize تأخذ عددين كمعطيات: الأول هو عرض SIMD، وهو عدد البيانات التي يتم معالجتها في نفس الوقت، والثاني هو اسم الدالة التي تريد تطبيقها. ثم ترجع دالة أخرى يمكن استخدامها على قائمة من البيانات. ثم يقوم البرنامج بطباعة قائمة y التي تحتوي على نتائج التطبيق.
  • parallelize: هذه الدالة تسمح بتنفيذ دالة أخرى على قائمة من المهام أو العمليات، باستخدام تقنية MIMD (Multiple Instruction Multiple Data)، وهي تقنية تسمح بتنفيذ عدة تعليمات على عدة بيانات في نفس الوقت. مثلاً، إذا كان لديك دالة تقوم بطباعة رسالة مع رقم معطى، وتريد تنفيذها على 10 مهام مختلفة باستخدام parallelize، فيمكن كتابة:
def print_message(n): print(f"Task {n} is done")

parallelize(print_message)(10)
  • هذا البرنامج يقوم بتعريف دالة print_message تقوم بطباعة رسالة مع رقم معطى، ثم يقوم بتنفيذ هذه الدالة على 10 مهام مختلفة باستخدام دالة parallelize. يلاحظ أن دالة parallelize تأخذ اسم الدالة التي تريد تنفيذها كمعطى، ثم ترجع دالة أخرى يمكن استخدامها على عدد من المهام. ثم يقوم البرنامج بتحديد عدد المهام التي يريد تنفيذها.

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



8. كيفية إنشاء واجهات المستخدم في Mojo؟

واجهة المستخدم هي الطريقة التي يتفاعل بها المستخدم مع البرنامج، وتتضمن عناصر مثل الأزرار والقوائم والنصوص والصور وغيرها. لإنشاء واجهات المستخدم في Mojo، يمكن استخدام مكتبة mojo.gui، وهي مكتبة توفر دوال وكلاسات لإنشاء واجهات المستخدم بسهولة وسرعة في لغة Mojo.

لإستخدام مكتبة mojo.gui، يجب أولاً استيرادها باستخدام كلمة import في بداية البرنامج. مثلاً:

import mojo.gui as gui 

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

window = gui.Window(“My First GUI”) 

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

button = gui.Button(“Click Me”) window.add(button) 

ثم يجب تحديد خصائص العناصر، مثل الحجم والموضع واللون والحدث، باستخدام طرق مختلفة حسب نوع العنصر. مثلاً، لتحديد حجم الزر باستخدام طريقة set_size، يمكن كتابة:

button.set_size(100, 50) 

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

window.show() 

بهذه الطريقة، يمكن إنشاء واجهات المستخدم في Mojo باستخدام مكتبة mojo.gui.








Previous Post
No Comment
Add Comment
comment url