किन गो डिजाइन स्मार्ट प्रोग्रामरहरूको लागि खराब छ

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

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

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

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

त्यसोभए किन यो यति सरल बनाइयो? यहाँ केही उद्धरणहरू छन् रोब पाइक (लगभग।: गो भाषाको सह-निर्माताहरू मध्ये एक):

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

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

अत्यधिक सरलता को कलाकृति

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

धेरै अभिव्यक्त छैन

यसको सरलताप्रति प्रतिबद्धताको कारण, Go सँग अन्य भाषाहरूमा प्राकृतिक रूपमा मानिने संरचनाहरूको अभाव छ। यो सुरुमा राम्रो विचार जस्तो लाग्न सक्छ, तर व्यवहारमा यसले वर्बोज कोडमा परिणाम दिन्छ। यसको कारण स्पष्ट हुनुपर्दछ - यो विकासकर्ताहरूको लागि अन्य व्यक्तिको कोड पढ्न सजिलो हुनु आवश्यक छ, तर वास्तवमा यी सरलीकरणहरूले मात्र पढ्न योग्यतालाई हानि पुर्‍याउँछ। 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)
}

यद्यपि यो कोडले सम्भव भएसम्म सामान्य बन्ने प्रयास गर्दछ, Go को जबरजस्ती verbosity बाटोमा हुन्छ, र परिणाम स्वरूप, साधारण समस्या समाधान गर्दा कोडको ठूलो मात्रामा परिणाम हुन्छ।

यहाँ, उदाहरण को लागी, मा समान समस्या को एक समाधान छ 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 लाई दिनेछु। उसको कोड धेरै पढ्न योग्य छ किनभने उसले कार्यहरू अझ स्पष्ट रूपमा वर्णन गर्दछ। 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))
}

र यो उदाहरणले हस्ताक्षरित प्रकारका लागि पनि काम गर्दैन। यो दृष्टिकोणले आफैलाई नदोहोर्याउने सिद्धान्तलाई पूर्ण रूपमा उल्लङ्घन गर्दछ (ड्राई), सबैभन्दा प्रसिद्ध र स्पष्ट सिद्धान्तहरू मध्ये एक, बेवास्ता गर्दै जुन धेरै त्रुटिहरूको स्रोत हो। गो यो किन गर्छ? यो भाषाको डरलाग्दो पक्ष हो।

D मा समान उदाहरण:

import std.stdio;
import std.algorithm;

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

सरल, सुरुचिपूर्ण र सीधा बिन्दुमा। यहाँ प्रयोग गरिएको प्रकार्य हो reduce टेम्प्लेट प्रकार र predicate को लागी। हो, यो गो संस्करण भन्दा धेरै जटिल छ, तर स्मार्ट प्रोग्रामरहरूलाई बुझ्न गाह्रो छैन। कुन उदाहरण राख्न सजिलो र पढ्न सजिलो छ?

सरल प्रकार प्रणाली बाइपास

म कल्पना गर्छु कि गो प्रोग्रामरहरू यो पढ्दै मुखमा फिँज आउनेछन् र कराउनेछन्, "तिमीले यो गलत गर्दैछौ!" ठिक छ, त्यहाँ सामान्य प्रकार्य र प्रकारहरू बनाउने अर्को तरिका छ, तर यसले प्रकार प्रणालीलाई पूर्ण रूपमा तोड्छ!

समस्याको वरिपरि काम गर्न मूर्ख भाषा फिक्सको यो उदाहरणलाई हेर्नुहोस्:

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 लेखबाट साभार गरिएको थियो Go मा idiomatic जेनेरिकहरू (लगभग।: मैले अनुवाद फेला पार्न सकिन, यदि तपाईंले यसमा मद्दत गर्नुभयो भने म खुसी हुनेछु)। ठिक छ, यदि यो मुहावरावादी हो भने, म गैर-मुहावरे उदाहरण हेर्न घृणा गर्छु। प्रयोग interface{} - एक प्रहसन, र भाषामा यो केवल टाइपिङ बाइपास गर्न आवश्यक छ। यो एक खाली इन्टरफेस हो र सबै प्रकारले यसलाई लागू गर्दछ, सबैको लागि पूर्ण स्वतन्त्रता अनुमति दिन्छ। प्रोग्रामिङको यो शैली एकदमै कुरूप छ, र त्यो मात्र होइन। यी जस्तै एक्रोबेटिक feats रनटाइम प्रतिबिम्ब को प्रयोग को आवश्यकता छ। रोब पाईकले पनि यो दुरुपयोग गर्ने व्यक्तिहरूलाई मन पराउँदैनन्, जसरी उनले आफ्नो एक रिपोर्टमा उल्लेख गरे।

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

म यो बकवासको सट्टा D टेम्प्लेटहरू लिन्छु। कसैले कसरी भन्न सक्छ interface{} अधिक पढ्न योग्य वा सुरक्षित टाइप पनि?

निर्भरता व्यवस्थापनको समस्या

Go सँग लोकप्रिय होस्टिंग प्रदायकहरूको शीर्षमा निर्मित निर्भरता प्रणाली छ कुलपतियों। Go सँग आउने उपकरणहरूले यी सेवाहरूको बारेमा जान्दछन् र तिनीहरूबाट कोड डाउनलोड, निर्माण र स्थापना गर्न सक्छन्। जबकि यो महान छ, त्यहाँ संस्करण संग एक प्रमुख त्रुटि छ! हो, यो सत्य हो कि तपाईंले Go उपकरणहरू प्रयोग गरेर github वा bitbucket जस्ता सेवाहरूबाट स्रोत कोड प्राप्त गर्न सक्नुहुन्छ, तर तपाईंले संस्करण निर्दिष्ट गर्न सक्नुहुन्न। र फेरि उपयोगिता को खर्च मा सादगी। म यस्तो निर्णयको तर्क बुझ्न सक्षम छैन।

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

सी बाट सांस्कृतिक सामान

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

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

आफ्नो फाइदाको लागि सरलता

Go सरल हुन डिजाइन गरिएको थियो र यो त्यो लक्ष्यमा सफल हुन्छ। यो कमजोर प्रोग्रामरहरूको लागि लेखिएको थियो, टेम्प्लेटको रूपमा पुरानो भाषा प्रयोग गरेर। यो साधारण चीजहरू गर्न सरल उपकरणहरूको साथ पूर्ण आउँछ। यो पढ्न सजिलो र प्रयोग गर्न सजिलो छ।

यो स्मार्ट प्रोग्रामरहरूको लागि अत्यन्तै शब्द, प्रभावहीन, र खराब छ।

Спасибо mersinvald सम्पादनका लागि

स्रोत: www.habr.com