వ్యాసం గతంలో ప్రచురించిన దానికి ప్రతిస్పందనగా వ్రాయబడింది .
గత రెండు-ప్లస్ సంవత్సరాలలో నేను అభివృద్ధి చెందిన బిల్లింగ్ సిస్టమ్‌తో ప్రత్యేకమైన RADIUS సర్వర్‌ని అమలు చేయడానికి Goని ఉపయోగిస్తున్నాను. అలాగే, నేను భాషలోని చిక్కులను నేర్చుకుంటున్నాను. ప్రోగ్రామ్‌లు చాలా సరళమైనవి మరియు ఈ కథనం యొక్క ఉద్దేశ్యం కాదు, కానీ గోను ఉపయోగించిన అనుభవం దాని రక్షణలో కొన్ని పదాలకు అర్హమైనది. గో తీవ్రమైన, స్కేలబుల్ కోడ్ కోసం పెరుగుతున్న ప్రధాన స్రవంతి భాషగా మారుతోంది. భాష Google ద్వారా సృష్టించబడింది, ఇక్కడ అది చురుకుగా ఉపయోగించబడుతుంది. బాటమ్ లైన్, గో భాష రూపకల్పన UNintelligent ప్రోగ్రామర్‌లకు చెడ్డదని నేను నిజాయితీగా భావిస్తున్నాను.
బలహీనమైన ప్రోగ్రామర్ల కోసం రూపొందించబడిందా?
బలహీనులు సమస్యల గురించి మాట్లాడుతారు. ఆలోచనలు మరియు కలల గురించి బలమైన చర్చ...
గో నేర్చుకోవడం చాలా సులభం, వాస్తవంగా ఎటువంటి శిక్షణ లేకుండా మీరు కోడ్‌ని చదవగలిగేంత సులభం. నాన్-కోర్ స్పెషలిస్ట్‌లతో (మేనేజర్‌లు, కస్టమర్‌లు మొదలైనవి) కలిసి కోడ్ చదవబడినప్పుడు భాష యొక్క ఈ లక్షణం అనేక గ్లోబల్ కంపెనీలలో ఉపయోగించబడుతుంది. డిజైన్ డ్రైవెన్ డెవలప్‌మెంట్ వంటి మెథడాలజీలకు ఇది చాలా సౌకర్యవంతంగా ఉంటుంది.
అనుభవం లేని ప్రోగ్రామర్లు కూడా ఒకటి లేదా రెండు వారాల తర్వాత చాలా మంచి కోడ్‌ను ఉత్పత్తి చేయడం ప్రారంభిస్తారు. నేను చదివిన పుస్తకం "గో ప్రోగ్రామింగ్" (మార్క్ సమ్మర్‌ఫీల్డ్ ద్వారా). పుస్తకం చాలా బాగుంది, ఇది భాష యొక్క అనేక సూక్ష్మ నైపుణ్యాలను స్పృశిస్తుంది. జావా, PHP వంటి అనవసరమైన సంక్లిష్ట భాషల తర్వాత, మ్యాజిక్ లేకపోవడం రిఫ్రెష్‌గా ఉంది. కానీ ముందుగానే లేదా తరువాత, చాలా మంది పరిమిత ప్రోగ్రామర్లు కొత్త రంగంలో పాత పద్ధతులను ఉపయోగించాలనే ఆలోచనను కలిగి ఉన్నారు. ఇది నిజంగా అవసరమా?
రాబ్ పైక్ (భాష యొక్క ప్రధాన భావజాలవేత్త) గో భాషను ఒక పారిశ్రామిక భాషగా రూపొందించారు, అది సులభంగా అర్థం చేసుకోవడానికి మరియు ఉపయోగించడానికి ప్రభావవంతంగా ఉంటుంది. భాష పెద్ద జట్లలో గరిష్ట ఉత్పాదకత కోసం రూపొందించబడింది మరియు దాని గురించి ఎటువంటి సందేహం లేదు. చాలా మంది అనుభవం లేని ప్రోగ్రామర్లు వారు తప్పిపోయిన అనేక లక్షణాలు ఉన్నాయని ఫిర్యాదు చేశారు. సరళత కోసం ఈ కోరిక అనేది భాష రూపకర్తల చేతన నిర్ణయం, మరియు అది ఎందుకు అవసరమో పూర్తిగా అర్థం చేసుకోవడానికి, డెవలపర్‌ల ప్రేరణ మరియు వారు గోలో ఏమి సాధించడానికి ప్రయత్నిస్తున్నారో మనం అర్థం చేసుకోవాలి.
కాబట్టి ఇది ఎందుకు చాలా సరళంగా చేయబడింది? రాబ్ పైక్ నుండి కొన్ని కోట్స్ ఇక్కడ ఉన్నాయి:
ఇక్కడ ప్రధాన విషయం ఏమిటంటే, మా ప్రోగ్రామర్లు పరిశోధకులు కాదు. వారు, ఒక నియమం వలె, చాలా చిన్నవారు, చదువుకున్న తర్వాత మా వద్దకు వస్తారు, బహుశా వారు జావా, లేదా C/C++, లేదా పైథాన్‌ని చదివారు. వారు గొప్ప భాషను అర్థం చేసుకోలేరు, కానీ అదే సమయంలో వారు మంచి సాఫ్ట్‌వేర్‌ను సృష్టించాలని మేము కోరుకుంటున్నాము. అందుకే భాష సులువుగా అర్థం చేసుకుని నేర్చుకునేలా ఉండాలి.
అతను సుపరిచితుడై ఉండాలి, ఇంచుమించుగా సి లాగానే మాట్లాడాలి. Googleలో పనిచేస్తున్న ప్రోగ్రామర్లు తమ కెరీర్‌ను ముందుగానే ప్రారంభిస్తారు మరియు ఎక్కువగా విధానపరమైన భాషలతో, ముఖ్యంగా C కుటుంబానికి బాగా తెలుసు. కొత్త ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో శీఘ్ర ఉత్పాదకత అవసరం అంటే భాష చాలా రాడికల్‌గా ఉండకూడదు.
తెలివైన పదాలు, కాదా?
సింప్లిసిటీ యొక్క కళాఖండాలు
అందానికి సరళత తప్పనిసరి పరిస్థితి. లెవ్ టాల్‌స్టాయ్.
ఏదైనా డిజైన్‌లో దీన్ని సరళంగా ఉంచడం చాలా ముఖ్యమైన లక్ష్యాలలో ఒకటి. మీకు తెలిసినట్లుగా, ఖచ్చితమైన ప్రాజెక్ట్ జోడించడానికి ఏమీ లేని ప్రాజెక్ట్ కాదు, కానీ తీసివేయడానికి ఏమీ లేదు. సంక్లిష్ట సమస్యలను పరిష్కరించడానికి (లేదా వ్యక్తీకరించడానికి) సంక్లిష్టమైన సాధనం అవసరమని చాలా మంది నమ్ముతారు. అయితే, అది కాదు. ఉదాహరణకు 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 ని ఉదాహరణగా తీసుకుందాం. ఇదే జెనరిక్స్ ఉన్నప్పటికీ, ఇది ఏకపక్ష డేటా రకాలతో కార్యకలాపాల కోసం ప్రత్యేక VARIANT రకాన్ని కలిగి ఉంది. గో భాష కూడా అలాగే చేస్తుంది.
ఫిరంగి నుండి పిచ్చుకల వరకు
మరియు స్ట్రెయిట్‌జాకెట్ పిచ్చి పరిమాణానికి సరిపోయేలా ఉండాలి. స్టానిస్లావ్ లెక్.
చాలా మంది విపరీతమైన అభిమానులు గో జెనరిక్‌లను రూపొందించడానికి మరొక మెకానిజం కలిగి ఉన్నారని చెప్పవచ్చు - ప్రతిబింబం. మరియు వారు సరిగ్గా ఉంటారు ... కానీ అరుదైన సందర్భాల్లో మాత్రమే.
రాబ్ పైక్ మమ్మల్ని హెచ్చరించాడు:
ఇది జాగ్రత్తగా ఉపయోగించాల్సిన శక్తివంతమైన సాధనం. ఖచ్చితంగా అవసరమైతే తప్ప దీనిని నివారించాలి.
వికీపీడియా మాకు ఈ క్రింది వాటిని చెబుతుంది:
ప్రతిబింబం అనేది ఒక ప్రోగ్రామ్ అమలు సమయంలో దాని స్వంత నిర్మాణం మరియు ప్రవర్తనను పర్యవేక్షించే మరియు సవరించగల ప్రక్రియను సూచిస్తుంది. ప్రోగ్రామింగ్ నమూనా అంతర్లీన ప్రతిబింబాన్ని ప్రతిబింబ ప్రోగ్రామింగ్ అంటారు. ఇది ఒక రకమైన మెటాప్రోగ్రామింగ్.
అయితే, మీకు తెలిసినట్లుగా, మీరు ప్రతిదానికీ చెల్లించాలి. ఈ సందర్భంలో ఇది:
- ప్రోగ్రామ్‌లు రాయడంలో ఇబ్బంది
- ప్రోగ్రామ్ అమలు వేగం
అందువల్ల, ప్రతిబింబాన్ని పెద్ద-క్యాలిబర్ ఆయుధం వలె జాగ్రత్తగా ఉపయోగించాలి. ప్రతిబింబం యొక్క ఆలోచనారహిత ఉపయోగం చదవలేని ప్రోగ్రామ్‌లు, స్థిరమైన లోపాలు మరియు తక్కువ వేగానికి దారితీస్తుంది. ఒక స్నోబ్ ప్రోగ్రామర్ తన కోడ్‌ను ఇతర, మరింత ఆచరణాత్మక మరియు నిరాడంబరమైన సహోద్యోగుల ముందు ప్రదర్శించగలగడం.
Xi నుండి సాంస్కృతిక సామాను? కాదు, అనేక భాషల నుండి!
అదృష్టంతోపాటు అప్పులు కూడా వారసులకు మిగులుతున్నాయి.
భాష పూర్తిగా సి వారసత్వంపై ఆధారపడి ఉందని చాలామంది నమ్ముతున్నప్పటికీ, ఇది అలా కాదు. భాష ఉత్తమ ప్రోగ్రామింగ్ భాషల యొక్క అనేక అంశాలను కలిగి ఉంటుంది.
వాక్యనిర్మాణం
అన్నింటిలో మొదటిది, వ్యాకరణ నిర్మాణాల వాక్యనిర్మాణం సి భాష యొక్క వాక్యనిర్మాణంపై ఆధారపడి ఉంటుంది. అయినప్పటికీ, DELPHI భాష కూడా గణనీయమైన ప్రభావాన్ని చూపింది. ఈ విధంగా, ప్రోగ్రామ్ యొక్క రీడబిలిటీని బాగా తగ్గించే రిడండెంట్ కుండలీకరణాలు పూర్తిగా తొలగించబడినట్లు మేము చూస్తాము. భాష DELPHI భాషకు స్వాభావికమైన “:=” ఆపరేటర్‌ను కూడా కలిగి ఉంది. ప్యాకేజీల భావన ADA వంటి భాషల నుండి తీసుకోబడింది. ఉపయోగించని ఎంటిటీల డిక్లరేషన్ PROLOG భాష నుండి తీసుకోబడింది.
అర్థశాస్త్రం
ప్యాకేజీలు DELPHI భాష యొక్క అర్థశాస్త్రంపై ఆధారపడి ఉన్నాయి. ప్రతి ప్యాకేజీ డేటా మరియు కోడ్‌ను కలుపుతుంది మరియు ప్రైవేట్ మరియు పబ్లిక్ ఎంటిటీలను కలిగి ఉంటుంది. ఇది ప్యాకేజీ ఇంటర్‌ఫేస్‌ను కనిష్ట స్థాయికి తగ్గించడానికి మిమ్మల్ని అనుమతిస్తుంది.
డెలిగేషన్ పద్ధతి ద్వారా అమలు ఆపరేషన్ DELPHI భాష నుండి తీసుకోబడింది.
సంగ్రహం
ఇది ఒక జోక్ అని కారణం లేకుండా కాదు: సి ప్రోగ్రామ్ కంపైల్ చేస్తున్నప్పుడు గో అభివృద్ధి చేయబడింది. భాష యొక్క బలాలలో ఒకటి దాని అతి-వేగవంతమైన సంకలనం. ఆలోచన DELPHI భాష నుండి తీసుకోబడింది. ప్రతి Go ప్యాకేజీ DELPHI మాడ్యూల్‌కు అనుగుణంగా ఉంటుంది. ఈ ప్యాకేజీలు నిజంగా అవసరమైనప్పుడు మాత్రమే తిరిగి కంపైల్ చేయబడతాయి. కాబట్టి, తదుపరి సవరణ తర్వాత, మీరు మొత్తం ప్రోగ్రామ్‌ను కంపైల్ చేయనవసరం లేదు, అయితే ఈ మార్చబడిన ప్యాకేజీలపై ఆధారపడిన మార్చబడిన ప్యాకేజీలు మరియు ప్యాకేజీలను మాత్రమే తిరిగి కంపైల్ చేయండి (మరియు అప్పుడు కూడా, ప్యాకేజీ ఇంటర్‌ఫేస్‌లు మారినట్లయితే మాత్రమే).
ఉన్నత స్థాయి నిర్మాణాలు
C వంటి తక్కువ-స్థాయి భాషలకు ఏ విధంగానూ సంబంధం లేని అనేక ఉన్నత-స్థాయి నిర్మాణాలను భాష కలిగి ఉంది.
- తీగలు
- హాష్ పట్టికలు
- ముక్కలు
- డక్ టైపింగ్ RUBY వంటి భాషల నుండి తీసుకోబడింది (దురదృష్టవశాత్తూ, చాలామంది అర్థం చేసుకోలేరు లేదా దాని పూర్తి సామర్థ్యాన్ని ఉపయోగించరు).
మెమరీ నిర్వహణ
మెమరీ నిర్వహణ సాధారణంగా ప్రత్యేక కథనానికి అర్హమైనది. C++ వంటి భాషలలో, నియంత్రణ పూర్తిగా డెవలపర్‌కు వదిలివేయబడితే, DELPHI వంటి తదుపరి భాషలలో, సూచన లెక్కింపు నమూనా ఉపయోగించబడింది. ఈ విధానంతో, చక్రీయ సూచనలు అనుమతించబడవు, ఎందుకంటే అనాధ సమూహాలు ఏర్పడినందున, గో అటువంటి క్లస్టర్‌లను (C# వంటి) అంతర్నిర్మిత గుర్తింపును కలిగి ఉంది. అదనంగా, చెత్త సేకరించే సాధనం ప్రస్తుతం తెలిసిన చాలా అమలుల కంటే మరింత సమర్థవంతమైనది మరియు ఇప్పటికే అనేక నిజ-సమయ పనుల కోసం ఉపయోగించవచ్చు. స్టాక్‌పై వేరియబుల్‌ని నిల్వ చేయడానికి విలువను కేటాయించగలిగినప్పుడు భాష స్వయంగా పరిస్థితులను గుర్తిస్తుంది. ఇది మెమరీ మేనేజర్‌పై లోడ్‌ను తగ్గిస్తుంది మరియు ప్రోగ్రామ్ యొక్క వేగాన్ని పెంచుతుంది.
కరెన్సీ మరియు కరెన్సీ
భాష యొక్క సమాంతరత మరియు పోటీతత్వం ప్రశంసలకు మించినది. గోతో ఏ తక్కువ స్థాయి భాష కూడా రిమోట్‌గా పోటీపడదు. నిజం చెప్పాలంటే, మోడల్ భాష యొక్క రచయితలచే కనుగొనబడలేదు, కానీ మంచి పాత ADA భాష నుండి తీసుకోబడింది. భాష అన్ని CPUలను ఉపయోగించి మిలియన్ల కొద్దీ సమాంతర కనెక్షన్‌లను ప్రాసెస్ చేయగలదు, అయితే బహుళ-థ్రెడ్ కోడ్‌కు విలక్షణమైన డెడ్‌లాక్‌లు మరియు రేస్ పరిస్థితులతో తక్కువ సంక్లిష్ట సమస్యలను కలిగి ఉంటుంది.
అదనపు ప్రయోజనాలు
లాభదాయకంగా ఉంటే అందరూ నిస్వార్థంగా మారతారు.
భాష మనకు అనేక నిస్సందేహమైన ప్రయోజనాలను కూడా అందిస్తుంది:
- ప్రాజెక్ట్‌ను నిర్మించిన తర్వాత ఒకే ఎక్జిక్యూటబుల్ ఫైల్ అప్లికేషన్‌ల విస్తరణను చాలా సులభతరం చేస్తుంది.
- స్టాటిక్ టైపింగ్ మరియు టైప్ ఇన్ఫరెన్స్ పరీక్షలు రాయకుండా కూడా మీ కోడ్‌లోని లోపాల సంఖ్యను గణనీయంగా తగ్గించగలవు. నాకు తెలుసు కొంతమంది ప్రోగ్రామర్లు పరీక్షలు రాయకుండానే మరియు వారి కోడ్ నాణ్యత గణనీయంగా బాధపడదు.
- చాలా సులభమైన క్రాస్-కంపైలేషన్ మరియు ప్రామాణిక లైబ్రరీ యొక్క అద్భుతమైన పోర్టబిలిటీ, ఇది క్రాస్-ప్లాట్‌ఫారమ్ అప్లికేషన్‌ల అభివృద్ధిని బాగా సులభతరం చేస్తుంది.
- RE2 సాధారణ వ్యక్తీకరణలు థ్రెడ్-సురక్షితమైనవి మరియు ఊహించదగిన అమలు సమయాలను కలిగి ఉంటాయి.
- థర్డ్-పార్టీ ఫ్రేమ్‌వర్క్‌లు లేకుండా చేయడానికి చాలా ప్రాజెక్ట్‌లను అనుమతించే శక్తివంతమైన ప్రామాణిక లైబ్రరీ.
- సమస్యను ఎలా పరిష్కరించాలి అనేదాని కంటే సమస్యపై దృష్టి సారించేంత శక్తివంతమైన భాష, అయితే సమస్యను సమర్ధవంతంగా పరిష్కరించగలిగేంత తక్కువ స్థాయి.
- Go ఎకో సిస్టమ్ ఇప్పటికే అన్ని సందర్భాలలో కోసం అభివృద్ధి చేసిన సాధనాలను కలిగి ఉంది: పరీక్షలు, డాక్యుమెంటేషన్, ప్యాకేజీ నిర్వహణ, శక్తివంతమైన లింటర్లు, కోడ్ ఉత్పత్తి, రేస్ కండిషన్ డిటెక్టర్ మొదలైనవి.
- గో వెర్షన్ 1.11 అంతర్నిర్మిత సెమాంటిక్ డిపెండెన్సీ మేనేజ్‌మెంట్‌ను ప్రవేశపెట్టింది, ఇది ప్రముఖ VCS హోస్టింగ్‌పై నిర్మించబడింది. Go పర్యావరణ వ్యవస్థను రూపొందించే అన్ని సాధనాలు ఈ సేవలను డౌన్‌లోడ్ చేయడానికి, రూపొందించడానికి మరియు వాటి నుండి కోడ్‌ను ఒక్కసారిగా ఇన్‌స్టాల్ చేయడానికి ఉపయోగిస్తాయి. మరియు అది గొప్పది. వెర్షన్ 1.11 రాకతో, ప్యాకేజీ సంస్కరణలో సమస్య కూడా పూర్తిగా పరిష్కరించబడింది.
- మాయాజాలాన్ని తగ్గించడం భాష యొక్క ప్రధాన ఆలోచన కాబట్టి, భాష డెవలపర్‌లను స్పష్టంగా దోష నిర్వహణ చేయడానికి ప్రోత్సహిస్తుంది. మరియు ఇది సరైనది, ఎందుకంటే లేకపోతే, ఇది పూర్తిగా లోపం నిర్వహణ గురించి మరచిపోతుంది. మరొక విషయం ఏమిటంటే, చాలా మంది డెవలపర్లు ఉద్దేశపూర్వకంగా ఎర్రర్ హ్యాండ్లింగ్‌ను విస్మరిస్తారు, వాటిని ప్రాసెస్ చేయడానికి బదులుగా లోపాన్ని పైకి ఫార్వార్డ్ చేయడానికి ఇష్టపడతారు.
- భాష సాంప్రదాయ OOP పద్ధతిని అమలు చేయదు, ఎందుకంటే దాని స్వచ్ఛమైన రూపంలో గోలో వర్చువాలిటీ లేదు. అయితే, ఇంటర్‌ఫేస్‌లను ఉపయోగిస్తున్నప్పుడు ఇది సమస్య కాదు. OOP లేకపోవడం ప్రారంభకులకు ప్రవేశానికి అడ్డంకిని గణనీయంగా తగ్గిస్తుంది.
సమాజ ప్రయోజనం కోసం సరళత
క్లిష్టతరం చేయడం సులభం, సరళీకృతం చేయడం కష్టం.
గో సింపుల్‌గా ఉండేలా రూపొందించబడింది మరియు అది ఆ లక్ష్యంలో విజయం సాధిస్తుంది. టీమ్‌వర్క్ యొక్క ప్రయోజనాలను అర్థం చేసుకునే మరియు ఎంటర్‌ప్రైజ్-స్థాయి భాషల అంతులేని వైవిధ్యంతో విసిగిపోయిన స్మార్ట్ ప్రోగ్రామర్ల కోసం ఇది వ్రాయబడింది. దాని ఆర్సెనల్‌లో సాపేక్షంగా చిన్న వాక్యనిర్మాణ నిర్మాణాలను కలిగి ఉండటం వలన, ఇది ఆచరణాత్మకంగా కాలక్రమేణా మార్పులకు లోబడి ఉండదు, కాబట్టి డెవలపర్లు అభివృద్ధి కోసం చాలా సమయాన్ని వెచ్చిస్తారు మరియు భాషా ఆవిష్కరణలను అనంతంగా అధ్యయనం చేయడం కోసం కాదు.
కంపెనీలు అనేక ప్రయోజనాలను కూడా పొందుతాయి: తక్కువ ప్రవేశ అవరోధం వారిని త్వరగా నిపుణుడిని కనుగొనడానికి అనుమతిస్తుంది మరియు భాష యొక్క మార్పులేనిది 10 సంవత్సరాల తర్వాత కూడా అదే కోడ్‌ను ఉపయోగించడానికి అనుమతిస్తుంది.
తీర్మానం
పెద్ద మెదడు పరిమాణం ఏ ఏనుగును నోబెల్ బహుమతి విజేతగా చేయలేదు.
టీమ్ స్పిరిట్ కంటే వ్యక్తిగత అహం ప్రాధాన్యతనిచ్చే ప్రోగ్రామర్‌లకు, అలాగే విద్యాపరమైన సవాళ్లను మరియు అంతులేని "స్వీయ-అభివృద్ధి"ని ఇష్టపడే సిద్ధాంతకర్తలకు, భాష నిజంగా చెడ్డది, ఎందుకంటే ఇది సాధారణ-ప్రయోజన శిల్పకళా భాష, ఇది మిమ్మల్ని పొందడానికి అనుమతించదు. మీ పని ఫలితం నుండి సౌందర్య ఆనందాన్ని పొందండి మరియు సహోద్యోగుల ముందు మిమ్మల్ని మీరు ప్రొఫెషనల్‌గా చూపించుకోండి (మేము తెలివితేటలను ఈ ప్రమాణాల ద్వారా కొలుస్తాము మరియు IQ ద్వారా కాదు). జీవితంలో ప్రతిదానిలాగే, ఇది వ్యక్తిగత ప్రాధాన్యతలకు సంబంధించినది. అన్ని విలువైన ఆవిష్కరణల మాదిరిగానే, భాష ఇప్పటికే సార్వత్రిక తిరస్కరణ నుండి సామూహిక ఆమోదం వరకు చాలా దూరం వచ్చింది. భాష దాని సరళతలో తెలివిగలది, మరియు మీకు తెలిసినట్లుగా, తెలివిగల ప్రతిదీ సులభం!
మూలం: www.habr.com