كيف تكتب كود برمجي مثل مهندسي البرمجيات

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

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

اقتباس

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

فهم وتحليل المشكلة البرمجية

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

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

حساب متوسط درجات الطلاب، ونحتاج لذلك إلى حساب المتوسط الحسابي لدرجات الطلاب
تحديد أعلى وأقل درجة
تحديد عدد الطلاب الذين حصلوا على درجات أعلى من المتوسط

تحليل متطلبات الكود البرمجي: نحدد هنا ما هي البيانات أو المدخلات التي يحتاجها الكود للعمل بشكل صحيح، والتي هي في هذه الحالة قائمة تحتوي على درجات الطلاب مثل: 85 و 90 و 78 و 92 و 88
تصميم الحل البرمجي: يسهّل استخدام المخططات الانسيابية لتصميم الحلول البرمجية عملية التفاعل مع المشكلة وفهمها بوضوح؛ ورغم أنه اختياري إلا أنه مهم. في المثال التالي مخطط انسيابي لمثال المشكلة البرمجية التي نريد كتابة كود احترافي لها:

شروط كتابة الكود البرمجي الجيد مثل مهندسي البرمجيات

تتطلب عملية كتابة كود برمجي مثل مهندسي البرمجيات، الالتزام بمعايير الكتابة الاحترافية لضمان وضوح وسهولة ونظام الكود. ومن أهم هذه المعايير ما يلي:

استخدام أسماء واضحة ومعبرة للمتغيرات

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

# كود سيء
x = 85
y = 90
z = (x + y) / 2


#  كود جيد
gradeOne = 85
gradeTwo = 90
averageGrade = (gradeOne + gradeTwo) / 2

وكما نلاحظ، يُعَد المثال الأول سيء لأن الأسماء (x، y, z) لا توضح غرض المتغيرات؛ أما في المثال الثاني، فالأسماء gradeOne و gradeTwo تعبر بوضوح عن محتويات المتغيرات، وهو درجات الطلاب.

تقليل التكرار وجعل الكود سهل القراءة

من المهم كتابة كود لا يحتوي على تكرار غير ضروري ويكون سهل القراءة لفهمه بسرعة:

# كود سيء
# حساب المعدل بطريقة غير فعالة
totalOne = (85 + 90) / 2
totalTwo = (78 + 92) / 2
totalThree = (88 + 81) / 2

average = (totalOne + totalTwo + totalThree) / 3


# كود جيد
# تعريف دالة لحساب معدل درجتين
def calculateAverage(gradeOne, gradeTwo):
    return (gradeOne + gradeTwo) / 2  

# استخدام الدالة لتقليل التكرار
totalOne = calculateAverage(85, 90)
totalTwo = calculateAverage(78, 92)
totalThree = calculateAverage(88, 81)

# حساب المعدل العام
overallAverage = (totalOne + totalTwo + totalThree) / 3

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

استخدام أسلوب موحد في تسمية المتغيرات

يجب استخدام نفس التسميات أو المفردات لنفس نوع المتغيرات عبر الكود لزيادة الاتساق:

# تسمية سيئة
gradeOne = 85
gradeTwo = 90
scoreThree = 78


# تسمية جيدة
gradeOne = 85
gradeTwo = 90
gradeThree= 78

في المثال الأول، تم استخدام أسماء غير متسقة مثل gradeOne و gradeTwo و scoreThree؛ أما في المثال الثاني، تم استخدام الأسماء المتسقة مثل gradeOne و gradeTwo و gradeThree.

يجب أن تعبر أسماء الدوال عما تفعله

اسم الدالة يجب أن يعكس بدقة الوظيفة التي تؤديها.

# سيء 
def calc(x, y):
  return x + y    


# جيد 
def calculateAverage(gradeOne, gradeTwo):
   return (gradeOne + gradeTwo) / 2

في المثال الأول، اسم الدالة calc غير واضح فيما يخص ما تقوم به. بينما في المثال الثاني، اسم الدالة calculateAverage يعبر بدقة عن العملية التي تقوم بها الدالة.

طريقة تنظيم الكود وهيكلته

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

استخدام الفواصل والفراغات لتنظيم الكود

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

# تعريف المتغيرات
gradeOne = 85
gradeTwo = 90


# دالة لحساب المتوسط 
def calculateAverage(gradeOne, gradeTwo):
     return (gradeOne + gradeTwo) / 2


# حساب المتوسط وطباعة النتيجة 
average = calculateAverage (gradeOne ,gradeTwo) 
print(average)

تقسيم الكود إلى وحدات ووظائف صغيرة

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

نلاحظ الكود التالي، المنظم والمهيكل لحل المشكلة البرمجية السابقة، والذي يتضمن الدوال الأساسية المطلوبة لتنفيذ الحل

grades = [85, 90, 78, 92, 88]

# تعريف دالة لحساب المتوسط
def calculateAverage(grades):
     return sum(grades) / len(grades)

# تعريف دالة لتحديد أعلى وأقل درجة 
def findHighestAndLowest(grades):
    highest = max(grades)
    lowest = min(grades)
    return highest, lowest
    
# تعريف دالة لحساب عدد الطلاب الذين حصلوا على درجات أعلى من المتوسط 
def countAboveAverage(grades,average):
    count = sum(1 for grade in grades if grade > average)
    return count
    
# الوظيفة الرئيسية التي تنظم تنفيذ الخطوات
def main():
	grades = [85, 90, 78, 92, 88]
    # التحقق من إذا كانت القائمة فارغة  
	if not grades:
    	  print("القائمة فارغة. لا يمكن إجراء الحسابات.")
    	  return # إنهاء التنفيذ إذا كانت القائمة فارغة
    
# حساب متوسط الدرجات 
average = calculateAverage(grades)
print(f"متوسط الدرجات: {average:.2f}")

# تحديد أعلى وأقل درجة 
highest, lowest = findHighestAndLowest(grades)
print(f"أعلى درجة: {highest}")
print(f"أقل درجة: {lowest}")

# حساب عدد الطلاب الذين حصلوا على درجات أعلى من المتوسط
aboveAverageCount = countAboveAverage(grades,average)
print(f"عدد الطلاب الذين حصلوا على درجات أعلى من المتوسط: {aboveAverageCount}")

# استدعاء الوظيفة الرئيسية 
if __name__ == "__main__":
    main()

استخدام التوثيق والتعليقات لشرح الأكواد

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

حالة التوثيق المفرط

يكون التوثيق مفرطًا إذا كان يشرح كل سطر برمجي دون الحاجة لكل ذلك، مما يشتت القارئ ويجعل الكود يبدو مزدحما، مثل:

# قائمة تحتوي على درجات الطلاب 
# هذه القائمة تمثل درجات الطلاب في مادة معينة، وهي عبارة عن أرقام صحيحة 
grades = [85, 90, 78, 92, 88]

# حساب متوسط الدرجات 
# يتم استخدام الدالة المدمجة sum لحساب مجموع الدرجات في القائمة 
# ثم يتم استخدام len لحساب عدد العناصر في القائمة 
average = sum(grades) / len(grades)

# طباعة المتوسط
# يتم طباعة متوسط الدرجات باستخدام دالة  print 
# يتم تضمين المتوسط داخل سلسلة نصية باستخدام f-string
print(f"The average grade is: {average}")

حالة انعدام التوثيق رغم الحاجة له

يكون الكود هنا غير واضح، وبدون إرشادات مساعدة على فهمه في التعليقات، بحيث يترك القارئ في حيرة بشأن الغرض أو المنطق العام للكود، مثل:

grades = [85, 90, 78, 92, 88]
average = sum(grades) / len(grades)
print(f"The average grade is: {average}")

حالة التوثيق الفعال

يكون التوثيق فعال عندما يكون متوازن ويحوي توضيحات حسب الحاجة فقط ضمن الكود دون مبالغة، مثل:

# قائمة تحتوي على درجات الطلاب 
grades = [85, 90, 78, 92, 88]

# حساب متوسط الدرجات 
average = sum(grades) / len(grades)

# طباعة المتوسط 
print(f"The average grade is: {average}")

اختبار الكود البرمجي وتصحيحه

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

اختبار الوظائف الفردية: بحيث يتم اختبار كل دالة على حدة باستخدام بيانات إدخال مختلفة للتحقق من صحة النتائج
اختبار التكامل: يتم التحقق من كيفية تفاعل الدوال أو الوحدات البرمجية مع بعضها البعض

دعنا نأخذ مثالًا عن كيفية اختبار دوال الكود البرمجي السابق:

def testCalculateAverage():
    grades = [85, 90, 78, 92, 88]
    expectedAverage = 86.6
    assert abs(calculateAverage(grades) - expectedAverage) < 0.01, "خطأ في دالة حساب المتوسط"


def testCountAboveAverage():
    grades = [85, 90, 78, 92, 88]
    average = 86.6
    expectedCount = 3
    assert countAboveAverage(grades, average) == expectedCount, "خطأ في حساب عدد الطلاب فوق المتوسط"


def runTests():
    # تشغيل اختبارات الكود 
    testCalculateAverage()
    testCountAboveAverage()
    print("جميع الاختبارات ناجحة!")


if __name__ == "__main__":
    runTests()

ملاحظة: يمكن استخدام الأسلوب اليدوي في الاختبار لكن في التطبيقات الاحترافية تستخدم أطر عمل مخصصة للاختبارات يمكن الاعتماد عليها.

استخدام الحزم البرمجية والمكتبات الجاهزة

يستخدم مهندس البرمجيات المحترف المكتبات الجاهزة والدوال المدمجة لتبسيط العمليات وتقليل عدد الأسطر المطلوبة في الكود البرمجي, بحيث تتميز كل لغة برمجة بالعديد من المكتبات والحزم التي تتناسب مع المشكلة البرمجية. لنأخذ على سبيل المثال استخدام مكتبة statistics في بايثون لحساب المتوسط واستخدام الدوال المدمجة مثل max وmin لتحديد أعلى وأقل درجة.

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

الكود الأول:

grades = [85, 90, 78, 92, 88]

# تعريف دالة لحساب المتوسط
def calculateAverage(grades):
    return sum(grades) / len(grades)

# تعريف دالة لتحديد أعلى وأقل درجة
def findHighestAndLowest(grades):
    highest = max(grades)
    lowest = min(grades)
    return highest, lowest

# تعريف دالة لحساب عدد الطلاب الذين حصلوا على درجات أعلى من المتوسط
def countAboveAverage(grades,average):
    count = sum(1 for grade in grades if grade > average)
    return count
    
# الوظيفة الرئيسية التي تنظم تنفيذ الخطوات
def main():
    grades = [85, 90, 78, 92, 88]
    if not grades:
          print("القائمة فارغة. لا يمكن إجراء الحسابات.")
          return # إنهاء التنفيذ إذا كانت القائمة فارغة

# حساب متوسط الدرجات 
average = calculateAverage(grades)
print(f"متوسط الدرجات: {average:.2f}")

# تحديد أعلى وأقل درجة 
highest, lowest = findHighestAndLowest(grades)
print(f"أعلى درجة: {highest}")
print(f"أقل درجة: {lowest}")

# حساب عدد الطلاب الذين حصلوا على درجات أعلى من المتوسط 
aboveAverageCount = countAboveAverage(grades,average)
print(f"عدد الطلاب الذين حصلوا على درجات أعلى من المتوسط: {aboveAverageCount}")

# استدعاء الوظيفة الرئيسية  
if __name__ == "__main__":
    main()

الكود الثاني:

import statistics

def main():
    #  قائمة درجات الطلاب
    grades = [85, 90, 78, 92, 88]
    # حساب متوسط الدرجات باستخدام مكتبة statistics
    average = statistics.mean(grades)
    print(f"متوسط الدرجات: {average:.2f}")
    # تحديد أعلى وأقل درجة باستخدام max و min
    highest = max(grades)
    lowest = min(grades)
    print(f"أعلى درجة: {highest}")
    print(f"أقل درجة: {lowest}")
    # حساب عدد الطلاب الذين حصلوا على درجات أعلى من المتوسط
    aboveAverageCount = sum(1 for grade in grades if grade > average)
    print(f"عدد الطلاب الذين حصلوا على درجات أعلى من المتوسط: {aboveAverageCount}")

# استدعاء الوظيفة الرئيسية
if __name__ == "__main__":
   main()

الفرق بين الكود البرمجي الاحترافي لمهندسي البرمجيات والكود العادي

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

عدم وجود الأكواد الميتة: وهي الأجزاء الغير مستخدمة في البرنامج، لأنها تضيف تعقيدا غير ضروري فالكود الخاص بمهندس، البرمجيات المحترف يكون خاليا منها، في المثال التالي بعض التعليمات البرمجية التي لا تحتاجها الدالة calculateAverage لحساب المتوسط الحسابي:

def calculateAverage(grades):
    total = sum(grades)
    aboveAverageCount = countAboveAverage(grades,average)  #تعليمة برمجية ميتة
    average = 86.6 # تعليمة برمجية ميتة
    unused_variable = "This is not used"  # تعليمة برمجية ميتة
    average = total / len(grades)
    return average

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

تقليل التعقيد Cyclomatic Complexity: يتميز كود مهندس البرمجيات المحترف بتقليل تعقيد الكود، مما يجعله أكثر قابلية للفهم والصيانة. يجب أن تكون الدوال قصيرة وبسيطة، بحيث لا تحتوي على الكثير من الشروط أو العمليات المعقدة.
التعامل مع البيانات بشكل أكثر فعالية: قد يقوم الكود بمعالجة البيانات بطريقة غير فعالة، مثل التكرار في التعامل مع القوائم أو استخدام العمليات البطيئة. نلاحظ المثال التالي:

# الكود العادي
def countAboveAverage(grades, average):
    count = 0
    for grade in grades:
        if grade > average:
            count += 1
            return count


# الكود الاحترافي 
def countAboveAverage(grades, average):
    return sum(1 for grade in grades if grade > average)

التفكير في قابلية التوسع: يتميز كود مهندس البرمجيات المحترف من القابلية للتوسع والتعديل في المستقبل، مما يضمن أن الكود يمكن تطويره بسهولة عند الحاجة إلى إضافة ميزات جديدة على سبيل المثال:

# الكود العادي
def calculateSum(grades):
   return sum(grades)

# الكود الاحترافي (قابل للتوسع)
def calculate(grades, operation):
    if operation == 'sum':
        return sum(grades)
    elif operation == 'average':
        return sum(grades) / len(grades)
    else:
        raise ValueError("Operation not supported")

الخاتمة

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