लेख पहिले प्रकाशित एक प्रतिक्रिया को रूप मा लेखिएको थियो antipodean लेख.

विगत दुई-प्लस वर्षहरूमा मैले विकसित बिलिङ प्रणालीको साथ एक विशेष RADIUS सर्भर लागू गर्न Go प्रयोग गरिरहेको छु। बाटोमा, म भाषाको जटिलताहरू सिकिरहेको छु। प्रोग्रामहरू आफैंमा धेरै सरल छन् र यो लेखको उद्देश्य होइन, तर Go प्रयोग गर्ने अनुभवले यसको रक्षामा केही शब्दहरूको हकदार छ। Go गम्भीर, स्केलेबल कोडको लागि बढ्दो मुख्यधाराको भाषा बनिरहेको छ। भाषा Google द्वारा सिर्जना गरिएको थियो, जहाँ यो सक्रिय रूपमा प्रयोग गरिन्छ। तल्लो रेखा, म इमानदारीपूर्वक सोच्छु कि गो भाषाको डिजाइन अविवेकी प्रोग्रामरहरूको लागि खराब छ।

कमजोर प्रोग्रामरहरूको लागि डिजाइन गरिएको हो?

कमजोरहरूले समस्याको कुरा गर्छन्। विचार र सपना को बारे मा बलियो कुराकानी ...

Go सिक्न धेरै सजिलो छ, यति सजिलो छ कि तपाईले कुनै पनि प्रशिक्षण बिना कोड पढ्न सक्नुहुन्छ। भाषाको यो सुविधा धेरै विश्वव्यापी कम्पनीहरूमा प्रयोग गरिन्छ, जब कोड गैर-कोर विशेषज्ञहरू (प्रबन्धकहरू, ग्राहकहरू, आदि) सँगसँगै पढिन्छ। यो डिजाइन संचालित विकास जस्ता विधिहरूको लागि धेरै सुविधाजनक छ।
नौसिखिया प्रोग्रामरहरूले पनि एक वा दुई हप्ता पछि एकदम सभ्य कोड उत्पादन गर्न थाल्छन्। मैले अध्ययन गरेको पुस्तक "गो प्रोग्रामिङ" (मार्क समरफिल्ड द्वारा) हो। पुस्तक धेरै राम्रो छ, यसले भाषाका धेरै सूक्ष्मताहरूलाई छुन्छ। जाभा, PHP जस्ता अनावश्यक जटिल भाषाहरू पछि, जादुको अभाव स्फूर्तिदायी छ। तर ढिलो वा पछि, धेरै सीमित प्रोग्रामरहरूसँग नयाँ क्षेत्रमा पुरानो विधिहरू प्रयोग गर्ने विचार छ। के यो साँच्चै आवश्यक छ?

रोब पाइक (भाषाको मुख्य विचारधारा) ले गो भाषालाई औद्योगिक भाषाको रूपमा सिर्जना गर्नुभयो जुन बुझ्न सजिलो र प्रयोग गर्न प्रभावकारी छ। भाषा ठूला टोलीहरूमा अधिकतम उत्पादकताको लागि डिजाइन गरिएको हो र यसमा कुनै शंका छैन। धेरै नौसिखिया प्रोग्रामरहरूले गुनासो गर्छन् कि त्यहाँ धेरै सुविधाहरू छन् जुन तिनीहरू हराइरहेका छन्। सरलताको लागि यो चाहना भाषाको डिजाइनरहरू द्वारा एक सचेत निर्णय थियो, र यो किन आवश्यक थियो भनेर पूर्ण रूपमा बुझ्नको लागि, हामीले विकासकर्ताहरूको प्रेरणा र उनीहरूले Go मा हासिल गर्न खोजिरहेका थिए भनेर बुझ्नुपर्छ।

त्यसोभए किन यो यति सरल बनाइयो? यहाँ रोब पाइकबाट केही उद्धरणहरू छन्:

यहाँ मुख्य कुरा यो हो कि हाम्रा प्रोग्रामरहरू अनुसन्धानकर्ताहरू होइनन्। तिनीहरू, एक नियमको रूपमा, एकदम जवान छन्, अध्ययन पछि हामीकहाँ आउँछन्, सायद तिनीहरूले जाभा, वा C/C++, वा पाइथन अध्ययन गरेका थिए। तिनीहरूले राम्रो भाषा बुझ्न सक्दैनन्, तर एकै समयमा हामी तिनीहरूले राम्रो सफ्टवेयर सिर्जना गर्न चाहन्छौं। त्यसैले भाषा बुझ्न र सिक्न सजिलो हुनुपर्छ।

ऊ परिचित हुनुपर्छ, लगभग सी जस्तै बोल्ने। Google मा काम गर्ने प्रोग्रामरहरूले आफ्नो करियर चाँडै सुरु गर्छन् र प्रायः प्रक्रियात्मक भाषाहरू, विशेष गरी C परिवारसँग परिचित हुन्छन्। नयाँ प्रोग्रामिङ भाषामा द्रुत उत्पादकताको आवश्यकता भनेको भाषा धेरै कट्टरपन्थी हुनुहुँदैन भन्ने हो।

बुद्धिमानी शब्दहरू, होइन र?

सरलता को कलाकृति

सुन्दरताको लागि सरलता आवश्यक शर्त हो। लेभ टोलस्टोय।

यसलाई सरल राख्नु कुनै पनि डिजाइनमा सबैभन्दा महत्त्वपूर्ण लक्ष्यहरू मध्ये एक हो। तपाईलाई थाहा छ, एक उत्तम परियोजना एक परियोजना होइन जहाँ थप्न को लागी केहि छैन, तर एक जसबाट हटाउन को लागी केहि छैन। धेरै मानिसहरू विश्वास गर्छन् कि जटिल समस्याहरू समाधान गर्न (वा व्यक्त) गर्न, एक जटिल उपकरण आवश्यक छ। यद्यपि, यो होइन। उदाहरणका लागि PERL भाषा लिनुहोस्। भाषा विचारधाराहरूले विश्वास गरे कि प्रोग्रामरसँग एउटा समस्या समाधान गर्न कम्तिमा तीन फरक तरिकाहरू हुनुपर्छ। गो भाषाका विचारधाराहरूले फरक बाटो लिएका थिए; तिनीहरूले निर्णय गरे कि एक बाटो, तर वास्तवमै राम्रो, लक्ष्य प्राप्त गर्न पर्याप्त थियो। यस दृष्टिकोणको गम्भीर आधार छ: एक मात्र तरिका सिक्न सजिलो छ र बिर्सन गाह्रो छ।

धेरै आप्रवासीहरूले गुनासो गर्छन् कि भाषामा सुरुचिपूर्ण एब्स्ट्र्याक्शनहरू छैनन्। हो, यो सत्य हो, तर यो भाषाको मुख्य फाइदाहरू मध्ये एक हो। भाषाले न्यूनतम जादू समावेश गर्दछ - त्यसैले कार्यक्रम पढ्नको लागि कुनै गहिरो ज्ञान आवश्यक पर्दैन। कोड को verbosity को लागी, यो कुनै पनि समस्या छैन। राम्रोसँग लेखिएको गोलाङ कार्यक्रम थोरै वा कुनै संरचना बिना ठाडो रूपमा पढ्छ। थप रूपमा, एक कार्यक्रम पढ्ने गति कम्तिमा एक क्रम को परिमाण यो लेख्ने गति भन्दा ठूलो छ। यदि तपाइँ सोच्नुहुन्छ कि सबै कोडमा समान ढाँचा छ (निर्मित 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)
}

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

नक्कलको नर्क

मानिसले आफूभित्र नरक बोक्छ। मार्टिन लुथर।

शुरुवातकर्ताहरूले जेनेरिकको अभावको सन्दर्भमा गोको बारेमा निरन्तर गुनासो गर्छन्। यो समस्या समाधान गर्न, तिनीहरूमध्ये धेरैले प्रत्यक्ष कोड प्रतिलिपि प्रयोग गर्छन्। उदाहरणका लागि, पूर्णांकहरूको सूची संक्षेप गर्नको लागि एउटा प्रकार्य, त्यस्ता हुन-हुने पेशेवरहरूले प्रत्येक डेटा प्रकारको लागि साधारण प्रतिलिपि टाँस्ने बाहेक अन्य कुनै पनि तरिकाले कार्यक्षमता लागू गर्न सकिँदैन भन्ने विश्वास गर्छन्।

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

र, यद्यपि हाम्रो कोड अघिल्लो केस भन्दा केही लामो भयो, यो सामान्यीकृत भएको छ। त्यसकारण, हामीलाई सबै अंकगणितीय कार्यहरू लागू गर्न गाह्रो हुनेछैन।

धेरैले भन्नेछन् कि D मा एउटा कार्यक्रम एकदम छोटो देखिन्छ, र तिनीहरू सही हुनेछन्।

import std.stdio;
import std.algorithm;

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

यद्यपि, यो केवल छोटो छ, तर अधिक सही छैन, किनकि D कार्यान्वयनले त्रुटि ह्यान्डलिंगको समस्यालाई पूर्ण रूपमा बेवास्ता गर्दछ।

वास्तविक जीवनमा, तर्कको जटिलता बढ्दै जाँदा, अन्तर द्रुत रूपमा संकुचित हुँदै जान्छ। तपाईंले मानक भाषा अपरेटरहरू प्रयोग गरेर गर्न नसकिने कार्य गर्न आवश्यक हुँदा यो अन्तर अझ छिटो बन्द हुन्छ।

मर्मत योग्यता, एक्स्टेन्सिबिलिटी, र पठनीयताको सन्दर्भमा, मेरो विचारमा, गो भाषाले जित्छ, यद्यपि यो verbosity मा हराउँछ।

केही अवस्थामा सामान्यीकृत प्रोग्रामिङले हामीलाई निर्विवाद फाइदाहरू दिन्छ। यो क्रमबद्ध प्याकेज द्वारा स्पष्ट रूपमा चित्रण गरिएको छ। त्यसैले, कुनै पनि सूची क्रमबद्ध गर्न, हामीले केवल sort.Interface इन्टरफेस लागू गर्न आवश्यक छ।

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 आदेश चलाउनुहुन्छ भने, तपाइँले देख्नुहुनेछ कि कति पटक भ्रमित इन्टरफेसहरू प्रयोग गरिन्छ। नजिकका साथीहरूले तुरुन्तै भन्नेछन् कि यो सबै जेनेरिकको कमीको कारण हो। यद्यपि, यो सधैं मामला होइन। डेल्फीलाई उदाहरणका रूपमा लिऔं। यी समान जेनेरिकहरूको उपस्थितिको बावजुद, यसले मनमानी डेटा प्रकारहरूसँग सञ्चालनका लागि विशेष VARIANT प्रकार समावेश गर्दछ। गो भाषाले पनि त्यस्तै गर्छ।

एक तोप देखि भँगेरा सम्म

र स्ट्रेटज्याकेट पागलपनको आकारमा फिट हुनुपर्छ। Stanislav Lec।

धेरै चरम फ्यानहरूले दावी गर्न सक्छन् कि गोसँग जेनेरिकहरू सिर्जना गर्ने अर्को संयन्त्र छ - प्रतिबिम्ब। र तिनीहरू सही हुनेछन् ... तर दुर्लभ अवस्थामा मात्र।

रोब पाइकले हामीलाई चेतावनी दिन्छ:

यो एक शक्तिशाली उपकरण हो जुन सावधानी संग प्रयोग गर्नुपर्छ। कडाइका साथ आवश्यक नभएसम्म यसबाट बच्नुपर्छ।

विकिपिडियाले हामीलाई निम्न बताउँछ:

प्रतिबिम्बले त्यो प्रक्रियालाई बुझाउँछ जसको अवधिमा कार्यक्रमले कार्यान्वयनको क्रममा आफ्नै संरचना र व्यवहारलाई निगरानी र परिमार्जन गर्न सक्छ। प्रोग्रामिङ प्रतिमान अन्तर्निहित प्रतिबिम्बलाई रिफ्लेक्टिव प्रोग्रामिङ भनिन्छ। यो metaprogramming को एक प्रकार हो।

यद्यपि, तपाईलाई थाहा छ, तपाईले सबै कुराको लागि तिर्नुपर्छ। यस अवस्थामा यो हो:

• कार्यक्रम लेख्न कठिनाई
• कार्यक्रम कार्यान्वयन गति

तसर्थ, प्रतिबिम्ब सावधानीका साथ प्रयोग गरिनुपर्छ, जस्तै ठूलो क्यालिबर हतियार। प्रतिबिम्बको सोचविहीन प्रयोगले पढ्न नसकिने कार्यक्रमहरू, निरन्तर त्रुटिहरू र कम गति निम्त्याउँछ। एक स्नोब प्रोग्रामरको लागि अन्य, अधिक व्यावहारिक र विनम्र सहकर्मीहरूको अगाडि आफ्नो कोड देखाउन सक्षम हुनको लागि मात्र चीज।

सीबाट सांस्कृतिक सामान? होइन, धेरै भाषाहरूबाट!

धनसम्पत्तिसँगै ऋण पनि उत्तराधिकारीलाई छोडिन्छ ।

यस तथ्यको बावजुद धेरैले विश्वास गर्छन् कि भाषा पूर्णतया सी विरासतमा आधारित छ, यो मामला होइन। भाषाले उत्कृष्ट प्रोग्रामिङ भाषाहरूको धेरै पक्षहरू समावेश गर्दछ।

विन्यास

सबै भन्दा पहिले, व्याकरण संरचना को वाक्य रचना C भाषा को वाक्य रचना मा आधारित छ। यद्यपि, डेल्फी भाषाको पनि महत्त्वपूर्ण प्रभाव थियो। यसरी, हामी देख्छौं कि अनावश्यक कोष्ठकहरू, जसले कार्यक्रमको पठनीयतालाई धेरै कम गर्छ, पूर्ण रूपमा हटाइयो। भाषाले DELPHI भाषामा निहित ":=" अपरेटर पनि समावेश गर्दछ। प्याकेजहरूको अवधारणा ADA जस्ता भाषाहरूबाट उधारिएको हो। प्रयोग नगरिएका संस्थाहरूको घोषणा PROLOG भाषाबाट लिइएको हो।

शब्दार्थ

प्याकेजहरू डेल्फी भाषाको अर्थशास्त्रमा आधारित थिए। प्रत्येक प्याकेजले डाटा र कोड समेट्छ र निजी र सार्वजनिक संस्थाहरू समावेश गर्दछ। यसले तपाईंलाई प्याकेज इन्टरफेसलाई न्यूनतममा कम गर्न अनुमति दिन्छ।

प्रतिनिधिमण्डल विधिद्वारा कार्यान्वयन कार्य डेल्फी भाषाबाट लिइएको थियो।

संकलन

यो कुनै कारण बिना होइन कि त्यहाँ मजाक छ: गो विकसित गरिएको थियो जब एक C कार्यक्रम कम्पाइल भइरहेको थियो। भाषाको एक बल यसको अल्ट्रा-फास्ट संकलन हो। यो विचार DELPHI भाषाबाट लिइएको हो। प्रत्येक गो प्याकेज डेल्फी मोड्युलसँग मेल खान्छ। यी प्याकेजहरू पुन: कम्पाइल हुन्छन् जब वास्तवमै आवश्यक हुन्छ। तसर्थ, अर्को सम्पादन पछि, तपाईंले सम्पूर्ण कार्यक्रम कम्पाइल गर्न आवश्यक छैन, बरु यी परिवर्तन गरिएका प्याकेजहरूमा निर्भर परिवर्तन गरिएका प्याकेजहरू र प्याकेजहरू मात्र पुन: कम्पाइल गर्नुहोस् (र त्यसपछि पनि, प्याकेज इन्टरफेसहरू परिवर्तन भएमा मात्र)।

उच्च स्तरीय निर्माण

भाषाले धेरै फरक उच्च-स्तर निर्माणहरू समावेश गर्दछ जुन कुनै पनि हिसाबले सी जस्तै निम्न-स्तर भाषाहरूसँग सम्बन्धित छैन।

• लाइनहरू
• ह्यास तालिकाहरू
• स्लाइसहरू
• बतख टाइपिङ रुबी जस्ता भाषाहरूबाट उधारिएको छ (जसलाई, दुर्भाग्यवश, धेरैले बुझ्दैनन् वा यसको पूर्ण क्षमतामा प्रयोग गर्दैनन्)।

मेमोरी व्यवस्थापन

मेमोरी व्यवस्थापन सामान्यतया छुट्टै लेखको योग्य हुन्छ। यदि C++ जस्ता भाषाहरूमा, नियन्त्रण पूर्ण रूपमा विकासकर्तालाई छोडिएको छ भने, पछि DELPHI जस्ता भाषाहरूमा, सन्दर्भ गणना मोडेल प्रयोग गरियो। यस दृष्टिकोणको साथ, चक्रीय सन्दर्भहरूलाई अनुमति दिइएन, किनकि अनाथ क्लस्टरहरू बनाइएका थिए, त्यसपछि Go ले त्यस्ता क्लस्टरहरूको बिल्ट-इन पत्ता लगाउन सक्छ (जस्तै C#)। थप रूपमा, फोहोर सङ्कलन हालका ज्ञात कार्यान्वयनहरू भन्दा बढी कुशल छ र पहिले नै धेरै वास्तविक-समय कार्यहरूको लागि प्रयोग गर्न सकिन्छ। भ्यारीएबल भण्डारण गर्ने मान स्ट्याकमा आवंटित गर्न सकिने अवस्थाहरूलाई भाषाले नै पहिचान गर्छ। यसले मेमोरी प्रबन्धकमा लोड घटाउँछ र कार्यक्रमको गति बढाउँछ।

समरूपता र समरूपता

भाषाको समानान्तरता र प्रतिस्पर्धात्मकता प्रशंसा भन्दा बाहिर छ। कुनै पनि निम्न-स्तरको भाषाले टाढाबाट Go सँग प्रतिस्पर्धा गर्न सक्दैन। निष्पक्ष हुन, यो नोट गर्न लायक छ कि मोडेल भाषा को लेखक द्वारा आविष्कार गरिएको थिएन, तर केवल राम्रो पुरानो ADA भाषा बाट उधारिएको थियो। भाषाले सबै CPU हरू प्रयोग गरेर लाखौं समानान्तर जडानहरू प्रशोधन गर्न सक्षम छ, जबकि डेडलकहरू र दौड अवस्थाहरू जुन बहु-थ्रेडेड कोडको लागि विशिष्ट छन् संग परिमाणको कम जटिल समस्याहरू छन्।

अतिरिक्त लाभहरू

नाफामुखी भयो भने सबै निस्वार्थ बन्छ ।

भाषाले हामीलाई धेरै निस्सन्देह फाइदाहरू पनि प्रदान गर्दछ:

• परियोजना निर्माण पछि एकल कार्यान्वयनयोग्य फाइलले अनुप्रयोगहरूको तैनातीलाई धेरै सरल बनाउँछ।
• स्थिर टाइपिङ र टाइप इन्फरेन्सले तपाईको कोडमा त्रुटिहरूको संख्यालाई उल्लेखनीय रूपमा कम गर्न सक्छ, परीक्षणहरू लेख्न बिना नै। मलाई केहि प्रोग्रामरहरू थाहा छ जसले परीक्षणहरू बिना नै लेख्छन् र तिनीहरूको कोडको गुणस्तरमा उल्लेखनीय असर पर्दैन।
• धेरै सरल क्रस-कम्पाइलेशन र मानक पुस्तकालयको उत्कृष्ट पोर्टेबिलिटी, जसले क्रस-प्लेटफर्म अनुप्रयोगहरूको विकासलाई धेरै सरल बनाउँछ।
• RE2 रेगुलर एक्सप्रेशनहरू थ्रेड-सेफ छन् र अनुमानित कार्यान्वयन समयहरू छन्।
• एक शक्तिशाली मानक पुस्तकालय जसले धेरै परियोजनाहरूलाई तेस्रो-पक्ष फ्रेमवर्क बिना गर्न अनुमति दिन्छ।
• समस्यालाई कसरी समाधान गर्ने भन्दा पनि त्यसमा ध्यान केन्द्रित गर्न भाषा पर्याप्त शक्तिशाली छ, तर समस्यालाई कुशलतापूर्वक समाधान गर्न सक्ने तल्लो तह पर्याप्त छ।
• गो इको प्रणालीले पहिले नै सबै अवसरहरूको लागि बक्स बाहिर विकसित उपकरणहरू समावेश गर्दछ: परीक्षण, कागजात, प्याकेज व्यवस्थापन, शक्तिशाली लिन्टरहरू, कोड उत्पादन, दौड अवस्था पत्ता लगाउने, आदि।
• Go संस्करण 1.11 ले बिल्ट-इन सिमेन्टिक निर्भरता व्यवस्थापन प्रस्तुत गर्‍यो, लोकप्रिय VCS होस्टिंगको शीर्षमा निर्मित। गो इकोसिस्टम बनाउने सबै उपकरणहरूले यी सेवाहरू डाउनलोड गर्न, निर्माण गर्न र तिनीहरूबाट कोड स्थापना गर्न प्रयोग गर्छन्। र त्यो महान छ। संस्करण 1.11 को आगमन संग, प्याकेज संस्करण संग समस्या पनि पूर्ण रूपमा हल भयो।
• किनभने भाषाको मूल विचार जादू कम गर्नु हो, भाषाले विकासकर्ताहरूलाई स्पष्ट रूपमा त्रुटि ह्यान्डलिंग गर्न प्रोत्साहन दिन्छ। र यो सहि छ, किनकि अन्यथा, यो केवल त्रुटि ह्यान्डलिङको बारेमा बिर्सनेछ। अर्को कुरा यो हो कि अधिकांश विकासकर्ताहरूले जानाजानी त्रुटि ह्यान्डलिङलाई बेवास्ता गर्छन्, त्रुटिलाई माथितिर फर्वार्ड गर्न प्रशोधन गर्नुको सट्टा प्राथमिकता दिन्छन्।
• भाषाले शास्त्रीय OOP पद्धति लागू गर्दैन, किनकि यसको शुद्ध रूपमा Go मा कुनै भर्चुअलता छैन। यद्यपि, इन्टरफेसहरू प्रयोग गर्दा यो समस्या होइन। OOP को अनुपस्थितिले शुरुआतीहरूको लागि प्रवेशको अवरोधलाई महत्त्वपूर्ण रूपमा घटाउँछ।

सामुदायिक लाभको लागि सरलता

यसलाई जटिल बनाउन सजिलो छ, सरल बनाउन गाह्रो छ।

Go सरल हुन डिजाइन गरिएको थियो र यो त्यो लक्ष्यमा सफल हुन्छ। यो स्मार्ट प्रोग्रामरहरूका लागि लेखिएको थियो जसले टोली कार्यका फाइदाहरू बुझ्दछन् र उद्यम-स्तर भाषाहरूको अनन्त परिवर्तनशीलताबाट थकित छन्। यसको शस्त्रागारमा सिन्ट्याक्टिक संरचनाहरूको अपेक्षाकृत सानो सेट भएकोले, यो व्यावहारिक रूपमा समयको साथ परिवर्तनको अधीनमा छैन, त्यसैले विकासकर्ताहरूले विकासको लागि धेरै समय खाली गरेका छन्, र अनन्त रूपमा भाषा आविष्कारहरूको अध्ययनको लागि होइन।

कम्पनीहरूले धेरै फाइदाहरू पनि पाउँछन्: कम प्रविष्टि अवरोधले तिनीहरूलाई चाँडै एक विशेषज्ञ फेला पार्न अनुमति दिन्छ, र भाषाको अपरिवर्तनीयताले तिनीहरूलाई 10 वर्ष पछि पनि उही कोड प्रयोग गर्न अनुमति दिन्छ।

निष्कर्षमा

ठूलो मस्तिष्कको आकारले कुनै हात्तीलाई नोबेल पुरस्कार विजेता बनाएको छैन।

ती प्रोग्रामरहरू जसको व्यक्तिगत अहंकारले टोली भावनामा प्राथमिकता लिन्छ, साथै शैक्षिक चुनौतीहरू र अनन्त "आत्म-सुधार" लाई माया गर्ने सिद्धान्तकारहरूका लागि, भाषा साँच्चै खराब छ, किनकि यो एक सामान्य-उद्देश्य कारीगरी भाषा हो जसले तपाईंलाई प्राप्त गर्न अनुमति दिँदैन। आफ्नो कामको नतिजाबाट सौन्दर्य आनन्द लिनुहोस् र सहकर्मीहरूको अगाडि आफूलाई व्यावसायिक देखाउनुहोस् (हामीले यी मापदण्डहरूद्वारा बुद्धिमत्ता मापन गर्छौं, IQ द्वारा होइन)। जीवनमा सबै कुरा जस्तै, यो व्यक्तिगत प्राथमिकताहरूको कुरा हो। सबै सार्थक आविष्कारहरू जस्तै, भाषाले पहिले नै विश्वव्यापी अस्वीकारबाट सामूहिक स्वीकृतिसम्मको लामो यात्रा गरिसकेको छ। भाषा यसको सरलतामा सरल छ, र, तपाईलाई थाहा छ, सबै सरल सरल छ!

स्रोत: www.habr.com