கட்டுரை முன்பு வெளியிடப்பட்ட பதிலுக்கு எழுதப்பட்டது ஆன்டிபோடியன் கட்டுரை.

கடந்த இரண்டு-க்கும் மேற்பட்ட ஆண்டுகளில், வளர்ந்த பில்லிங் அமைப்புடன் கூடிய சிறப்பு RADIUS சேவையகத்தைச் செயல்படுத்த, Go ஐப் பயன்படுத்துகிறேன். வழியில், நான் மொழியின் நுணுக்கங்களைக் கற்றுக்கொள்கிறேன். நிரல்களே மிகவும் எளிமையானவை மற்றும் இந்த கட்டுரையின் நோக்கம் அல்ல, ஆனால் Go ஐப் பயன்படுத்தும் அனுபவம் அதன் பாதுகாப்பில் சில வார்த்தைகளுக்குத் தகுதியானது. கோ தீவிரமான, அளவிடக்கூடிய குறியீட்டிற்கான பெருகிய முறையில் முக்கிய மொழியாக மாறி வருகிறது. இந்த மொழி கூகுளால் உருவாக்கப்பட்டது, அங்கு அது தீவிரமாகப் பயன்படுத்தப்படுகிறது. கீழே வரி, கோ மொழியின் வடிவமைப்பு அறிவாற்றல் இல்லாத புரோகிராமர்களுக்கு மோசமானது என்று நான் நேர்மையாக நினைக்கிறேன்.

பலவீனமான புரோகிராமர்களுக்காக வடிவமைக்கப்பட்டதா?

பலவீனமானவர்கள் பிரச்சனைகளைப் பற்றி பேசுகிறார்கள். யோசனைகள் மற்றும் கனவுகள் பற்றிய வலுவான பேச்சு...

கோ கற்றுக்கொள்வது மிகவும் எளிதானது, எந்த பயிற்சியும் இல்லாமல் குறியீட்டைப் படிக்க முடியும். மொழியின் இந்த அம்சம் பல உலகளாவிய நிறுவனங்களில் பயன்படுத்தப்படுகிறது, குறியீடு அல்லாத முக்கிய நிபுணர்களுடன் (மேலாளர்கள், வாடிக்கையாளர்கள், முதலியன) ஒன்றாகப் படிக்கப்படும் போது. டிசைன் டிரைவன் டெவலப்மென்ட் போன்ற வழிமுறைகளுக்கு இது மிகவும் வசதியானது.
புதிய புரோகிராமர்கள் கூட ஒரு வாரம் அல்லது இரண்டு நாட்களுக்குப் பிறகு மிகவும் ஒழுக்கமான குறியீட்டை உருவாக்கத் தொடங்குகிறார்கள். நான் படித்த புத்தகம் “கோ புரோகிராமிங்” (மார்க் சம்மர்ஃபீல்ட் எழுதியது). புத்தகம் மிகவும் நன்றாக உள்ளது, இது மொழியின் பல நுணுக்கங்களைத் தொடுகிறது. ஜாவா, PHP போன்ற தேவையற்ற சிக்கலான மொழிகளுக்குப் பிறகு, மந்திரம் இல்லாதது புத்துணர்ச்சி அளிக்கிறது. ஆனால் விரைவில் அல்லது பின்னர், பல வரையறுக்கப்பட்ட புரோகிராமர்கள் புதிய துறையில் பழைய முறைகளைப் பயன்படுத்துவதற்கான யோசனையைக் கொண்டுள்ளனர். இது உண்மையில் அவசியமா?

ராப் பைக் (மொழியின் முக்கிய சித்தாந்தவாதி) கோ மொழியை ஒரு தொழில்துறை மொழியாக உருவாக்கினார், இது புரிந்து கொள்ள எளிதானது மற்றும் பயன்படுத்த பயனுள்ளதாக இருக்கும். பெரிய அணிகளில் அதிகபட்ச உற்பத்தித்திறனுக்காக மொழி வடிவமைக்கப்பட்டுள்ளது, அதைப் பற்றி எந்த சந்தேகமும் இல்லை. பல புதிய புரோகிராமர்கள் பல அம்சங்களைக் காணவில்லை என்று புகார் கூறுகின்றனர். எளிமைக்கான இந்த விருப்பம் மொழியின் வடிவமைப்பாளர்களின் நனவான முடிவாகும், மேலும் அது ஏன் தேவைப்பட்டது என்பதை முழுமையாகப் புரிந்துகொள்வதற்கு, டெவலப்பர்களின் உந்துதலையும் அவர்கள் கோவில் எதைச் சாதிக்க முயற்சிக்கிறார்கள் என்பதையும் நாம் புரிந்து கொள்ள வேண்டும்.

அது ஏன் மிகவும் எளிமையாக செய்யப்பட்டது? ராப் பைக்கின் சில மேற்கோள்கள் இங்கே:

இங்கே முக்கிய விஷயம் என்னவென்றால், எங்கள் புரோகிராமர்கள் ஆராய்ச்சியாளர்கள் அல்ல. அவர்கள், ஒரு விதியாக, மிகவும் இளமையாக இருக்கிறார்கள், படித்த பிறகு எங்களிடம் வருகிறார்கள், ஒருவேளை அவர்கள் ஜாவா, அல்லது சி/சி++ அல்லது பைதான் படித்திருக்கலாம். அவர்களால் ஒரு சிறந்த மொழியைப் புரிந்து கொள்ள முடியாது, ஆனால் அதே நேரத்தில் அவர்கள் நல்ல மென்பொருளை உருவாக்க வேண்டும் என்று நாங்கள் விரும்புகிறோம். எனவேதான் மொழி எளிதாகப் புரிந்துகொள்ளவும் கற்றுக்கொள்ளவும் இருக்க வேண்டும்.

அவர் பரிச்சயமானவராக இருக்க வேண்டும், தோராயமாக சியைப் போலவே பேசுகிறார். கூகுளில் பணிபுரியும் புரோகிராமர்கள் தங்கள் பணியை ஆரம்பத்திலேயே தொடங்குகின்றனர் மற்றும் பெரும்பாலும் நடைமுறை மொழிகள், குறிப்பாக சி குடும்பத்தை நன்கு அறிந்தவர்கள். ஒரு புதிய நிரலாக்க மொழியில் விரைவான உற்பத்தித்திறன் தேவை என்பது மொழி மிகவும் தீவிரமானதாக இருக்கக்கூடாது என்பதாகும்.

புத்திசாலித்தனமான வார்த்தைகள், இல்லையா?

எளிமையின் கலைப்பொருட்கள்

அழகுக்கு எளிமை அவசியமான நிபந்தனை. லெவ் டால்ஸ்டாய்.

எந்தவொரு வடிவமைப்பிலும் அதை எளிமையாக வைத்திருப்பது மிக முக்கியமான குறிக்கோள்களில் ஒன்றாகும். உங்களுக்குத் தெரியும், ஒரு சரியான திட்டம் என்பது சேர்க்க எதுவும் இல்லாத ஒரு திட்டம் அல்ல, ஆனால் அதில் இருந்து நீக்க எதுவும் இல்லை. சிக்கலான சிக்கல்களைத் தீர்க்க (அல்லது வெளிப்படுத்தவும்) ஒரு சிக்கலான கருவி தேவை என்று பலர் நம்புகிறார்கள். எனினும், அது இல்லை. உதாரணமாக 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)
}

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 செயல்படுத்தல் பிழை கையாளுதலின் சிக்கலை முற்றிலும் புறக்கணிக்கிறது.

நிஜ வாழ்க்கையில், தர்க்கத்தின் சிக்கலான தன்மை அதிகரிக்கும்போது, ​​இடைவெளி வேகமாகக் குறைகிறது. நிலையான மொழி ஆபரேட்டர்களைப் பயன்படுத்தி செய்ய முடியாத செயலைச் செய்ய வேண்டியிருக்கும் போது இடைவெளி இன்னும் வேகமாக மூடப்படும்.

பராமரித்தல், நீட்டிப்பு மற்றும் வாசிப்புத்திறன் ஆகியவற்றின் அடிப்படையில், என் கருத்துப்படி, கோ மொழி வெற்றி பெறுகிறது, இருப்பினும் அது வாய்மொழியில் இழந்தது.

சில சந்தர்ப்பங்களில் பொதுவான நிரலாக்கமானது நமக்கு மறுக்க முடியாத பலன்களை அளிக்கிறது. இது வரிசை தொகுப்பு மூலம் தெளிவாக விளக்கப்பட்டுள்ளது. எனவே, எந்த பட்டியலையும் வரிசைப்படுத்த, நாம் 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 கட்டளையை இயக்கினால், குழப்பமான இடைமுகங்கள் எவ்வளவு அடிக்கடி பயன்படுத்தப்படுகின்றன என்பதை நீங்கள் காண்பீர்கள். இதற்கெல்லாம் ஜெனரிக்ஸ் இல்லாததுதான் காரணம் என்று நெருங்கிய தோழர்கள் உடனே சொல்வார்கள். இருப்பினும், இது எப்போதும் வழக்கு அல்ல. உதாரணமாக DELPHI ஐ எடுத்துக்கொள்வோம். இதே ஜெனரிக்ஸ் இருந்தபோதிலும், தன்னிச்சையான தரவு வகைகளைக் கொண்ட செயல்பாடுகளுக்கு இது ஒரு சிறப்பு மாறுபாடு வகையைக் கொண்டுள்ளது. கோ மொழியும் அதையே செய்கிறது.

பீரங்கி முதல் சிட்டுக்குருவிகள் வரை

மற்றும் ஸ்ட்ரைட்ஜாக்கெட் பைத்தியக்காரத்தனத்தின் அளவிற்கு பொருந்த வேண்டும். ஸ்டானிஸ்லாவ் லெக்.

பல தீவிர ரசிகர்கள் Go விற்கு பொதுவானவற்றை உருவாக்குவதற்கான மற்றொரு வழிமுறை உள்ளது என்று கூறலாம் - பிரதிபலிப்பு. அவர்கள் சரியாக இருப்பார்கள் ... ஆனால் அரிதான சந்தர்ப்பங்களில் மட்டுமே.

ராப் பைக் நம்மை எச்சரிக்கிறார்:

இது ஒரு சக்திவாய்ந்த கருவியாகும், இது எச்சரிக்கையுடன் பயன்படுத்தப்பட வேண்டும். கண்டிப்பாக தேவையில்லாமல் தவிர்க்கப்பட வேண்டும்.

விக்கிபீடியா நமக்கு பின்வருவனவற்றைச் சொல்கிறது:

பிரதிபலிப்பு என்பது செயல்பாட்டின் போது ஒரு நிரல் அதன் சொந்த அமைப்பு மற்றும் நடத்தையை கண்காணிக்கும் மற்றும் மாற்றியமைக்கும் செயல்முறையை குறிக்கிறது. பிரதிபலிப்புக்கு அடிப்படையான நிரலாக்க முன்னுதாரணமானது பிரதிபலிப்பு நிரலாக்கம் எனப்படும். இது ஒரு வகை மெட்டா புரோகிராமிங்.

இருப்பினும், உங்களுக்குத் தெரிந்தபடி, நீங்கள் எல்லாவற்றிற்கும் பணம் செலுத்த வேண்டும். இந்த வழக்கில் இது:

• நிரல்களை எழுதுவதில் சிரமம்
• நிரல் செயல்படுத்தும் வேகம்

எனவே, பிரதிபலிப்பு ஒரு பெரிய அளவிலான ஆயுதம் போன்ற எச்சரிக்கையுடன் பயன்படுத்தப்பட வேண்டும். சிந்தனையற்ற பிரதிபலிப்பு பயன்பாடு படிக்க முடியாத நிரல்களுக்கு வழிவகுக்கிறது, நிலையான பிழைகள் மற்றும் குறைந்த வேகம். ஒரு ஸ்னோப் புரோகிராமர் தனது குறியீட்டை மற்ற, மிகவும் நடைமுறை மற்றும் அடக்கமான சக ஊழியர்களுக்கு முன்னால் காட்ட முடியும்.

Xi இலிருந்து கலாச்சார சாமான்கள்? இல்லை, பல மொழிகளில் இருந்து!

அதிர்ஷ்டத்துடன், கடன்களும் வாரிசுகளுக்கு விடப்படுகின்றன.

மொழி முற்றிலும் சி பாரம்பரியத்தை அடிப்படையாகக் கொண்டது என்று பலர் நம்பினாலும், இது அவ்வாறு இல்லை. மொழி சிறந்த நிரலாக்க மொழிகளின் பல அம்சங்களை உள்ளடக்கியது.

தொடரியல்

முதலாவதாக, இலக்கண அமைப்புகளின் தொடரியல் சி மொழியின் தொடரியல் அடிப்படையிலானது. இருப்பினும், DELPHI மொழியும் குறிப்பிடத்தக்க தாக்கத்தை ஏற்படுத்தியது. இதனால், நிரலின் வாசிப்புத்திறனை வெகுவாகக் குறைக்கும் தேவையற்ற அடைப்புக்குறிகள் முற்றிலும் நீக்கப்பட்டிருப்பதைக் காண்கிறோம். DELPHI மொழியின் உள்ளார்ந்த “:=” ஆபரேட்டரையும் மொழி கொண்டுள்ளது. தொகுப்புகளின் கருத்து ADA போன்ற மொழிகளிலிருந்து கடன் வாங்கப்பட்டது. பயன்படுத்தப்படாத நிறுவனங்களின் அறிவிப்பு PROLOG மொழியிலிருந்து கடன் வாங்கப்பட்டது.

சொற்பொருள்

தொகுப்புகள் DELPHI மொழியின் சொற்பொருளின் அடிப்படையில் அமைந்தன. ஒவ்வொரு தொகுப்பும் தரவு மற்றும் குறியீட்டை இணைக்கிறது மற்றும் தனியார் மற்றும் பொது நிறுவனங்களைக் கொண்டுள்ளது. தொகுப்பு இடைமுகத்தை குறைந்தபட்சமாக குறைக்க இது உங்களை அனுமதிக்கிறது.

பிரதிநிதித்துவ முறை மூலம் செயல்படுத்தும் செயல்பாடு DELPHI மொழியிலிருந்து கடன் வாங்கப்பட்டது.

தொகுப்பு

ஒரு நகைச்சுவை இருப்பது காரணமின்றி இல்லை: ஒரு C நிரல் தொகுக்கப்படும் போது Go உருவாக்கப்பட்டது. மொழியின் பலங்களில் ஒன்று அதன் அதிவேக தொகுப்பு. யோசனை DELPHI மொழியிலிருந்து கடன் வாங்கப்பட்டது. ஒவ்வொரு Go தொகுப்பும் DELPHI தொகுதிக்கு ஒத்திருக்கும். இந்த தொகுப்புகள் உண்மையில் தேவைப்படும் போது மட்டுமே மீண்டும் தொகுக்கப்படும். எனவே, அடுத்த திருத்தத்திற்குப் பிறகு, நீங்கள் முழு நிரலையும் தொகுக்க வேண்டியதில்லை, மாறாக மாற்றப்பட்ட தொகுப்புகள் மற்றும் தொகுப்புகளை மட்டுமே மீண்டும் தொகுக்க வேண்டும் (அப்போது கூட, தொகுப்பு இடைமுகங்கள் மாறியிருந்தால் மட்டுமே).

உயர் நிலை கட்டுமானங்கள்

சி போன்ற குறைந்த-நிலை மொழிகளுடன் எந்த வகையிலும் தொடர்பில்லாத பல உயர்-நிலை கட்டமைப்புகளை மொழி கொண்டுள்ளது.

• சரங்கள்
• ஹாஷ் அட்டவணைகள்
• துண்டுகள்
• டக் டைப்பிங் RUBY போன்ற மொழிகளிலிருந்து கடன் வாங்கப்பட்டது (துரதிர்ஷ்டவசமாக, பலர் புரிந்து கொள்ளவில்லை அல்லது அதன் முழு திறனைப் பயன்படுத்துகிறார்கள்).

நினைவக மேலாண்மை

நினைவக மேலாண்மை பொதுவாக ஒரு தனி கட்டுரைக்கு தகுதியானது. C++ போன்ற மொழிகளில், கட்டுப்பாடு முழுமையாக டெவலப்பரிடம் விடப்பட்டால், பின்னர் DELPHI போன்ற மொழிகளில், ஒரு குறிப்பு எண்ணும் மாதிரி பயன்படுத்தப்பட்டது. இந்த அணுகுமுறையால், சுழற்சி குறிப்புகள் அனுமதிக்கப்படவில்லை, ஏனெனில் அனாதைக் குழுக்கள் உருவாக்கப்பட்டன, பின்னர் கோ அத்தகைய கிளஸ்டர்களை (C# போன்றவை) உள்ளமைந்த கண்டறிதலை கொண்டுள்ளது. கூடுதலாக, குப்பை சேகரிப்பான் தற்போது அறியப்பட்ட செயலாக்கங்களை விட மிகவும் திறமையானது மற்றும் பல நிகழ்நேர பணிகளுக்கு ஏற்கனவே பயன்படுத்தப்படலாம். ஒரு மாறியை சேமிப்பதற்கான மதிப்பை அடுக்கில் ஒதுக்கப்படும் போது மொழியே சூழ்நிலைகளை அங்கீகரிக்கிறது. இது நினைவக மேலாளரின் சுமையை குறைக்கிறது மற்றும் நிரலின் வேகத்தை அதிகரிக்கிறது.

ஒத்திசைவு மற்றும் ஒத்திசைவு

மொழியின் இணையான தன்மையும் போட்டித்தன்மையும் பாராட்டிற்கு அப்பாற்பட்டது. எந்த ஒரு குறைந்த-நிலை மொழியும் Go உடன் தொலைதூரத்தில் கூட போட்டியிட முடியாது. சரியாகச் சொல்வதானால், இந்த மாதிரி மொழியின் ஆசிரியர்களால் கண்டுபிடிக்கப்படவில்லை, ஆனால் நல்ல பழைய ADA மொழியிலிருந்து கடன் வாங்கப்பட்டது என்பது கவனிக்கத்தக்கது. இந்த மொழியானது அனைத்து CPUகளைப் பயன்படுத்தி மில்லியன் கணக்கான இணையான இணைப்புகளைச் செயலாக்கும் திறன் கொண்டது, அதே சமயம் மல்டி-த்ரெட் குறியீடுகளுக்கான பொதுவான டெட்லாக்குகள் மற்றும் ரேஸ் நிலைமைகள் ஆகியவற்றுடன் குறைவான சிக்கலான சிக்கல்களைக் கொண்டிருக்கும்.

கூடுதல் நன்மைகள்

லாபகரமாக இருந்தால் எல்லாரும் தன்னலமற்றவர்களாகி விடுவார்கள்.

மொழி நமக்கு சந்தேகத்திற்கு இடமில்லாத பல நன்மைகளையும் வழங்குகிறது:

• திட்டத்தை உருவாக்கிய பிறகு ஒரு இயங்கக்கூடிய கோப்பு பயன்பாடுகளின் வரிசைப்படுத்தலை பெரிதும் எளிதாக்குகிறது.
• நிலையான தட்டச்சு மற்றும் வகை அனுமானம் சோதனைகளை எழுதாமல் கூட, உங்கள் குறியீட்டில் உள்ள பிழைகளின் எண்ணிக்கையைக் கணிசமாகக் குறைக்கும். சோதனைகளை எழுதாமல் செய்யும் சில புரோகிராமர்களை நான் அறிவேன், மேலும் அவர்களின் குறியீட்டின் தரம் கணிசமாக பாதிக்கப்படாது.
• மிகவும் எளிமையான குறுக்கு-தொகுப்பு மற்றும் நிலையான நூலகத்தின் சிறந்த பெயர்வுத்திறன், இது குறுக்கு-தளம் பயன்பாடுகளின் வளர்ச்சியை பெரிதும் எளிதாக்குகிறது.
• RE2 வழக்கமான வெளிப்பாடுகள் நூல்-பாதுகாப்பானவை மற்றும் கணிக்கக்கூடிய செயல்பாட்டு நேரங்களைக் கொண்டுள்ளன.
• மூன்றாம் தரப்பு கட்டமைப்புகள் இல்லாமல் பெரும்பாலான திட்டங்களைச் செய்ய அனுமதிக்கும் சக்திவாய்ந்த நிலையான நூலகம்.
• மொழியானது சிக்கலை எவ்வாறு தீர்ப்பது என்பதைக் காட்டிலும் அதன் மீது கவனம் செலுத்தும் அளவுக்கு சக்தி வாய்ந்தது, ஆனால் சிக்கலைத் திறமையாகத் தீர்க்கும் அளவுக்கு குறைந்த மட்டத்தில் உள்ளது.
• Go eco அமைப்பில் ஏற்கனவே அனைத்து சந்தர்ப்பங்களிலும் உருவாக்கப்பட்ட கருவிகள் உள்ளன: சோதனைகள், ஆவணங்கள், தொகுப்பு மேலாண்மை, சக்திவாய்ந்த லின்டர்கள், குறியீடு உருவாக்கம், ரேஸ் நிலைமைகளைக் கண்டறியும் கருவி போன்றவை.
• Go பதிப்பு 1.11 பிரபலமான VCS ஹோஸ்டிங்கின் மேல் கட்டமைக்கப்பட்ட உள்ளமைக்கப்பட்ட சொற்பொருள் சார்பு மேலாண்மையை அறிமுகப்படுத்தியது. Go சுற்றுச்சூழல் அமைப்பை உருவாக்கும் அனைத்துக் கருவிகளும் இந்தச் சேவைகளைப் பயன்படுத்தி ஒரேயடியாக அவற்றிலிருந்து குறியீட்டைப் பதிவிறக்கவும், உருவாக்கவும் மற்றும் நிறுவவும். அதுவும் நன்றாக இருக்கிறது. பதிப்பு 1.11 இன் வருகையுடன், தொகுப்பு பதிப்பில் உள்ள சிக்கல் முற்றிலும் தீர்க்கப்பட்டது.
• மாயாஜாலத்தைக் குறைப்பதே மொழியின் முக்கிய யோசனையாக இருப்பதால், மொழி டெவலப்பர்களை பிழை கையாளுதலை வெளிப்படையாகச் செய்ய ஊக்குவிக்கிறது. இது சரியானது, இல்லையெனில், பிழை கையாளுதலை முற்றிலும் மறந்துவிடும். மற்றொரு விஷயம் என்னவென்றால், பெரும்பாலான டெவலப்பர்கள் வேண்டுமென்றே பிழை கையாளுதலைப் புறக்கணிக்கிறார்கள், அவற்றைச் செயலாக்குவதற்குப் பதிலாக பிழையை மேல்நோக்கி அனுப்ப விரும்புகிறார்கள்.
• மொழி கிளாசிக்கல் OOP முறையை செயல்படுத்தவில்லை, ஏனெனில் அதன் தூய வடிவத்தில் கோவில் மெய்நிகர் இல்லை. இருப்பினும், இடைமுகங்களைப் பயன்படுத்தும் போது இது ஒரு பிரச்சனையல்ல. OOP இல்லாமை ஆரம்பநிலைக்கு நுழைவதற்கான தடையை கணிசமாகக் குறைக்கிறது.

சமூக நலனுக்கான எளிமை

சிக்கலாக்குவது எளிது, எளிமைப்படுத்துவது கடினம்.

கோ எளிமையானதாக வடிவமைக்கப்பட்டுள்ளது, அது அந்த இலக்கை அடையும். குழுப்பணியின் நன்மைகளைப் புரிந்துகொள்ளும் மற்றும் நிறுவன அளவிலான மொழிகளின் முடிவில்லாத மாறுபாட்டால் சோர்வடைந்த ஸ்மார்ட் புரோகிராமர்களுக்காக இது எழுதப்பட்டது. அதன் ஆயுதக் களஞ்சியத்தில் ஒப்பீட்டளவில் சிறிய தொடரியல் கட்டமைப்புகளைக் கொண்டிருப்பதால், இது நடைமுறையில் காலப்போக்கில் மாற்றங்களுக்கு உட்பட்டது அல்ல, எனவே டெவலப்பர்கள் வளர்ச்சிக்காக நிறைய நேரம் விடுவிக்கப்படுகிறார்கள், மொழி கண்டுபிடிப்புகளை முடிவில்லாமல் படிப்பதற்காக அல்ல.

நிறுவனங்கள் பல நன்மைகளைப் பெறுகின்றன: குறைந்த நுழைவுத் தடையானது ஒரு நிபுணரை விரைவாகக் கண்டறிய அனுமதிக்கிறது, மேலும் மொழியின் மாறாத தன்மை 10 ஆண்டுகளுக்குப் பிறகும் அதே குறியீட்டைப் பயன்படுத்த அனுமதிக்கிறது.

முடிவுக்கு

பெரிய மூளை அளவு எந்த யானையையும் நோபல் பரிசை வென்றதில்லை.

குழு உணர்வை விட தனிப்பட்ட ஈகோ முன்னுரிமை பெறும் புரோகிராமர்களுக்கும், கல்வி சவால்கள் மற்றும் முடிவில்லாத "சுய முன்னேற்றம்" ஆகியவற்றை விரும்பும் கோட்பாட்டாளர்களுக்கும், மொழி மிகவும் மோசமாக உள்ளது, ஏனெனில் இது ஒரு பொது-நோக்க கைவினைஞர் மொழியாகும், இது உங்களைப் பெற அனுமதிக்காது. உங்கள் பணியின் விளைவாக அழகியல் இன்பம் மற்றும் சக ஊழியர்களுக்கு முன்னால் உங்களை நிபுணத்துவமாகக் காட்டுங்கள் (இந்த அளவுகோல்களால் நாங்கள் அறிவாற்றலை அளவிடுகிறோம், ஆனால் IQ மூலம் அல்ல). வாழ்க்கையில் எல்லாவற்றையும் போலவே, இது தனிப்பட்ட முன்னுரிமைகளின் விஷயம். அனைத்து பயனுள்ள புதுமைகளைப் போலவே, மொழியும் ஏற்கனவே உலகளாவிய மறுப்பிலிருந்து வெகுஜன ஏற்றுக்கொள்ளல் வரை நீண்ட தூரம் வந்துவிட்டது. மொழி அதன் எளிமையில் தனித்துவமானது, மேலும், உங்களுக்குத் தெரிந்தபடி, தனித்துவமான அனைத்தும் எளிமையானவை!

ஆதாரம்: www.habr.com