مضمون اڳ ۾ شايع ٿيل هڪ جواب جي طور تي لکيو ويو هو antipodean مضمون.

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

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

ڪمزور مسئلن بابت ڳالهائيندو آهي. خيالن ۽ خوابن بابت مضبوط ڳالهيون...

Go سکڻ تمام آسان آهي، ايترو آسان ته توهان ڪوڊ پڙهي سگهو ٿا عملي طور تي بغير ڪنهن تربيت سان. ٻولي جي اها خاصيت ڪيترن ئي عالمي ڪمپنين ۾ استعمال ڪئي ويندي آهي جڏهن ڪوڊ کي غير بنيادي ماهرن (مينيجر، گراهڪ، وغيره) سان گڏ پڙهيو ويندو آهي. اهو طريقو لاءِ تمام آسان آهي جهڙوڪ ڊيزائن ڊولپمينٽ ڊولپمينٽ.
جيتوڻيڪ نوان پروگرامر هڪ يا ٻن هفتن کان پوء ڪافي مهذب ڪوڊ پيدا ڪرڻ شروع ڪن ٿا. جنهن ڪتاب مان پڙهيو اٿم ”گو پروگرامنگ“ (مارڪ سمر فيلڊ پاران). ڪتاب تمام سٺو آهي، ان ۾ ٻوليءَ جي ڪيترن ئي نزاڪتن کي ڇهيو ويو آهي. غير ضروري پيچيده ٻولين جهڙوڪ جاوا، PHP کان پوء، جادو جي گهٽتائي تازگي آهي. پر جلدي يا بعد ۾، ڪيترن ئي محدود پروگرامرن کي نئين فيلڊ ۾ پراڻي طريقن کي استعمال ڪرڻ جو خيال آهي. ڇا اهو واقعي ضروري آهي؟

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

پوءِ ان کي ايترو سادو ڇو بڻايو ويو؟ هتي روب پائيڪ کان ڪجهه حوالا آهن:

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

هن کي واقف هجڻ گهرجي، تقريبن C سان ملندڙ جلندڙ ڳالهائڻ. گوگل تي ڪم ڪندڙ پروگرامر پنهنجو ڪيريئر جلد شروع ڪندا آهن ۽ گهڻو ڪري پروسيجرل ٻولين سان واقف هوندا آهن، خاص طور تي C خاندان. نئين پروگرامنگ ٻولي ۾ جلدي پيداوار جي گهرج جو مطلب آهي ته ٻولي تمام بنيادي نه هجڻ گهرجي.

حڪمت وارا لفظ، اهي نه آهن؟

سادگي جا آثار

سادگي حسن لاءِ لازمي شرط آهي. ليو ٽالسٽاءِ.

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

ڪيترائي مهاجر شڪايت ڪن ٿا ته ٻولي خوبصورت خلاصن تي مشتمل ناهي. ها، اهو سچ آهي، پر هي ٻولي جي مکيه فائدن مان هڪ آهي. ٻولي ۾ گھٽ ۾ گھٽ جادو آھي - تنھنڪري پروگرام کي پڙھڻ لاءِ ڪا بھترين ڄاڻ جي ضرورت ناھي. جيئن ته ڪوڊ جي فعليت لاء، اهو سڀ ڪجهه مسئلو ناهي. هڪ سٺو لکيل گولانگ پروگرام عمودي طور تي پڙهي ٿو، ٿوري يا بنا ڪنهن ساخت سان. ان کان علاوه، هڪ پروگرام پڙهڻ جي رفتار گهٽ ۾ گهٽ هڪ آرڊر جي شدت آهي ان کي لکڻ جي رفتار کان وڌيڪ. جيڪڏهن توهان غور ڪيو ته سڀني ڪوڊ ۾ يونيفارم فارميٽنگ آهي (بلٽ ان gofmt ڪمانڊ استعمال ڪندي)، پوءِ ڪجهه اضافي لائينون پڙهڻ ڪو مسئلو ناهي.

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

فن برداشت نه ڪندو آهي جڏهن ان جي آزادي کي محدود ڪيو وڃي. درستگي هن جي ذميواري نه آهي.

سادگي جي خواهش جي ڪري، گو ۾ تعميرات جو فقدان آهي ته ٻين ٻولين ۾ انهن جي عادي ماڻهن طرفان قدرتي شيء سمجهي ويندي آهي. پهرين ته اهو ڪجهه تڪليف ٿي سگهي ٿو، پر پوء توهان محسوس ڪيو ته پروگرام پڙهڻ لاء تمام آسان ۽ وڌيڪ غير واضح آهي.

مثال طور، هڪ ڪنسول افاديت جيڪا پڙهي ٿي stdin يا هڪ فائيل ڪمانڊ لائن دليلن مان هن طرح نظر ايندي:

package main

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

func main() {

    flag.Parse()

    scanner := newScanner(flag.Args())

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

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

    fmt.Println(text)
}

func newScanner(flags []string) *bufio.Scanner {
    if len(flags) == 0 {
        return bufio.NewScanner(os.Stdin)
    }

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

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

    return bufio.NewScanner(file)
}

ڊي ۾ ساڳئي مسئلي جو حل، جيتوڻيڪ اهو ڪجهه ننڍو ڏسڻ ۾ اچي ٿو، پڙهڻ لاء آسان ناهي

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);
    }
}

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

انسان پاڻ ۾ جهنم کڻي ٿو. مارٽن لوٿر.

شروع ڪندڙ مسلسل شڪايت ڪن ٿا گو بابت عام جي کوٽ جي لحاظ کان. ھن مسئلي کي حل ڪرڻ لاء، انھن مان گھڻا سڌو ڪوڊ ڪاپي استعمال ڪندا آھن. مثال طور، انگن اکرن جي فهرست کي اختصار ڪرڻ لاءِ هڪ فنڪشن، اهڙي قسم جا پيشه ور مڃيندا آهن ته ڪارڪردگيءَ کي ڪنهن ٻئي طريقي سان لاڳو نٿو ڪري سگهجي، سواءِ هر ڊيٽا جي قسم لاءِ سادي ڪاپي پيسٽ ڪرڻ جي.

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 main() {

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

    fmt.Println(int32Sum(list32))
    fmt.Println(int64Sum(list64))
}

اهڙين اڏاوتن کي عمل ۾ آڻڻ لاءِ ٻوليءَ وٽ ڪافي وسيلا آهن. مثال طور، عام پروگرامنگ ٺيڪ ٿي ويندو.

package main

import "fmt"

func Eval32(list []int32, fn func(a, b int32)int32) int32 {
    var res int32
    for _, val := range list {
        res = fn(res, val)
    }
    return res
}

func int32Add(a, b int32) int32 {
    return a + b
}

func int32Sub(a, b int32) int32 {
    return a + b
}

func Eval64(list []int64, fn func(a, b int64)int64) int64 {
    var res int64
    for _, val := range list {
        res = fn(res, val)
    }
    return res
}

func int64Add(a, b int64) int64 {
    return a + b
}

func int64Sub(a, b int64) int64 {
    return a - b
}

func main() {

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

    fmt.Println(Eval32(list32, int32Add))
    fmt.Println(Eval64(list64, int64Add))
    fmt.Println(Eval64(list64, int64Sub))
}

۽، جيتوڻيڪ اسان جو ڪوڊ اڳئين صورت کان ڪجهه ڊگهو ٿي ويو، اهو عام ٿي چڪو آهي. تنهن ڪري، اسان لاء تمام رياضياتي عملن کي لاڳو ڪرڻ ڏکيو نه ٿيندو.

گھڻا چوندا ته ڊي ۾ ھڪڙو پروگرام تمام ننڍو نظر اچي ٿو، ۽ اھي صحيح ھوندا.

import std.stdio;
import std.algorithm;

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

بهرحال، اهو صرف ننڍو آهي، پر وڌيڪ صحيح ناهي، ڇو ته ڊي عمل درآمد مڪمل طور تي غلطي جي سنڀال جي مسئلي کي نظر انداز ڪري ٿو.

حقيقي زندگيءَ ۾، جيئن منطق جي پيچيدگي وڌي ٿي، تيئن خال تيزيءَ سان گهٽجي ٿو. خال اڃا به وڌيڪ تيزي سان بند ٿي ويندو آهي جڏهن توهان کي هڪ عمل انجام ڏيڻ جي ضرورت آهي جيڪا معياري ٻولي آپريٽرز استعمال ڪندي نه ٿي ڪري سگهجي.

برقرار رکڻ، وسعت ۽ پڙهڻ جي لحاظ کان، منهنجي خيال ۾، گو ٻولي جيتري ٿي، جيتوڻيڪ اهو لفظي طور تي وڃائي ٿو.

ڪجھ ڪيسن ۾ عام پروگرامنگ اسان کي ناقابل ترديد فائدا ڏئي ٿو. اهو واضح طور تي ترتيب ڏنل پيڪيج پاران بيان ڪيو ويو آهي. تنهن ڪري، ڪنهن به فهرست کي ترتيب ڏيڻ لاء، اسان کي صرف ترتيب ڏيڻ جي ضرورت آهي.انٽرفيس انٽرفيس.

import "sort"

type Names []string

func (ns Names) Len() int {
    return len(ns)
}

func (ns Names) Less(i, j int) bool {
    return ns[i] < ns[j]
}

func (ns Names) Swap(i, j int) {
    ns[i], ns[j] = ns[j], ns[i]
}

func main() {
    names := Names{"London", "Berlin", "Rim"}
    sort.Sort(names)
}

جيڪڏهن توهان ڪنهن اوپن سورس پروجيڪٽ کي وٺو ۽ grep “interface{}” -R ڪمانڊ کي هلايو، توهان ڏسندا ته ڪيترا ڀيرا پريشان ڪندڙ انٽرفيس استعمال ڪيا ويندا آهن. ويجهن ذهن وارا ڪامريڊ فوري طور تي چوندا ته اهو سڀ ڪجهه جنريڪس جي کوٽ سبب آهي. بهرحال، اهو هميشه ناهي. اچو ته DELPHI کي مثال طور وٺون. انهن ساڳين generics جي موجودگي جي باوجود، ان ۾ هڪ خاص VARIANT قسم شامل آهي آپريشنز لاءِ پاڻمرادو ڊيٽا جي قسمن سان. گو ٻولي به ائين ئي ڪري ٿي.

تپ کان وٺي چورن تائين

۽ اسٽريٽ جيڪٽ لازمي طور تي جنون جي سائيز کي پورو ڪرڻ گهرجي. Stanislav Lec.

ڪيترائي انتهائي مداح دعوي ڪري سگھن ٿا ته Go وٽ ھڪڙو ٻيو ميکانيزم آھي جنريڪس ٺاهڻ لاءِ - عڪاسي. ۽ اهي صحيح هوندا ... پر صرف نادر ڪيسن ۾.

Rob Pike اسان کي ڊيڄاري ٿو:

هي هڪ طاقتور اوزار آهي جنهن کي احتياط سان استعمال ڪيو وڃي. ان کان پاسو ڪيو وڃي جيستائين سخت ضرورت هجي.

وڪيپيڊيا اسان کي ٻڌائي ٿو ته:

عڪاسي ان عمل ڏانهن اشارو ڪري ٿو جنهن دوران هڪ پروگرام عمل جي دوران پنهنجي ساخت ۽ رويي جي نگراني ۽ ترميم ڪري سگهي ٿو. پروگرامنگ پيراڊم جي هيٺئين عڪاسي کي عکاس پروگرامنگ سڏيو ويندو آهي. هي ميٽا پروگرامنگ جو هڪ قسم آهي.

بهرحال، جيئن توهان ڄاڻو ٿا، توهان کي هر شيء لاء ادا ڪرڻو پوندو. هن معاملي ۾ اهو آهي:

• پروگرام لکڻ ۾ مشڪل
• پروگرام جي عمل جي رفتار

تنهن ڪري، عڪاسي کي احتياط سان استعمال ڪيو وڃي، جهڙوڪ وڏي پيماني تي هٿيار. عڪاسي جي بغير سوچ جي استعمال اڻ پڙهيل پروگرامن، مسلسل غلطيون ۽ گهٽ رفتار جي ڪري ٿي. صرف هڪ سنوب پروگرامر لاءِ اها شيءِ آهي ته هو پنهنجي ڪوڊ کي ٻين ، وڌيڪ عملي ۽ معمولي ساٿين جي سامهون ڏيکاري سگهي.

Xi کان ثقافتي سامان؟ نه، ڪيترن ئي ٻولين مان!

دولت سان گڏ، قرض به وارثن تي ڇڏيا ويندا آهن.

ان حقيقت جي باوجود ته ڪيترن کي يقين آهي ته ٻولي مڪمل طور تي سي ورثي تي ٻڌل آهي، اهو معاملو ناهي. ٻولي بهترين پروگرامنگ ٻولين جا ڪيترائي حصا شامل ڪري ٿي.

نحو

سڀ کان پهرين، گرامر جي جوڙجڪ جو نحو سي ٻوليء جي نحو تي ٻڌل آهي. بهرحال، ڊيلفي ٻولي پڻ هڪ اهم اثر پيو. اهڙيء طرح، اسان ڏسون ٿا ته بيڪار قوس، جيڪي پروگرام جي پڙهڻ جي صلاحيت کي تمام گهڻو گھٽائي ڇڏيندا آهن، مڪمل طور تي هٽايو ويو آهي. ٻولي ۾ پڻ شامل آهي “:=” آپريٽر DELPHI ٻوليءَ ۾ شامل آهي. پيڪيجز جو تصور ADA وانگر ٻولين مان قرض ورتو ويو آهي. غير استعمال ٿيل ادارن جو اعلان PROLOG ٻولي مان ورتو ويو آهي.

معنيٰ

پيڪيجز ڊيلفي ٻولي جي اصطلاحن تي ٻڌل هئا. هر پيڪيج ڊيٽا ۽ ڪوڊ کي گڏ ڪري ٿو ۽ نجي ۽ عوامي ادارن تي مشتمل آهي. هي توهان کي اجازت ڏئي ٿو ته پئڪيج انٽرفيس کي گھٽ ۾ گھٽ گھٽائي.

عمل درآمد عمل وفد جي طريقي سان DELPHI ٻولي مان قرض ورتو ويو.

تاليف

اهو بغير ڪنهن سبب جي ناهي ته اتي هڪ مذاق آهي: وڃو ترقي ڪئي وئي جڏهن هڪ سي پروگرام مرتب ڪيو پيو وڃي. ٻوليءَ جي هڪ خوبي ان جي انتهائي تيز تاليف آهي. اهو خيال DELPHI ٻولي مان ورتو ويو هو. هر Go پيڪيج هڪ DELPHI ماڊل سان ملندو آهي. اهي پيڪيجز صرف ان وقت ٻيهر ٺهيل آهن جڏهن واقعي ضروري هجي. تنهن ڪري، ايندڙ ترميم کان پوء، توهان کي مڪمل پروگرام کي گڏ ڪرڻ جي ضرورت ناهي، بلڪه صرف تبديل ٿيل پيڪيجز ۽ پيڪيجز کي ٻيهر ترتيب ڏيو جيڪي انهن تبديل ٿيل پيڪيجز تي منحصر آهن (۽ ان جي باوجود، صرف ان صورت ۾ جڏهن پيڪيجز انٽرفيس تبديل ٿي ويا آهن).

اعلي سطحي تعميرات

ٻولي ۾ ڪيتريون ئي مختلف اعليٰ سطحي تعميرات شامل آهن جيڪي ڪنهن به طرح سان هيٺين سطح جي ٻولين جهڙوڪ C.

• تارون
• هيش ٽيبل
• سليس
• بتھ ٽائپنگ ٻولين مان قرض ورتو ويو آهي جهڙوڪ RUBY (جيڪي، بدقسمتي سان، ڪيترائي نه سمجھندا آهن يا ان جي مڪمل صلاحيت کي استعمال ڪندا آهن).

ياداشت جو انتظام

ياداشت جو انتظام عام طور تي هڪ الڳ مضمون جو مستحق آهي. جيڪڏهن ٻولين ۾ C++، ڪنٽرول مڪمل طور تي ڊولپر ڏانهن ڇڏي ويو آهي، پوء بعد ۾ ٻولين جهڙوڪ DELPHI، هڪ حوالو ڳڻپ ماڊل استعمال ڪيو ويو. هن طريقي سان، cyclic حوالن جي اجازت نه ڏني وئي هئي، ڇاڪاڻ ته يتيم ڪلستر ٺاهيا ويا آهن، پوء گو کي تعمير ٿيل آهي اهڙن ڪلستر جي سڃاڻپ (جهڙوڪ C#). ان کان علاوه، ڪچرو ڪليڪٽر سڀ کان وڌيڪ سڃاتل عملن کان وڌيڪ موثر آهي ۽ اڳ ۾ ئي ڪيترن ئي حقيقي وقت جي ڪمن لاء استعمال ڪري سگهجي ٿو. ٻولي پاڻ حالتن کي سڃاڻي ٿي جڏهن هڪ قدر کي ذخيرو ڪرڻ لاءِ متغير کي اسٽيڪ تي مختص ڪري سگهجي ٿو. هي ميموري مئنيجر تي لوڊ گھٽائي ٿو ۽ پروگرام جي رفتار وڌائي ٿو.

اتفاق ۽ اتفاق

ٻوليءَ جي هم آهنگيءَ ۽ مقابلي بازيءَ کان ٻاهر آهي. ڪابه گهٽ-سطح واري ٻولي به پري کان Go سان مقابلو ڪري سگهي ٿي. صحيح هجڻ لاء، اهو قابل ذڪر آهي ته ماڊل ٻولي جي ليکڪن طرفان ايجاد نه ڪيو ويو، پر صرف سٺي پراڻي ADA ٻولي مان قرض ورتو ويو. ٻولي سڀني سي پي يوز کي استعمال ڪندي لکين متوازي ڪنيڪشن کي پروسيس ڪرڻ جي قابل آهي، جڏهن ته ڊيڊ لاڪ ۽ نسل جي حالتن سان گهٽ پيچيده مسئلن جو آرڊر آهي جيڪي ملٽي ٿريڊ ڪوڊ لاءِ عام آهن.

اضافي فائدا

جيڪڏهن اهو منافعو آهي، هرڪو بي نياز ٿي ويندو.

ٻولي پڻ اسان کي بيشمار فائدا مهيا ڪري ٿي:

• پروجيڪٽ جي تعمير کان پوء هڪ واحد قابل عمل فائل ايپليڪيشنن جي ترتيب کي آسان بڻائي ٿو.
• جامد ٽائپنگ ۽ قسم جو اندازو توهان جي ڪوڊ ۾ غلطين جو تعداد گهٽائي سگھي ٿو، جيتوڻيڪ لکڻ جي ٽيسٽ کان سواءِ. مان ڄاڻان ٿو ڪجھ پروگرامر جيڪي بغير لکڻ جي ٽيسٽن کان سواء ڪندا آھن ۽ انھن جي ڪوڊ جي معيار کي خاص طور تي متاثر نه ٿيندو آھي.
• تمام سادو ڪراس تاليف ۽ معياري لائبريري جي شاندار پورائيزيشن، جيڪا ڪراس پليٽ فارم ايپليڪيشنن جي ترقي کي تمام آسان بڻائي ٿي.
• RE2 ريگيولر ايڪسپريشنز ٿريڊ-محفوظ آهن ۽ پيشڪش ڪرڻ جي قابل وقت آهن.
• هڪ طاقتور معياري لائبريري جيڪا اڪثر منصوبن کي ٽئين پارٽي فريم ورڪ جي بغير ڪرڻ جي اجازت ڏئي ٿي.
• ٻولي ايتري طاقتور آهي ته مسئلي تي ڌيان ڏيڻ بجاءِ ان کي ڪيئن حل ڪجي، پر ان جي باوجود گهٽ سطح ايتري آهي جو مسئلو موثر طريقي سان حل ڪري سگهجي.
• گو ايڪو سسٽم اڳ ۾ ئي سڀني موقعن لاءِ باڪس کان ٻاهر ترقي يافته اوزارن تي مشتمل آهي: ٽيسٽ، دستاويز، پيڪيج مينيجمينٽ، طاقتور لينٽر، ڪوڊ جنريشن، نسل جي حالتن جو پتو لڳائڻ، وغيره.
• Go ورجن 1.11 متعارف ڪرايو بلٽ ان سيمينٽڪ انحصار مينيجمينٽ، جيڪو مشهور VCS هوسٽنگ جي مٿان ٺهيل آهي. سڀئي اوزار جيڪي ٺاهيندا آهن Go ecosystem انهن خدمتن کي ڊائون لوڊ ڪرڻ، تعمير ڪرڻ ۽ انسٽال ڪرڻ لاءِ انهن مان ڪوڊ هڪ ئي گري ۾. ۽ اهو عظيم آهي. ورجن 1.11 جي اچڻ سان، پيڪيج ورزننگ جو مسئلو پڻ مڪمل طور حل ٿي ويو.
• ڇاڪاڻ ته ٻولي جو بنيادي خيال جادو کي گهٽائڻ آهي، ٻولي ڊولپرز کي حوصلا افزائي ڪري ٿي ته واضح طور تي غلطي کي سنڀالڻ لاء. ۽ اهو صحيح آهي، ڇاڪاڻ ته ٻي صورت ۾، اهو صرف مڪمل طور تي غلطي سنڀالڻ جي باري ۾ وساري ڇڏيندو. هڪ ٻي ڳالهه اها آهي ته اڪثر ڊولپرز عمدي طور تي غلطي کي سنڀالڻ کي نظر انداز ڪندا آهن، انهن کي پروسيس ڪرڻ بدران صرف غلطي کي اڳتي وڌائڻ لاء ترجيح ڏيندا آهن.
• ٻولي ڪلاسيڪل OOP جي طريقي کي لاڳو نٿو ڪري، ڇاڪاڻ ته ان جي خالص روپ ۾ گو ۾ ڪا به مجازي ناهي. بهرحال، اهو مسئلو ناهي جڏهن انٽرنيٽ استعمال ڪندي. OOP جي غير موجودگي خاص طور تي شروعات ڪندڙن لاءِ داخلا جي رڪاوٽ کي گھٽائي ٿي.

ڪميونٽي جي فائدي لاء سادگي

اهو پيچيده ڪرڻ آسان آهي، آسان ڪرڻ ڏکيو آهي.

Go سادو ٿيڻ لاءِ ٺهيل هو ۽ اهو ان مقصد تي ڪامياب ٿيو. اهو سمارٽ پروگرامرز لاءِ لکيو ويو آهي جيڪي ٽيم ورڪ جي فائدن کي سمجهن ٿا ۽ انٽرنيشنل-سطح جي ٻولين جي لامحدود تبديليءَ کان ٿڪجي پيا آهن. هن جي هٿيارن ۾ نحوي جوڙجڪ جو هڪ نسبتا ننڍڙو سيٽ هجڻ، اهو عملي طور تي وقت سان تبديلين جي تابع نه آهي، تنهنڪري ڊولپرز کي ترقي لاء گهڻو وقت آزاد ڪيو ويو آهي، ۽ ٻوليء جي جدت جي اڻڄاتل مطالعي لاء نه.

ڪمپنيون پڻ ڪيترائي فائدا حاصل ڪن ٿيون: گھٽ داخلا رڪاوٽ انھن کي جلدي ھڪڙي ماهر ڳولڻ جي اجازت ڏئي ٿي، ۽ ٻوليء جي غير موثريت انھن کي 10 سالن کان پوء به ساڳيو ڪوڊ استعمال ڪرڻ جي اجازت ڏئي ٿو.

ٿڪل

وڏي دماغ جي ماپ ڪڏهن به ڪنهن هاٿي کي نوبل انعام ماڻي نه سگهيو آهي.

انهن پروگرامرن لاءِ جن جي ذاتي انا ٽيم جي روح تي اوليت رکي ٿي، ۽ گڏوگڏ نظرياتي جيڪي علمي چئلينجن کي پسند ڪن ٿا ۽ لامحدود ”خود سڌار“، ٻولي واقعي خراب آهي، ڇاڪاڻ ته اها هڪ عام مقصدي فني ٻولي آهي جيڪا توهان کي حاصل ڪرڻ جي اجازت نه ڏيندي آهي. توهان جي ڪم جي نتيجي ۾ جمالياتي خوشي حاصل ڪريو ۽ پنهنجي ساٿين جي سامهون پنهنجو پاڻ کي پيشه ورانه ڏيکاريو (بشرططي ته اسان ذهانت کي انهن معيارن سان ماپون، ۽ نه IQ سان). زندگي ۾ هر شيء وانگر، اهو ذاتي ترجيحن جو معاملو آهي. سڀني قابل قدر جدت وانگر، ٻولي اڳ ۾ ئي عالمگير انڪار کان وڏي قبوليت تائين هڪ ڊگهو رستو اچي چڪو آهي. ٻولي پنهنجي سادگي ۾ ذهين آهي، ۽، جيئن توهان ڄاڻو ٿا، هر شيء سادي آهي!

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