ગો (પ્રોગ્રામિંગ ભાષા)
ગો એક સંકલિત, ગાર્બેજ-એકત્રિત, સહવર્તી  ગૂગલ સંસ્થાપિત પ્રોગ્રામિંગ ભાષા છે.
"ગો" ભાષાની પ્રારંભિક ડિઝાઇન સપ્ટેમ્બર ૨૦૦૭ માં રોબર્ટ ગ્રીસેમર,રોબ પાઇક અને કેન થોમ્પસનએ કરી હતી.તેની સત્તાવાર રીતે નવેમ્બર ૨૦૦૯ માં જાહેરાત થઇ હતી. લિનક્સ,માઇક્રોસોફ્ટ વિન્ડોઝ,MAC OS X,ફ્રી BSD,પ્લાન ૯(બેલ પ્રયોગશાળા) જેવા ઑપરેટિંગ સિસ્ટમ આ ભાષાને  આધાર આપે છે.

લક્ષ્યાંકો
ગોનો લક્ષ્ય ડાયનેમિક પ્રોગ્રામિંગ ભાષાની સરળતા સાથે  સ્ટેટિક - સંકલિત ભાષાની કાર્યક્ષમતા પૂરું પાડવાનો છે.
અન્ય લક્ષ્યાંકો:

  સલામતી: પ્રકાર સુરક્ષિત અને મેમરી સુરક્ષિત.
  સમાંતર અને સંચાર માટે સારો આધાર
  કાર્યક્ષમ અને  ગાર્બેજ- કલેક્ટરનો ઉપયોગ કરે છે 
 ઉચ્ચ ગતિનું સંકલન.

વર્ણન
ગોનું સિંટેક્સ વ્યાપક પણે  C જેવું જ છે:  કોડ-બ્લોક સર્પાકાર કૌંસની અંદર મર્યાદિત છે;  સામાન્ય નિયંત્રણ ફ્લો સ્ટ્રક્ચરમાં if,switch,forનો સમાવેશ થાય છે.
દરેક નિવેદનોમાં અર્ધવિરામ અને "વેરિયેબલ ડિક્લેરેશન"  સામાન્ય રીતે વૈકલ્પિક છે.નવા go અને select નિયંત્રણ-કીવર્ડ્સ સહવર્તી પ્રોગ્રામિંગને આધાર આપે છે.નવા આંતરિક પ્રકારોમાં  મેપ , UTF-૮ સ્ટ્રિંગ્સ(યોગ્ય યુનિકોડ સ્ટ્રિંગ્સ ખંડગ્રહ વગર), એરે સ્લાઇસેસ અને આંતર થ્રેડ સંદેશાવ્યવહાર માટે ચેનલોનો સમાવેશ કરાયો છે.

ગો  અપવાદરૂપે ઝડપી કમ્પાઇલ સમય માટે રચાયેલ છે.તેના અમુક સમાંતર-સંબંધિત સ્ટ્રક્ચરલ સંમેલનો  ટોની હોરના  CSPમાંથી લેવામાં આવ્યું છે.પહેલાંના સહવર્તી પ્રોગ્રામિંગ ભાષાઓ જેમ કે ઓકમ અને લિમ્બોની જેવી ગોમાં સહવર્તી  આંતરિક-સુરક્ષિત  નથી. 

C++ અને  જાવાની વિપરીત "ગો"માં વારસાઈ(Inheritance),સામાન્ય પ્રોગ્રામિંગ, મેથડ ઓવરલોડિંગ,પોઇન્ટર અંકગણિત જેવી સુવિધાઓ નથી.શરૂઆતમાં, ભાષામાં અપવાદ હેન્ડલિંગનો સમાવેશ થયો ન હતો,પણ માર્ચ 2010 માં એક પદ્ધતિ   panic/recover અસાધારણ ભૂલોને નિયંત્રિત કરવા માટે અમલમાં મુકાઇ હતી.

પ્રકારનું સિસ્ટમ
ગો  પ્રોગ્રામરને એવા કર્યો લખવા માટે પરવાનગી આપે છે જે કોઈપણ મનસ્વી ઇનપુટ પર કામ કરી શકે છે, પણ તે કાર્યોનું વિવરણ ઇંટરફેસમાં અમલ હોવું જોઇએ.
ગો ઈન્ટરફેસ પદ્ધતિઓનો સમૂહ તરીકે વર્ણવવામાં આવે છે, એક નામ અને સિગ્નેચર દ્વારા ઓળખાય છે.એક પ્રકાર માટે ઈન્ટરફેસ અમલમાં માનવામાં આવે છે જો તમામ જરૂરી પદ્ધતિઓ તે પ્રકાર માટે વ્યાખ્યાયિત થયેલ છે.એક ઇન્ટરફેસ માટે અન્ય ઈન્ટરફેસો "એમ્બેડ" જાહેર કરી શકાય છે જ્યારે  અન્ય ઈન્ટરફેસોની વ્યાખ્યાયિત પદ્ધતિઓનો તેમાં સમાવેશ હોય છે.
જાવા વિપરીત, એક ઓબ્જેક્ટ તેની આંતરિક-મેમરીની રજૂઆતમાં વર્ચ્યુઅલ પદ્ધતિ ટેબલ પર પોઇન્ટર ધરાવતું નથી.તેના બદલે ઈન્ટરફેસ પ્રકારની કિંમત તરીકે  ૨ પોઇંટરો અમલમાં મૂકાયેલ છે;૧) ઓબ્જેક્ટ માટે પોઇન્ટર ૨)તે પ્રકાર માટે ઇન્ટરફેસ પદ્ધતિઓ અમલીકરણો સમાવતી શબ્દકોશ માટે પોઇન્ટર.

ઉદાહરણ તરીકે:
type Sequence []int

func (s Sequence) Len() int {
    return len(s)
}

type HasLength interface {
    Len() int
}

func Foo (o HasLength) {
    ...
}

આ ચાર વ્યાખ્યાઓને અલગ ફાઈલોમાં તથા કાર્યક્રમના વિવિધ ભાગોમાં મૂકી શકાય.નોંધનીય છે કે, પ્રોગ્રામર જેઓએ Sequence પ્રકારનું વિવરણ કર્યુ છે તેમને  HasLength અમલમાં મૂકાયેલ છે તેવી જાહેરાત કરવાની જરૂર નથી.જે વ્યક્તિએ Sequence માટે Len પદ્ધતિ અમલમાં મૂકાયેલ છે કે તે પદ્ધતિ HasLengthનો ભાગ હોય તે જરૂરી નથી.

નામ દ્રશ્યતા
	સ્ટ્રક્ચર્સ,	સ્ટ્રક્ચર ફીલ્ડ્સ , ચલો, સ્થિરાંકો, પદ્ધતિઓ,ટોચના સ્તરના પ્રકારોની દૃશ્યતા તેમના ઓળખકર્તા ના કેપીટલાયસેશન મુજબ નિર્વિવાદરૂપે વ્યાખ્યાયિત હોય છે.

સમાંતરણ
ગો, નાના લાઇટવેઇટ થ્રેડ્સ "ગોરુટિન્સ" પૂરા પાડે છે , જેનું નામ પરોક્ષ રીતે કોરુટિન્સને ઉલ્લેખ કરે છે.ગોરુટિન્સ અનામિક અથવા નામવાળી કાર્યોમાં go સ્ટેટમેન્ટ સાથે બનાવામાં આવે છે.
ગોરુટિન્સ તેમના કોલર સહિત અન્ય ગોરુટિન્સ સાથે સમાંતર ચાલે છે.તેઓ અલગ થ્રેડોમાં નથી ચાલતા, પરંતુ ગોરુટિન્સ ,એક જૂથ, મલ્ટીપલ થ્રેડો માં મલ્ટિપ્લેક્સ્ડ છે.

અમલીકરણ
હાલમાં બે(૨) ગો કમ્પાઇલરો છે:
6g/8g/5g (અનુક્રમે AMD64, x86, અને ARM માટેના કમ્પાઇલરો) તેમના સહાયક સાધનો (સામૂહિક તરીકે "gc" તરીકે ઓળખાય છે) જે  કેન થોમ્પસનના પુર્વ કામ "પ્લાન ૯(બેલ પ્રયોગશાળા)ના C ટૂલચેન" પર અધારિત છે.
gccgo,એક GCC ફ્રન્ટએન્ડ C++ માં લખાયેલ છે.
બંને કમ્પાઇલરોનો યુનિક્સ જેવી સિસ્ટમો પર કામ કરે છે અને તેની મોટા ભાગની લાઈબ્રેરીઓ વિન્ડોઝ પર પણ કામ કરે છે.

ઉદાહરણો

હેલો વર્લ્ડ
નીચે "હેલો વર્લ્ડ"નો  પ્રોગ્રામ છે:
package main

import "fmt"

func main() {
	fmt.Println("Hello, World")
}
"ગો"ના સ્વયંસંચાલિત અર્ધવિરામ નિવેશ લક્ષણના કારણે પ્રારંભિક કૌંસ પોતાની લીટીમાં હોવા જરૂરી નથી,એટલા માટે આ કૌંસ શૈલી વાપરવામાં આવે છે.

ઇકો
નીચેનો ઉદાહરણ , ગોમાં યુનિક્સનો "ઇકો કમાન્ડ" કઇ રીતે લખવો તે દર્શાવે છે:
package main

import (
	"os"
	"flag"  // Command line option parser.
)

var omitNewline = flag.Bool("n", false, "don't print final newline")

const (
	Space = " "
	Newline = "\n"
)

func main() {
	flag.Parse()   // Scans the arg list and sets up flags.
	var s string
	for i := 0; i < flag.NArg(); i++ {
		if i > 0 {
			s += Space
		}
		s += flag.Arg(i)
	}
	if !*omitNewline {
		s += Newline
	}
	os.Stdout.WriteString(s)
}

નામકરણ વિવાદ
ભાષાના સામાન્ય પ્રકાશન દિવસે,ફ્રાન્સિસ મેકકેબે, ગો!(આ ઉદ્ગારવાચક બિંદુની નોંધ કરો)ના વિકાસકર્તાએ ગૂગલની ભાષાનું નામ બદલવા માટે વિનંતી કરી જેથી મૂંઝવણ ઊભી ના થાય..આ મુદ્દાને ગૂગલ વિકાસકર્તા દ્વારા ૧૨ ઓક્ટોબર ૨૦૧૦ ના રોજ, "ઘણા કમ્પ્યુટિંગ ઉત્પાદનો અને સેવાઓને "ગો" નામ આપવામાં આવ્યું છે, અમારા પ્રકાશનના ૧૧ મહિના પછી , આ બે ભાષાઓ વચ્ચે ન્યૂનતમ મૂંઝવણ રહી છે"
આ ટિપ્પણી સાથે બંધ કરવામાં આવ્યો હતો.

સંદર્ભો 
નોંધો

પ્રોગ્રામિંગ ભાષા
કમ્પ્યુટર વિજ્ઞાન