{"id":70014,"date":"2017-02-24T12:20:51","date_gmt":"2017-02-24T12:20:51","guid":{"rendered":"https:\/\/www.simple-talk.com\/?p=70014"},"modified":"2021-06-03T16:47:04","modified_gmt":"2021-06-03T16:47:04","slug":"go-language-useful","status":"publish","type":"post","link":"https:\/\/www.red-gate.com\/simple-talk\/development\/dotnet-development\/go-language-useful\/","title":{"rendered":"What is the Go Language, and Why is it Useful?"},"content":{"rendered":"

What is Go?<\/h1>\n

The Go documentation describes Go succinctly:<\/p>\n

“Go is expressive, concise, clean, and efficient. Its concurrency mechanisms make it easy to write programs that get the most out of multicore and networked machines, while its novel type system enables flexible and modular program construction. Go compiles quickly to machine code yet has the convenience of garbage collection and the power of run-time reflection. It’s a fast, statically typed, compiled language that feels like a dynamically typed, interpreted language.”<\/p>\n

What this means is that it is:<\/p>\n

    \n
  1. a relatively simple language, certainly compared to c++ and to some extents c#.<\/li>\n
  2. easy to write programs that scale on multicores<\/li>\n
  3. networked software<\/li>\n
  4. fast to compile, even the largest applications take seconds to compile<\/li>\n
  5. statically typed for safety<\/li>\n<\/ol>\n

    If you are going to write something that will serve network requests of some sort, and will need to scale to a significant numbers of requests, then I would say that Go should be one of the languages that you ought to consider using. Furthermore, if you are looking for a cross platform language that compiles to a console application which will run on the target machine without any dependencies, you also can’t go too far wrong in looking at using Go.<\/p>\n

    What is the history?<\/h1>\n

    Go was invented by three engineers at Google, supposedly impatient at the time it took to build the C++ source at Google. The idea was to build a replacement for C++ that would mean that where they had chosen between C++ for performance with both its complexity and slow build times, and something like Java or Python. The inventors decided that a new language was the only way forward, and that language ended up as Go.<\/p>\n

    What is it best suited to?<\/h1>\n

    Go is best suited to networked services that need to scale. Go has a number of features that mean that it is well-suited to building applications that have to be fast. The first of these ‘turbo’ features is Go’s ability to scale across multiple cores by making multi-threaded programming straightforward. Go uses a model for concurrency called CSP or ‘Communicating Sequential Processes’. The idea is that, instead of sharing variables and having to control access to those variables, shared values are passed between threads using channels. If only one thread can access a value at a given time then you don’t need to lock the variable. The Go authors have reduced this to a slogan:<\/p>\n

    “Do not communicate by sharing memory; instead, share memory by communicating.”<\/h3>\n

    In a practical sense what this slogan means is that, instead of doing it by using locks, mutexes or ReadWriterLockSlims, we pass the object that contains the variable from one GoRoutine<\/span><\/code> (akin to a thread) to another – you use the object and then, when you are finished, you pass it onto the next channel or throw it away.<\/p>\n

    Cross Platform<\/h1>\n

    A further benefit of Go is that it is a cross-platform language and has a runtime that works on Windows, FreeBSD, Mac OS X and Linux. When you compile your Go binary, the runtime is compiled into the executable and that can be copied onto a machine and run – there is no need to run an installer or get any dependencies for your application to run. Go also includes support for building on one architecture but targeting another so from a 32-bit Windows XP machine, should you be unfortunate enough to have a Windows XP machine, you can build a 64-bit binary to run on a Linux machine.<\/p>\n

    Installing Go<\/h1>\n

    To get going with Go you need to install it on your development machine, the latest version can be downloaded from:<\/p>\n

    https:\/\/golang.org\/dl\/<\/a><\/p>\n

    Once you have downloaded and either installed the MSI on Windows or extracted the .tar.gz<\/span><\/code> on Linx\/FreeBSD\/Mac<\/span><\/code>, you need to set a couple of environment variables:<\/p>\n

    The first environment variable is GOROOT<\/span><\/code> which needs to be set to the value of the path to the root installation folder, assuming you installed to “c:\\go<\/span><\/code>” on windows or “~\/go<\/span><\/code>” then you would use the console command:<\/p>\n

    \"set GOROOT=c:\\Go\" or \"export GOROOT=$HOME\/go\"<\/span><\/code><\/div>\n

    You should also update your path variable so that it includes the \"%GOROOT%\/bin\"<\/span><\/code> or \"$GOROOT\/bin<\/span><\/code>” folder.<\/p>\n

    The next step is to set up your workspace folder, which stores downloaded packages etc. and source code. The environment variable “GOPATH<\/span><\/code>” should point to that folder:<\/span><\/p>\n

    \n

    “set GOPATH=c:\\Users\\User.Name\\Documents\\gocode\" or \"export GOPATH=$HOME\/gocode<\/span><\/code>“<\/span><\/p>\n<\/div>\n

    To test that you have everything set up correctly, you should open a command prompt and type “go env<\/span><\/code>“, and make sure you have a value under GOROOT<\/span><\/code> and GOPATH<\/span><\/code>.<\/p>\n

    Our first Go Program<\/h1>\n

    If you create a new folder under “%GOPATH%” or “$GOPATH” and call it “src”, then inside that create a folder called “simple-talk” and inside that create a text file called “main.go” and write:<\/p>\n

    \n

    package<\/span> main<\/span><\/p>\n

    \u00a0<\/span><\/p>\n

    import<\/span> “<\/span>fmt<\/span>“<\/span><\/p>\n

    \u00a0<\/span><\/p>\n

    func<\/span> main<\/span>(){<\/span><\/p>\n

    \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span>fmt.<\/span>Println<\/span>(<\/span>“<\/span>Hello Simple Talk!<\/span>“<\/span>)<\/span><\/p>\n

    }<\/span><\/p>\n<\/div>\n

    https:\/\/play.golang.org\/p\/Uet9PBWaCo<\/a><\/p>\n

    Save this and from the same directory run “go build” which should run without any errors and complete within a second or so. If you are on Windows you will have a “simple-talk.exe” or on other platforms a “simple-talk” executable. If you run the executable it should give you the output “Hello Simple Talk!”.<\/p>\n

    If we take this line-by-line, we have:<\/p>\n

    “package main<\/span><\/code>” This is like a namespace in C#, but differs from a namespace in C# in that you can’t put whatever you like as the package name. An application always starts with “package main” and most smaller programs do not use any other packages: Instead, packages are used to load libraries to control visibility outside of the library.<\/p>\n

    The next line is ‘import \"fmt\"<\/span><\/code>‘. This is importing the “fmt<\/span><\/code>” package which we are using to print out some text: In Go you need to import the name of any packages that you are going to use. Import is like adding a reference to a dll and using the using keyword in C#. When you import a package, the targeted package is compiled into the Go binary; so if you import a package that you do not use, the compiler will throw an error and force you to “use it or lose it”.<\/p>\n

    We then have “func main(){<\/span><\/code>” which is the start of the main func – main is the entry point to every Go app. In this line we also see that Go is based on the C style of languages, preferring to use cURLy braces to separate code rather than whitespace or keywords.<\/p>\n

    The second to last line is:<\/p>\n

    \u00a0\u00a0\u00a0\u00a0`fmt.Println(\"Hello Simple Talk!\")`<\/span><\/code><\/div>\n

    This uses the “Println<\/span><\/code>” method which is in the “fmt<\/span><\/code>” package and simply prints out a string. The last line is the cURLy brace that ends the method.<\/p>\n

    The first of a couple of points here is the lack of semi-colons anywhere, Go does use semi-colons and while you can end a line with one, the standard Go tools will, if configured, remove the semi-colons. When the code is compiled, semi-colons are added for you but are only seen by the compiler. This means that your source code is mostly free of semi-colons in order to aid readability.<\/p>\n

    The second point is that this is exactly how this Go program should look: The writers of Go are very opinionated and say what they consider to be “Idiomatic Go” and what isn’t – anything that isn’t idiomatic is normally wrong. Although I use semi-colons in JavaScript and it feels a little mean being told how to layout my code, it actually makes life a lot easier because every sample on the internet is the same, the code in the standard libraries acts and looks the same and it means you don’t end up with different coding standards and styles.<\/p>\n

    Go toolchain<\/h1>\n

    go fmt<\/h2>\n

    The command to build Go programs is “go build”. There are also other commands such as “go fmt” which takes your source code and re-formats it in the Go style. If we took this as an example …<\/p>\n

    \n

    package<\/span> main;<\/span><\/p>\n

    import<\/span> “<\/span>fmt<\/span>“<\/span>;<\/span><\/p>\n

    func<\/span> main<\/span>() { <\/span><\/p>\n

    fmt.<\/span>Println<\/span>(<\/span>“<\/span>Hello Simple Talk!<\/span>“<\/span>);<\/span><\/p>\n

    }<\/span><\/p>\n<\/div>\n

    … we can see that we have been a little frugal with whitespace and a little over the top with semi-colons. By running “go fmt” in the same directory, you will be able to re-format the code as:<\/p>\n

    \n

    package<\/span> main<\/span><\/p>\n

    \u00a0<\/span><\/p>\n

    import<\/span> “<\/span>fmt<\/span>“<\/span><\/p>\n

    \u00a0<\/span><\/p>\n

    func<\/span> main<\/span>() {<\/span><\/p>\n

    \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span>fmt.<\/span>Println<\/span>(<\/span>“<\/span>Hello Simple Talk!<\/span>“<\/span>)<\/span><\/p>\n

    }<\/span><\/p>\n<\/div>\n

    go vet<\/h2>\n

    Code can also be validated at compile time to find common issues that were not found by the compiler, such as Printf<\/span><\/code> calls that do not match the format string. I have personally seen many many issues in C# that were caused by null reference exceptions in String.Format or some variant.<\/p>\n

    If we change our sample code so it looks like this (note the missing value which should be passed into Printf after the format string) …<\/p>\n

    \n

    package<\/span> main<\/span><\/p>\n

    \u00a0<\/span><\/p>\n

    import<\/span> “<\/span>fmt<\/span>“<\/span><\/p>\n

    \u00a0<\/span><\/p>\n

    func<\/span> main<\/span>() {<\/span><\/p>\n

    \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span>fmt.<\/span>Printf<\/span>(<\/span>“<\/span>Hello Simple Talk! My name is <\/span>%v<\/span>\\n<\/span><\/span>“<\/span>)<\/span><\/p>\n

    }<\/span><\/p>\n<\/div>\n

    https:\/\/play.golang.org\/p\/28WdebLPnc<\/a><\/p>\n

    …then running “go vet” in the folder gives us this error:<\/p>\n

    \n

    test.go:6: missing argument for Printf(\"%v\"): format reads arg 1, have only 0 args<\/span><\/code><\/p>\n

    exit status 1<\/span><\/code><\/p>\n<\/div>\n

    Although, in Go, this wouldn’t be a runtime error, it wouldn’t actually log a value. This would be very annoying to find out when you are debugging an issue and you see the text “Hello Simple Talk! My name is %!v(MISSING)” so it is nice to have tooling ‘out-of-the-box’ that can help stop these sort of silly errors.<\/p>\n

    IDEs<\/h1>\n

    There are a number of IDEs that are available for Go, I am using Visual Studio Code with the Go extension but Jetbrains have an IDE and there are a few other ones as well:<\/p>\n