الانتقال من Python إلى Go: ما يجب أن يعرفه مطورو Python

يمكنك قراءة صيغة Go كلها في فترة بعد الظهر، وإذا كنت تكتب Python أصلًا فسيبدو لك معظمها مألوفًا. لكن هذه الألفة مضللة. تعلم الكلمات المفتاحية الجديدة سهل. الصعوبة في الانتقال إلى Go هي التخلي عن مجموعة صغيرة من عادات Python التي لا تدعمها Go. لا توجد في Go استثناءات (exceptions) لالتقاطها، ولا أصناف (classes) ترث منها، ولا list comprehensions، ولا مفسر تفتحه لتجرب فيه. بدلًا من ذلك تحصل على قيم أخطاء صريحة، و structs مع interfaces، و goroutines، ومترجم (compiler) يعترض قبل أن يعمل الكود أصلًا. يتناول هذا المقال التحولات التي تحدد هل سيبدو شهرك الأول مع Go راحة أم معركة.

الخلاصة

• مطورو Go راضون عنها. قال 91% من المشاركين إنهم راضون عن Go، وكان نحو الثلثين «راضين جدًا»، وهي أقوى نتيجة في استبيان Google الرسمي (Go Developer Survey 2025).
• أنت تستخدم بالفعل الفكرة التي يقوم عليها أكبر تغيير في Go. يقول 88% من مطوري Python إنهم يستخدمون تلميحات الأنواع (type hints) «دائمًا» أو «غالبًا». أي أن التحديد الثابت للأنواع عادة بدأتها بالفعل (Typed Python 2024 Survey, Meta).
• الفرق التي انتقلت حققت مكاسب حقيقية. عندما أعادت Khan Academy كتابة الواجهة الخلفية (backend) المكتوبة بـ Python باستخدام Go، انخفض وقت عرض صفحة من نحو 28 ثانية إلى قرابة 4 ثوانٍ (Khan Academy Engineering). وخفّض انتقال Reddit إلى خدمة تعليقات مكتوبة بـ Go زمن الكتابة عند p99 إلى النصف (InfoQ).
• ما زالت Python أكبر، ولا مشكلة في ذلك. يستخدم 54.8% من المطورين المحترفين Python، مقابل 17.4% يستخدمون Go، وتهيمن Python على أعمال البيانات والذكاء الاصطناعي (Stack Overflow 2025). أما Go فتنافس في مساحة أضيق: الواجهات الخلفية الحساسة لزمن الاستجابة، وواجهات API، وأدوات سطر الأوامر (CLI).

جدول المحتويات

• هل يجب على مطوري Python تعلم Go؟
• لماذا تنتقل الفرق من Python إلى Go
• التحديد الثابت للأنواع: قطعت نصف الطريق بالفعل
• الأخطاء قيم وليست استثناءات
• التزامن: goroutines في مواجهة GIL
• تحل structs و interfaces محل الأصناف والوراثة
• سحر أقل ووضوح أكثر
• مرجع سريع: من Python إلى Go
• الأدوات: ملف تنفيذي واحد، ومنسق واحد، واختبارات مدمجة
• ما الذي ستفتقده من Python
• كيف تنتقل إلى Go
• الأسئلة الشائعة
• ابدأ كتابة Go اليوم

هل يجب على مطوري Python تعلم Go؟

نعم، خصوصًا إذا كان عملك يتجه نحو خدمات الواجهة الخلفية، أو واجهات API، أو البنية التحتية، أو أدوات سطر الأوامر. يسجل مطورو Go أعلى مستوى رضا بين اللغات الرئيسية كلها، إذ أبدى 91% رضاهم وقال قرابة الثلثين إنهم «راضون جدًا» في استبيان Google الرسمي (Go Developer Survey 2025). يأتي هذا الرضا من أن سلوك Go يمكن التنبؤ به أكثر مما يأتي من ذكائها. وإمكانية التنبؤ هي ما يبدأ معظم مطوري Python في طلبه حين تتجاوز قاعدة الكود بضعة آلاف من الأسطر.

الانتقال سريع لأن الكثير مما تعرفه ينتقل معك. أنت تفكر بالفعل بالدوال و slices و maps. وتقسم العمل بالفعل إلى حزم وتكتب الاختبارات. طريقتك في تناول المشكلات تبقى كما هي. ما يتغير هو مدى صرامة اللغة في إلزامك بقراراتك. تتخلى Go عن بعض مرونة Python مقابل الضمانات، ومعظم هذا المقال يدور حول المواضع التي يظهر فيها ذلك.

لماذا تنتقل الفرق من Python إلى Go

تنتقل الفرق عادة للسبب نفسه: خدمة Python كانت كتابتها سريعة، ثم أصبح تشغيلها بطيئًا أو مكلفًا أكثر من اللازم. عندما أعادت Khan Academy كتابة خادمها بـ Go، أصبحت قائمة فصل دراسي تضم 1,000 طالب، كان تحميلها يستغرق نحو 28 ثانية في Python، تُعرض في قرابة 4 ثوانٍ، أي بتحسن يقارب 7 أضعاف. وانخفضت تحذيرات التنافس على مخزن البيانات (datastore contention) من نحو 100 في الساعة إلى ما يقارب الصفر (Khan Academy Engineering).

وحدث أمر مشابه في Reddit. بعد أن نقلت الواجهة الخلفية لشجرة التعليقات إلى خدمة مصغرة (microservice) مكتوبة بـ Go في 2025، أصبح زمن الكتابة عند p99 نصف ما كان عليه في نظام Python القديم، الذي كان زمنه يقفز أحيانًا إلى 15 ثانية (InfoQ).

ويُعد Lovable، أداة بناء التطبيقات بالذكاء الاصطناعي، أبرز مثال حديث. فقد أعاد كتابة الواجهة الخلفية بالكامل من Python إلى Go، أي 42,000 سطر من الكود. انخفض عدد نسخ الخوادم من 200 إلى 10، وتراجع وقت النشر من 15 دقيقة إلى 3 دقائق، وأصبح متوسط زمن الطلبات أسرع بنسبة 12% (Lovable Engineering). وكان التزامن هو دافع إعادة الكتابة. فطلب محادثة واحد في Lovable قد يتفرع إلى أكثر من 50 استدعاء HTTP. تتعامل Go مع هذا النوع من العمل المتوازي بشكل أصيل، بينما يجعله GIL في Python مرهقًا.

في كل حالة من هذه الحالات، بيئة التشغيل في Go، وهي مترجمة وثابتة الأنواع ومزودة بجامع المهملات (garbage collector)، تنجز عملًا أكثر لكل خادم. لذلك تصبح كلفة حجم الطلبات نفسه أقل، ويصبح السلوك أكثر ثباتًا تحت الضغط.

التحديد الثابت للأنواع: قطعت نصف الطريق بالفعل

يخشى مطورو Python التحديد الثابت للأنواع (static typing) أكثر من أي شيء آخر في Go، ومع ذلك يتأقلمون معه أسرع من غيره، لأن معظمهم اختاره بالفعل. في استبيان أُجري عام 2024، قال 88% من مطوري Python إنهم يستخدمون تلميحات الأنواع «دائمًا» أو «غالبًا»، وكانت mypy و Pydantic أكثر الأدوات شيوعًا (Typed Python 2024 Survey, Meta). إذا كنت تضيف الأنواع إلى تواقيع الدوال وتشغل مدقق أنواع في CI، فقد قبلت بالفعل الفكرة الأساسية في Go. تجعل Go الفحص إلزاميًا، وتضعه داخل المترجم بدلًا من أداة اختيارية.

الفرق العملي هو توقيت اكتشافك للخطأ. في Python يظهر عدم تطابق الأنواع وقت التشغيل، وغالبًا في بيئة الإنتاج، وأحيانًا بعد ساعات من النشر. في Go يوقف الخطأ نفسه عملية البناء. لا يمكنك تمرير string حيث يُتوقع int، ولا يمكنك ترك متغير دون استخدام، لذلك لن يُترجم كود فيه err أسندت إليه قيمة ولم تتحقق منه. يبدو هذا للمبتدئ إزعاجًا متكررًا. أما إذا اضطررت يومًا إلى تتبع خطأ NoneType has no attribute في الثانية فجرًا، فسيبدو لك أقرب إلى شبكة أمان.

إليك كيف يبدو ذلك. لن تُترجم نسخة Go إذا كان Total من نوع خاطئ في أي موضع، بينما تكتفي نسخة Python بأن تأمل أن المستدعي مرر رقمًا:

example.gogo
type Order struct {
	ID    string
	Total int // cents, never a float, never a string
}

func discount(o Order, pct int) int {
	return o.Total - (o.Total * pct / 100)
}

استنتاج الأنواع (type inference) يمنع هذا من أن يصبح مطولًا. مع := تستنتج Go النوع من القيمة، فتكتب count := 0 بدلًا من كتابة int صراحة في كل مكان. تحتفظ بأمان التصريحات وبمعظم إيجاز Python.

الأخطاء قيم وليست استثناءات

هذا أكبر تغيير، وسيبدو غريبًا لمدة أسبوع تقريبًا. لا يوجد في Go try ولا except، ولا استثناءات بالمعنى المعروف في Python. تعيد الدوال التي قد تفشل قيمة error في آخر قيمها المعادة، وتتحقق منها في موضع الاستدعاء نفسه. لا يُرمى شيء إلى أعلى مكدس الاستدعاءات ليُلتقط في مكان بعيد. تعالج الخطأ أو تتجاهله أو تمرره، في السطر الذي وقع فيه.

ستكتب هذا النمط الاصطلاحي آلاف المرات:

example.gogo
resp, err := http.Get(url)
if err != nil {
	return fmt.Errorf("fetch %s: %w", url, err)
}
defer resp.Body.Close()

كثيرًا ما لا يحب مطورو Python كتلة if err != nil في البداية. فثلاثة أسطر لمعالجة الخطأ بعد كل استدعاء تبدو مزعجة مقارنة بكتلة try واحدة تحيط بمقطع كامل. لكن هذا التكرار مقصود. يمكنك رؤية كل مسارات الفشل في الدالة بالقراءة من الأعلى إلى الأسفل، دون قفزات خفية إلى معالج بعيد. أما رمز التنسيق %w فيغلّف الخطأ الأصلي حتى يتمكن المستدعون من فحصه، وهذا هو مقابل سلسلة الاستثناءات في Go.

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

التزامن: goroutines في مواجهة GIL

في التزامن تتوقف Go عن كونها «Python مع أنواع» وتصبح أداة مختلفة. يسمح قفل المفسر العام (Global Interpreter Lock) في CPython لخيط (thread) واحد فقط بتنفيذ bytecode الخاص بـ Python في كل لحظة، لذلك لا تستطيع الخيوط تشغيل الأعمال المعتمدة على المعالج (CPU-bound) بالتوازي. وصلت نسخ free-threaded التي تعمل دون GIL بشكل تجريبي في Python 3.13 ضمن PEP 703، لكنها ليست الخيار الافتراضي، وما زالت المنظومة تلحق بها (Python docs). في الوقت الحالي، يعني توسيع Python للأعمال المعتمدة على المعالج عادة تشغيل عدة عمليات (processes) ودفع ما يأتي معها من كلفة في الذاكرة والتنسيق.

صُممت Go حول التزامن منذ البداية. الـ goroutine هي استدعاء دالة تسبقه الكلمة go، وتوزع بيئة التشغيل آلافًا منها على أنوية المعالج دون GIL يعترض طريقها. وتتواصل goroutines عبر channels بدلًا من الذاكرة المشتركة. تشغيل مئة عملية جلب متزامنة يحتاج إلى هذا القدر من الكود:

example.gogo
results := make(chan string)
for _, url := range urls {
	go func() {
		resp, err := http.Get(url)
		if err != nil {
			results <- "error: " + url
			return
		}
		defer resp.Body.Close()
		results <- url + " ok"
	}()
}
for range urls {
	fmt.Println(<-results)
}

إذا كنت قد كتبت asyncio فأنت تفهم الهدف بالفعل. تصل Go إليه دون أن تقسم الكود إلى نصفين «ملونين»، async و sync. يمكن لأي دالة أن تعمل داخل goroutine. لا تكتب await، ولا تشغّل حلقة أحداث (event loop)، ولا تبحث عن نسخ async فقط من المكتبات. وهذا جزء كبير من سبب صمود خدمات Go تحت الضغط: نموذج التزامن في Go مبني داخل اللغة نفسها، ولم يُضف إليها لاحقًا.

تحل structs و interfaces محل الأصناف والوراثة

لا توجد في Go أصناف ولا وراثة، وهذا يفاجئ الناس أكثر مما ينبغي. تمثل البيانات بـ struct، وتمنحه سلوكًا بربط دوال (methods) به. لا شيء يمرر self ضمنيًا، ولا يوجد __init__، ولا صنف أساسي توسعه. وحيث تستخدم Python تسلسلًا هرميًا من الأصناف، تستخدم Go التركيب (composition). تضمّن struct داخل struct آخر لتعيد استخدام حقوله ودواله بدلًا من الوراثة من صنف أب.

وفي interfaces تظهر أناقة Go، وهي لا تعمل بالطريقة التي تتوقعها. يحقق النوع interface بمجرد امتلاكه الدوال المطلوبة. لا توجد كلمة مفتاحية implements ولا خطوة تسجيل. إذا كان لدى الـ struct دالة Read([]byte) (int, error) فهو io.Reader. هذا هو duck typing الذي تعرفه من Python، مع فحص وقت الترجمة:

example.gogo
type Notifier interface {
	Notify(msg string) error
}

type SlackClient struct{ webhook string }

func (s SlackClient) Notify(msg string) error {
	// any type with this method is a Notifier, automatically
	return post(s.webhook, msg)
}

التحول الذهني هو الانتقال من سؤال «ما هذا الكائن» إلى سؤال «ماذا يستطيع هذا الكائن أن يفعل». ستكون interfaces التي تكتبها أصغر مما تتوقع، وغالبًا بدالة واحدة، وستعرّفها بجوار الكود الذي يستخدمها لا بجوار النوع الذي يحققها. يحتاج هذا الانعكاس بضعة أيام حتى يصبح طبيعيًا. بعد ذلك يصبح غالبًا من أكثر ما تفتقده حين تعود إلى Python.

سحر أقل ووضوح أكثر

تكافئ Python الحيل الذكية. فالمزخرفات (decorators) والأصناف الوصفية (metaclasses) ودوال dunder والتعديل وقت التشغيل (monkey-patching) والوصول الديناميكي إلى السمات كلها تتيح لك تطويع اللغة كما تشاء. أما Go فتستبعد عمدًا كل ذلك تقريبًا. ليس فيها مزخرفات، ولا أصناف وصفية، ولا تحميل زائد للعوامل (operator overloading)، ولا طريقة لإضافة دالة إلى نوع لا تملكه. تستطيع في الغالب أن تعرف ما يفعله أي سطر دون أن تعرف شيئًا عن أمر يحدث في مكان آخر.

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

مرجع سريع: من Python إلى Go

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

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

الأدوات: ملف تنفيذي واحد، ومنسق واحد، واختبارات مدمجة

أدوات Go من أكثر الأسباب التي تبقي الناس مع Go دون أن تنال حقها من التقدير. لا يوجد انحراف في requirements.txt، ولا بيئة افتراضية تحتاج إلى تفعيلها، ولا منسق وأداة فحص (linter) ومشغل اختبارات منفصلة عليك ربطها معًا. الأمر go يغطي كل ذلك، ويأتي في تثبيت واحد. وتنتج الترجمة ملفًا تنفيذيًا ثابتًا (static binary) واحدًا دون مفسر أو اعتماديات تُشحن معه، لذلك كثيرًا ما يكون النشر مجرد نسخ ملف واحد إلى الخادم.

أول ما ستلاحظه:

• go build ينتج ملفًا تنفيذيًا واحدًا. لا يحتاج الجهاز الهدف إلى تثبيت Python، ولا تحزّم مفسرًا، ولا تظهر مشكلات الاعتماديات عند النشر.
• gofmt ينهي الجدال حول التنسيق. لدى Go أسلوب معتمد واحد وأداة تفرضه، فلا تناقش مراجعة الكود المسافات البيضاء أبدًا. فكّر في black، لكنه مدمج ويستخدمه الجميع.
• go test يأتي مع سلسلة الأدوات. تعيش الاختبارات بجوار الكود في ملفات _test.go وتعمل بأمر واحد. لا تحتاج إلى تثبيت pytest أو ضبطه.
• go vet ونظام الوحدات مدمجان. تُحدد إصدارات الاعتماديات في go.mod وتُجلب باستخدام go get، ويمكن إعادة إنتاج عمليات البناء دون أداة من طرف ثالث.

بعد سنوات من إدارة بيئات Python، يصبح عدم الحاجة إلى إدارة أي بيئة راحة صغيرة كل يوم. تكتب الكود، وتشغل go build، وتنشر الناتج.

ما الذي ستفتقده من Python

لصرامة Go تكاليف حقيقية، ومن الأفضل أن تعرف ما تتخلى عنه. أكثر ما ستفتقده هو REPL. لا تملك Go مفسرًا تفاعليًا تجرب فيه مكتبة أو تختبر مقتطفًا، لذلك يعني الاستكشاف كتابة main صغيرة وتشغيلها. وستفتقد list comprehensions و dict comprehensions، لأن Go تجبرك على كتابة الحلقة في كل مرة. وستفتقد بين حين وآخر مرونة Python، والطريقة التي تتيح لك بها إعادة تشكيل البيانات أثناء العمل دون أن تصرح بنوع أولًا.

فجوة المنظومة أهم، لأنها تمس مسيرتك المهنية وليس راحتك فقط. تهيمن Python على علم البيانات وتعلم الآلة والحوسبة العلمية. ويظهر ذلك في المجالات التي يقضي فيها مطورو Python وقتهم: استكشاف البيانات وتطوير الويب وتعلم الآلة في مقدمة القائمة (JetBrains State of Python 2025). إذا كان عملك تدريب النماذج أو معالجة dataframes، فلن تحل Go محل Python هناك ولا تحاول ذلك. من المنطقي أكثر أن تضيف Go إلى أدواتك بدلًا من أن تستبدل بها Python. احتفظ بـ Python لأعمال البيانات والذكاء الاصطناعي، واستخدم Go عندما تحتاج إلى خدمة سريعة وموثوقة، أو أداة CLI، أو أدوات للبنية التحتية. وهذا يتوافق مع ما يبنيه مطورو Go: يبني 75% منهم خدمات API أو RPC، ويبني 62% منهم أدوات سطر أوامر (Go Developer Survey 2024 H2).

كيف تنتقل إلى Go

أسرع طريقة لتعلم Go بصفتك مطور Python هي أن تتوقف عن القراءة عن الفروق وتصطدم بها في كود حقيقي. أنت تفهم المفاهيم بالفعل. ما تحتاجه هو التكرار: عدد كافٍ من التمارين الصغيرة المقيّمة حتى تتوقف الصيغة وإيقاع معالجة الأخطاء عن الحاجة إلى تفكير واعٍ. والانتقال من الاستثناءات إلى الأخطاء كقيم لا يترسخ إلا بعد أن تكتب if err != nil بضع مئات من المرات في برامج حقيقية.

لا تقع في مشاهدة الشروحات المصورة بشكل سلبي. مشاهدة شخص آخر يكتب Go تعلمك القليل جدًا عن كتابتها بنفسك، وهي مغرية بشكل خاص عندما تبدو اللغة بهذه السهولة. اكتب قليلًا من Go كل يوم، واحصل على ملاحظات تخبرك فورًا عندما تخطئ، وابنِ شيئًا حقيقيًا بمجرد أن تستطيع كتابة دالة دون البحث عن شيء. واجهة JSON API صغيرة، أو أداة CLI تعيد تنسيق ملف، أو برنامج يستدعي خدمة أخرى ويعيد تشكيل الاستجابة، كلها مشاريع قصيرة في Go، وتستخدم الأنماط التي ستعتمد عليها في العمل.

الأسئلة الشائعة

هل تعلم Go أصعب من Python؟

الصيغة ليست أصعب. لدى Go 25 كلمة مفتاحية فقط وأسلوب تنسيق واحد مفروض، لذلك ما تحتاج إلى حفظه أقل مما في Python. الجزء الأصعب هو الانضباط: التعامل مع الأخطاء كقيم والتصريح بالأنواع يتطلبان جهدًا أكبر في البداية. ومطورو Python الذين يستخدمون تلميحات الأنواع بالفعل، وهم 88% منهم، يبدؤون بأفضلية حقيقية (Typed Python 2024 Survey, Meta).

لماذا تتعامل Go مع التزامن أفضل من Python؟

يسمح قفل المفسر العام (GIL) في CPython لخيط واحد فقط بتشغيل bytecode في كل لحظة، لذلك يحتاج العمل المتوازي على المعالج إلى عدة عمليات (Python docs). أما goroutines في Go فتعمل على جميع الأنوية دون GIL، وتتواصل عبر channels، ولا تحتاج إلى منظومة async منفصلة. وهذا النموذج سبب كبير في بقاء خدمات Go أكثر ثباتًا تحت الضغط.

كم من الوقت يحتاج مطور Python لتعلم Go؟

الصيغة الأساسية تأتي بسرعة، لأن الدوال و slices و maps والحزم كلها تنتقل معك من Python. أما كتابة كود Go يوافق عليه فريق في مراجعة الكود فتستغرق وقتًا أطول. ما يجعل كود Go اصطلاحيًا هو ما لم تعلمك إياه Python: الأخطاء كقيم، و interfaces الصغيرة، والتركيب بدلًا من الوراثة، و goroutines و channels، وأعراف المكتبة القياسية. يحتاج معظم المطورين إلى بضعة أشهر من التركيز على بناء مشاريع حقيقية قبل أن يستوعبوا ذلك. قراءة الشروحات لن تنقلك من «أستطيع قراءة Go» إلى «أكتب Go الاصطلاحية». الممارسة العملية المنظمة هي التي تفعل ذلك، أي أن تبني أشياء وتتلقى ملاحظات على تمارين حقيقية.

هل ما زلت أحتاج إلى Python لتطوير الواجهة الخلفية إذا تعلمت Go؟

لا. في عمل الواجهة الخلفية، تغطي Go كل شيء بمفردها. تتضمن المكتبة القياسية خوادم HTTP و JSON وبرامج تشغيل SQL (drivers) والتزامن دون إطار عمل، لذلك يمكنك بناء خدمات جاهزة لبيئة الإنتاج ونشرها بالكامل بـ Go. وتُترجم إلى ملف تنفيذي ثابت واحد دون بيئة تشغيل تحتاج إلى تثبيتها، وتبدأ بسرعة، وتتعامل مع أحمال التزامن العالية باستخدام goroutines، ولهذا يعمل جزء كبير من البنية التحتية الحديثة عليها. ما زالت Python الخيار الافتراضي لعلم البيانات وتعلم الآلة، لكن هذا عمل مختلف. أما لواجهات API والخدمات المصغرة وأدوات CLI وأدوات البنية التحتية، فتكفيك Go.

ابدأ كتابة Go اليوم

خبرتك في Python تساعدك هنا. أنت تفكر بالفعل بالأشكال الصحيحة. ما تبقى هو أن تستوعب مجموعة صغيرة من القواعد الجديدة، وتفعل ذلك بكتابة Go. معالجة الأخطاء و interfaces و goroutines ليست صعبة، لكن كلًا منها يحتاج إلى ممارسة قبل أن يصبح طبيعيًا.

ولهذا صُمم LevelUpGo. كل درس هو تمرين في المتصفح يشغّل الكود الذي تكتبه على سلسلة أدوات Go الحالية ويقيّمه فورًا، لذلك تكتب Go حقيقية من اليوم الأول.

إليك مسارًا لمطور Python:

• ابدأ بالأساسيات. تأخذك دورة Go Fundamentals من برنامجك الأول إلى الدوال والأنواع و structs، وتتدرب فيها على نمط معالجة الأخطاء منذ البداية. ويمكنك البدء مجانًا دون الحاجة إلى بطاقة ائتمان.
• تعلم النموذج الوحيد الجديد فعلًا. تعلّمك دورة Go Concurrency Fundamentals كيفية استخدام goroutines و channels و select. لا يوجد لهذا مقابل مباشر في Python، وهو الجزء الذي يعطي أكبر عائد تحت الضغط.
• تعلم كتابة Go على طريقة Go. يغطي مسار Clean Go Code الأنماط الاصطلاحية والتسمية ومعالجة الأخطاء التي تجعل كود Go يُقرأ مثل Go، لا مثل Python مع أقواس معقوفة.

ابدأ الدورة المجانية، واكتب قليلًا من Go كل يوم، وحافظ على سلسلة أيامك المتتالية.