کیوں گو ڈیزائن اسمارٹ پروگرامرز کے لیے برا ہے۔

پچھلے مہینوں میں میں گو کو نفاذ کے لیے استعمال کر رہا ہوں۔ تصور کا ثبوت (تقریبا.: کوڈ ایک خیال کی فعالیت کو جانچنے کے لیے) اپنے فارغ وقت میں، جزوی طور پر خود پروگرامنگ زبان کا مطالعہ کرنے کے لیے۔ پروگرام خود بہت آسان ہیں اور اس مضمون کا مقصد نہیں ہے، لیکن خود گو کو استعمال کرنے کا تجربہ اس کے بارے میں چند الفاظ کا مستحق ہے۔ جانے کا وعدہ کرتے ہیں (تقریبا.: 2015 میں لکھا گیا مضمون) سنجیدہ توسیع پذیر کوڈ کے لیے ایک مقبول زبان۔ یہ زبان گوگل نے بنائی تھی، جہاں اسے فعال طور پر استعمال کیا جاتا ہے۔ نیچے کی سطر، میں ایمانداری سے سوچتا ہوں کہ گو زبان کا ڈیزائن سمارٹ پروگرامرز کے لیے برا ہے۔

کمزور پروگرامرز کے لیے ڈیزائن کیا گیا؟

گو سیکھنا بہت آسان ہے، اتنا آسان کہ تعارف مجھے ایک شام لے گیا، جس کے بعد میں پہلے ہی نتیجہ خیز کوڈ کر سکتا تھا۔ میں جس کتاب کو گو سیکھتا تھا اسے کہتے ہیں۔ گو میں پروگرامنگ کا تعارف (ترجمہ)، یہ آن لائن دستیاب ہے۔ کتاب، گو سورس کوڈ کی طرح، پڑھنا آسان ہے، کوڈ کی اچھی مثالیں ہیں، اور اس میں تقریباً 150 صفحات ہیں جنہیں ایک ہی بار پڑھا جا سکتا ہے۔ یہ سادگی پہلے تو تازگی بخشتی ہے، خاص طور پر ایک پروگرامنگ کی دنیا میں جو زیادہ پیچیدہ ٹیکنالوجی سے بھری ہوئی ہے۔ لیکن آخر میں، جلد یا بدیر یہ خیال پیدا ہوتا ہے: "کیا واقعی ایسا ہے؟"

گوگل کا دعویٰ ہے کہ گو کی سادگی اس کا سیلنگ پوائنٹ ہے اور زبان کو بڑی ٹیموں میں زیادہ سے زیادہ پیداواری صلاحیت کے لیے ڈیزائن کیا گیا ہے، لیکن مجھے اس پر شک ہے۔ ایسی خصوصیات ہیں جو یا تو غائب ہیں یا حد سے زیادہ تفصیلی ہیں۔ اور یہ سب کچھ ڈویلپرز میں اعتماد کی کمی کی وجہ سے، اس مفروضے کے ساتھ کہ وہ کچھ بھی درست کرنے کے قابل نہیں ہیں۔ سادگی کی یہ خواہش زبان کے ڈیزائنرز کا ایک شعوری فیصلہ تھا، اور پوری طرح سے یہ سمجھنے کے لیے کہ اس کی ضرورت کیوں تھی، ہمیں ڈویلپرز کی حوصلہ افزائی کو سمجھنا چاہیے اور وہ Go میں کیا حاصل کرنے کی کوشش کر رہے تھے۔

تو اسے اتنا سادہ کیوں بنایا گیا؟ یہاں چند اقتباسات ہیں۔ روب پائیک (تقریبا.: گو زبان کے شریک مصنفین میں سے ایک):

یہاں اہم بات یہ ہے کہ ہمارے پروگرامرز (تقریبا.: گوگلرز) محققین نہیں ہیں۔ وہ، ایک اصول کے طور پر، کافی نوجوان ہیں، تعلیم حاصل کرنے کے بعد ہمارے پاس آتے ہیں، شاید انہوں نے جاوا، یا C/C++، یا ازگر کا مطالعہ کیا ہو۔ وہ اچھی زبان نہیں سمجھ سکتے، لیکن ساتھ ہی ہم چاہتے ہیں کہ وہ اچھا سافٹ ویئر بنائیں۔ اس لیے ان کی زبان ان کے سمجھنے اور سیکھنے میں آسان ہونی چاہیے۔
 
اسے واقف ہونا چاہئے، تقریباً سی کی طرح بولنا۔ گوگل میں کام کرنے والے پروگرامرز اپنے کیریئر کا آغاز جلد کرتے ہیں اور زیادہ تر طریقہ کار کی زبانوں سے واقف ہوتے ہیں، خاص طور پر سی فیملی۔ نئی پروگرامنگ لینگویج میں فوری پیداواری صلاحیت کی ضرورت کا مطلب یہ ہے کہ زبان زیادہ بنیاد پرست نہیں ہونی چاہیے۔

کیا؟ تو روب پائیک بنیادی طور پر کہہ رہا ہے کہ گوگل کے ڈویلپرز اتنے اچھے نہیں ہیں، اسی لیے انہوں نے بیوقوفوں کے لیے ایک زبان بنائی (تقریبا.: dumbed down) تاکہ وہ کچھ کر سکیں۔ اپنے ہی ساتھیوں پر کیسی مغرور نظر؟ میں نے ہمیشہ یقین کیا ہے کہ گوگل کے ڈویلپرز زمین پر سب سے روشن اور بہترین لوگوں میں سے منتخب کیے گئے ہیں۔ یقینا وہ کچھ زیادہ مشکل کو سنبھال سکتے ہیں؟

ضرورت سے زیادہ سادگی کے نمونے۔

سادہ ہونا کسی بھی ڈیزائن میں ایک قابل مقصد ہے، اور کچھ آسان بنانے کی کوشش کرنا مشکل ہے۔ تاہم، جب پیچیدہ مسائل کو حل کرنے کی کوشش کرتے ہیں (یا اظہار بھی) کرتے ہیں، بعض اوقات ایک پیچیدہ ٹول کی ضرورت ہوتی ہے۔ پیچیدگی اور پیچیدگی کسی پروگرامنگ زبان کی بہترین خصوصیات نہیں ہیں، لیکن ایک درمیانی زمین ہے جس میں زبان خوبصورت تجریدات تخلیق کر سکتی ہے جو سمجھنے اور استعمال کرنے میں آسان ہیں۔

بہت اظہار خیال نہیں ہے۔

سادگی سے وابستگی کی وجہ سے، گو میں ایسی تعمیرات کا فقدان ہے جو دوسری زبانوں میں قدرتی سمجھی جاتی ہیں۔ یہ شروع میں ایک اچھا خیال لگتا ہے، لیکن عملی طور پر اس کا نتیجہ لفظی کوڈ میں ہوتا ہے۔ اس کی وجہ واضح ہونی چاہیے - ڈویلپرز کے لیے دوسرے لوگوں کے کوڈ کو پڑھنا آسان ہونا چاہیے، لیکن درحقیقت یہ آسانیاں صرف پڑھنے کی اہلیت کو نقصان پہنچاتی ہیں۔ گو میں کوئی مخفف نہیں ہے: یا تو بہت کچھ یا کچھ بھی نہیں۔

مثال کے طور پر، ایک کنسول یوٹیلیٹی جو stdin پڑھتی ہے یا کمانڈ لائن آرگومینٹس سے فائل اس طرح نظر آئے گی:

package main

import (
    "bufio"
    "flag"
    "fmt"
    "log"
    "os"
)

func main() {

    flag.Parse()
    flags := flag.Args()

    var text string
    var scanner *bufio.Scanner
    var err error

    if len(flags) > 0 {

        file, err := os.Open(flags[0])

        if err != nil {
            log.Fatal(err)
        }

        scanner = bufio.NewScanner(file)

    } else {
        scanner = bufio.NewScanner(os.Stdin)
    }

    for scanner.Scan() {
        text += scanner.Text()
    }

    err = scanner.Err()
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(text)
}

اگرچہ یہ کوڈ ہر ممکن حد تک عام ہونے کی کوشش کرتا ہے، گو کی زبردستی زبانی رکاوٹ بن جاتی ہے، اور اس کے نتیجے میں، ایک سادہ مسئلے کو حل کرنے کے نتیجے میں کوڈ کی ایک بڑی مقدار ہوتی ہے۔

یہاں، مثال کے طور پر، میں اسی مسئلے کا حل ہے۔ D:

import std.stdio, std.array, std.conv;

void main(string[] args)
{
    try
    {
        auto source = args.length > 1 ? File(args[1], "r") : stdin;
        auto text   = source.byLine.join.to!(string);

        writeln(text);
    }
    catch (Exception ex)
    {
        writeln(ex.msg);
    }
}

اور اب کون زیادہ پڑھنے والا ہے؟ میں اپنا ووٹ ڈی کو دوں گا۔ اس کا کوڈ زیادہ پڑھنے کے قابل ہے کیونکہ وہ اعمال کو زیادہ واضح طور پر بیان کرتا ہے۔ D بہت زیادہ پیچیدہ تصورات استعمال کرتا ہے (تقریبا.: متبادل فنکشن کال и پیٹرن) گو مثال کے مقابلے میں، لیکن ان کو سمجھنے میں واقعی کچھ بھی پیچیدہ نہیں ہے۔

نقل کرنے کا جہنم

Go کو بہتر بنانے کے لیے ایک مقبول تجویز عمومیت ہے۔ اس سے کم از کم تمام ڈیٹا کی اقسام کو سپورٹ کرنے کے لیے کوڈ کی غیر ضروری کاپی کرنے سے بچنے میں مدد ملے گی۔ مثال کے طور پر، انٹیجرز کی فہرست کو جمع کرنے کے لیے ایک فنکشن کو ہر ایک عدد کی قسم کے لیے اس کے بنیادی فنکشن کو کاپی پیسٹ کرنے کے علاوہ کسی اور طریقے سے لاگو نہیں کیا جا سکتا؛ اس کے علاوہ کوئی اور طریقہ نہیں ہے:

package main

import "fmt"

func int64Sum(list []int64) (uint64) {
    var result int64 = 0
    for x := 0; x < len(list); x++ {
        result += list[x]
    }
    return uint64(result)
}

func int32Sum(list []int32) (uint64) {
    var result int32 = 0
    for x := 0; x < len(list); x++ {
        result += list[x]
    }
    return uint64(result)
}

func int16Sum(list []int16) (uint64) {
    var result int16 = 0
    for x := 0; x < len(list); x++ {
        result += list[x]
    }
    return uint64(result)
}

func int8Sum(list []int8) (uint64) {
    var result int8 = 0
    for x := 0; x < len(list); x++ {
        result += list[x]
    }
    return uint64(result)
}

func main() {

    list8  := []int8 {1, 2, 3, 4, 5}
    list16 := []int16{1, 2, 3, 4, 5}
    list32 := []int32{1, 2, 3, 4, 5}
    list64 := []int64{1, 2, 3, 4, 5}

    fmt.Println(int8Sum(list8))
    fmt.Println(int16Sum(list16))
    fmt.Println(int32Sum(list32))
    fmt.Println(int64Sum(list64))
}

اور یہ مثال دستخط شدہ اقسام کے لیے بھی کام نہیں کرتی۔ یہ نقطہ نظر اپنے آپ کو نہ دہرانے کے اصول کی مکمل خلاف ورزی کرتا ہے (خشک)، سب سے مشہور اور واضح اصولوں میں سے ایک، جس کو نظر انداز کرنا بہت سی غلطیوں کا ذریعہ ہے۔ گو ایسا کیوں کرتا ہے؟ یہ زبان کا ایک خوفناک پہلو ہے۔

ڈی پر ایک ہی مثال:

import std.stdio;
import std.algorithm;

void main(string[] args)
{
    [1, 2, 3, 4, 5].reduce!((a, b) => a + b).writeln;
}

سادہ، خوبصورت اور سیدھے نقطہ پر۔ یہاں استعمال ہونے والا فنکشن ہے۔ reduce ٹیمپلیٹ کی قسم اور پیش گوئی کے لیے۔ ہاں، یہ پھر سے گو ورژن سے زیادہ پیچیدہ ہے، لیکن سمارٹ پروگرامرز کے لیے سمجھنا اتنا مشکل نہیں۔ کونسی مثال برقرار رکھنا آسان اور پڑھنا آسان ہے؟

سادہ قسم کا نظام بائی پاس

میں تصور کرتا ہوں کہ گو پروگرامرز اسے پڑھ رہے ہوں گے اور منہ سے جھاگ آ رہے ہوں گے اور چیخ رہے ہوں گے، "تم غلط کر رہے ہو!" ٹھیک ہے، عام فنکشن اور اقسام بنانے کا ایک اور طریقہ ہے، لیکن یہ ٹائپ سسٹم کو مکمل طور پر توڑ دیتا ہے!

اس مسئلے کو حل کرنے کے لیے ایک احمقانہ زبان کے حل کی اس مثال پر ایک نظر ڈالیں:

package main

import "fmt"
import "reflect"

func Reduce(in interface{}, memo interface{}, fn func(interface{}, interface{}) interface{}) interface{} {
    val := reflect.ValueOf(in)

    for i := 0; i < val.Len(); i++ {
        memo = fn(val.Index(i).Interface(), memo)
    }

    return memo
}

func main() {

    list := []int{1, 2, 3, 4, 5}

    result := Reduce(list, 0, func(val interface{}, memo interface{}) interface{} {
        return memo.(int) + val.(int)
    })

    fmt.Println(result)
}

یہ نفاذ Reduce مضمون سے مستعار لیا گیا تھا۔ گو میں محاوراتی عمومیات (تقریبا.: مجھے ترجمہ نہیں مل سکا، اگر آپ اس میں مدد کریں تو مجھے خوشی ہوگی)۔ ٹھیک ہے، اگر یہ محاورہ ہے، تو مجھے غیر محاوراتی مثال دیکھنے سے نفرت ہوگی۔ استعمال interface{} - ایک طنز، اور زبان میں اسے صرف ٹائپنگ کو نظرانداز کرنے کی ضرورت ہے۔ یہ ایک خالی انٹرفیس ہے اور تمام قسمیں اسے نافذ کرتی ہیں، جس سے ہر ایک کو مکمل آزادی ملتی ہے۔ پروگرامنگ کا یہ انداز انتہائی بدصورت ہے، اور بس اتنا ہی نہیں ہے۔ اس طرح کے ایکروبیٹک فیٹس میں رن ٹائم عکاسی کے استعمال کی ضرورت ہوتی ہے۔ یہاں تک کہ روب پائیک بھی ایسے افراد کو پسند نہیں کرتا جو اس کا غلط استعمال کرتے ہیں، جیسا کہ اس نے اپنی ایک رپورٹ میں ذکر کیا ہے۔

یہ ایک طاقتور ٹول ہے جسے احتیاط کے ساتھ استعمال کیا جانا چاہیے۔ جب تک سختی سے ضروری نہ ہو اس سے گریز کرنا چاہیے۔

میں اس بکواس کی بجائے ڈی ٹیمپلیٹس لوں گا۔ ایسا کوئی کیسے کہہ سکتا ہے۔ interface{} زیادہ پڑھنے کے قابل یا یہاں تک کہ محفوظ ٹائپ؟

انحصار کے انتظام کی پریشانیاں

گو میں ایک بلٹ ان انحصاری نظام ہے جو مقبول ہوسٹنگ فراہم کنندگان کے اوپر بنایا گیا ہے۔ وی سی ایس۔. گو کے ساتھ آنے والے ٹولز ان سروسز کے بارے میں جانتے ہیں اور ان سے کوڈ ڈاؤن لوڈ، بنا اور انسٹال کر سکتے ہیں۔ اگرچہ یہ بہت اچھا ہے، ورژن بنانے میں ایک بڑی خامی ہے! ہاں، یہ سچ ہے کہ آپ گو ٹولز کا استعمال کرتے ہوئے گیتھب یا بٹ بکٹ جیسی سروسز سے سورس کوڈ حاصل کر سکتے ہیں، لیکن آپ ورژن کی وضاحت نہیں کر سکتے۔ اور افادیت کی قیمت پر ایک بار پھر سادگی۔ میں ایسے فیصلے کی منطق کو سمجھنے سے قاصر ہوں۔

اس مسئلے کے حل کے بارے میں سوالات پوچھنے کے بعد، گو ڈویلپمنٹ ٹیم بنائی فورم تھریڈ، جس نے بتایا کہ وہ اس مسئلے کو کیسے حل کریں گے۔ ان کی سفارش یہ تھی کہ ایک دن پورے ذخیرہ کو اپنے پروجیکٹ میں کاپی کریں اور اسے "جیسا ہے" چھوڑ دیں۔ یہ کیا سوچ رہے ہیں؟ ہمارے پاس زبردست ٹیگنگ اور ورژن سپورٹ کے ساتھ حیرت انگیز ورژن کنٹرول سسٹم ہے جسے گو تخلیق کار نظر انداز کرتے ہیں اور صرف سورس کوڈ کاپی کرتے ہیں۔

الیون سے ثقافتی سامان

میری رائے میں، گو کو ان لوگوں نے تیار کیا تھا جنہوں نے ساری زندگی C کا استعمال کیا تھا اور ان لوگوں نے جو کچھ نیا کرنے کی کوشش نہیں کرنا چاہتے تھے۔ زبان کو اضافی پہیوں کے ساتھ C کے طور پر بیان کیا جا سکتا ہے۔اصل: تربیتی پہیے)۔ اس میں کوئی نئے خیالات نہیں ہیں، سوائے اس کے متوازی کی حمایت کے (جو، ویسے، شاندار ہے) اور یہ شرم کی بات ہے۔ آپ کے پاس بمشکل قابل استعمال، لنگڑی زبان میں بہترین ہم آہنگی ہے۔

ایک اور کریکنگ مسئلہ یہ ہے کہ گو ایک طریقہ کار کی زبان ہے (جیسے سی کی خاموش ہارر)۔ آپ ایک طریقہ کار کے انداز میں کوڈ لکھتے ہیں جو قدیم اور پرانا محسوس ہوتا ہے۔ میں جانتا ہوں کہ آبجیکٹ اورینٹڈ پروگرامنگ سلور بلٹ نہیں ہے، لیکن تفصیلات کو اقسام میں خلاصہ کرنے اور انکیپسولیشن فراہم کرنے کے قابل ہونا بہت اچھا ہوگا۔

اپنے فائدے کے لیے سادگی

Go کو سادہ بنانے کے لیے ڈیزائن کیا گیا تھا اور یہ اس مقصد میں کامیاب ہوتا ہے۔ یہ کمزور پروگرامرز کے لیے لکھا گیا تھا، ایک پرانی زبان کو بطور ٹیمپلیٹ استعمال کرتے ہوئے۔ یہ سادہ چیزیں کرنے کے لیے آسان ٹولز کے ساتھ مکمل آتا ہے۔ یہ پڑھنے میں آسان اور استعمال میں آسان ہے۔

یہ سمارٹ پروگرامرز کے لیے انتہائی لفظی، غیر متاثر کن اور برا ہے۔

شکریہ mersinvald ترامیم کے لیے

ماخذ: www.habr.com