ጽሑፉ የተፃፈው ቀደም ሲል ለታተመው ምላሽ ነው። antipodean ጽሑፍ.

ላለፉት ሁለት እና ተጨማሪ ዓመታት Goን እየተጠቀምኩ የዳበረ የሂሳብ አከፋፈል ስርዓት ያለው ልዩ RADIUS አገልጋይ ነው። በመንገዴ ላይ, የቋንቋውን ውስብስብነት እየተማርኩ ነው. ፕሮግራሞቹ እራሳቸው በጣም ቀላል ናቸው እና የዚህ ጽሑፍ አላማ አይደሉም, ነገር ግን Go ን የመጠቀም ልምድ እራሱን ለመከላከል ጥቂት ቃላት ይገባዋል. Go ለቁም ነገር፣ ሊሰፋ የሚችል ኮድ እየጨመረ ዋና ቋንቋ እየሆነ ነው። ቋንቋው የተፈጠረው በGoogle ነው፣ እሱም በንቃት ጥቅም ላይ በሚውልበት። በቁም ነገር፣ የ Go ቋንቋ ንድፍ የማሰብ ችሎታ ለሌላቸው ፕሮግራመሮች መጥፎ ነው ብዬ በእውነት አስባለሁ።

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

ደካማው ስለ ችግሮች ይናገራል. ስለ ሀሳቦች እና ህልሞች ጠንካራ ንግግር…

Go ለመማር በጣም ቀላል ነው፣ በጣም ቀላል ስለሆነ ምንም አይነት ስልጠና ሳይኖር ኮዱን ማንበብ ይችላሉ። ይህ የቋንቋ ባህሪ በብዙ አለምአቀፍ ኩባንያዎች ውስጥ ኮዱ ከዋና ካልሆኑ ስፔሻሊስቶች (አስተዳዳሪዎች, ደንበኞች, ወዘተ) ጋር ሲነበብ ጥቅም ላይ ይውላል. ይህ እንደ ዲዛይን የሚነዳ ልማት ላሉ ዘዴዎች በጣም ምቹ ነው።
ጀማሪ ፕሮግራመሮች እንኳን ከአንድ ሳምንት ወይም ከሁለት ሳምንት በኋላ ጥሩ ኮድ ማዘጋጀት ይጀምራሉ። የተማርኩት መጽሐፍ “Go Programming” (በማርክ ሰመርፊልድ) ነው። መጽሐፉ በጣም ጥሩ ነው፣ ብዙ የቋንቋውን ውስብስቦች ይዳስሳል። እንደ ጃቫ ፣ ፒኤችፒ ካሉ አላስፈላጊ ውስብስብ ቋንቋዎች በኋላ የአስማት እጥረት መንፈስን የሚያድስ ነው። ነገር ግን ይዋል ይደር እንጂ ብዙ ውስን ፕሮግራመሮች በአዲስ መስክ ውስጥ የቆዩ ዘዴዎችን የመጠቀም ሀሳብ አላቸው። ይህ በእርግጥ አስፈላጊ ነው?

ሮብ ፓይክ (የቋንቋው ዋና ርዕዮተ ዓለም) የ Go ቋንቋን እንደ ኢንደስትሪ ቋንቋ ፈጥሯል፣ ይህም ለመረዳት ቀላል እና ለመጠቀም ውጤታማ ነው። ቋንቋው በትልልቅ ቡድኖች ውስጥ ለከፍተኛ ምርታማነት የተነደፈ ነው እና ስለ እሱ ምንም ጥርጥር የለውም። ብዙ ጀማሪ ፕሮግራም አድራጊዎች የጠፉባቸው ብዙ ባህሪያት እንዳሉ ያማርራሉ። ይህ የቀላልነት ፍላጎት በቋንቋው ዲዛይነሮች የተገነዘበ ውሳኔ ነበር፣ እና ለምን እንደሚያስፈልግ ሙሉ በሙሉ ለመረዳት የገንቢዎችን ተነሳሽነት እና በGo ውስጥ ምን ለማግኘት እየሞከሩ እንደነበር መረዳት አለብን።

ታዲያ ለምን ቀላል ሆነ? ከ Rob Pike ሁለት ጥቅሶች እነሆ፡-

እዚህ ላይ ዋናው ነጥብ የእኛ ፕሮግራመሮች ተመራማሪዎች አለመሆናቸው ነው. እነሱ፣ እንደ አንድ ደንብ፣ በጣም ወጣት ናቸው፣ ከተማሩ በኋላ ወደ እኛ ይመጣሉ፣ ምናልባት ጃቫን፣ ወይም ሲ/ሲ++ን፣ ወይም ፒቲንን ያጠኑ ይሆናል። በጣም ጥሩ ቋንቋ ሊረዱ አይችሉም, ግን በተመሳሳይ ጊዜ ጥሩ ሶፍትዌር እንዲፈጥሩ እንፈልጋለን. ለዚያም ነው ቋንቋው ለመረዳት እና ለመማር ቀላል መሆን ያለበት.

እሱ ጠንቅቆ ማወቅ አለበት፣ በግምት ከሲ ጋር ይመሳሰላል። ጎግል ላይ የሚሰሩ ፕሮግራመሮች ስራቸውን የሚጀምሩት ቀደም ብለው ነው እና በአብዛኛዎቹ የሥርዓት ቋንቋዎችን በተለይም የC ቤተሰብን ያውቃሉ። በአዲስ የፕሮግራሚንግ ቋንቋ ፈጣን ምርታማነት መስፈርት ቋንቋው በጣም አክራሪ መሆን የለበትም ማለት ነው።

ጥበብ የተሞላባቸው ቃላት አይደል?

የቀላልነት ቅርሶች

ቀላልነት ለውበት አስፈላጊ ሁኔታ ነው. ሌቭ ቶልስቶይ.

ቀላል ማድረግ በማንኛውም ንድፍ ውስጥ በጣም አስፈላጊ ከሆኑ ግቦች ውስጥ አንዱ ነው. እንደሚታወቀው, ፍጹም የሆነ ፕሮጀክት ምንም የሚጨመርበት ነገር የሌለበት ፕሮጀክት አይደለም, ነገር ግን ምንም የሚወገድበት ነገር የሌለበት ነው. ብዙ ሰዎች ውስብስብ ችግሮችን ለመፍታት (ወይም እንዲያውም ለመግለጽ) ውስብስብ መሣሪያ እንደሚያስፈልግ ያምናሉ. ሆኖም ግን አይደለም. ለምሳሌ የPERL ቋንቋን እንውሰድ። የቋንቋ ርዕዮተ ዓለም ተመራማሪዎች አንድን ችግር ለመፍታት ፕሮግራመር ቢያንስ ሦስት የተለያዩ መንገዶች ሊኖሩት እንደሚገባ ያምኑ ነበር። የጎ ቋንቋ ርዕዮተ ዓለም ጠበብቶች የተለየ መንገድ ያዙ፤ ግቡን ለማሳካት አንድ መንገድ፣ ነገር ግን ጥሩ መንገድ ብቻ በቂ እንደሆነ ወሰኑ። ይህ አካሄድ ከባድ መሰረት አለው፡ ብቸኛው መንገድ ለመማር ቀላል እና ለመርሳትም ከባድ ነው።

ብዙ ስደተኞች ቋንቋው የሚያምሩ ረቂቅ ጽሁፎችን አልያዘም ሲሉ ያማርራሉ። አዎ, ይህ እውነት ነው, ነገር ግን ይህ የቋንቋው ዋነኛ ጥቅሞች አንዱ ነው. ቋንቋው በትንሹ አስማት ይዟል - ስለዚህ ፕሮግራሙን ለማንበብ ጥልቅ እውቀት አያስፈልግም. ስለ ኮዱ አነጋገር፣ ይህ ምንም ችግር የለውም። በደንብ የተጻፈ የጎላንግ ፕሮግራም በትንሽ ወይም ምንም መዋቅር ሳይኖረው በአቀባዊ ይነበባል። በተጨማሪም አንድን ፕሮግራም የማንበብ ፍጥነት ቢያንስ ከመጻፍ ፍጥነት የበለጠ የክብደት ቅደም ተከተል ነው። ሁሉም ኮድ አንድ አይነት ቅርጸት እንዳለው ካሰቡ (የተሰራውን gofmt ትዕዛዝ በመጠቀም) ጥቂት ተጨማሪ መስመሮችን ማንበብ ምንም ችግር የለውም።

በጣም ገላጭ አይደለም

አርት ነፃነቱ ሲገደብ አይታገስም። ትክክለኛነት የእሱ ኃላፊነት አይደለም.

በቀላልነት ፍላጎት ምክንያት Go በሌሎች ቋንቋዎች በሰዎች በለመዱት እንደ ተፈጥሯዊ ነገር የሚገነዘቡ ግንባታዎች ይጎድላቸዋል። መጀመሪያ ላይ ትንሽ የማይመች ሊሆን ይችላል፣ ነገር ግን ፕሮግራሙ ለማንበብ በጣም ቀላል እና የበለጠ የማያሻማ መሆኑን ያስተውላሉ።

ለምሳሌ፣ 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);
    }
}

ገሃነም መኮረጅ

ሰው በራሱ ውስጥ ሲኦልን ይሸከማል። ማርቲን ሉተር.

ጀማሪዎች ከጄኔቲክስ እጥረት አንጻር ስለ 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 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;
}

ይሁን እንጂ የዲ ትግበራ የስህተት አያያዝን ችግር ሙሉ በሙሉ ችላ ስለሚል አጭር ብቻ ነው, ግን የበለጠ ትክክል አይደለም.

በእውነተኛ ህይወት, የሎጂክ ውስብስብነት እየጨመረ ሲሄድ, ክፍተቱ በፍጥነት ይቀንሳል. መደበኛ የቋንቋ ኦፕሬተሮችን በመጠቀም ሊከናወን የማይችል ተግባር ማከናወን ሲያስፈልግ ክፍተቱ በበለጠ ፍጥነት ይዘጋል.

ከጠባቂነት፣ ቅልጥፍና እና ተነባቢነት አንፃር፣ በእኔ አስተያየት፣ የ Go ቋንቋ በንግግር ቢሸነፍም፣ ያሸንፋል።

በአንዳንድ ሁኔታዎች አጠቃላይ ፕሮግራሚንግ የማይካዱ ጥቅሞችን ይሰጠናል። ይህ በድርድሩ ጥቅል በግልፅ ተብራርቷል። ስለዚህ, ማንኛውንም ዝርዝር ለመደርደር, የመደርደርን መተግበር ብቻ ያስፈልገናል የበይነገጽ በይነገጽ.

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ን እንደ ምሳሌ እንውሰድ። ምንም እንኳን እነዚህ ተመሳሳይ የጄኔቲክስ ዓይነቶች ቢኖሩም ፣ የዘፈቀደ የመረጃ ዓይነቶች ላሉት ኦፕሬሽኖች ልዩ VARIANT ዓይነት ይይዛል። የጎ ቋንቋም እንዲሁ ያደርጋል።

ከመድፍ እስከ ድንቢጦች

እና የጭረት ጃኬቱ ከእብደቱ መጠን ጋር መስማማት አለበት። ስታኒስላቭ ሌክ.

ብዙ ጽንፈኛ አድናቂዎች Go ጅነሮችን ለመፍጠር ሌላ ዘዴ አለው ሊሉ ይችላሉ - ነጸብራቅ። እና ትክክል ይሆናሉ ... ግን አልፎ አልፎ ብቻ ነው.

ሮብ ፓይክ ያስጠነቅቀናል፡-

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

ዊኪፔዲያ የሚከተለውን ይነግረናል፡-

ነጸብራቅ ማለት አንድ ፕሮግራም በአፈፃፀም ወቅት የራሱን መዋቅር እና ባህሪ መቆጣጠር እና ማስተካከል የሚችልበትን ሂደት ያመለክታል። የፕሮግራሚንግ ፓራዳይም ነጸብራቅ ነጸብራቅ ፕሮግራሚንግ ይባላል። ይህ የሜታፕሮግራም አይነት ነው።

ሆኖም ግን, እንደምታውቁት, ለሁሉም ነገር መክፈል አለቦት. በዚህ ጉዳይ ላይ የሚከተለው ነው-

• ፕሮግራሞችን ለመጻፍ አስቸጋሪነት
• የፕሮግራም አፈፃፀም ፍጥነት

ስለዚህ ነጸብራቅ እንደ ትልቅ መጠን ያለው መሳሪያ በጥንቃቄ ጥቅም ላይ መዋል አለበት. የማሰብ ችሎታ የሌለው ነጸብራቅ መጠቀም ወደማይነበብ ፕሮግራሞች, ቋሚ ስህተቶች እና ዝቅተኛ ፍጥነት ያመጣል. አንድ snob ፕሮግራመር የራሱን ኮድ በሌሎች ፊት ማሳየት መቻል ብቻ ነገር, ይበልጥ ተግባራዊ እና ልከኛ ባልደረቦች.

የባህል ሻንጣ ከ Xi? አይ፣ ከብዙ ቋንቋዎች!

ከሀብቱ ጋር, ዕዳዎች ለወራሾችም ይቀራሉ.

ብዙዎች ቋንቋው ሙሉ በሙሉ በ C ቅርስ ላይ የተመሰረተ ነው ብለው ቢያምኑም, ይህ ግን አይደለም. ቋንቋው ብዙ የምርጥ የፕሮግራም አወጣጥ ቋንቋዎችን ያካትታል።

አገባብ

በመጀመሪያ ደረጃ የሰዋሰው አወቃቀሮች አገባብ በ C ቋንቋ አገባብ ላይ የተመሰረተ ነው. ሆኖም፣ የDELPHI ቋንቋም ከፍተኛ ተጽዕኖ አሳድሯል። ስለዚህ የፕሮግራሙን ተነባቢነት በእጅጉ የሚቀንሱት ተደጋጋሚ ቅንፎች ሙሉ በሙሉ ተወግደዋል። ቋንቋው ከDELPHI ቋንቋ ጋር ያለውን የ":=" ኦፕሬተርን ይዟል። የጥቅሎች ጽንሰ-ሀሳብ እንደ ADA ካሉ ቋንቋዎች የተበደረ ነው። ጥቅም ላይ ያልዋሉ አካላት መግለጫ ከPROLOG ቋንቋ ተበድሯል።

ፍችዎች

ጥቅሎቹ በDELPHI ቋንቋ ፍቺ ላይ የተመሰረቱ ናቸው። እያንዳንዱ ጥቅል መረጃን እና ኮድን ያጠቃልላል እና የግል እና የህዝብ አካላትን ይይዛል። ይህ የጥቅል በይነገጽን በትንሹ እንዲቀንሱ ያስችልዎታል።

በውክልና ዘዴ የማስፈጸሚያ ክዋኔ የተበደረው ከDELPHI ቋንቋ ነው።

ማጠናቀር

ቀልድ ያለው ያለምክንያት አይደለም፡ጎ የተሰራው የC ፕሮግራም እየተጠናቀረ እያለ ነው። የቋንቋው አንዱ ጥንካሬ እጅግ በጣም ፈጣን ቅንብር ነው። ሀሳቡ የተበደረው ከDELPHI ቋንቋ ነው። እያንዳንዱ የGo ጥቅል ከDELPHI ሞጁል ጋር ይዛመዳል። እነዚህ ጥቅሎች እንደገና የሚጠናቀቁት በጣም አስፈላጊ ሲሆን ብቻ ነው። ስለዚህ, ከሚቀጥለው አርትዖት በኋላ, ሙሉውን ፕሮግራም ማጠናቀር አያስፈልግዎትም, ነገር ግን በተቀየሩት ጥቅሎች ላይ የተመሰረቱትን የተለወጡ ፓኬጆችን እና ፓኬጆችን ብቻ እንደገና ያጠናቅቁ (እና ከዚያ በኋላ, የጥቅል መገናኛዎች ከተቀየሩ ብቻ).

ከፍተኛ ደረጃ ግንባታዎች

ቋንቋው እንደ ሲ ካሉ ዝቅተኛ ደረጃ ቋንቋዎች ጋር በምንም መልኩ የማይገናኙ ብዙ የተለያዩ ከፍተኛ ደረጃ ግንባታዎችን ይዟል።

• ሕብረቁምፊዎች
• የሃሽ ጠረጴዛዎች
• ቁርጥራጮች
• ዳክዬ መተየብ እንደ RUBY ካሉ ቋንቋዎች የተበደረ ነው (ይህም በሚያሳዝን ሁኔታ ብዙዎች የማይረዱት ወይም ሙሉ አቅማቸውን የማይጠቀሙ)።

የማህደረ ትውስታ አስተዳደር

የማህደረ ትውስታ አስተዳደር በአጠቃላይ የተለየ ጽሑፍ ይገባዋል። እንደ C++ ባሉ ቋንቋዎች ቁጥጥር ሙሉ ለሙሉ ለገንቢው የተተወ ከሆነ እንደ DELPHI ባሉ በኋላ ቋንቋዎች የማጣቀሻ ቆጠራ ሞዴል ጥቅም ላይ ውሏል። በዚህ አቀራረብ፣ ወላጅ አልባ ክላስተር ስለተፈጠሩ፣ ሳይክል ማመሳከሪያዎች አይፈቀዱም፣ ከዚያ Go ውስጠ ግንቡ እንደዚህ ያሉ ስብስቦችን ማወቂያ አለው (እንደ C #)። በተጨማሪም የቆሻሻ አሰባሳቢው በአሁኑ ጊዜ ከሚታወቁት አተገባበርዎች የበለጠ ቀልጣፋ እና ለብዙ የእውነተኛ ጊዜ ስራዎች ጥቅም ላይ ሊውል ይችላል. ቋንቋው ራሱ ተለዋዋጭን ለማከማቸት እሴት በመደርደሪያው ላይ ሊመደብ በሚችልበት ጊዜ ሁኔታዎችን ያውቃል። ይህ በማስታወሻ አስተዳዳሪው ላይ ያለውን ጭነት ይቀንሳል እና የፕሮግራሙን ፍጥነት ይጨምራል.

Concurrency እና Concurrency

የቋንቋው ትይዩነትና ተወዳዳሪነት ከምስጋና በላይ ነው። የትኛውም ዝቅተኛ ደረጃ ከGo ጋር በርቀት እንኳን ሊወዳደር አይችልም። እውነቱን ለመናገር, ሞዴሉ በቋንቋው ደራሲዎች ያልተፈለሰፈ ሳይሆን በቀላሉ ከድሮው ጥሩ የ ADA ቋንቋ የተበደረ መሆኑን ልብ ሊባል ይገባል. ቋንቋው ሁሉንም ሲፒዩዎች በመጠቀም በሚሊዮኖች የሚቆጠሩ ትይዩ ግንኙነቶችን ማቀናበር የሚችል ሲሆን መጠኑ አነስተኛ ውስብስብ ችግሮች ለባለብዙ-ክር ኮድ የተለመዱ የሞት መቆለፊያዎች እና የዘር ሁኔታዎች አሉት።

ተጨማሪ ጥቅሞች

ትርፋማ ከሆነ ሁሉም ከራስ ወዳድነት ነፃ ይሆናሉ።

ቋንቋ እንዲሁ ብዙ የማያጠራጥር ጥቅሞችን ይሰጠናል፡-

• ፕሮጀክቱን ከገነባ በኋላ አንድ ነጠላ ሊተገበር የሚችል ፋይል የመተግበሪያዎችን መዘርጋት በእጅጉ ያቃልላል።
• የማይለዋወጥ ትየባ እና የመተየብ ማመሳከሪያ በኮድዎ ውስጥ ያሉትን ስህተቶች ብዛት በእጅጉ ሊቀንሱት ይችላሉ፣ ምንም እንኳን ሙከራዎችን ሳይጽፉ። ፈተናዎችን ሳይጽፉ የሚሠሩ አንዳንድ ፕሮግራመሮችን አውቃለሁ እና የኮዳቸው ጥራት ብዙም አይጎዳም።
• በጣም ቀላል የመስቀል-ማጠናቀር እና የመደበኛ ቤተ-መጽሐፍት እጅግ በጣም ጥሩ ተንቀሳቃሽነት ፣ ይህም የመድረክ አፕሊኬሽኖችን እድገት በእጅጉ ያቃልላል።
• RE2 መደበኛ አገላለጾች በክር-አስተማማኝ እና ሊገመቱ የሚችሉ የማስፈጸሚያ ጊዜዎች አሏቸው።
• አብዛኛዎቹ ፕሮጀክቶች ከሶስተኛ ወገን ማዕቀፎች ውጭ እንዲሰሩ የሚያስችል ኃይለኛ መደበኛ ቤተ-መጽሐፍት።
• ቋንቋው ችግሩን እንዴት መፍታት እንዳለበት ከማስቀመጥ ይልቅ ለችግሩ ትኩረት ለመስጠት የሚያስችል ሃይለኛ ነው፣ ነገር ግን ችግሩን በብቃት ለመፍታት የሚያስችል በቂ ደረጃ ዝቅተኛ ነው።
• የ Go eco ስርዓት አስቀድሞ በሁሉም አጋጣሚዎች ከሳጥኑ ውጭ የተሰሩ መሳሪያዎችን ይዟል፡ ሙከራዎች፣ ሰነዶች፣ የጥቅል አስተዳደር፣ ኃይለኛ ሊንተሮች፣ ኮድ ማመንጨት፣ የዘር ሁኔታዎች መፈለጊያ፣ ወዘተ።
• Go ስሪት 1.11 በታዋቂው የቪሲኤስ ማስተናገጃ ላይ አብሮ የተሰራ የትርጉም ጥገኝነት አስተዳደር አስተዋውቋል። የ Go ስነ-ምህዳርን ያካተቱ ሁሉም መሳሪያዎች እነዚህን አገልግሎቶች በአንድ ጊዜ ኮድ ለማውረድ፣ ለመገንባት እና ለመጫን ይጠቀማሉ። እና ያ በጣም ጥሩ ነው። ስሪት 1.11 ሲመጣ፣ የጥቅል እትም ችግርም ሙሉ በሙሉ ተፈትቷል።
• የቋንቋው ዋና ሀሳብ አስማትን መቀነስ ስለሆነ ቋንቋው ገንቢዎች ስህተትን በግልፅ እንዲቆጣጠሩ ያበረታታል። እና ይሄ ትክክል ነው, ምክንያቱም አለበለዚያ, ስለ ስህተት አያያዝ በቀላሉ ይረሳል. ሌላው ነገር አብዛኞቹ ገንቢዎች ሆን ብለው የስህተት አያያዝን ችላ ይሉታል፣ ስህተቱን በቀላሉ ወደ ላይ ማስተላለፍን ይመርጣሉ።
• በንጹህ መልክ በ Go ውስጥ ምንም ምናባዊነት ስለሌለ ቋንቋው የጥንታዊውን OOP ዘዴን አይተገበርም። ነገር ግን, በይነገጾች ሲጠቀሙ ይህ ችግር አይደለም. የኦኦፒ አለመኖር ለጀማሪዎች የመግባት እንቅፋትን በእጅጉ ይቀንሳል።

ለማህበረሰብ ጥቅም ቀላልነት

ለማወሳሰብ ቀላል ነው፣ ለማቅለልም ከባድ ነው።

ሂድ ቀላል እንዲሆን ታስቦ ነበር እና ግቡ ላይ ተሳክቶለታል። የተፃፈው የቡድን ስራን ጥቅሞች ለሚረዱ እና ማለቂያ በሌለው የኢንተርፕራይዝ ደረጃ ቋንቋዎች መለዋወጥ ለሰለቸው ስማርት ፕሮግራመሮች ነው። በአንፃራዊነት አነስተኛ የሆነ የአገባብ አወቃቀሮች ስብስብ በጦር ጦሩ ውስጥ ያለው፣ በጊዜ ሂደት ለለውጥ የተጋለጠ አይደለም፣ ስለዚህ ገንቢዎች ለልማት ብዙ ጊዜ የለቀቁ እንጂ ማለቂያ የለሽ የቋንቋ ፈጠራዎችን ለማጥናት አይደለም።

ኩባንያዎችም በርካታ ጥቅሞችን ይቀበላሉ-ዝቅተኛ የመግቢያ እንቅፋት ልዩ ባለሙያተኞችን በፍጥነት እንዲያገኙ ያስችላቸዋል, እና የቋንቋው ተለዋዋጭነት ከ 10 አመታት በኋላ እንኳን ተመሳሳይ ኮድ እንዲጠቀሙ ያስችላቸዋል.

መደምደሚያ

ትልቅ የአዕምሮ መጠን የትኛውንም ዝሆን የኖቤል ሽልማት አሸናፊ አድርጎ አያውቅም።

ለእነዚያ የግል ኢጎ ከቡድን መንፈስ ቅድሚያ ለሚሰጣቸው ፕሮግራመሮች፣ እንዲሁም የአካዳሚክ ፈተናዎችን ለሚወዱ እና ማለቂያ ለሌለው "ራስን ማሻሻል" ለሚወዱ ቲዎሪስቶች ቋንቋው በጣም መጥፎ ነው ፣ ምክንያቱም እርስዎ እንዲያገኙ የማይፈቅድ አጠቃላይ ዓላማ ያለው የእጅ ጥበብ ቋንቋ ስለሆነ። ከስራህ ውጤት ውበታዊ ደስታ እና በባልደረቦች ፊት እራስህን ሙያዊ አሳይ (ዕውቀትን በ IQ ሳይሆን በእነዚህ መመዘኛዎች የምንለካ ከሆነ)። በህይወት ውስጥ እንደ ሁሉም ነገር, የግል ቅድሚያ የሚሰጣቸው ጉዳዮች ጉዳይ ነው. ልክ እንደ ሁሉም ጠቃሚ ፈጠራዎች፣ ቋንቋው ከዓለም አቀፋዊ ክህደት እስከ የጅምላ ተቀባይነት ድረስ ብዙ ርቀት ተጉዟል። ቋንቋው በቀላልነቱ ብልህ ነው ፣ እና እርስዎ እንደሚያውቁት ፣ ሁሉም ብልህነት ቀላል ነው!

ምንጭ: hab.com