മുമ്പ് പ്രസിദ്ധീകരിച്ച ഒരു ലേഖനത്തിനുള്ള മറുപടി എന്ന നിലയിലാണ് ലേഖനം എഴുതിയത് ആന്റിപോഡിയൻ ലേഖനം.

വികസിത ബില്ലിംഗ് സംവിധാനമുള്ള ഒരു പ്രത്യേക RADIUS സെർവർ നടപ്പിലാക്കാൻ കഴിഞ്ഞ രണ്ട്-ലധികം വർഷങ്ങളായി ഞാൻ Go ഉപയോഗിക്കുന്നു. വഴിയിൽ, ഞാൻ ഭാഷയുടെ സങ്കീർണതകൾ പഠിക്കുകയാണ്. പ്രോഗ്രാമുകൾ തന്നെ വളരെ ലളിതവും ഈ ലേഖനത്തിന്റെ ഉദ്ദേശ്യവുമല്ല, എന്നാൽ Go ഉപയോഗിക്കുന്ന അനുഭവം അതിന്റെ പ്രതിരോധത്തിൽ കുറച്ച് വാക്കുകൾ അർഹിക്കുന്നു. ഗൌരവമുള്ളതും അളക്കാവുന്നതുമായ കോഡിനായി Go ഒരു മുഖ്യധാരാ ഭാഷയായി മാറുകയാണ്. ഭാഷ സൃഷ്ടിച്ചത് Google ആണ്, അവിടെ അത് സജീവമായി ഉപയോഗിക്കുന്നു. അടിവരയിട്ട്, ഗോ ഭാഷയുടെ രൂപകൽപ്പന ബുദ്ധിയില്ലാത്ത പ്രോഗ്രാമർമാർക്ക് മോശമാണെന്ന് ഞാൻ സത്യസന്ധമായി കരുതുന്നു.

ദുർബലമായ പ്രോഗ്രാമർമാർക്കായി രൂപകൽപ്പന ചെയ്‌തിട്ടുണ്ടോ?

ദുർബലർ പ്രശ്നങ്ങളെക്കുറിച്ച് സംസാരിക്കുന്നു. ആശയങ്ങളെയും സ്വപ്നങ്ങളെയും കുറിച്ചുള്ള ശക്തമായ സംസാരം...

ഗോ പഠിക്കാൻ വളരെ എളുപ്പമാണ്, പരിശീലനമൊന്നും കൂടാതെ നിങ്ങൾക്ക് കോഡ് വായിക്കാൻ കഴിയുന്നത്ര എളുപ്പമാണ്. കോഡ് നോൺ-കോർ സ്പെഷ്യലിസ്റ്റുകൾ (മാനേജർമാർ, ഉപഭോക്താക്കൾ മുതലായവ) ഒരുമിച്ച് വായിക്കുമ്പോൾ, പല ആഗോള കമ്പനികളിലും ഭാഷയുടെ ഈ സവിശേഷത ഉപയോഗിക്കുന്നു. ഡിസൈൻ ഡ്രൈവൺ ഡെവലപ്‌മെന്റ് പോലുള്ള രീതിശാസ്ത്രങ്ങൾക്ക് ഇത് വളരെ സൗകര്യപ്രദമാണ്.
തുടക്കക്കാരായ പ്രോഗ്രാമർമാർ പോലും ഒന്നോ രണ്ടോ ആഴ്ചകൾക്കുശേഷം മാന്യമായ കോഡ് നിർമ്മിക്കാൻ തുടങ്ങുന്നു. ഞാൻ പഠിച്ച പുസ്തകമാണ് "ഗോ പ്രോഗ്രാമിംഗ്" (മാർക്ക് സമ്മർഫീൽഡ് എഴുതിയത്). പുസ്തകം വളരെ നല്ലതാണ്, അത് ഭാഷയുടെ നിരവധി സൂക്ഷ്മതകളെ സ്പർശിക്കുന്നു. ജാവ, പി‌എച്ച്‌പി പോലുള്ള അനാവശ്യ സങ്കീർണ്ണമായ ഭാഷകൾക്ക് ശേഷം, മാന്ത്രികതയുടെ അഭാവം ഉന്മേഷദായകമാണ്. എന്നാൽ താമസിയാതെ അല്ലെങ്കിൽ പിന്നീട്, പല പരിമിത പ്രോഗ്രാമർമാർക്കും ഒരു പുതിയ ഫീൽഡിൽ പഴയ രീതികൾ ഉപയോഗിക്കാനുള്ള ആശയം ഉണ്ട്. ഇത് ശരിക്കും ആവശ്യമാണോ?

റോബ് പൈക്ക് (ഭാഷയുടെ പ്രധാന പ്രത്യയശാസ്ത്രജ്ഞൻ) ഗോ ഭാഷ ഒരു വ്യാവസായിക ഭാഷയായി സൃഷ്ടിച്ചു, അത് മനസ്സിലാക്കാൻ എളുപ്പവും ഉപയോഗിക്കാൻ ഫലപ്രദവുമാണ്. വലിയ ടീമുകളിൽ പരമാവധി ഉൽപ്പാദനക്ഷമതയ്ക്കായി ഭാഷ രൂപകൽപ്പന ചെയ്തിട്ടുള്ളതാണ്, അതിൽ യാതൊരു സംശയവുമില്ല. പല തുടക്കക്കാരായ പ്രോഗ്രാമർമാരും തങ്ങൾക്ക് നഷ്‌ടമായ നിരവധി സവിശേഷതകൾ ഉണ്ടെന്ന് പരാതിപ്പെടുന്നു. ലാളിത്യത്തിനായുള്ള ഈ ആഗ്രഹം ഭാഷയുടെ ഡിസൈനർമാരുടെ ബോധപൂർവമായ തീരുമാനമായിരുന്നു, അത് എന്തുകൊണ്ട് ആവശ്യമാണെന്ന് പൂർണ്ണമായി മനസിലാക്കാൻ, ഡെവലപ്പർമാരുടെ പ്രചോദനവും അവർ Go-യിൽ എന്താണ് നേടാൻ ശ്രമിക്കുന്നതെന്നും നമ്മൾ മനസ്സിലാക്കണം.

പിന്നെ എന്തിനാണ് ഇത് ഇത്ര ലളിതമാക്കിയത്? റോബ് പൈക്കിൽ നിന്നുള്ള രണ്ട് ഉദ്ധരണികൾ ഇതാ:

ഞങ്ങളുടെ പ്രോഗ്രാമർമാർ ഗവേഷകരല്ല എന്നതാണ് ഇവിടെ പ്രധാന കാര്യം. അവർ, ചട്ടം പോലെ, വളരെ ചെറുപ്പമാണ്, പഠിച്ചതിന് ശേഷം ഞങ്ങളുടെ അടുത്തേക്ക് വരുന്നു, ഒരുപക്ഷേ അവർ ജാവ, അല്ലെങ്കിൽ സി / സി ++ അല്ലെങ്കിൽ പൈത്തൺ പഠിച്ചു. അവർക്ക് മികച്ച ഭാഷ മനസ്സിലാക്കാൻ കഴിയില്ല, എന്നാൽ അതേ സമയം അവർ നല്ല സോഫ്റ്റ്‌വെയർ സൃഷ്ടിക്കണമെന്ന് ഞങ്ങൾ ആഗ്രഹിക്കുന്നു. അതുകൊണ്ടാണ് ഭാഷ മനസ്സിലാക്കാനും പഠിക്കാനും എളുപ്പമുള്ളതായിരിക്കണം.

അവൻ പരിചിതനായിരിക്കണം, ഏകദേശം പറഞ്ഞാൽ സി. ഗൂഗിളിൽ പ്രവർത്തിക്കുന്ന പ്രോഗ്രാമർമാർ അവരുടെ കരിയർ നേരത്തെ ആരംഭിക്കുകയും നടപടിക്രമ ഭാഷകൾ, പ്രത്യേകിച്ച് സി ഫാമിലിയുമായി പരിചയപ്പെടുകയും ചെയ്യുന്നു. ഒരു പുതിയ പ്രോഗ്രാമിംഗ് ഭാഷയിൽ ദ്രുത ഉൽപ്പാദനക്ഷമതയുടെ ആവശ്യകത അർത്ഥമാക്കുന്നത് ഭാഷ വളരെ സമൂലമായിരിക്കരുത് എന്നാണ്.

ബുദ്ധിയുള്ള വാക്കുകൾ, അല്ലേ?

ലാളിത്യത്തിന്റെ പുരാവസ്തുക്കൾ

ലാളിത്യം സൗന്ദര്യത്തിന് ആവശ്യമായ ഒരു വ്യവസ്ഥയാണ്. ലെവ് ടോൾസ്റ്റോയ്.

ലളിതമായി സൂക്ഷിക്കുക എന്നത് ഏതൊരു ഡിസൈനിലെയും ഏറ്റവും പ്രധാനപ്പെട്ട ലക്ഷ്യങ്ങളിലൊന്നാണ്. നിങ്ങൾക്കറിയാവുന്നതുപോലെ, ഒരു പെർഫെക്റ്റ് പ്രോജക്റ്റ് എന്നത് ചേർക്കാൻ ഒന്നുമില്ലാത്ത ഒരു പ്രോജക്റ്റല്ല, എന്നാൽ അതിൽ നിന്ന് നീക്കം ചെയ്യാൻ ഒന്നുമില്ല. സങ്കീർണ്ണമായ പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നതിന് (അല്ലെങ്കിൽ പോലും പ്രകടിപ്പിക്കാൻ) സങ്കീർണ്ണമായ ഒരു ഉപകരണം ആവശ്യമാണെന്ന് പലരും വിശ്വസിക്കുന്നു. എന്നിരുന്നാലും, അങ്ങനെയല്ല. ഉദാഹരണത്തിന് 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)
}

ഡിയിലെ അതേ പ്രശ്‌നത്തിനുള്ള പരിഹാരം, കുറച്ചുകൂടി ചെറുതായി തോന്നുമെങ്കിലും, വായിക്കാൻ എളുപ്പമല്ല

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

കൂടാതെ, ഞങ്ങളുടെ കോഡ് മുമ്പത്തെ കേസിനേക്കാൾ ദൈർഘ്യമേറിയതാണെങ്കിലും, അത് സാമാന്യവൽക്കരിക്കപ്പെട്ടിരിക്കുന്നു. അതിനാൽ, എല്ലാ ഗണിത പ്രവർത്തനങ്ങളും നടപ്പിലാക്കാൻ ഞങ്ങൾക്ക് ബുദ്ധിമുട്ടുണ്ടാകില്ല.

ഡിയിലെ ഒരു പ്രോഗ്രാം വളരെ ചെറുതായി കാണപ്പെടുന്നുവെന്നും അവ ശരിയായിരിക്കുമെന്നും പലരും പറയും.

import std.stdio;
import std.algorithm;

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

എന്നിരുന്നാലും, ഇത് ചെറുതാണ്, പക്ഷേ കൂടുതൽ ശരിയല്ല, കാരണം ഡി നടപ്പിലാക്കൽ പിശക് കൈകാര്യം ചെയ്യുന്നതിന്റെ പ്രശ്നം പൂർണ്ണമായും അവഗണിക്കുന്നു.

യഥാർത്ഥ ജീവിതത്തിൽ, യുക്തിയുടെ സങ്കീർണ്ണത വർദ്ധിക്കുന്നതിനനുസരിച്ച്, വിടവ് അതിവേഗം കുറയുന്നു. സ്റ്റാൻഡേർഡ് ലാംഗ്വേജ് ഓപ്പറേറ്റർമാർ ഉപയോഗിച്ച് ചെയ്യാൻ കഴിയാത്ത ഒരു പ്രവർത്തനം നിങ്ങൾക്ക് ആവശ്യമുള്ളപ്പോൾ വിടവ് കൂടുതൽ വേഗത്തിൽ അടയ്ക്കുന്നു.

മെയിന്റനബിലിറ്റി, എക്സ്റ്റൻസിബിലിറ്റി, റീഡബിലിറ്റി എന്നിവയുടെ കാര്യത്തിൽ, എന്റെ അഭിപ്രായത്തിൽ, വാക്ചാതുര്യത്തിൽ തോറ്റാലും ഗോ ഭാഷ വിജയിക്കുന്നു.

ചില സന്ദർഭങ്ങളിൽ സാമാന്യവൽക്കരിച്ച പ്രോഗ്രാമിംഗ് നമുക്ക് നിഷേധിക്കാനാവാത്ത നേട്ടങ്ങൾ നൽകുന്നു. സോർട്ട് പാക്കേജ് ഇത് വ്യക്തമായി ചിത്രീകരിക്കുന്നു. അതിനാൽ, ഏതെങ്കിലും ലിസ്റ്റ് അടുക്കുന്നതിന്, ഞങ്ങൾ സോർട്ട്.ഇന്റർഫേസ് ഇന്റർഫേസ് നടപ്പിലാക്കേണ്ടതുണ്ട്.

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 തരം അടങ്ങിയിരിക്കുന്നു. ഗോ ഭാഷയും അതുതന്നെ ചെയ്യുന്നു.

ഒരു പീരങ്കി മുതൽ കുരുവികൾ വരെ

സ്‌ട്രെയിറ്റ്‌ജാക്കറ്റ് ഭ്രാന്തിന്റെ വലുപ്പത്തിന് യോജിച്ചതായിരിക്കണം. സ്റ്റാനിസ്ലാവ് ലെക്.

ജനറിക്‌സ് സൃഷ്‌ടിക്കുന്നതിന് ഗോയ്‌ക്ക് മറ്റൊരു സംവിധാനം ഉണ്ടെന്ന് പല തീവ്ര ആരാധകരും അവകാശപ്പെട്ടേക്കാം - പ്രതിഫലനം. അവർ ശരിയായിരിക്കും... എന്നാൽ അപൂർവ സന്ദർഭങ്ങളിൽ മാത്രം.

റോബ് പൈക്ക് മുന്നറിയിപ്പ് നൽകുന്നു:

ജാഗ്രതയോടെ ഉപയോഗിക്കേണ്ട ശക്തമായ ഉപകരണമാണിത്. കർശനമായി ആവശ്യമില്ലെങ്കിൽ അത് ഒഴിവാക്കണം.

വിക്കിപീഡിയ ഞങ്ങളോട് ഇനിപ്പറയുന്നവ പറയുന്നു:

നിർവ്വഹണ വേളയിൽ ഒരു പ്രോഗ്രാമിന് സ്വന്തം ഘടനയും പെരുമാറ്റവും നിരീക്ഷിക്കാനും പരിഷ്കരിക്കാനും കഴിയുന്ന പ്രക്രിയയെ പ്രതിഫലനം സൂചിപ്പിക്കുന്നു. പ്രതിഫലനത്തിന് അടിസ്ഥാനമായ പ്രോഗ്രാമിംഗ് മാതൃകയെ പ്രതിഫലന പ്രോഗ്രാമിംഗ് എന്ന് വിളിക്കുന്നു. ഇതൊരു തരം മെറ്റാപ്രോഗ്രാമിംഗ് ആണ്.

എന്നിരുന്നാലും, നിങ്ങൾക്കറിയാവുന്നതുപോലെ, നിങ്ങൾ എല്ലാത്തിനും പണം നൽകണം. ഈ സാഹചര്യത്തിൽ ഇത്:

• പ്രോഗ്രാമുകൾ എഴുതാനുള്ള ബുദ്ധിമുട്ട്
• പ്രോഗ്രാം എക്സിക്യൂഷൻ വേഗത

അതിനാൽ, ഒരു വലിയ കാലിബർ ആയുധം പോലെ, പ്രതിഫലനം ജാഗ്രതയോടെ ഉപയോഗിക്കണം. പ്രതിഫലനത്തിന്റെ ചിന്താശൂന്യമായ ഉപയോഗം വായിക്കാൻ കഴിയാത്ത പ്രോഗ്രാമുകൾ, സ്ഥിരമായ പിശകുകൾ, കുറഞ്ഞ വേഗത എന്നിവയിലേക്ക് നയിക്കുന്നു. ഒരു സ്നോബ് പ്രോഗ്രാമർക്ക് തന്റെ കോഡ് മറ്റ്, കൂടുതൽ പ്രായോഗികവും എളിമയുള്ളതുമായ സഹപ്രവർത്തകർക്ക് മുന്നിൽ കാണിക്കാൻ കഴിയുന്നത് മാത്രമാണ്.

Xi-ൽ നിന്നുള്ള സാംസ്കാരിക ലഗേജ്? ഇല്ല, നിരവധി ഭാഷകളിൽ നിന്ന്!

ഭാഗ്യത്തിനൊപ്പം കടങ്ങളും അവകാശികൾക്ക് വിട്ടുകൊടുക്കുന്നു.

ഭാഷ പൂർണ്ണമായും സി പാരമ്പര്യത്തെ അടിസ്ഥാനമാക്കിയുള്ളതാണെന്ന് പലരും വിശ്വസിക്കുന്നുണ്ടെങ്കിലും, ഇത് അങ്ങനെയല്ല. മികച്ച പ്രോഗ്രാമിംഗ് ഭാഷകളുടെ നിരവധി വശങ്ങൾ ഭാഷ ഉൾക്കൊള്ളുന്നു.

വാക്യഘടന

ഒന്നാമതായി, വ്യാകരണ ഘടനകളുടെ വാക്യഘടന സി ഭാഷയുടെ വാക്യഘടനയെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്. എന്നിരുന്നാലും, ഡെൽഫി ഭാഷയ്ക്കും കാര്യമായ സ്വാധീനമുണ്ടായിരുന്നു. അങ്ങനെ, പ്രോഗ്രാമിന്റെ വായനാക്ഷമതയെ വളരെയധികം കുറയ്ക്കുന്ന അനാവശ്യ പരാൻതീസിസുകൾ പൂർണ്ണമായും നീക്കം ചെയ്തതായി ഞങ്ങൾ കാണുന്നു. DELPHI ഭാഷയിൽ അന്തർലീനമായ ":=" ഓപ്പറേറ്ററും ഭാഷയിൽ അടങ്ങിയിരിക്കുന്നു. പാക്കേജുകൾ എന്ന ആശയം എഡിഎ പോലുള്ള ഭാഷകളിൽ നിന്ന് കടമെടുത്തതാണ്. ഉപയോഗിക്കാത്ത എന്റിറ്റികളുടെ പ്രഖ്യാപനം PROLOG ഭാഷയിൽ നിന്ന് കടമെടുത്തതാണ്.

സെമാന്റിക്സ്

പാക്കേജുകൾ ഡെൽഫി ഭാഷയുടെ അർത്ഥശാസ്ത്രത്തെ അടിസ്ഥാനമാക്കിയുള്ളതായിരുന്നു. ഓരോ പാക്കേജും ഡാറ്റയും കോഡും ഉൾക്കൊള്ളുന്നു കൂടാതെ സ്വകാര്യവും പൊതു സ്ഥാപനങ്ങളും ഉൾക്കൊള്ളുന്നു. പാക്കേജ് ഇന്റർഫേസ് പരമാവധി കുറയ്ക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.

ഡെലിഗേഷൻ രീതിയിലുള്ള നടപ്പാക്കൽ പ്രവർത്തനം ഡെൽഫി ഭാഷയിൽ നിന്ന് കടമെടുത്തതാണ്.

സമാഹരണം

ഒരു തമാശയുണ്ടെന്നത് കാരണമില്ലാതെയല്ല: ഒരു സി പ്രോഗ്രാം കംപൈൽ ചെയ്യുമ്പോൾ ഗോ വികസിപ്പിച്ചെടുത്തു. വളരെ വേഗത്തിലുള്ള സമാഹാരമാണ് ഭാഷയുടെ ശക്തികളിലൊന്ന്. ഈ ആശയം ഡെൽഫി ഭാഷയിൽ നിന്ന് കടമെടുത്തതാണ്. ഓരോ Go പാക്കേജും ഒരു DELPHI മൊഡ്യൂളുമായി യോജിക്കുന്നു. ശരിക്കും ആവശ്യമുള്ളപ്പോൾ മാത്രമേ ഈ പാക്കേജുകൾ വീണ്ടും കംപൈൽ ചെയ്യുകയുള്ളൂ. അതിനാൽ, അടുത്ത തിരുത്തലിനുശേഷം, നിങ്ങൾ മുഴുവൻ പ്രോഗ്രാമും കംപൈൽ ചെയ്യേണ്ടതില്ല, പകരം ഈ മാറിയ പാക്കേജുകളെ ആശ്രയിക്കുന്ന മാറിയ പാക്കേജുകളും പാക്കേജുകളും മാത്രം വീണ്ടും കംപൈൽ ചെയ്യുക (അപ്പോഴും, പാക്കേജ് ഇന്റർഫേസുകൾ മാറിയെങ്കിൽ മാത്രം).

ഉയർന്ന തലത്തിലുള്ള നിർമ്മാണങ്ങൾ

സി പോലുള്ള താഴ്ന്ന നിലയിലുള്ള ഭാഷകളുമായി ഒരു തരത്തിലും ബന്ധമില്ലാത്ത നിരവധി ഉയർന്ന തലത്തിലുള്ള ഘടനകൾ ഭാഷയിൽ അടങ്ങിയിരിക്കുന്നു.

• സ്ട്രിംഗുകൾ
• ഹാഷ് ടേബിളുകൾ
• കഷ്ണങ്ങൾ
• ഡക്ക് ടൈപ്പിംഗ് RUBY പോലുള്ള ഭാഷകളിൽ നിന്ന് കടമെടുത്തതാണ് (നിർഭാഗ്യവശാൽ, പലർക്കും ഇത് മനസ്സിലാകുന്നില്ല അല്ലെങ്കിൽ അതിന്റെ പൂർണ്ണ ശേഷി ഉപയോഗിക്കുന്നില്ല).

മെമ്മറി മാനേജ്മെന്റ്

മെമ്മറി മാനേജ്മെന്റ് സാധാരണയായി ഒരു പ്രത്യേക ലേഖനം അർഹിക്കുന്നു. C++ പോലുള്ള ഭാഷകളിൽ, നിയന്ത്രണം പൂർണ്ണമായും ഡെവലപ്പർക്ക് വിട്ടുകൊടുത്താൽ, പിന്നീട് DELPHI പോലുള്ള ഭാഷകളിൽ, ഒരു റഫറൻസ് കൗണ്ടിംഗ് മോഡൽ ഉപയോഗിച്ചു. ഈ സമീപനത്തിലൂടെ, ചാക്രിക റഫറൻസുകൾ അനുവദനീയമല്ല, കാരണം അനാഥ ക്ലസ്റ്ററുകൾ രൂപപ്പെട്ടതിനാൽ, അത്തരം ക്ലസ്റ്ററുകൾ (C# പോലെയുള്ള) അന്തർനിർമ്മിതമായ കണ്ടെത്തൽ Go-യ്ക്ക് ഉണ്ട്. കൂടാതെ, ഗാർബേജ് കളക്ടർ നിലവിൽ അറിയപ്പെടുന്ന മിക്ക നിർവ്വഹണങ്ങളേക്കാളും കൂടുതൽ കാര്യക്ഷമമാണ്, കൂടാതെ നിരവധി തത്സമയ ജോലികൾക്കായി ഇതിനകം തന്നെ ഉപയോഗിക്കാനും കഴിയും. ഒരു വേരിയബിൾ സംഭരിക്കുന്നതിനുള്ള ഒരു മൂല്യം സ്റ്റാക്കിൽ അനുവദിക്കുമ്പോൾ ഭാഷ തന്നെ സാഹചര്യങ്ങൾ തിരിച്ചറിയുന്നു. ഇത് മെമ്മറി മാനേജറിലെ ലോഡ് കുറയ്ക്കുകയും പ്രോഗ്രാമിന്റെ വേഗത വർദ്ധിപ്പിക്കുകയും ചെയ്യുന്നു.

കൺകറൻസിയും കൺകറൻസിയും

ഭാഷയുടെ സമാന്തരത്വവും മത്സരക്ഷമതയും പ്രശംസയ്ക്ക് അതീതമാണ്. താഴ്ന്ന നിലയിലുള്ള ഒരു ഭാഷയ്ക്കും ഗോയുമായി വിദൂരമായി പോലും മത്സരിക്കാനാവില്ല. ശരിയായി പറഞ്ഞാൽ, ഈ മോഡൽ ഭാഷയുടെ രചയിതാക്കൾ കണ്ടുപിടിച്ചതല്ല, മറിച്ച് നല്ല പഴയ എഡിഎ ഭാഷയിൽ നിന്ന് കടമെടുത്തതാണ് എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. എല്ലാ CPU-കളും ഉപയോഗിച്ച് ദശലക്ഷക്കണക്കിന് സമാന്തര കണക്ഷനുകൾ പ്രോസസ്സ് ചെയ്യാൻ ഭാഷയ്ക്ക് പ്രാപ്തമാണ്, അതേസമയം മൾട്ടി-ത്രെഡഡ് കോഡിന് സാധാരണമായ ഡെഡ്‌ലോക്കുകളും റേസ് അവസ്ഥകളും ഉള്ള സങ്കീർണ്ണമായ പ്രശ്‌നങ്ങളുടെ ക്രമം.

അധിക ആനുകൂല്യങ്ങൾ

ലാഭകരമായാൽ എല്ലാവരും നിസ്വാർത്ഥരായി മാറും.

ഭാഷ നമുക്ക് സംശയരഹിതമായ നിരവധി നേട്ടങ്ങൾ നൽകുന്നു:

• പ്രോജക്റ്റ് നിർമ്മിച്ചതിന് ശേഷമുള്ള ഒരു എക്സിക്യൂട്ടബിൾ ഫയൽ ആപ്ലിക്കേഷനുകളുടെ വിന്യാസം വളരെ ലളിതമാക്കുന്നു.
• സ്റ്റാറ്റിക് ടൈപ്പിംഗും ടൈപ്പ് അനുമാനവും നിങ്ങളുടെ കോഡിലെ പിശകുകളുടെ എണ്ണം ഗണ്യമായി കുറയ്ക്കും, ടെസ്റ്റുകൾ എഴുതാതെ പോലും. ടെസ്റ്റുകൾ എഴുതാതെ ചെയ്യുന്ന ചില പ്രോഗ്രാമർമാരെ എനിക്കറിയാം, അവരുടെ കോഡിന്റെ ഗുണനിലവാരം കാര്യമായി ബാധിക്കില്ല.
• വളരെ ലളിതമായ ക്രോസ്-കംപൈലേഷനും സ്റ്റാൻഡേർഡ് ലൈബ്രറിയുടെ മികച്ച പോർട്ടബിലിറ്റിയും, ഇത് ക്രോസ്-പ്ലാറ്റ്ഫോം ആപ്ലിക്കേഷനുകളുടെ വികസനം വളരെ ലളിതമാക്കുന്നു.
• RE2 റെഗുലർ എക്സ്പ്രഷനുകൾ ത്രെഡ്-സുരക്ഷിതവും പ്രവചിക്കാവുന്ന എക്സിക്യൂഷൻ സമയവുമുണ്ട്.
• മൂന്നാം കക്ഷി ചട്ടക്കൂടുകളില്ലാതെ മിക്ക പ്രോജക്റ്റുകളും ചെയ്യാൻ അനുവദിക്കുന്ന ശക്തമായ ഒരു സാധാരണ ലൈബ്രറി.
• പ്രശ്‌നം എങ്ങനെ പരിഹരിക്കാം എന്നതിനേക്കാൾ പ്രശ്‌നത്തിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കാൻ ഭാഷ ശക്തമാണ്, എന്നിട്ടും പ്രശ്‌നം കാര്യക്ഷമമായി പരിഹരിക്കാൻ കഴിയുന്നത്ര താഴ്ന്ന നിലയിലാണ്.
• Go ഇക്കോ സിസ്റ്റത്തിൽ ഇതിനകം തന്നെ എല്ലാ അവസരങ്ങൾക്കുമായി വികസിപ്പിച്ച ടൂളുകൾ അടങ്ങിയിരിക്കുന്നു: ടെസ്റ്റുകൾ, ഡോക്യുമെന്റേഷൻ, പാക്കേജ് മാനേജുമെന്റ്, ശക്തമായ ലിന്ററുകൾ, കോഡ് സൃഷ്ടിക്കൽ, റേസ് അവസ്ഥ ഡിറ്റക്ടർ മുതലായവ.
• Go പതിപ്പ് 1.11, ജനപ്രിയ VCS ഹോസ്റ്റിംഗിന്റെ മുകളിൽ നിർമ്മിച്ച ബിൽറ്റ്-ഇൻ സെമാന്റിക് ഡിപൻഡൻസി മാനേജ്‌മെന്റ് അവതരിപ്പിച്ചു. Go ഇക്കോസിസ്റ്റം നിർമ്മിക്കുന്ന എല്ലാ ഉപകരണങ്ങളും ഒറ്റയടിക്ക് അവയിൽ നിന്ന് കോഡ് ഡൗൺലോഡ് ചെയ്യാനും നിർമ്മിക്കാനും ഇൻസ്റ്റാൾ ചെയ്യാനും ഈ സേവനങ്ങൾ ഉപയോഗിക്കുന്നു. അത് മഹത്തരമാണ്. പതിപ്പ് 1.11-ന്റെ വരവോടെ, പാക്കേജ് പതിപ്പിംഗിലെ പ്രശ്‌നവും പൂർണ്ണമായും പരിഹരിച്ചു.
• മാജിക് കുറയ്ക്കുക എന്നതാണ് ഭാഷയുടെ പ്രധാന ആശയം എന്നതിനാൽ, പിശക് കൈകാര്യം ചെയ്യാൻ ഭാഷ ഡെവലപ്പർമാരെ പ്രേരിപ്പിക്കുന്നു. ഇത് ശരിയാണ്, അല്ലാത്തപക്ഷം, പിശക് കൈകാര്യം ചെയ്യുന്നതിനെക്കുറിച്ച് ഇത് പൂർണ്ണമായും മറക്കും. മറ്റൊരു കാര്യം, മിക്ക ഡെവലപ്പർമാരും മനഃപൂർവ്വം പിശക് കൈകാര്യം ചെയ്യലിനെ അവഗണിക്കുന്നു, അവ പ്രോസസ്സ് ചെയ്യുന്നതിനുപകരം പിശക് മുകളിലേക്ക് കൈമാറാൻ മുൻഗണന നൽകുന്നു.
• ഭാഷ ക്ലാസിക്കൽ OOP രീതി നടപ്പിലാക്കുന്നില്ല, കാരണം അതിന്റെ ശുദ്ധമായ രൂപത്തിൽ ഗോയിൽ വെർച്വാലിറ്റി ഇല്ല. എന്നിരുന്നാലും, ഇന്റർഫേസുകൾ ഉപയോഗിക്കുമ്പോൾ ഇത് ഒരു പ്രശ്നമല്ല. OOP യുടെ അഭാവം തുടക്കക്കാർക്ക് പ്രവേശനത്തിനുള്ള തടസ്സം ഗണ്യമായി കുറയ്ക്കുന്നു.

കമ്മ്യൂണിറ്റി പ്രയോജനത്തിന് ലാളിത്യം

ഇത് സങ്കീർണ്ണമാക്കാൻ എളുപ്പമാണ്, ലളിതമാക്കാൻ പ്രയാസമാണ്.

Go രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നത് ലളിതമാണ്, അത് ആ ലക്ഷ്യത്തിൽ വിജയിക്കുന്നു. ടീം വർക്കിന്റെ പ്രയോജനങ്ങൾ മനസ്സിലാക്കുകയും എന്റർപ്രൈസ് ലെവൽ ഭാഷകളുടെ അനന്തമായ വ്യതിയാനങ്ങളിൽ മടുത്തുനിൽക്കുകയും ചെയ്യുന്ന സ്മാർട്ട് പ്രോഗ്രാമർമാർക്കായി ഇത് എഴുതിയിരിക്കുന്നു. അതിന്റെ ആയുധപ്പുരയിൽ താരതമ്യേന ചെറിയ ഒരു കൂട്ടം വാക്യഘടനകൾ ഉള്ളതിനാൽ, ഇത് പ്രായോഗികമായി കാലക്രമേണ മാറ്റങ്ങൾക്ക് വിധേയമല്ല, അതിനാൽ ഡവലപ്പർമാർക്ക് വികസനത്തിനായി ധാരാളം സമയം അനുവദിച്ചിട്ടുണ്ട്, അല്ലാതെ ഭാഷാ നവീകരണങ്ങൾ അനന്തമായി പഠിക്കുന്നതിലല്ല.

കമ്പനികൾക്ക് നിരവധി നേട്ടങ്ങളും ലഭിക്കുന്നു: കുറഞ്ഞ പ്രവേശന തടസ്സം ഒരു സ്പെഷ്യലിസ്റ്റിനെ വേഗത്തിൽ കണ്ടെത്താൻ അവരെ അനുവദിക്കുന്നു, കൂടാതെ ഭാഷയുടെ മാറ്റമില്ലാത്തത് 10 വർഷത്തിന് ശേഷവും ഒരേ കോഡ് ഉപയോഗിക്കാൻ അവരെ അനുവദിക്കുന്നു.

തീരുമാനം

വലിയ മസ്തിഷ്ക വലിപ്പം ഒരു ആനയെയും നൊബേൽ സമ്മാന ജേതാവാക്കിയിട്ടില്ല.

ടീം സ്പിരിറ്റിനേക്കാൾ വ്യക്തിഗത അഹന്തയ്ക്ക് മുൻഗണന നൽകുന്ന പ്രോഗ്രാമർമാർക്കും അക്കാദമിക് വെല്ലുവിളികളും അനന്തമായ "സ്വയം മെച്ചപ്പെടുത്തലും" ഇഷ്ടപ്പെടുന്ന സൈദ്ധാന്തികർക്കും, ഭാഷ വളരെ മോശമാണ്, കാരണം ഇത് നിങ്ങൾക്ക് ലഭിക്കാൻ അനുവദിക്കാത്ത ഒരു പൊതു-ഉദ്ദേശ്യ ആർട്ടിസാനൽ ഭാഷയാണ്. നിങ്ങളുടെ ജോലിയുടെ ഫലത്തിൽ നിന്നുള്ള സൗന്ദര്യാത്മക ആനന്ദം, സഹപ്രവർത്തകരുടെ മുന്നിൽ സ്വയം പ്രൊഫഷണലായി കാണിക്കുക (ഞങ്ങൾ ബുദ്ധി അളക്കുന്നത് ഈ മാനദണ്ഡങ്ങളിലൂടെയാണ്, അല്ലാതെ IQ പ്രകാരമല്ല). ജീവിതത്തിലെ എല്ലാ കാര്യങ്ങളും പോലെ, ഇത് വ്യക്തിപരമായ മുൻഗണനകളുടെ കാര്യമാണ്. മൂല്യവത്തായ എല്ലാ പുതുമകളെയും പോലെ, ഭാഷ ഇതിനകം തന്നെ സാർവത്രിക നിഷേധത്തിൽ നിന്ന് ബഹുജന സ്വീകാര്യതയിലേക്ക് ഒരുപാട് മുന്നോട്ട് പോയിക്കഴിഞ്ഞു. ഭാഷ അതിന്റെ ലാളിത്യത്തിൽ സമർത്ഥമാണ്, നിങ്ങൾക്കറിയാവുന്നതുപോലെ, സമർത്ഥമായ എല്ലാം ലളിതമാണ്!

അവലംബം: www.habr.com