ለምን ሂድ ዲዛይን ለስማርት ፕሮግራመሮች መጥፎ ነው።

ባለፉት ወራት Go ለትግበራዎች እየተጠቀምኩበት ነው። የጽንሰ ሀሳብ ማረጋገጫ። (በግምትኮድ: የሃሳብን ተግባራዊነት ለመፈተሽ) በትርፍ ጊዜው, በከፊል የፕሮግራም ቋንቋን እራሱ ለማጥናት. ፕሮግራሞቹ እራሳቸው በጣም ቀላል ናቸው እና የዚህ ጽሑፍ አላማ አይደሉም, ነገር ግን Go ን የመጠቀም ልምድ ስለእሱ ጥቂት ቃላት ይገባዋል. ለመሆን ቃል ገብቷል (በግምትእ.ኤ.አ. በ 2015 የተጻፈ ጽሑፍ) ለከባድ ሊለካ የሚችል ኮድ ታዋቂ ቋንቋ። ቋንቋው የተፈጠረው በGoogle ነው፣ እሱም በንቃት ጥቅም ላይ በሚውልበት። በቁም ነገር፣ የ Go ቋንቋ ንድፍ ለስማርት ፕሮግራመሮች መጥፎ ነው ብዬ በእውነት አስባለሁ።

ለደካማ ፕሮግራመሮች የተነደፈ?

ሂድ ለመማር በጣም ቀላል ነው፣ መግቢያው አንድ ምሽት ወሰደኝ፣ ከዚያ በኋላ በምርታማነት ኮድ ማድረግ ቻልኩ። ጎ የተማርኩት መጽሐፍ ይባላል በ Go ውስጥ የፕሮግራም አወጣጥ መግቢያ (ትርጉም) በመስመር ላይ ይገኛል። መፅሃፉ ልክ እንደ Go ምንጭ ኮድ እራሱ ለማንበብ ቀላል ነው፣ ጥሩ የኮድ ምሳሌዎች ያሉት እና በአንድ መቀመጫ ውስጥ ሊነበቡ የሚችሉ 150 ገጾችን ይዟል። ይህ ቀላልነት በመጀመሪያ መንፈስን የሚያድስ ነው፣ በተለይም በፕሮግራሚግ አለም ውስጥ በተወሳሰበ ቴክኖሎጂ በተሞላ። በመጨረሻ ግን ፈጥኖም ይሁን ዘግይቶ “በእርግጥ ይህ ነው?” የሚል ሀሳብ ይነሳል።

ጎግል የ Go ቀላልነት መሸጫ ነጥቡ ነው ይላል እና ቋንቋው በትልልቅ ቡድኖች ውስጥ ለከፍተኛ ምርታማነት የተነደፈ ነው፣ ግን እጠራጠራለሁ። የጎደሉ ወይም ከልክ በላይ የተዘረዘሩ ባህሪያት አሉ። እና ሁሉም በገንቢዎች ላይ እምነት ስለሌላቸው, ምንም ነገር በትክክል መስራት እንደማይችሉ በማሰብ. ይህ የቀላልነት ፍላጎት በቋንቋው ዲዛይነሮች የተገነዘበ ውሳኔ ነበር፣ እና ለምን እንደሚያስፈልግ ሙሉ በሙሉ ለመረዳት የገንቢዎችን ተነሳሽነት እና በGo ውስጥ ምን ለማግኘት እየሞከሩ እንደነበር መረዳት አለብን።

ታዲያ ለምን ቀላል ሆነ? ሁለት ጥቅሶች እነሆ ሮብ ፓይክ (በግምትየ Go ቋንቋ ተባባሪ ፈጣሪዎች አንዱ፡-

ዋናው ነጥብ የእኛ ፕሮግራም አውጪዎች (እ.ኤ.አ.)በግምት: ጎግል ሰሪዎች) ተመራማሪዎች አይደሉም። እነሱ፣ እንደ አንድ ደንብ፣ በጣም ወጣት ናቸው፣ ከተማሩ በኋላ ወደ እኛ ይመጣሉ፣ ምናልባት ጃቫን፣ ወይም ሲ/ሲ++ን፣ ወይም ፒቲንን ያጠኑ ይሆናል። በጣም ጥሩ ቋንቋ ሊረዱ አይችሉም, ግን በተመሳሳይ ጊዜ ጥሩ ሶፍትዌር እንዲፈጥሩ እንፈልጋለን. ለዚህም ነው ቋንቋቸው በቀላሉ እንዲረዱ እና እንዲማሩ ማድረግ ያለባቸው።
 
እሱ ጠንቅቆ ማወቅ አለበት፣ በግምት ከሲ ጋር ይመሳሰላል። ጎግል ላይ የሚሰሩ ፕሮግራመሮች ስራቸውን የሚጀምሩት ቀደም ብለው ነው እና በአብዛኛዎቹ የሥርዓት ቋንቋዎችን በተለይም የC ቤተሰብን ያውቃሉ። በአዲስ የፕሮግራሚንግ ቋንቋ ፈጣን ምርታማነት መስፈርት ቋንቋው በጣም አክራሪ መሆን የለበትም ማለት ነው።

ምንድን? ስለዚህ ሮብ ፓይክ በመሠረቱ ጎግል ላይ ያሉ ገንቢዎች ያን ያህል ጥሩ አይደሉም እያለ ነው ለዛም ነው ለደደቦች ቋንቋ የፈጠሩት (በግምት: dumbed down) የሆነ ነገር ለማድረግ እንዲችሉ። በእራስዎ ባልደረቦችዎ ላይ ምን አይነት እብሪተኛ እይታ ነው? ሁልጊዜም የጉግል ገንቢዎች በምድር ላይ ካሉት በጣም ብሩህ እና ምርጥ ሆነው የተመረጡ ናቸው ብዬ አምናለሁ። በእርግጥ እነሱ የበለጠ አስቸጋሪ ነገርን መቋቋም ይችላሉ?

ከመጠን በላይ ቀላልነት ያላቸው ቅርሶች

ቀላል መሆን በማንኛውም ንድፍ ውስጥ የሚገባ ግብ ነው, እና ቀላል ነገር ለማድረግ መሞከር ከባድ ነው. ሆኖም ግን, ውስብስብ ችግሮችን ለመፍታት (ወይም እንዲያውም ለመግለጽ) ሲሞክር, አንዳንድ ጊዜ ውስብስብ መሣሪያ ያስፈልጋል. ውስብስብነት እና ውስብስብነት የፕሮግራሚንግ ቋንቋ ምርጥ ባህሪያት አይደሉም, ነገር ግን ቋንቋው በቀላሉ ሊረዱት እና ሊጠቀሙባቸው የሚችሉ ውብ ማጠቃለያዎችን መፍጠር የሚችሉበት መካከለኛ ደረጃ አለ.

በጣም ገላጭ አይደለም

ለቀላልነት ባለው ቁርጠኝነት ምክንያት፣ 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 የግዳጅ ቃላቶች መንገድ ላይ ገብተዋል ፣ እናም በዚህ ምክንያት ቀላል ችግርን መፍታት ከፍተኛ መጠን ያለው ኮድ ያስከትላል።

እዚህ, ለምሳሌ, በ ውስጥ ለተመሳሳይ ችግር መፍትሄ ነው 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 ምሳሌ ይልቅ፣ ነገር ግን እነርሱን ለመረዳት ምንም የተወሳሰበ ነገር የለም።

ገሃነም መኮረጅ

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 ለአብነት አይነት እና ተሳቢ. አዎ፣ ይሄ እንደገና ከGo ስሪት የበለጠ የተወሳሰበ ነው፣ ነገር ግን ለስማርት ፕሮግራመሮች ለመረዳት ያን ያህል አስቸጋሪ አይደለም። የትኛውን ምሳሌ ለማቆየት ቀላል እና ለማንበብ ቀላል ነው?

ቀላል ዓይነት የስርዓት ማለፊያ

የ Go ፕሮግራመሮች ይህንን እያነበቡ በአፍ ላይ አረፋ እየደፉ “እየተሳሳተ ነው!” ብለው የሚጮኹ ይመስለኛል። ደህና ፣ አጠቃላይ ተግባርን እና ዓይነቶችን ለመስራት ሌላ መንገድ አለ ፣ ግን የአይነቱን ስርዓት ሙሉ በሙሉ ይሰብራል!

በችግሩ ዙሪያ ለመስራት ይህን የሞኝ ቋንቋ ማስተካከል ምሳሌ ተመልከት፡

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 (በግምት: ትርጉሙን ማግኘት አልቻልኩም, በዚህ ላይ ብትረዱኝ ደስ ይለኛል). እንግዲህ፣ ፈሊጣዊ ከሆነ፣ ፈሊጣዊ ያልሆነ ምሳሌ ማየት እጠላለሁ። አጠቃቀም interface{} - ፋሬስ ፣ እና በቋንቋው መፃፍን ለማለፍ ብቻ ያስፈልጋል። ይህ ባዶ በይነገጽ ነው እና ሁሉም ዓይነቶች ይተገብራሉ, ይህም ለሁሉም ሰው ሙሉ ነፃነትን ይፈቅዳል. ይህ የፕሮግራም አወጣጥ ዘይቤ በጣም አስቀያሚ ነው፣ እና ያ ብቻ አይደለም። እንደነዚህ ያሉት የአክሮባቲክ ስራዎች የሩጫ ጊዜ ነጸብራቅ መጠቀምን ይጠይቃሉ። ሮብ ፓይክ እንኳን ይህን አላግባብ የሚጠቀሙ ግለሰቦችን አይወድም በአንዱ ዘገባዎቹ ላይ እንደገለፀው።

ይህ በጥንቃቄ ጥቅም ላይ መዋል ያለበት ኃይለኛ መሳሪያ ነው. በጣም አስፈላጊ ካልሆነ በስተቀር መወገድ አለበት.

ከዚህ ከንቱነት ይልቅ ዲ አብነቶችን እወስድ ነበር። አንድ ሰው እንዴት እንዲህ ይላል interface{} የበለጠ ሊነበብ የሚችል ወይም ደህንነቱ በተጠበቀ ሁኔታ ይተይቡ?

የጥገኛ አስተዳደር ወዮታ

Go በታዋቂ አስተናጋጅ አቅራቢዎች ላይ አብሮ የተሰራ የጥገኝነት ስርዓት አለው። VCS. ከGo ጋር የሚመጡት መሳሪያዎች ስለእነዚህ አገልግሎቶች ያውቃሉ እና ኮድ በአንድ ጊዜ ማውረድ፣ መገንባት እና መጫን ይችላሉ። ይህ በጣም ጥሩ ቢሆንም፣ ከስሪት ጋር በተያያዘ ትልቅ ስህተት አለ! አዎ እውነት ነው የምንጭ ኮዱን እንደ github ወይም bitbucket Go tools ን በመጠቀም ማግኘት ይችላሉ ነገርግን ስሪቱን መግለጽ አይችሉም። እና እንደገና ቀላልነት በጥቅም ወጪ። የእንደዚህ አይነት ውሳኔ አመክንዮ ለመረዳት አልችልም.

ለዚህ ችግር መፍትሄ ጥያቄዎችን ከጠየቁ በኋላ የ Go ልማት ቡድን ፈጠረ መድረክ ክርበዚህ ጉዳይ ላይ እንዴት ሊራመዱ እንደሚችሉ የሚገልጽ ነበር። የእነርሱ ምክር አንድ ቀን ሙሉውን ማከማቻ ወደ ፕሮጀክትዎ ገልብጠው “እንደነበረው” እንዲተውት ነበር። ምን እያሰቡ ነው? የ Go ፈጣሪዎች ችላ የሚሉ እና የምንጭ ኮዱን ብቻ የሚገለብጡ አስደናቂ የስሪት ቁጥጥር ስርዓቶች አለን።

ከ Xi የባህል ሻንጣ

በእኔ አስተያየት Go የተገነባው ህይወታቸውን ሙሉ ሲን በተጠቀሙ እና አዲስ ነገር መሞከር በማይፈልጉ ሰዎች ነው። ቋንቋው ከተጨማሪ ጎማዎች (C) ጋር ሊገለፅ ይችላል።ኦሪጅ: የሥልጠና ጎማዎች). በውስጡ ምንም አዲስ ሀሳቦች የሉም, ለትይዩነት ድጋፍ ካልሆነ በስተቀር (በነገራችን ላይ ድንቅ ነው) እና ይህ አሳፋሪ ነው. በቀላሉ ጥቅም ላይ በማይውል፣ አንካሳ ቋንቋ ውስጥ በጣም ጥሩ ትይዩነት አለዎት።

ሌላው የሚያስደነግጥ ችግር ሂድ የሥርዓት ቋንቋ ነው (እንደ ዝም አስፈሪ የ C)። እርስዎ ጥንታዊ እና ጊዜ ያለፈበት በሚመስል የሥርዓት ዘይቤ ኮድ በመጻፍ ይጨርሳሉ። የነገር ተኮር ፕሮግራሚንግ የብር ጥይት እንዳልሆነ አውቃለሁ ነገር ግን ዝርዝሩን ወደ ዐይነት ማጠቃለል እና ማቀፊያ ማቅረብ መቻል በጣም ጥሩ ነው።

ለራስህ ጥቅም ቀላልነት

ሂድ ቀላል እንዲሆን ታስቦ ነበር እና ግቡ ላይ ተሳክቶለታል። የድሮ ቋንቋን እንደ አብነት በመጠቀም ለደካማ ፕሮግራመሮች የተጻፈ ነው። ቀላል ነገሮችን ለመስራት በቀላል መሳሪያዎች የተሟላ ነው. ለማንበብ ቀላል እና ለመጠቀም ቀላል ነው።

እጅግ በጣም የቃላት አነጋገር፣ የማያስደስት እና ለብልጥ ፕሮግራመሮች መጥፎ ነው።

Спасибо መርሲንቫልድ ለአርትዖቶች

ምንጭ: hab.com