ڇو گو ڊيزائن سمارٽ پروگرامرز لاءِ خراب آهي

گذريل مهينن کان آئون استعمال ڪري رهيو آهيان Go استعمال ڪرڻ لاءِ. تصور جو ثبوت (لڳ ڀڳ: ڪوڊ هڪ خيال جي ڪارڪردگي کي جانچڻ لاء) هن جي مفت وقت ۾، جزوي طور تي پروگرامنگ ٻولي جو مطالعو ڪرڻ لاء. پروگرام پاڻ ڏاڍا سادا آهن ۽ هن مضمون جو مقصد نه آهن، پر Go استعمال ڪرڻ جو تجربو پاڻ ان بابت ڪجهه لفظن جو مستحق آهي. وڃڻ جو واعدو ڪيو (لڳ ڀڳ: آرٽيڪل 2015 ۾ لکيل) سنگين اسڪيلبل ڪوڊ لاءِ مشهور ٻولي. ٻولي گوگل طرفان ٺاهي وئي، جتي اهو فعال طور تي استعمال ڪيو ويو آهي. هيٺئين لڪير، مان ايمانداري سان سمجهان ٿو ته گو ٻولي جو ڊزائين سمارٽ پروگرامرز لاءِ خراب آهي.

ڪمزور پروگرامرز لاء ٺهيل؟

وڃ سکڻ تمام آسان آهي، ايترو آسان ته تعارف مون کي هڪ شام وٺي ويو، جنهن کان پوءِ مان اڳ ۾ ئي پيداواري طريقي سان ڪوڊ ڪري سگهان ٿو. جنهن ڪتاب کي مان سکندو هوس Go سڏيو ويندو آهي Go ۾ پروگرامنگ جو هڪ تعارف (ترجمو)، اهو آن لائن دستياب آهي. ڪتاب، جيئن گو سورس ڪوڊ پاڻ، پڙهڻ ۾ آسان آهي، سٺن ڪوڊ جا مثال آهن، ۽ اٽڪل 150 صفحن تي مشتمل آهي، جيڪي هڪ ويٺي ۾ پڙهي سگهجن ٿا. اها سادگي پهرين تي تازگي آهي، خاص طور تي هڪ پروگرامنگ دنيا ۾، جيڪو وڌيڪ پيچيده ٽيڪنالاجي سان ڀريل آهي. پر آخر ۾، جلدي يا بعد ۾ اهو خيال پيدا ٿئي ٿو: "ڇا اهو واقعي ائين آهي؟"

گوگل دعويٰ ڪري ٿو گو جي سادگي ان جو وڪرو نقطو آهي ۽ ٻولي وڏي ٽيمن ۾ وڌ کان وڌ پيداوار لاءِ ٺهيل آهي، پر مون کي شڪ آهي. اهڙا خاصيتون آهن جيڪي يا ته غائب آهن يا گهڻو تفصيلي. ۽ اهو سڀ ڪجهه ڊولپرز ۾ اعتماد جي کوٽ جي ڪري، انهي فرض سان ته اهي ڪجهه به صحيح ڪرڻ جي قابل نه آهن. سادگي جي اها خواهش ٻوليءَ جي ڊيزائنرز طرفان هڪ شعوري فيصلو هو، ۽ مڪمل طور تي سمجهڻ لاءِ ته ان جي ضرورت ڇو هئي، اسان کي لازمي طور سمجهڻ گهرجي ته ڊولپرز جي حوصلي ۽ جيڪي هو حاصل ڪرڻ جي ڪوشش ڪري رهيا هئا.

پوءِ ان کي ايترو سادو ڇو بڻايو ويو؟ هتي ڪجهه حوالا آهن روب پائيڪ (لڳ ڀڳ: گو ٻولي جي گڏيل تخليق ڪندڙن مان هڪ):

هتي اهم نقطو اهو آهي ته اسان جا پروگرامر (لڳ ڀڳ: گوگلرز) محقق نه آهن. اهي آهن، ضابطي جي طور تي، ڪافي نوجوان، پڙهڻ کان پوءِ اسان وٽ ايندا آهن، شايد انهن جاوا، يا C/C++، يا پٿون جو اڀياس ڪيو هجي. اهي هڪ بهترين ٻولي سمجهي نٿا سگهن، پر ساڳئي وقت اسان چاهيون ٿا ته اهي سٺو سافٽ ويئر ٺاهي. ان ڪري انهن جي ٻولي سمجهڻ ۽ سکڻ لاءِ آسان هئڻ گهرجي.
 
هن کي واقف هجڻ گهرجي، تقريبن C سان ملندڙ جلندڙ ڳالهائڻ. گوگل تي ڪم ڪندڙ پروگرامر پنهنجو ڪيريئر جلد شروع ڪندا آهن ۽ گهڻو ڪري پروسيجرل ٻولين سان واقف هوندا آهن، خاص طور تي C خاندان. نئين پروگرامنگ ٻولي ۾ جلدي پيداوار جي گهرج جو مطلب آهي ته ٻولي تمام بنيادي نه هجڻ گهرجي.

ڇا؟ تنهن ڪري Rob Pike بنيادي طور تي چئي رهيو آهي ته گوگل تي ڊولپرز ايترا سٺا نه آهن، ان ڪري انهن بيوقوفن لاءِ ٻولي ٺاهي آهي (لڳ ڀڳ: dumbed down) ته جيئن اهي ڪجهه ڪري سگهن. توهان جي پنهنجي ساٿين تي ڪهڙي قسم جي وڏائي نظر اچي ٿي؟ مون هميشه يقين ڪيو آهي ته گوگل جا ڊولپرز ڌرتيءَ تي روشن ۽ بهترين مان هٿ ڪيا ويا آهن. يقينن اهي ڪجهه وڌيڪ مشڪل سان هٿ ڪري سگهن ٿا؟

زياده سادگيءَ جا آثار

سادو هجڻ ڪنهن به ڊزائن ۾ هڪ قابل مقصد آهي، ۽ ڪجهه سادو ٺاهڻ جي ڪوشش ڪرڻ ڏکيو آهي. تنهن هوندي، جڏهن حل ڪرڻ جي ڪوشش ڪري ٿي (يا اڃا به ظاهر) پيچيده مسئلا، ڪڏهن ڪڏهن هڪ پيچيده اوزار جي ضرورت هوندي آهي. پيچيدگي ۽ پيچيدگي هڪ پروگرامنگ ٻولي جي بهترين خوبيون نه آهن، پر هڪ وچولي ميدان آهي جنهن ۾ ٻولي خوبصورت تجريد پيدا ڪري سگهي ٿي جيڪي سمجهڻ ۽ استعمال ڪرڻ ۾ آسان آهن.

تمام گهڻو اظهار ڪندڙ ناهي

سادگي جي وابستگي جي ڪري، گو ۾ تعميرات جو فقدان آهي جيڪي ٻين ٻولين ۾ قدرتي سمجهيا وڃن ٿا. اهو لڳي سگھي ٿو ته پهرين ۾ سٺو خيال، پر عملي طور تي اهو لفظي ڪوڊ ۾ نتيجو آهي. هن جو سبب واضح هجڻ گهرجي - ڊولپرز لاءِ ٻين ماڻهن جي ڪوڊ پڙهڻ لاءِ آسان هجڻ ضروري آهي، پر حقيقت ۾ اهي آسانيون صرف پڙهڻ جي صلاحيت کي نقصان پهچائين ٿيون. Go ۾ ڪو به مخفف نه آهي: يا ته گهڻو يا ڪجھ به نه.

مثال طور، هڪ ڪنسول افاديت جيڪا پڙهي ٿي 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);
    }
}

۽ هاڻي ڪير وڌيڪ پڙهيل آهي؟ مان پنهنجو ووٽ ڊي کي ڏيندس. هن جو ڪوڊ تمام گهڻو پڙهڻ لائق آهي ڇاڪاڻ ته هو عملن کي وڌيڪ واضح طور تي بيان ڪري ٿو. ڊي استعمال ڪري ٿو وڌيڪ پيچيده تصورات (لڳ ڀڳ: متبادل فنڪشن ڪال и نمونن) گو مثال جي ڀيٽ ۾، پر حقيقت ۾ انھن کي سمجھڻ بابت ڪجھ به پيچيده نه آھي.

نقل ڪرڻ جو جهنڊو

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{} وڌيڪ پڙهڻ لائق يا ان کان به محفوظ ٽائپ؟

انحصار جي انتظام جي پريشاني

Go وٽ هڪ تعمير ٿيل انحصار وارو نظام آهي جيڪو مشهور هوسٽنگ فراهم ڪندڙن جي مٿان ٺهيل آهي VCS. اهي اوزار جيڪي Go سان ايندا آهن انهن خدمتن جي باري ۾ ڄاڻن ٿا ۽ انهن مان ڪوڊ ڊائون لوڊ، ٺاهي ۽ انسٽال ڪري سگهن ٿا هڪ ئي گري ۾. جڏهن ته هي عظيم آهي، نسخي سان گڏ هڪ وڏو نقص آهي! ها، اهو سچ آهي ته توهان حاصل ڪري سگهو ٿا ماخذ ڪوڊ خدمتن مان حاصل ڪري سگهو ٿا گيٿب يا بٽ بڪٽ وانگر Go اوزار استعمال ڪندي، پر توهان ورزن جي وضاحت نٿا ڪري سگهو. ۽ ٻيهر سادگي، فائدي جي قيمت تي. مان اهڙي فيصلي جي منطق کي سمجهي نه سگهيو آهيان.

هن مسئلي جي حل بابت سوال پڇڻ کان پوء، گو ڊولپمينٽ ٽيم ٺاهي وئي فورم جو سلسلو، جنهن بيان ڪيو ته اهي هن مسئلي جي چوڌاري ڪيئن حاصل ڪرڻ وارا هئا. انهن جي سفارش اها هئي ته صرف هڪ ڏينهن توهان جي پروجيڪٽ ۾ پوري مخزن کي نقل ڪريو ۽ ان کي ڇڏي ڏيو "جيئن آهي." هي ڇا سوچي رهيا آهن؟ اسان وٽ بهترين ٽيگنگ ۽ ورجن سپورٽ سان گڏ شاندار ورجن ڪنٽرول سسٽم آهي جنهن کي Go Creators نظر انداز ڪندا آهن ۽ صرف سورس ڪوڊ ڪاپي ڪندا آهن.

Xi کان ثقافتي سامان

منهنجي خيال ۾، گو انهن ماڻهن طرفان ترقي ڪئي وئي هئي جن پنهنجي سڄي زندگي سي استعمال ڪيو هو ۽ انهن طرفان جيڪي ڪجهه نئين ڪوشش ڪرڻ نٿا چاهين. ٻولي کي C طور بيان ڪري سگھجي ٿو اضافي ويلز سان (اصل: ٽريننگ ويلز). ان ۾ ڪي به نوان خيال نه آهن، سواءِ برابريءَ جي حمايت جي (جيڪو، طريقي سان، شاندار آهي) ۽ اها شرم جي ڳالهه آهي. توهان وٽ هڪ مشڪل استعمال لائق، لنگڙي ٻولي ۾ بهترين متوازي آهي.

هڪ ٻيو تخليقي مسئلو اهو آهي ته گو هڪ طريقيڪار ٻولي آهي (جهڙوڪ خاموش خوفناڪ سي جي). توھان ختم ڪريو ڪوڊ لکڻ واري طريقي سان انداز ۾ جيڪو پراڻي ۽ پراڻي محسوس ٿئي ٿو. مان ڄاڻان ٿو آبجیکٹ اورينٽيڊ پروگرامنگ ڪا سلور بلٽ نه آهي، پر اهو تمام سٺو هوندو ته تفصيلات کي قسمن ۾ خلاصي ڪرڻ ۽ انڪپسوليشن مهيا ڪرڻ جي قابل ٿي.

پنهنجي فائدي لاءِ سادگي

Go سادو ٿيڻ لاءِ ٺهيل هو ۽ اهو ان مقصد تي ڪامياب ٿيو. اهو ڪمزور پروگرامرز لاءِ لکيو ويو هو، هڪ پراڻي ٻولي کي ٽيمپليٽ طور استعمال ڪندي. اهو سادو ڪم ڪرڻ لاء سادي اوزار سان مڪمل اچي ٿو. اهو پڙهڻ لاء آسان ۽ استعمال ڪرڻ آسان آهي.

اهو سمارٽ پروگرامرز لاءِ انتهائي لفظي، غير متاثر ڪندڙ ۽ خراب آهي.

Спасибо mersinvald تبديلين لاءِ

جو ذريعو: www.habr.com