ഗോ (പ്രോഗ്രാമിങ് ഭാഷ)

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

 സ്റ്റാറ്റിക് ടൈപ്പിംഗും കാര്യക്ഷമതയും (സി++ അല്ലെങ്കിൽ ജാവ പോലുള്ള)
 ഉത്പാദനക്ഷമതയും എളുപ്പത്തിലുള്ള ഉപയോഗവും (പൈത്തൺ അല്ലെങ്കിൽ ജാവാസ്ക്രിപ്റ്റ് പോലെ)
 ഹൈ പെർഫോമൻസ് നെറ്റ്വർക്കിങ്, മൾട്ടിപ്രോസിസിങ് തുടങ്ങിയവ
ഡിസൈനർമാർക്ക് സി++ നോടുള്ള അനിഷ്ടം ഒരു പുതിയ ഭാഷ രൂപപ്പെടുത്തുന്നതിനുള്ള ഒരു പ്രധാന പ്രചോദനമായി.

ഗോ പ്രോഗ്രാമിംഗ് ഭാഷ നവംബർ 2009 ൽ പരസ്യമായി പ്രഖ്യാപിച്ചു,2012 മാർച്ചിൽ പതിപ്പ് 1.0 പുറത്തിറങ്ങി.2012 മാർച്ചിൽ പതിപ്പ് 1.0 പുറത്തിറങ്ങി.ഗൂഗിളിൽ ഉത്പാദനത്തിനായി വ്യാപകമായി ഉപയോഗിക്കുന്നുമറ്റു പല സംഘടനകളിലും ഓപ്പൺ സോഴ്സ് പ്രോജക്ടുകളിലും ഇത് ഉപയോഗിക്കുന്നുണ്ട്.

2018 ഏപ്രിലിൽ, യഥാർത്ഥ ലോഗോ (ഗോഫർ മസ്ക്കറ്റ്) മാറ്റി സ്ഥാപിക്കപ്പെട്ടു, മനോഹരമായ ഗോ സ്ലാന്റിംഗോട്(GO slanting)കൂടിയ വലതുവശത്തെ ട്രെയിലിംഗ് സ്ട്രീംലൈൻ. എന്നിരുന്നാലും, ചിഹ്നം സമാനമായി നിലനിന്നു.

2018 ആഗസ്റ്റിൽ ഗോയുടെ പ്രധാന സംഭാവനക്കാർക്ക് പുതിയ ഭാഷാ ഫീച്ചറുകൾ, ജനറിക്സ്, എറർ ഹാൻഡലിംഗ് എന്നിവയ്ക്കായി രണ്ട് "ഡ്രാഫ്റ്റ് ഡിസൈൻ" പ്രസിദ്ധീകരിച്ചു.ജനറിക് പ്രോഗ്രാമിങ്ങിനുള്ള പിന്തുണയില്ലായ്മയും ഗോ 1.x ൽ എറർ ഹാൻഡിലിംഗിന്റെ അത്യുക്തിയും ഗണ്യമായ വിമർശനത്തിന് ഇടയാക്കി.
പതിപ്പ് ചരിത്രം
ഭാഷാ സ്പെസിഫിക്കേഷനും അടിസ്ഥാന ലൈബ്രറിയുടെ പ്രധാന ഭാഗങ്ങളുക്കുമായി ഗോ വൺ ഗ്യാരന്റി പൊരുത്തം നൽകുന്നു. നിലവിലെ ഗോ 1.11 റിലീസിലേക്ക്  വരെയുള്ള എല്ലാ പതിപ്പുകളും ഈ വാഗ്ദാനം പാലിച്ചിട്ടുണ്ട്. 

രണ്ട് പ്രധാന റിലീസുകൾ ഉള്ളതുവരെ ഓരോ ഗോ ഗോ റിലീസും പിന്തുണയ്ക്കുന്നു.
+പ്രധാന പതിപ്പ്പ്രാരംഭ റിലീസ് തീയതിഭാഷാ മാറ്റങ്ങൾമറ്റ് മാറ്റങ്ങൾ1 - 1.0.32012/03/28പ്രാരംഭ റിലീസ്1.1 - 1.1.22013/05/13ഗോ 1.1-ൽ, സ്ഥിരമായ പൂജ്യം കൊണ്ട് ഒരു പൂർണ്ണസംഖ്യയെ വിഭജിക്കുന്നത് നിയമപരമായ പ്രോഗ്രാമല്ല, അതിനാൽ ഇത് ഒരു കംപൈൽ-ടൈം എററാണ്.
 സാധുതയുള്ള യൂണികോഡ് കോഡ് പോയിന്റുകളുടെ ഗണത്തിൽ നിന്ന് സറോഗേറ്റ് ഹാൾവ്സ് ഒഴിവാക്കാൻ സ്ട്രിംഗ്, റൂൺ ലിറ്ററൽ എന്നിവയുടെ നിർവചനം പരിഷ്കരിച്ചിരിക്കുന്നു.
 റിട്ടേൺ റിക്വയർമെന്റ് നിയമങ്ങൾ ലൂസൻഡ് ചെയ്തു(Loosened). ഒരു ഫംഗ്‌ഷൻ അവസാനത്തിൽ എത്തുന്നതിന് മുമ്പ് ഒരു ഫംഗ്‌ഷൻ എല്ലായ്‌പ്പോഴും റിട്ടേൺ ചെയ്യാൻ സാധിക്കുമെന്ന് കംപൈലറിന് തെളിയിക്കാൻ കഴിയുമെങ്കിൽ, ഒരു ഫൈനൽ ടെർമിനേറ്റിംഗ് സ്റ്റേറ്റ്‌മെന്റ് ഒഴിവാക്കാവുന്നതാണ്. int തരവും uint തരങ്ങളും 32 അല്ലെങ്കിൽ 64 ബിറ്റാണോ എന്ന് തിരഞ്ഞെടുക്കാൻ ലാങ്വേജ് ഇമ്പ്ലിമെന്റേഷനെ അനുവദിക്കുന്നു.
 64-ബിറ്റ് ആർക്കിടെക്ചറുകളിൽ, പരമാവധി ഹീപ് സൈസ് കുറച്ച് ജിഗാബൈറ്റുകളിൽ നിന്ന് സെവറൽ ടെൻസ്(20 അല്ലെങ്കിൽ 30-ൽ കൂടുതലുള്ളതും എന്നാൽ 100-ൽ താഴെയും ഉള്ള ഒരു അളവ്) ജിഗാബൈറ്റുകളായി  വർദ്ധിപ്പിച്ചിരിക്കുന്നു.
 സ്റ്റാൻഡേർഡ് ടൂൾ സെറ്റിലേക്ക് ഒരു റേസ് ഡിറ്റക്ടറിന്റെ കൂട്ടിച്ചേർക്കൽ.1.2 - 1.2.22013/12/01 സുരക്ഷാ കാരണങ്ങളാൽ, nil പോയിന്ററുകളുടെ ചില ഉപയോഗങ്ങൾ റൺ-ടൈം പാനിക്ക് സൃഷ്ടിക്കുമെന്ന് വ്യക്തമാക്കുന്നു.
 നിലവിലുള്ള ഒരു അറേയിലോ സ്ലൈസിലോ സ്ലൈസിംഗ് ഓപ്പറേഷൻ ഉപയോഗിക്കുമ്പോൾ ശേഷിയും വിഡ്തും വ്യക്തമാക്കാനുള്ള കഴിവ് Go 1.2 ചേർക്കുന്നു. ഒരു സ്ലൈസിംഗ് ഓപ്പറേഷൻ, ഇതിനകം സൃഷ്‌ടിച്ച അറേയുടെയോ സ്ലൈസിന്റെയോ തുടർച്ചയായ ഭാഗം വിവരിച്ചുകൊണ്ട് ഒരു പുതിയ സ്ലൈസ് സൃഷ്‌ടിക്കുന്നു. റൺടൈം ഷെഡ്യൂളറിന് ഇപ്പോൾ (ഇൻലൈൻ ചെയ്യാത്ത) ഫംഗ്‌ഷൻ കോളുകളിൽ അഭ്യർത്ഥിക്കാൻ കഴിയും.
 Go 1.2 ഒരു പ്രോഗ്രാമിന് ഉണ്ടായിരിക്കാവുന്ന ആകെ ത്രെഡുകളുടെ എണ്ണം ക്രമീകരിക്കാവുന്ന ഒരു പരിധി (സ്ഥിരസ്ഥിതി(default) 10,000) അവതരിപ്പിക്കുന്നു.
 Go 1.2-ൽ, ഒരു ഗൊറൂട്ടിൻ സൃഷ്ടിക്കുമ്പോൾ സ്റ്റാക്കിന്റെ ഏറ്റവും കുറഞ്ഞ വലുപ്പം 4 കെബിയിൽ നിന്ന് 8 കെബിലേക്ക് ഉയർത്തി.1.3 - 1.3.32014/06/18ഈ റിലീസിൽ ഭാഷാ മാറ്റങ്ങളൊന്നുമില്ല. Go 1.3 മെമ്മറി മോഡൽ, ബഫർ ചെയ്‌ത ചാനലുകളിൽ അയയ്‌ക്കുന്നതും സ്വീകരിക്കുന്നതും സംബന്ധിച്ച ഒരു പുതിയ നിയമം ചേർക്കുന്നു, ഒരു ബഫർ ചെയ്‌ത ചാനൽ ഒരു ലളിതമായ സെമാഫോറായി ഉപയോഗിക്കാമെന്നും, ചാനലിലേക്ക് സെൻഡ് ചെയ്യുന്നതും, റിലീസുചെയ്യാൻ ചാനലിൽ നിന്ന് സ്വീകരണം നടത്താമെന്നും വ്യക്തമാക്കുന്നു.
 Go 1.3 has changed the implementation of goroutine stacks away from the old, "segmented" model to a contiguous model.
 For a while now, the garbage collector has been precise when examining values in the heap; the Go 1.3 release adds equivalent precision to values on the stack.
 Iterations over small maps no longer happen in a consistent order. This is due to developers abusing implementation behaviour.1.4 - 1.4.32014/12/10 Range-expression without assignment
 Automatic double-dereference on method calls is now disallowed in gc and gccgo. This is a backwards incompatible change but inline within the language specification. In 1.4, much of the runtime code has been translated to Go so that the garbage collector can scan the stacks of programs in the runtime and get accurate information about what variables are active.
 The language accepted by the assemblers cmd/5a, cmd/6a and cmd/8a has had several changes, mostly to make it easier to deliver type information to the runtime.
 Addition of internal packages.
 New subcommand go generate.1.5 - 1.5.42015/08/19 Due to an oversight, the rule that allowed the element type to be elided from slice literals was not applied to map keys. This has been corrected in Go 1.5. The compiler and runtime are now implemented in Go and assembler, without C. Now that the Go compiler and runtime are implemented in Go, a Go compiler must be available to compile the distribution from source. The compiler is now self-hosted.
 The garbage collector has been re-engineered for 1.5. The "stop the world" phase of the collector will almost always be under 10 milliseconds and usually much less.
 In Go 1.5, the order in which goroutines are scheduled has been changed.1.6 - 1.6.42016/02/17There are no language changes in this release. A major change was made to cgo defining the rules for sharing Go pointers with C code, to ensure that such C code can coexist with Go's garbage collector.
 The Go parser is now hand-written instead of generated.
 The go vet command now diagnoses passing function or method values as arguments to Printf, such as when passing f where f() was intended.1.7 - 1.7.62016/08/15 Clarification on terminating statements in the language specification. This does not change existing behaviour.  For 64-bit x86 systems, the following instructions have been added: PCMPESTRI, RORXL, RORXQ, VINSERTI128, VPADDD, VPADDQ, VPALIGNR, VPBLENDD, VPERM2F128, VPERM2I128, VPOR, VPSHUFB, VPSHUFD, VPSLLD, VPSLLDQ, VPSLLQ, VPSRLD, VPSRLDQ, and VPSRLQ.
 This release includes a new code generation back end for 64-bit x86 systems, based on SSA.
 Packages using cgo may now include Fortran source files (in addition to C, C++, Objective C, and SWIG), although the Go bindings must still use C language APIs.
 The new subcommand “go tool dist list” prints all supported operating system/architecture pairs.1.8 - 1.8.72017/02/16 When explicitly converting a value from one struct type to another,  as of Go 1.8 the tags are ignored. Thus two structs that differ  only in their tags may be converted from one to the other. For 64-bit x86 systems, the following instructions have been added: VBROADCASTSD, BROADCASTSS, MOVDDUP, MOVSHDUP, MOVSLDUP, VMOVDDUP, VMOVSHDUP, and VMOVSLDUP.
 Garbage collection pauses should be significantly shorter than they  were in Go 1.7, usually under 100 microseconds and often as low as  10 microseconds.  See the  document on eliminating stop-the-world stack re-scanning  for details.
 The overhead of deferred  function calls has been reduced by about half.
 The overhead of calls from Go into C has been reduced by about half.1.9 - 1.9.72017/08/24 Go now supports type aliases.
 Force the intermediate rounding in floating-point arithmetic. The Go compiler now supports compiling a package's functions in parallel, taking  advantage of multiple cores.1.10 - 1.10.32018/02/16 A corner case involving shifts of untyped constants has been clarified.
 The grammar for method expressions has been updated to relax the syntax to allow any type expression as a receiver. For the X86 64-bit port, the assembler now supports 359 new instructions, including the full AVX, AVX2, BMI, BMI2, F16C, FMA3, SSE2, SSE3, SSSE3, SSE4.1, and SSE4.2 extension sets. The assembler also no longer implements MOVL $0, AX as an XORL instruction, to avoid clearing the condition flags unexpectedly.1.11 - 1.11.12018/08/24There are no changes to the language specification. Go 1.11 adds an experimental port to WebAssembly.
 Go 1.11 adds preliminary support for a new concept called “modules,”  an alternative to GOPATH with integrated support for versioning and  package distribution.
 The assembler for amd64 now accepts AVX512 instructions.
 Go 1.11 drops support of Windows XP and Windows Vista.https://golang.org/doc/go1.11

നടപ്പിലാക്കൽ
രണ്ട് പ്രധാന പ്രവർത്തനങ്ങൾ നിലവിൽ ഉണ്ട്:
 ലിനക്സ്, ബിഎസ്ഡി, മാക് ഒഎസ് , പ്ലാൻ 9, വിൻഡോസ്, (2015 മുതൽ) മൊബൈൽ ഉപകരണങ്ങൾ ഉൾപ്പെടെയുള്ള ഒന്നിലധികം പ്ലാറ്റ്ഫോമുകൾ ടാർഗെറ്റ് ചെയ്യുന്ന ഗൂഗിളിന്റെ ഗോ ടൂൾചെയിൻ.പ്രാഥമിക ഗോ കമ്പൈലർ പതിപ്പ് 1.5 ൽ സ്വയം ഹോസ്റ്റിംഗ് നടത്തി.
 രണ്ടാമത്തെ കമ്പൈലർ, ജിസിസിഗോ(gccgo), ഒരു ജിസിസി ഫ്രണ്ട്എൻഡ് ആണ്.

ഗോഫർജെഎസ്(GopherJS) എന്നറിയപ്പെടുന്ന ഒരു മൂന്നാം ഗോ കമ്പൈലർ, https://github.com/gopherjs/gopherjs ഉണ്ട്. ഗോഫർജെഎസ്  ജാവസ്ക്രിപ്റ്റ്(JavaScript) കോഡിലേക്ക് കംപൈൽ ചെയ്യുന്നു,
ഭാഷാ രൂപകല്പന
ഗോ സി യുടെ പാരമ്പര്യത്തിലൂടെ തിരിച്ചറിയാം, പക്ഷേ, ബ്രേവറ്റി, ലാളിത്യം, സുരക്ഷ എന്നിവ മെച്ചപ്പെടുത്തുന്നതിന് നിരവധി മാറ്റങ്ങൾ വരുത്തുന്നു. ഭാഷയിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്നവ താഴെ കൊടുക്കുന്നു:
 ഡൈനാമിക് ഭാഷയിൽ വളരെ സാധാരണമായ ഒരു വാക്യഘടനയും പരിസ്ഥിതി പാറ്റേണുകളും:
 ടൈപ്പ് അനുപാതത്തിൽ (x: = 0 അല്ല Int x = 0 അല്ലെങ്കിൽ var x = 0;) വഴിയുള്ള തിരഞ്ഞെടുക്കാവുന്ന സംക്ഷിപ്ത വേരിയബിൾ ഡിക്ലറേഷൻ ആൻഡ് ഇനിഷ്യലൈസേഷൻ.
ചുരുങ്ങിയ സമയത്തിനുള്ളിലുള്ള വേഗതയ്യാർന്ന് കംപൈലിംഗ്.
റിമോട്ട് പാക്കേജ് മാനേജ്മെന്റും (‌go get)Download and install packages and dependencies - go - The Go Programming Language; see godoc.org for addresses and documentation of some packages ഓൺലൈൻ പാക്കേജ് ഡോക്യുമെന്റേഷനും.
പ്രത്യേക പ്രശ്നങ്ങളിലേക്ക് പ്രത്യേകമായുള്ള സമീപനം:
അന്തർനിർമ്മിത കൺകറൻസി പ്രെമീറ്റീവ്സ്: ലഘുവായ പ്രോസസ് (ഗോറൗണ്ടിനസ്), ചാനലുകൾ, selectസ്റ്റേറ്റ്മെന്റ്.
അയഥാർത്ഥ(virtual)പാരമ്പര്യത്തിന് പകരം ഒരു ഇന്റർഫേസ് സംവിധാനം, മാത്രമല്ല നോൺ-വെർച്ച്വൽ ഇൻഹെറിറ്റൻസിന് പകരം എംബെഡിംഗ് ടൈപ്പ് ചെയ്യുക.
ഒരു ടൂൾചെയിൻ സ്ഥിരമായി, ബാഹ്യ ഡിപൻഡൻസികൾ ഇല്ലാതെ സ്റ്റാറ്റിസ്റ്റിക്കൽ ലിങ്ക് ചെയ്ത നേറ്റീവ് ബൈനറികൾ ഉൽപാദിപ്പിക്കുന്നു.
സമാനമായ ഭാഷകളിലെ സവിശേഷതകളെ ഒഴിവാക്കുന്നതിലൂടെ, ഭാഗികമായോ ഒരു പ്രോഗ്രാമർക്ക്Rob Pike, on The Changelog  podcast എളുപ്പത്തിൽ മനസ്സിലാക്കാൻ മതിയായ ലളിതമായ ഭാഷാ വിവരണം നിലനിർത്താനുള്ള ആഗ്രഹമാണ് ഈ ഭാഷ വികസിപ്പിക്കുന്നതിനുള്ള കാരണം.
വാക്യഘടന
കോഡ് സംക്ഷിപ്തവും വായനക്ഷമതയും ലക്ഷ്യമിട്ട് ഗോയുടെ വാക്യഘടന സിയിൽ നിന്നുള്ള മാറ്റങ്ങൾ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. വേരിയബിളുകൾ തരം വ്യക്തമാക്കാതെ തന്നെ പ്രോഗ്രാമർക്ക് എഴുതാൻ അനുവദിക്കുന്ന സംയുക്ത പ്രഖ്യാപന / പ്രാരംഭ വിതരണ ഓപ്പറേറ്റർ അവതരിപ്പിച്ചു,i := 3അല്ലെങ്കിൽs := "Hello, world!". ഇത് സി യുടെ int i = 3;const char *s = "Hello, world!"; എന്നീ കോഡുകൾ വിഭിന്നമാണ്. അർദ്ധവിരാമങ്ങൾ ഇപ്പോഴും പ്രസ്താവനകൾ നിർത്തലാക്കുന്നു, എന്നാൽ ഒരു വരിയുടെ അവസാനം ഉണ്ടാകുമ്പോൾ അർത്ഥവത്താണ്.
ഫംഗ്ഷനുകൾക്ക് ഒന്നിലധികം മൂല്യങ്ങൾ നൽകാം, result, err എന്നീ ജോഡികളിലേക്ക് മടങ്ങിവരാം, സാമ്പ്രദായികമായ പ്രവർത്തനം അതിന്റെ കോളർ എന്നതിലേക്ക് ഒരു പിശക് സൂചിപ്പിക്കുന്നു. പേര് ഉപയോഗിച്ച് സ്ട്രറ്റ്(struct) ഘടകം ആരംഭിക്കുന്നതിനും മാപ്പുകളും സ്ലൈസുകളും ആരംഭിക്കുന്നതിനുമായി ലിറ്റററായ വാക്യഘടനകൾ ചേർക്കുന്നു.
തരങ്ങൾ
ഗോയുടെ സംഖ്യകൾ (ബൈറ്റ്, int64, float32, മുതലായവ), ബൂളിയൻസ്, പ്രതീക സ്ട്രിങ്സ് (സ്ട്രിംഗ്) എന്നിവയുൾപ്പെടെ ധാരാളം അന്തർനിർമ്മിത തരങ്ങൾ ഉണ്ട്. സ്ട്രിങ്സ് മാറ്റമില്ലാത്തവയാണ്; ബിൽറ്റ്-ഇൻ ഓപ്പറേറ്റർമാർ, കീവേഡുകൾ (ഫംഗ്ഷണേക്കാൾ) എന്നിവ സങ്കലനം, താരതമ്യം, യോജിപ്പിക്കൽ, യു.ടി.എഫ്-8(UTF-8) എൻകോഡിംഗ് / ഡീകോഡിംഗ് എന്നിവ നൽകുന്നു.Rob Pike, Strings, bytes, runes and characters in Go, October 23, 2013റെക്കോർഡ് തരങ്ങൾ സ്ട്രറ്റ് കീവേഡ്(struct keyword) ഉപയോഗിച്ച് നിർവചിക്കാവുന്നതാണ്.

ഓരോ തരത്തിനും, ഓരോ നോൺ-നെഗറ്റീവ് ഇന്റഗ്രേറ്റ് കോൺസ്റ്റന്റന്റ് n എന്നിവയ്ക്കും ഒരു അറേ തരം സൂചിപ്പിച്ചിരിക്കുന്നത് ; വിവിധ ദൈർഘ്യമുള്ള അറേകൾ പല തരത്തിലുണ്ട്, ഇത് വ്യത്യസ്ത തരം പോലെയാണ്. ചലനാത്മക ശ്രേണികൾ "സ്ലൈസ്സെസ്" എന്ന പേരിൽ ലഭ്യമാണ്,  []T എന്നത് ചില തരത്തിലുള്ള ടിയെ സൂചിപ്പിച്ചിരിക്കുന്നു. ശ്രേണികളെ വിപുലീകരിക്കാൻ പുതിയ മെമ്മറി ആവശ്യമായി വരുമ്പോൾ അവയ്ക്ക് ഒരു നീളവും ശേഷിയുമുണ്ട്. നിരവധി ഭാഗങ്ങൾ അവരുടെ അന്തർഭവിച്ചിരിക്കുന്ന മെമ്മറി പങ്കിടാനിടയുണ്ട്.Andrew Gerrand, Go Slices: usage and internalsThe Go Authors, Effective Go: Slices

എല്ലാ തരങ്ങൾക്കും പോയിന്ററുകൾ ലഭ്യമാണ്, കൂടാതെ പോയിന്റർ-ടു-T എന്നത് ടൈപ്പ് * T എന്ന് സൂചിപ്പിക്കുന്നു. പരോക്ഷമായ അഡ്രസ്സ് ടേക്കിംഗും, & ഉം * സിയിലേപോലെയാണ് ഉപയോഗിക്കുന്നത് അല്ലെങ്കിൽ മെത്തേഡ് കോൾ അല്ലെങ്കിൽ ആട്രിബ്യൂട്ട് ആക്സസ് സിന്റാക്സ് വഴി പൂർണ്ണമായും സംഭവിക്കുന്നു.The Go authors Selectors - The Go Programming Language Specification and Calls - The Go Programming Language Specificationസ്റ്റാൻഡേർഡ് ലൈബ്രറിയിൽ സ്പെഷ്യൽ unsafe.Pointer ഒഴികെ പോയിന്റർ അരിത്മെറ്റിക് ഇല്ല.

ഒരു ജോടി തരങ്ങൾക്ക് K, V, ടൈപ്പ് മാപ്പ് [K] V ടൈപ്പ്- V മൂല്യങ്ങളുള്ള ടൈപ്പ്- K കീകൾ മാപ്പുചെയ്യുന്ന ഹാഷ് ടേബിളുകളുടെ തരങ്ങളാണ് ഉള്ളത്. പ്രത്യേക വാക്യഘടനയും അന്തർനിർമ്മിതവുമായ ഫംഗ്ഷനുകൾ ഉപയോഗിച്ച് ഭാഷയിലേക്ക് ഹാഷ് ടേബിളുകൾ നിർമ്മിച്ചിരിക്കുന്നു. സമയോചിതമായ ഗോ പ്രക്രിയകൾക്കിടയിൽ chanT സമകാലിക ഗണിത പ്രക്രിയകൾ തമ്മിലുള്ള ടൈപ്പ് ടി മൂല്യങ്ങൾ അയയ്ക്കാൻ അനുവദിക്കുന്ന ഒരു ചാനൽ ആണ്.

ഇൻറർഫെയ്സുകൾക്കുള്ള പിന്തുണ കൂടാതെ, ഗോ ടൈപ്പ് സംവിധാനം നാമമാത്രമാണ്: ഒരു പുതിയ പേരുള്ള തരം നിർവചിക്കുവാനുള്ള ടൈപ്പ് കീവേഡ് ഉപയോഗിയ്ക്കാം, ഇത് ഒരേ ലേഔട്ട് ഉള്ള മറ്റ് പേരുള്ളതിൽ നിന്നും വ്യത്യസ്തമാണ് (ഒരു structന്റെ കാര്യത്തിൽ, ഒരേ നിലയിലുള്ള അതേ അംഗങ്ങൾ). വിവിധ തരത്തിലുള്ള രൂപപരിണാമം (ഉദാഹരണത്തിന്, വിവിധ പൂർണ്ണസംഖ്യാതരങ്ങൾക്ക് ഇടയിൽ) മുൻകൂർ നിർവചിച്ചിരിക്കുകയും ഒരു പുതിയ തരം കൂട്ടിച്ചേർക്കുകയും ചെയ്യുന്നത് അധിക പരിവർത്തനങ്ങൾ നിർവചിച്ചേക്കാം, എന്നാൽ പേരുള്ള തരങ്ങൾ തമ്മിലുള്ള പരിവർത്തനങ്ങൾ സ്പഷ്ടമായി പ്രവർത്തിപഥത്തിൽ എത്തിക്കണം.ഉദാഹരണത്തിനു്, 32-ബിറ്റ് അജ്ഞാതമായ (unsigned)പൂർണ്ണസംഖ്യകളുടെ അടിസ്ഥാനത്തിൽ IPv4 വിലാസങ്ങൾക്കുള്ള ഒരു രീതി നിഷ്കർഷിയ്ക്കുന്നതിനായി typeകീവേഡ് ഉപയോഗിയ്ക്കാം.

type ipv4addr uint32

ഈ തരത്തിലുള്ള നിർവ്വചനത്തിൽ, ipv4addr (x) ഒരു ഐപി(IP) വിലാസം ആയി uint32  x നെ വ്യാഖ്യാനിക്കുന്നു. ഉദാഹരണത്തിനു്, ipv4addr എന്ന തരം വേരിയബിളിലേക്കു് x നൽകുന്നതു് ഒരു ടൈപ്പ് എറർ ആണ്.

സ്ഥായിയായ എക്സ്പ്രഷനുകൾ ഒന്നുകിൽ ടൈപ്പ് ചെയ്തതോ അല്ലെങ്കിൽ "ടൈപ്പ്ചെയ്യാത്തതോ" ആയിരിക്കും; അവർ പ്രതിനിധാനം ചെയ്യുന്ന മൂല്യം ഒരു കംപൈൽ-ടൈം പരിശോധനയിലൂടെ കടന്നുപോകുമ്പോൾ ടൈപ്പ് ചെയ്ത ഒരു വേരിയബിളിന് നിയുക്തമാകുമ്പോൾ അവർക്ക് ഒരു മാതൃക നൽകിയിരിക്കുന്നു.

func കീവേഡ് വഴി; ഫങ്ഷൻ തരങ്ങൾ സൂചിപ്പിച്ചിരിക്കുന്നു അവർ പൂജ്യമോ കൂടുതൽ പരാമീറ്ററുകളോ എടുക്കുകയും പൂജ്യം അല്ലെങ്കിൽ കൂടുതൽ മൂല്യങ്ങൾ തിരികെ നൽകുകയും ചെയ്യുന്നു, എല്ലാം ടൈപ്പ് ചെയ്തു. പരാമീറ്ററും റിട്ടേൺ മൂല്ല്യങ്ങളും ഒരു ഫംഗ്ഷൻ തരം നിർണ്ണയിക്കുന്നു; അങ്ങനെ, func (string, int32) (int, error) ഒരു സ്ട്രിംഗ് എടുക്കുന്ന ഫങ്ഷനുകളുടെ തരം, ഒരു 32-ബിറ്റ് സൈൻഡ് സംഖ്യ, സൈൻഡ് പൂർണ്ണസംഖ്യ തിരികെ നൽകുന്നു (സ്ഥിരമായ വീതിയുടെ) ബിൽറ്റ്-ഇൻ ഇന്റർഫെയിസ് ടൈപ്പ് ,error എന്നിവയുടെ മൂല്യത്തിലൂടെ.

ഏതെങ്കിലും പേരുള്ള ടൈപ്പിന് ഒരു രീതി ഉണ്ട്. മുകളിലുള്ള ഐപി(IP)വിലാസത്തിലുള്ള ഉദാഹരണം അതിന്റെ മൂല്യം അറിയപ്പെടുന്ന നിലവാരമാണോ എന്ന് പരിശോധിക്കുന്നതിനായി ഒരു രീതി ഉപയോഗിച്ച് വിപുലീകരിക്കാം.
// ZeroBroadcast reports whether addr is 255.255.255.255.
func (addr ipv4addr) ZeroBroadcast() bool {
    return addr == 0xFFFFFFFF
}
നാമമാത്ര ടൈപ്പിങ് കാരണം, ipv4addr- ലേക്കു് ഈ രീതി വിശദീകരിയ്ക്കുന്നു, പക്ഷേ uint32- ൽ അല്ല. എന്നാലും മെത്തേഡിന് പ്രത്യേക നിർവ്വചനവും കോൾ സിന്റാക്സും ഉണ്ടെങ്കിലും, വ്യത്യസ്തമായ മെത്തേഡ് ഇല്ല.
ഇന്റർഫെയിസ് സിസ്റ്റം
ക്ലാസ് പാരമ്പര്യത്തിന് പകരം രണ്ടു സവിശേഷതകൾ നൽകുന്നു. ഒന്നാമത്തേത് ഉൾച്ചേർക്കൽ ആണ്, അത് ഒരു ഓട്ടോമേറ്റഡ് രൂപകൽപ്പനയായി അല്ലെങ്കിൽ ഡെലിഗേഷനായി കാണാൻ കഴിയും.

രണ്ടാമത്തേത് അതിന്റെ ഇന്റർഫേസുകളാണ്. റൺ ടൈം പോളിമോർഫിസം നൽകുന്നു.ഇന്റർഫെയിസുകൾ ഒരു തരത്തിലുള്ള ടൈപ്പാണ്, പരിമിതമായ ഘടനയുള്ള ടൈപ്പിങ് രീതി ലഭ്യമാക്കുന്നു അല്ലെങ്കിൽ ഗോയുടെ നാമമാത്ര ടൈപ്പ് സിസ്റ്റം. ഒരു ഇന്റർഫെയിസ് തരത്തിലുള്ള ഒരു വസ്തുവും മറ്റൊരു തരത്തിലുള്ളതാണ്, ഒരേസമയം സി++ ഒബ്ജക്റ്റുകൾ പോലെയാണ് അതിന്റെ അടിത്തറ ഒപ്പം ഡെറിവേഡ് ക്ലാസും. സ്മാൾടോക്ക് പ്രോഗ്രാമിങ് ഭാഷയിൽ നിന്നുള്ള പ്രോട്ടോകോളുകൾക്ക് ശേഷം ഗോ ഇൻറർഫേസുകൾ രൂപകൽപ്പന ചെയ്തിട്ടുണ്ട്.ഗോ ഇന്റർഫെയ്സുകളെ വിവരിക്കുമ്പോൾ ഡക്ക് ടൈപ്പിങ് എന്ന വാക്ക് ഒന്നിലധികം സ്രോതസ്സുകൾ ഉപയോഗിക്കുന്നുഡക്ക് ടൈപ്പിങ് എന്ന പദം കൃത്യമായി നിർവ്വചിച്ചിട്ടില്ലെന്നും അതുകൊണ്ടുതന്നെ തെറ്റാകുന്നില്ലെന്നും, അത് സാധാരണയായി തരം തിട്ടപ്പെടുത്തുന്നത് സ്ഥിരമായി പരിശോധിക്കില്ല എന്നാണ്. ഒരു ഗോ കമ്പൈലർ ഉപയോഗിച്ച് ഗോ ഇന്റർഫേസിന്റെ മാനദണ്ഡം സ്ഥിരമായി പരിശോധിക്കുന്നു(ഒരു തരം ദൃഢപ്രസ്താവം നടത്തുമ്പോൾ ഒഴികെ), ഗോ രചയിതാക്കൾ ഘടനാപരമായ ടൈപ്പിംഗ് എന്ന പദം ഇഷ്ടപ്പെടുന്നു.

ഒരു ഇന്റർഫെയിസ് ടൈപ്പിന്റെ നിർവ്വചനം ആവശ്യമുള്ള രീതികളെ പേര്, തരം എന്നിവ പ്രകാരം പട്ടികയിൽപ്പെടുത്തുന്നു. ഏതു  തരത്തിലുള്ള T ഫങ്ഷനുകൾക്കായി, ഏത് തരത്തിലുളള ഫങ്ഷനുകൾ തമ്മിൽ പൊരുത്തപ്പെടുന്ന എല്ലാ വസ്തുക്കളും  ഇന്റർഫേസ് ടൈപ്പ് , I ടൈപ്പിലുള്ള വസ്തുവാണ്. ടൈപ്പ് T ന്റെ നിർവ്വചനം ടൈപ്പ് I തിരിച്ചറിയാൻ (കൂടാതെ കഴിയില്ല). ഉദാഹരണത്തിന്, ആകൃതി, സ്ക്വയർ, സർക്കിൾ എന്നിവ നിർവ്വചിച്ചിട്ടുണ്ടെങ്കിൽ:
import "math"

type Shape interface {
    Area() float64
}

type Square struct { // Note: no "implements" declaration
    side float64
}

func (sq Square) Area() float64 { return sq.side * sq.side }

type Circle struct { // No "implements" declaration here either
    radius float64
}

func (c Circle) Area() float64 { return math.Pi * math.Pow(c.radius, 2) }
ഒരു ചതുരാകൃതിയിലും ഒരു സർക്കിളിലും അന്തർലീനമായ ഒരു ആകൃതിയാണ്, അത് ഒരു ആകൃതിയിലുള്ള ടൈപ്പിംഗ് വേരിയബിളായി നൽകാം. ഔപചാരികഭാഷയിൽ, ഗോയുടെ ഇൻഫർമേഷൻ സിസ്റ്റം നാമമാത്ര ടൈപ്പിങിന് പകരം ഘടനാപരമായ രീതിയിൽ നൽകുന്നു. സംയോജിത ഇന്റർഫെയിസ് ഉണ്ടാക്കുന്നതിന്റെ ഫലമായി ഇന്റർഫെയിസുകൾക്ക് മറ്റ് ഇന്റർഫെയിസുകൾ ഉൾപ്പെടുത്താൻ കഴിയും ഇത് എംബഡ്ചെയ്ത ഇന്റർഫേസ് നടപ്പിലാക്കുന്ന രീതികളും പുതുതായി നിർവചിച്ച ഇൻറർഫേസ് ചേർക്കുന്ന രീതികളും ആവശ്യങ്ങൾ നിർവ്വഹിക്കുവാൻ പ്രാപ്തിയുള്ളതാണ്.

ഗോ അടിസ്ഥാന ലൈബ്രറി റീഡർ, റൈറ്റർ എന്നിവയെ അടിസ്ഥാനമാക്കിയുള്ള ഇൻപുട്ട് / ഔട്ട്പുട്ട് സിസ്റ്റം ഉൾപ്പെടെ നിരവധി സ്ഥലങ്ങളിൽ ജനറിസിറ്റി നൽകുന്നതിന് ഇന്റർഫേസ് ഉപയോഗിക്കുന്നു.

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

ശൂന്യമായ ഇന്റർഫേസ് interface{} ഒരു സുപ്രധാന അടിസ്ഥാന കേസ്സാണ്, കാരണം ഇത് ഒരു നിശ്ചിത തരത്തിലുള്ള ഒരു ഇനത്തെ സൂചിപ്പിക്കാൻ കഴിയും. ഇത് ജാവ അല്ലെങ്കിൽ സി# ലെ ഒബ്ജക്റ്റ് ക്ലാസുമായി സാമ്യമുള്ളതും ഏതെങ്കിലും തരവുമായി സ്റ്റാറ്റിഫൈഡാണ്, intപോലുള്ള അന്തർനിർമ്മിത തരങ്ങൾ ഉൾപ്പെടെയുള്ളവ. ശൂന്യമായ ഇൻറർഫേസ് ഉപയോഗിച്ചുള്ള കോഡ്, പരാമർശിത വസ്തുവിനെ ലളിതമായ രീതികൾ (അല്ലെങ്കിൽ അന്തർനിർമ്മിത ഓപ്പറേറ്റർമാർ) വിളിക്കാൻ കഴിയില്ല, പക്ഷെ അതിനെinterface{}മൂല്യം സൂക്ഷിച്ചു്, ഒരു ടൈപ്പ് അസ്സേർഷൻ അല്ലെങ്കിൽ ടൈപ്പ് സ്വിച്ച് വഴി കൂടുതൽ പ്രയോജനപ്രദമായ തരത്തിലേക്കു് മാറ്റുവാൻ ശ്രമിയ്ക്കുക അല്ലെങ്കിൽ ഗോയുടെ reflect പാക്കേജിൽ ഇത് പരിശോധിക്കുക.reflect.ValueOf(i interface{}) converts an interface{} to a reflect.Value that can be further inspectedinterface{}ഏതൊരു മൂല്യത്തെയും സൂചിപ്പിയ്ക്കുന്നതിനാൽ, സ്റ്റാറ്റിക് ടൈപ്പിങിന്റെ നിയന്ത്രണത്തിൽ നിന്നും രക്ഷപ്പെടാൻ പരിമിതമായ മാർഗ്ഗമാണ് ഇത്, void* എന്ന കോഡ് സിയിൽ ഉപയോഗിക്കുന്നത് പോലെ പക്ഷെ കൂടുതൽ റൺ ടൈം ടൈപ്പ് പരിശോധനകൾ കൂടി നടത്തുന്നു.

ഇന്റർഫെയിസ് മൂല്ല്യങ്ങൾ ഡാറ്റയിലേക്കുള്ള പോയിന്റും റൺ സമയ ടൈപ്പ് വിവരങ്ങൾക്കുള്ള രണ്ടാമത്തെ പോയിന്റും ഉപയോഗിച്ച് നടപ്പിലാക്കുന്നു. ഗോയിൽ പോയിന്ററുകൾ ഉപയോഗിച്ച് നടപ്പിലാക്കാവുന്ന മറ്റു ചില രീതികളെപ്പോലെ, അൺഇനിസൈലസെഡ് ചെയ്തിട്ടില്ലെങ്കിൽ ഇന്റർഫെയിസ് മൂല്ല്യങ്ങൾ ലഭ്യമല്ല.

പാക്കേജ് സിസ്റ്റം
ഗോ പാക്കേജ് സിസ്റ്റത്തിൽ, ഓരോ പാക്കേജിനും ഒരു പാത്ത് ഉണ്ട് (ഉദാ: "compress/bzip2" or "golang.org/x/net/html") കൂടാതെ ഒരു പേരും (ഉദാ: bzip2 or html)ഉണ്ട്. മറ്റ് പാക്കേജുകളുടെ നിർവ്വചനങ്ങൾക്കുള്ള റെഫറൻസുകൾ എല്ലായ്പ്പോഴും മറ്റ് പാക്കേജുകളുടെ പേരിൽ മുൻഗണന നൽകണം, മറ്റ് പാക്കേജുകളിൽ നിന്നുള്ള ക്യാപിറ്റലൈസ്ഡ് പേരുകൾ മാത്രമേ ആക്സസ് ചെയ്യാൻ കഴിയൂ: ഐഓ.റീഡർ(io.Reader) പൊതുവാണെങ്കിലും ബിസിപ്പ്2.റീഡർ(bzip2.reader)അല്ല.ഒരു go getകമാൻഡ് ഉപയോഗിച്ച് ഒരു റിമോട്ട് റിപ്പോസിറ്ററിയിൽ സൂക്ഷിച്ചിരിക്കുന്ന പാക്കേജുകൾ വീണ്ടെടുക്കുവാൻ സാധിക്കുന്നു  സോഴ്സ് ശേഖരവുമായി പൊരുത്തപ്പെടുന്ന അടിസ്ഥാന പാത്തിനുള്ളിൽ പാക്കേജുകൾ വികസിപ്പിയ്ക്കാൻ ഡവലപ്പർമാരെ പ്രോത്സാഹിപ്പിയ്ക്കുന്നു, ഒരു സോഴ്സ് റിപ്പോസിറ്ററിയുമായി (അതുപോലെ example.user_name/package_name) ഭാവി കൂട്ടിച്ചേർക്കലുകളോടൊപ്പം നെയിം കോളീഷൻ സാധ്യത കുറയ്ക്കാൻ സാധിക്കുന്നു.

റസ്റ്റ് കാർഗോ സിസ്റ്റം പോലെ അല്ലെങ്കിൽ നോഡിന്റെ എൻപിഎം(npm) സിസ്റ്റത്തിന് സമാനമായ ഒരു ശരിയായ പാക്കേജ് മാനേജ്മെന്റ് പരിഹാരം അവതരിപ്പിക്കുന്നതിന് നിർദ്ദേശങ്ങൾ നിലവിലുണ്ട്.
കൺകറൻസി: ഗോറുട്ടീൻസുകളും ചാനലുകളും
ഗോ ഭാഷക്ക് കൺകറണ്ട് പ്രോഗ്രാമുകൾ എഴുതുന്നതിന് ബിൽറ്റ്-ഇൻ സൗകര്യങ്ങളും, അതുപോലെതന്നെ ലൈബ്രറി പിന്തുണയും ഉണ്ട്. കൺകറണ്ട് സിപിയു പാരലിസം മാത്രമല്ല, എസിൻക്രണിയും: ഉണ്ട് പ്രോഗ്രാമിന് മറ്റ് പ്രവർത്തനങ്ങൾ ചെയ്യുമ്പോൾ ഒരു ഡാറ്റാബേസ് അല്ലെങ്കിൽ നെറ്റ്വർക്ക് റീഡർ പോലെ സ്ലോ പ്രവർത്തനങ്ങൾ അനുവദിക്കുന്നത്, ഇവന്റ് അടിസ്ഥാനമാക്കിയുള്ള സെർവറുകളിൽ സാധാരണമാണ്.Rob Pike, Concurrency is not Parallelism

പ്രാഥമിക കൺകറൻസി നിർമ്മാണം ഗോറൂട്ടിൻ ആണ്, ഒരു തരം ലൈറ്റ് വെയിറ്റ് പ്രോസസ്സ്. ഗോ കീവേഡിനു മുൻപുള്ള ഒരു ഫംഗ്ഷൻ കോൾ പുതിയ ഗോറുട്ടീനുകളിൽ ഒരു ഫംഗ്ഷൻ ആരംഭിക്കുന്നു. ഗോറുട്ടീനുകളിൽ എങ്ങനെയാണ് നടപ്പാക്കേണ്ടതെന്ന് ഭാഷാ സ്പെസിഫിക്കേഷൻ വ്യക്തമാക്കുന്നില്ല. എന്നാൽ, ഇർലാങ്ങിൽ(ഇർലാങ്(Erlang)ഒരു പ്രോഗ്രാമിംഗ് ഭാഷയാണ്) ഷെഡ്യൂൾ ചെയ്തതുപോലുള്ള സമാനമായ ഒരു ചെറിയ ഓപ്പറേറ്റിങ് സിസ്റ്റം ത്രെഡുകളിലേക്ക് നിലവിലെ നടപ്പാക്കലുകൾ ഒരു ഗോ പ്രോസസിന്റെ ഗോറുട്ടീനുകൾ മൾട്ടിപ്ലെക്സ് ചെയ്യുന്നു.

ക്ലാസിക്കൽ കൺകറണ്ട് കൺട്രോൾ ഓർഗനൈസേഷനുകൾ (മൂട്ടക്സ് ലോക്കുകൾ, മുതലായവ) അവതരിപ്പിക്കുന്ന ഒരു സാധാരണ ലൈബ്രറി പാക്കേജ് ലഭ്യമാണെങ്കിലും ഐഡിയോമാറ്റിക് കൺകറണ്ട് പ്രോഗ്രാമുകൾക്ക് പകരം ചാനലുകളാണ് ഗോറുട്ടീൻസിനായി സന്ദേശങ്ങൾ അയയ്ക്കുന്നത്.ഓപ്ഷണൽ ബഫറുകൾ ഫിഫോ ഓർഡറിൽ സൂക്ഷിക്കുന്നു, അവരുടെ സന്ദേശങ്ങൾ ലഭിക്കുന്നതിന് മുമ്പ്  തുടരുന്നതിനായി ഗോറുട്ടീൻസ് അയയ്ക്കാൻ അനുവദിക്കുന്നു.

ചാനലുകൾ ടൈപ്പ് ചെയ്തു, അതിനാൽ ടൈപ്പ്T സന്ദേശങ്ങൾ കൈമാറാൻ മാത്രമേ chan T ചാനൽ ഉപയോഗിക്കാനാകൂ. അവയക്ക് മേൽ പ്രത്യേക വാക്യഘടന പ്രവർത്തിപ്പിക്കാൻ ഉപയോഗിക്കുന്നു; ചാനൽ  ch, ഒരു മൂല്യം വരുന്നതുവരെ പ്രവർത്തിപ്പിക്കുന്നതിന് ഗോറുട്ടീൻ തടയാൻ കാരണമാകുന്ന ഒരു പദമാണ് <-ch. ch <- x മൂല്യം x (മറ്റൊരു ഗോറുട്ടീൻ സ്വീകരിക്കുന്നതുവരെ തടയുന്നുണ്ടാകാം) അയയ്ക്കുന്നു. ഒന്നിലധികം ചാനലുകളിൽ തടസ്സമില്ലാത്ത ആശയവിനിമയം നടപ്പിലാക്കുന്നതിന് അന്തർനിർമ്മിത സ്വിച്ച് പോലുള്ള തിരഞ്ഞെടുക്കൽ ഉപയോഗിക്കാം. ഗോറുട്ടീൻസ് എങ്ങനെ ചാനലുകൾ ഉപയോഗിക്കണം എന്നത് വിവരിക്കുന്ന ഗോയുക്കുള്ള ഒരു മെമ്മറി മോഡിനൊപ്പം പോകുക അല്ലെങ്കിൽ മറ്റ് പ്രവർത്തനങ്ങൾക്കായി സുരക്ഷിതമായി ഡാറ്റ പങ്കുവയ്ക്കാൻ.

കൺകറണ്ട് ഭാഷയായ എർലാങ് പോലെ ആക്ടർ മോഡൽ ശൈലിയിൽ നിന്ന് വ്യത്യസ്തമായി ചാനലുകൾ നിലനിൽക്കുന്നു,  ആക്ടേഴ്സ് അവിടെ സന്ദേശങ്ങൾ അഭിസംബോധന ചെയ്യപ്പെടുന്നു(ഗോറുട്ടീൻസിന് സമാനമാണ്). ഗോറുട്ടീനുകൾക്കും ചാനലുകൾക്കുമിടയിൽ വൺ ടു വൺ ശൈലിയിൽ ഒരു ബന്ധം നിലനിർത്തുക വഴി, ആക്ടേഴ്സ് ശൈലി ബലവത്താക്കാൻ കഴിയും ഒന്നിലധികം ഗോറുട്ടീൻസ് ഒന്നിലധികം ചാനലുകളിൽ അയയ്ക്കാനും സ്വീകരിക്കാനും ഒരു ചാനൽ അല്ലെങ്കിൽ ഒരൊറ്റ ഗോറുട്ടീൻ പങ്കിടുന്നതിന് ഭാഷയെ അനുവദിക്കുന്നു.

വർക്കർ പൂളുകൾ പോലെ ഈ ഉപകരണങ്ങളിൽ നിന്ന്  ഒരേയൊരു നിർമ്മിതി ഉണ്ടാക്കാൻ കഴിയും, പൈപ്പ് ലൈനുകൾ (ഇതിൽ ഫയൽ ഡികംപ്രസ് ചെയ്യപ്പെടും അതോടൊപ്പം ഡൌൺലോഡ് ചെയ്യുമ്പോൾ വിശകലനം ചെയ്യുകയും ചെയ്യുന്നു), കാലാവധി നീണ്ടുനിൽക്കുന്ന പശ്ചാത്തല കോളുകൾ, ഒരു കൂട്ടം സേവനങ്ങൾക്ക് സമാന്തരമായി "ഫാൻ-ഔട്ട്" സമാന്തര കോൾ ചെയ്യുന്നു.ഇന്റർപ്രോസ്സസ് ആശയവിനിമയത്തിന്റെ പരമ്പരാഗത ആശയങ്ങളിൽ നിന്ന് കൂടുതൽ ചാനലുകൾ കണ്ടെത്തിയിട്ടുണ്ട്, മാത്രമല്ല റീസൈക്കിൾഡ് ബഫറുകളുടെ  കൺകറൻസി-സേഫ് ലിസ്റ്റായി പ്രയോജനപ്പെടുത്തുകയും ചെയ്യുന്നു.John Graham-Cumming, Recycling Memory Buffers in Goകോറുട്ടീനസ് നടപ്പാക്കൽ (ഇത് ഗോറുട്ടീൻ നാമത്താൽ പ്രചോദിപ്പിക്കാൻ സഹായിച്ചു), ഒപ്പം ഇറ്ററേറ്ററുകൾ നടപ്പിലാക്കുകയും ചെയ്യുന്നു.Ewen Cheslack-Postava, Iterators in Go

ഗോ ഘടനയുടെ അനുബന്ധ ഘടനാപരമായ കൺവെൻഷനുകൾ (ചാനലുകളും ബദൽ ചാനൽ ഇൻപുട്ടുകൾ) ടോണി ഹോറേയുടെ ആശയവിനിമയ ശ്രേണി പ്രക്രിയാ മാതൃകയിൽ നിന്ന് ഉരുത്തിരിഞ്ഞു വന്നിട്ടുള്ളതാണ്. ഒകാം (Occam) അല്ലെങ്കിൽ ലിംബോ (ഗോ കോ-ഡിസൈനർ റോബ് പൈക്ക് പ്രവർത്തിച്ചിരുന്ന ഒരു ഭാഷ) പോലുള്ള മുൻകാല പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ നിന്ന് വ്യത്യസ്തമായി,Brian W. Kernighan, A Descent Into Limbo സുരക്ഷിതമായി പരിശോധിച്ചുറപ്പിക്കാവുന്ന കൺകറൻസിയുടെ ഏതെങ്കിലും അന്തർനിർമ്മിത വിഭാവനം ചെയ്തിട്ടില്ല.ആശയവിനിമയ പ്രക്രിയകളെ മോഡലിലേക്ക് ആകർഷിക്കപ്പെടുമ്പോൾ, അത് മാത്രമല്ല, ഒരു പ്രോഗ്രാമിലെ എല്ലാ ഗോറുട്ടീൻസിന്റെ ഒരു ഒറ്റ അഡ്രസ്സ് സ്പേസ് പങ്കിടുന്നു. ഇത് അർഥമാക്കുന്നത് ഗോറുട്ടീനുകൾക്കിടയിൽ മ്യൂട്ടബിൾ വസ്തുക്കളും പോയിന്റുകളും പങ്കിടാം എന്നാണ്.
സമാന്തര പ്രോഗ്രാമിംഗിനുള്ള അനുയോജ്യത
ഗോ സമന്വയ സവിശേഷതകൾ പ്രധാനമായും സമാന്തരമായി പ്രോസസ്സ് ചെയ്യാതെ ലക്ഷ്യം വച്ചില്ലെങ്കിലും, അവ പങ്കിട്ട പ്രോഗ്രാം മെമ്മറി മൾട്ടി-പ്രൊസസ്സർ മെഷീനുകളിൽ ഉപയോഗിക്കാം. ഈ സമീപനത്തിന്റെ ഫലപ്രാപ്തിയെപറ്റി നിരവധി പഠനങ്ങൾ നടത്തിയിട്ടുണ്ട്.ഈ പഠനത്തിൽ ഒന്ന് വലിപ്പം (കോഡുകളുടെ വരികളിൽ), ഭാഷയെ പരിചിതമല്ലാത്ത അനുഭവസമ്പത്തുള്ള പ്രോഗ്രാമർ വഴി എഴുതിയിരിക്കുന്ന പ്രോഗ്രാമുകളുടെ വേഗത എന്നിവയെ താരതമ്യം ചെയ്തു, ഈ പ്രോഗ്രാമുകളുടെ തിരുത്തലുകൾ, ഗോ വിദഗ്ദ്ധർ (ഗൂഗിളിന്റെ വികസന ടീമിൽ നിന്നും), ചാപ്പലിനും(Chapel) സിൽകിനും(Cilk) ഇന്റൽ ടിബിബിയ്ക്കും(Inter TBB) വേണ്ടിയാണ് ഇത് ചെയ്യുന്നത്. ഓരോ റിക്രർഷനുള്ള ഒരു goപ്രസ്താവനയിലൂടെ, വിദഗ്ദ്ധരല്ലാത്തവർ ഡിവൈഡ്-ആന്റ്-കോൺഗർ അൽഗോരിതം എഴുതാൻ ശ്രമിക്കുന്നതായി പഠനം കണ്ടെത്തി. വിദഗ്ദ്ധർ ഒരു ഗോറുട്ടീൻ പ്രോസസ്സർ ഉപയോഗിച്ച് ഡിസ്ട്രിബൂട്ട്-വർക്ക്-സിൻക്രൊണൈസ്  പ്രോഗ്രാമുകൾ എഴുതി.  വിദഗ്ദ്ധരുടെ പ്രോഗ്രാമുകൾ സാധാരണ വേഗത്തിലായിരുന്നു, എന്നിരുന്നാലും നീളമേറിയതായിരുന്നു.
റേസിംഗ് കണ്ടീഷൻ സുരക്ഷയുടെ അഭാവം
ഗോറുട്ടീൻസ് പങ്കിട്ട ഡാറ്റ എങ്ങനെ ആക്സസ് ചെയ്യുന്നു എന്നതിനെക്കുറിച്ചുള്ള നിയന്ത്രണങ്ങൾ ഒന്നുമില്ല, റേസിംഗ് കണ്ടീഷൻ സാധ്യമാണ്. പ്രത്യേകിച്ചും, ഒരു പ്രോഗ്രാം സ്പഷ്ടമായി ചാനലുകൾ അല്ലെങ്കിൽ മറ്റ് മാർഗങ്ങളിലൂടെ സമന്വയിപ്പിച്ചില്ലെങ്കിൽ, ഒരു ഗോറുട്ടീനിൽ നിന്ന് എഴുതുന്നത് ഭാഗികമായും, മറ്റൊരാൾക്ക് പൂർണ്ണമായും ദ‌ൃശ്യമല്ല. പലപ്പോഴും എഴുത്തുകളുടെ ക്രമത്തെപറ്റി ഒരു ഉറപ്പും ഇല്ല. കൂടാതെ, ഗോയുടെ ആന്തരിക ഡാറ്റാ ഘടനകൾ ഇന്റർഫേസ് മൂല്യങ്ങൾ, സ്ലൈസ് ശീർഷകങ്ങൾ, ഹാഷ് ടേബിളുകൾ, സ്ട്രിംഗ് ശീർഷലേഖനങ്ങളുടെ റേസ് വ്യവസ്ഥകൾ ബാധിക്കാത്ത ടൈപ്പുകളും മെമ്മറി സുരക്ഷയും സമന്വയിപ്പിക്കാതെ ഇത്തരം പങ്കിട്ട ഇൻസ്റ്റൻസുകൾ പരിഷ്കരിക്കുന്നതിനായി മൾട്ടിത്രെഡെഡ്(multithreaded) പ്രോഗ്രാമുകൾ ലംഘിക്കപ്പെടാം.Russ Cox, Off to the Races "There is one important caveat: Go is not purely memory safe in the presence of concurrency."ഭാഷാ പിന്തുണയ്ക്ക് പകരം, സുരക്ഷിതമായ കൺകറണ്ട് പ്രോഗ്രാമിങ് സമ്പ്രദായങ്ങളെ ആശ്രയിച്ചിരിക്കുന്നു; ഉദാഹരണത്തിന്, ഒരു മൂട്ടബിൾ മൂല്യം (അല്ലെങ്കിൽ പോയിന്റർ) ഒരു ചാനൽ വഴി കൈമാറുന്നതിന്റെ മൂല്യം, ഉടമസ്ഥാവകാശം അതിന്റെ റിസീവറിന് കൈമാറ്റം ചെയ്യുമെന്നാണ് ഇതുകൊണ്ട് അർത്ഥമാക്കുന്നത്, "aliases xor mutable" എന്ന് വിളിക്കുന്ന ഒരു ഭാഷാരീതി ചിസ്നാൽ(Chisnall) നിർദ്ദേശിക്കുന്നു.
ബൈനറികൾ
ജിസി ടൂൾച്ചെയ്നിലുള്ള ലിങ്ക് ഡിഫാൾട്ട് ആയി സ്റ്റാറ്റിസ്റ്റിക്കൽ ലിങ്ക്ഡ് ബൈനറികളെ സൃഷ്ടിക്കുന്നു, അതിനാൽ എല്ലാ ഗോ ബൈനറികളും ഗോ റൺടൈം ഉൾപ്പെടുന്നു.https://golang.org/doc/faq
ഒഴിവാക്കലുകൾ
(ഇംപ്ലിമെന്റേഷൻ) പാരമ്പര്യം, ജനറിക് പ്രോഗ്രാമിങ്, അസറ്റുകൾ, പോയിന്റർ അരിത്മെറ്റിക്, അചഞ്ചലമായ ടൈപ്പ് പരിവർത്തനങ്ങൾ, ടാർജെറ്റ് ചെയ്തിട്ടില്ലാത്ത യൂണിയനുകൾ, ടാഗുചെയ്ത യൂണിയൻസ് ഉൾപ്പെടെയുള്ള മറ്റ് ഭാഷകളിൽ സാധാരണമായ ചില സവിശേഷതകൾ ആലോചനാപൂർവ്വം ഗോ ഒഴിവാക്കിയിട്ടുണ്ട്. ഡിസൈനർമാർ അംഗീകരിച്ച മൂന്ന് സൗകര്യങ്ങൾ മാത്രം ചേർത്തു. ഒഴിവാക്കിയ ഭാഷാ സവിശേഷതകളിൽ, ഡിസൈനർമാർ ബോധപൂർവ്വമായി വാദങ്ങൾ, പോയിന്റർ അരിത്മെറ്റിക്, കൂടുതൽ പ്രയോജനപ്രദമായ ഭാഷ നൽകുന്നതുവഴി, ടൈപ്പ് ഇൻഹെറിറ്റൻസിനെ ഉപേക്ഷിക്കുന്നതിനുള്ള തിരഞ്ഞെടുക്കലിനെ എതിർത്ത്, ഡൈനാമിക് ഡിസ്പാച്ച്, കോഡുകൾ പുനരുപയോഗിക്കാനുള്ള ഘടന എന്നിവയ്ക്കായി ഇന്റർഫേസുകളുടെ ഉപയോഗം പ്രോത്സാഹിപ്പിക്കുന്നു. കോമ്പോസിഷനും ഡെലിഗേഷനും വാസ്തവത്തിൽ വലിയ തോതിൽ സ്ട്രറ്റ് എംബഡ്ഡിംഗ് വഴി യാന്ത്രികമായി നിർവചിക്കപ്പെട്ടിട്ടുണ്ട്; ഷ്മിയർ ഇറ്റി എഎൽ, ഗവേഷകർ പറയുന്നു ഈ സവിശേഷതക്ക് "ഇൻഹെറിറ്റൻസിൽ ധാരാളം പോരായ്മകൾ ഉണ്ട്: അത് വസ്തുക്കളുടെ പൊതു ഇടപെടലുകളെ ബാധിക്കുന്നു, അത് അത്ര മികച്ചതല്ല (അതായത്, ഉൾച്ചേർത്തുകൊണ്ടുള്ള ഒരു രീതി-നിലവാര നിയന്ത്രണം ഇല്ല), എംബഡ് ചെയ്ത വസ്തുക്കളുടെ രീതികൾ മറയ്ക്കാൻ കഴിയില്ല, കാരണം അത് സ്റ്റാറ്റിക് ആണ് ", അത് ഒരു പരിധി വരെ പ്രോഗ്രാമർമാർ അമിതമായി ഉപയോഗിക്കുമോയെന്ന് വ്യക്തമല്ല, മറ്റ് ഭാഷകളിലെ പ്രോഗ്രാമർമാർ ഇൻഹെറിറ്റൻസിന്റെ അമിതയുപോഗത്താലാണ് പ്രശസ്തിയിലേക്ക് ഉയർന്നിട്ടുള്ളത്.

ജെനറിക് പ്രോഗ്രാമിങ്ങിൽ ഡിസൈനർമാർ ഒരു തുറന്ന പ്രകടനം നടത്തുകയും, ബിൽറ്റ്-ഇൻ ഫംഗ്ഷനുകൾ യഥാർഥത്തിൽ തരം-ജനറിക് ആണ്, എന്നാൽ ഇവ പ്രത്യേക കേസുകളായി പരിഗണിക്കുന്നു; പൈക്ക് (Pike) ചില കാര്യങ്ങളിൽ മാറ്റം വരുത്താനാകുന്ന ഒരു വീക്ക്നെസ്സിനെ വിളിക്കുന്നു. ഗൂഗിൾ സംഘം ജനറിക്സുമായി ഒരു പരീക്ഷണാത്മക ഗോ ഡൈലറ്റിന് വേണ്ടി കുറഞ്ഞത് ഒരു കമ്പൈലറെങ്കിലും നിർമ്മിച്ചു, പക്ഷേ അത് റിലീസ് ചെയ്തില്ല. കോഡ് ജനറേഷൻ നടപ്പിലാക്കാൻ തുറന്ന രീതിയിലാണ് അവർ വഴികൾ വിലയിരുത്തുന്നത്.Rob Pike, Generating code

തുടക്കത്തിൽ ഒഴിവാക്കിയത്, ഒഴിവാക്കൽ പോലുള്ള പാനിക് / റിസർവ് സംവിധാനം അവസാനം കൂട്ടിച്ചേർത്തു, ഒരു മുഴുവൻ പ്രോഗ്രാം അല്ലെങ്കിൽ സെർവർ അഭ്യർത്ഥന നിർത്തിവയ്ക്കാൻ കഴിയുന്ന അനൌദ്യോഗിക പിശകുകൾക്കായി ഗോ രചയിതാക്കൾ നിർദ്ദേശിക്കുന്ന, അല്ലെങ്കിൽ ഒരു പാക്കേജിൽ പിശകുകൾ സ്റ്റാക്ക് അപ്രാപ്തമാക്കുന്നതിനുള്ള കുറുക്കുവഴിയായിട്ടാണ് ഉപയോഗിക്കുന്നത്. (പക്ഷേ പാക്കേജ് അതിരുകൾക്കപ്പുറമുള്ളതല്ല; അവിടെ പിശക് റെഫറൻസ് സ്റ്റാൻഡേർഡ് എപിഐ (API) ആണ്).Panic And Recover, Go wiki
വിമർശനങ്ങൾ
ഗോയുടെ വിമർശകർ ഇങ്ങനെ പ്രസ്താവിക്കുന്നു:
 ജെനറിക് പ്രോഗ്രാമിങ്ങിനുള്ള പാരാമീറ്റീവ് പോളിമോർഫിസത്തിന്റെ അഭാവം ഡ്യൂപ്ലിക്കേഷനിലേക്ക് നയിക്കുന്നു അല്ലെങ്കിൽ സുരക്ഷിതമല്ലാത്ത ടൈപ്പ് കൺവെർട്ടൻസ്, വെർബോസിറ്റിയുടെ ഒഴുക്കിനെ തടസ്സപ്പെടുത്തുന്നു.
 ഗോയുടെ നില്ലും(nil)കൂടിച്ചേർന്നുള്ള ആൽജിബ്രായിക് ടൈപ്പിന്റെ അഭാവം ബുദ്ധിമുട്ട് കൈകാര്യം ചെയ്യൽ പരാജയങ്ങളിലേക്കും അടിസ്ഥാന കേസുകളിലേക്കും അതിനെ നയിക്കുകയും ചെയ്യുന്നു.
 ഭാഷ ചുമത്തുന്ന ഫോർമാറ്റിംഗ് നിയന്ത്രണങ്ങൾ, ഒരു തുറന്ന വക്രമായ ബ്രേസ് സ്വന്തം വരിയിൽ മാത്രം പ്രത്യക്ഷപ്പെടാത്തത് പോലുള്ളവ, അതിന്റെ ക്ലാസ് ഭാഷയ്ക്ക് അസാധാരണമാണ്, ചില ഡെവലപ്പർമാർക്ക് ഇത് ക്ലേശമേറിയ അനുഭവം സമ്മാനിക്കുന്നു.
 ഗോയ്ക്ക് ധാരാളം ആധുനിക ഭാഷാ സവിശേഷതകളുടെ അഭാവം ഉണ്ട്, വിമർശകർ വിശ്വസിക്കുന്നത് കൂടുതൽ വെർബോസിലേക്ക് നയിക്കും എന്നാണ് കൂടാതെ പിശക് പ്രോൺ കോഡ്, ഇവയെല്ലാം ഇനിപ്പറയുന്ന സവിശേഷതകൾ ഉൾക്കൊള്ളുന്നു:
ഓപ്പറേറ്റർ ഓവർലോഡിംഗ്
ടൈപ്പ് അനുമാനം 
സ്ഥായിയായ ഡാറ്റ തരങ്ങൾ
പൊരുത്തപ്പെടുന്ന ഡാറ്റാ തരങ്ങൾ
ഗോയെ ശക്തിപ്പെടുത്തിന്നതിന് സംഭാവന ചെയ്യുന്ന ലളിതവൽക്കരണത്തിന് വേണ്ടി ഡിസൈനർമാർ വാദിക്കുന്നു
കൺവെൻഷനുകളും കോഡു ശൈലിയും
ഗോ പരിപാടികളുടെ ശൈലിയും രൂപകൽപ്പനയും രൂപപ്പെടുത്തുന്നതിനായി ഗോ എഴുത്തുകാർ ഗണ്യമായ ശ്രമം നടത്തി:
ഇൻഡെൻറേഷൻ, സ്പെയ്സിങ്, കോഡിന്റെ മറ്റ് ഉപരിതല-ലെവൽ വിശദാംശങ്ങൾ എന്നിവ ഓട്ടോമാറ്റിക്കായി gofmt ടൂൾ വഴി ക്രമീകരിക്കപ്പെട്ടിരിക്കുന്നു. അധിക സ്റ്റൈൽ പരിശോധനകൾ golint സ്വയം ചെയ്യുന്നു.
എപിഐ ഡോക്യുമെന്റേഷൻ (ഗോഡോക്ക്) പോലെയുള്ള കാര്യങ്ങൾക്കായി സ്റ്റാൻഡേർഡ് സമീപനങ്ങളെ നിർദ്ദേശിക്കാൻ ഗോ വിതരണം ചെയ്ത ഉപകരണങ്ങളും ലൈബ്രറികളും നൽകിയിട്ടുണ്ട്,ടെസ്റ്റിംഗ് (go test), നിർമ്മാണം (go build), പാക്കേജ് മാനേജ്മെൻറ് (go get), തുടങ്ങിയവ.
ഗോ നിയമങ്ങൾ മറ്റ് ഭാഷകളിലെ ശുപാർശകൾ നടപ്പിലാക്കുന്നു, ഉദാഹരണത്തിന്, സൈക്ലിക്ക് ഡിപൻഡൻസികൾ, ഉപയോഗിക്കാത്ത വേരിയബിളുകൾ അല്ലെങ്കിൽ ഇംപോർട്ടുകൾ, കൂടാതെ അസ്പഷ്ടത ടൈപ്പ് പരിവർത്തനങ്ങൾ എന്നിവ നിരോധിക്കുന്നു.
ചില ഫീച്ചറുകളുടെ ഒഴിവാക്കൽ (ഉദാഹരണത്തിന്, ഫങ്ഷണൽ-പ്രോഗ്രാമിംഗ് കുറുക്കുവഴികൾ മാപ്പ്, ജാവ-ശൈലിയിലുള്ള try/finallyബ്ലോക്കുകൾ) ഒരു പ്രത്യേക സ്പഷ്ടമായ, കോൺക്രീറ്റ്, ഇംപെറേറ്റീവ് പ്രോഗ്രാമിങ് ശൈലി പ്രോത്സാഹിപ്പിക്കുന്നു.
ആദ്യ ദിവസം തന്നെ ഗോ സംഘം ഗോ ഭാഷാശൈലിയുടെ ശേഖരം പ്രസിദ്ധീകരിച്ചു, കൂടാതെ പിന്നീട് കോഡ് അവലോകനം ചെയ്ത അഭിപ്രായങ്ങളും ശേഖരിച്ചു, ചർച്ചകൾ,കൂടാതെ ഔദ്യോഗിക ബ്ലോഗ് പോസ്റ്റുകൾശൈലിയിലേക്കും കോഡിംഗ് തത്ത്വശാസ്ത്രത്തിലേക്കും പഠിക്കുന്നതിന് സഹായകരമായി.
ഉപകരണങ്ങൾ
നിരവധി ഭാഷാ ഡിസ്ട്രിബ്യൂഷനുകൾ പോലെ സമാന സോർട്ട് ഓഫ് ഡീബഗ്ഗിംഗ്, പരിശോധന, കോഡ്-വെറ്റിങ് ഉപകരണങ്ങൾ എന്നിവ ഉൾപ്പെടുന്നു. മറ്റ് ഉപകരണങ്ങളിൽ, ഗോ വിതരണങ്ങൾ ഉൾപ്പെടുത്തിയിരിക്കുന്നു,
go build അത് ബൈനറികൾ ഉറവിടം ഫയലുകളിൽ മാത്രം വിവരങ്ങൾ മാത്രം ഉപയോഗിച്ച് നിർമ്മിക്കുന്നു, വേറൊരു മേക്ക് ഫയലുകളില്ല.
യൂണിറ്റ് ടെസ്റ്റിനും മൈക്രോബെഞ്ച്മാർക്കിനും വേണ്ടിയുള്ള go test 
ഫോർമാറ്റിംഗ് കോഡിനായി go fmtഉപയോഗിക്കുന്നു
go get, റിമോട്ട് പാക്കേജുകൾ ലഭ്യമാക്കുകയും ഇൻസ്റ്റോൾ ചെയ്യുകയും ചെയ്യുക
go vet, എന്നത് കോഡുകളിൽ വരാൻ സാധ്യതയുള്ള പിശകുകൾ തിരയുന്ന ഒരു സ്റ്റാറ്റിക് അനലിസർ ആണ്
go run, എന്നത് കോഡ് നിർമ്മിക്കുന്നതിനും പ്രവർത്തിപ്പിക്കുന്നതിനുമുള്ള ഒരു കുറുക്കുവഴി ഉപയോഗിക്കുന്നു.
godoc, വിവരണക്കുറിപ്പുകൾ പ്രദർശിപ്പിയ്ക്കുകയോ എച്ച്ടിടിപി(HTTP)വഴി ലഭ്യമാക്കുകയോ ചെയ്യുക
gorename,  വേരിയബിളുകളുടെ പേരുമാറ്റം, പ്രവർത്തനങ്ങൾ, അങ്ങനെ ഒരു തരത്തിലുള്ള-സുരക്ഷിത വഴിക്കു വേണ്ടിയാണിത് ഉപയോഗിക്കുന്നത്
go generate, കോഡ് ജനറേറ്ററുകൾ വിളിക്കാൻ ഉള്ള ഒരു സ്റ്റാൻഡേർഡ് മാർഗ്ഗമാണിത്

റൺടൈം ഇൻസ്ട്രുമെന്റേഷൻ പിന്തുണയും ഡീബഗ്ഗിങ്ങും ഇതിൽ ഉൾപ്പെടുന്നു(ഉദാഹരണമായി, ട്രാൻസ്ഫർ ശേഖരണ പോസുകൾ), കൂടാതെ ഒരു റേസ് കണ്ടീഷൻ ടെസ്റ്ററും ഉണ്ട്. മൂന്നാം-കക്ഷി ഉപകരണങ്ങളുടെ ഒരു ആവാസ വ്യവസ്ഥ സ്റ്റാൻഡേർഡ് വിതരണം നൽകുന്നു, പല ടെക്സ്റ്റ് എഡിറ്റർമാർക്കൊപ്പം കോഡ് സ്വയം പൂർത്തീകരണം പ്രാപ്തമാക്കുന്ന go code, goimports (ഒരു ഗോ ടീം അംഗം), ആവശ്യമുള്ളിടത്തോളം പാക്കേജ് ഇറക്കുമതി കൂട്ടിച്ചേർക്കുന്നു / നീക്കം ചെയ്യുന്നു, errcheck അവഗണിച്ചേക്കാവുന്ന കോഡ് കണ്ടുപിടിക്കുന്ന തെറ്റ് പരിശോധനയും. നിരവധി ടെക്സ്റ്റ് എഡിറ്റർമാർക്ക് ഭാഷാ പിന്തുണ ചേർക്കുന്നതിനായി പ്ലഗിനുകൾ നിലവിലുണ്ട്. നിരവധി ഐഡിഇ(IDE)കൾ ലഭ്യമാണ്. ഉദാഹരണത്തിന്, ലൈറ്റ്ഐഡിഇ(LiteIDE) "ഒരു ലളിതമായ, ഓപ്പൺ സോഴ്സ്, ക്രോസ് പ്ലാറ്റ്ഫോം ഗോ ഐഡിഇ","കഴിവുള്ളതും സുഗമവുമായ" അവകാശവാദങ്ങളുമായിട്ടാണ് ഗോലാൻഡ്(GoLand)എത്തിയിരിക്കുന്നത്. 

അവലംബം