Hi, I could be wrong (please correct me ;-), but here you are what I think 
about Go:

Computers and software were initially developed for scientific computing; 
e.g., ALGOL and FORTRAN from the 1950s! Therefore, several computer 
languages and libraries have been invented and are used in scientific 
computing to date.  Nonetheless, when programming a new scientific 
simulation, the question about computational efficiency versus ease-of-use 
remains open. Here, we aim to shed light on a suitable answer to this 
question---TL;DR use Go and Gosl!

One would say that scripting (interpreted) languages might provide the 
convenient platform for computations as long as care is taken to send 
intensive tasks to functions pre-compiled with high-performance languages. 
This strategy fails to create an easy-to-use environment because the 
programmer needs to think when and where those tasks should go. Considering 
that this kind of decision is essential for performance, we argue that 
scripting language is not the best solution.  Furthermore, we argue that 
scripting is the worst tool for teaching new programmers in scientific 

We argue that only experts should use scripting languages (scripts) for 
computer programming because beginners cannot understand how dangerous the 
flexibility of scripts can be. For example, the assignment of variables 
with the same name to different types is often a cause of misunderstandings 
and failures. To make this problem even worse, failures due to wrong types 
are not captured at runtime---certainly not at compilation time (there is 
no compilation time in scripts). In other words, the interpreter is too 
permissive.  The scientist, if aware (rarely the case with students), will 
investigate the numerical output and, after much work, will find the source 
of the error. Therefore, this situation is not ideal. To exemplify, the 
following is allowed in Python (or Julia---similar syntax):

a = 1.0
a = "a" # OK in Python or Julia

In the following code, Go will detect the error with a message such as 
`./test.go:5: cannot use "a" (type string) as type float64 in assignment`:

package main
func main() {
    a := 1.0
    a = "a" // not accepted in Go

The problem propagates in scripting languages when developing 
objected-oriented code. For example, a member data of a class can be 
entirely modified by `anyone`, `anywhere` in Python! This issue completely 
defeats the purpose of encapsulation in OOP.

In summary, scripting (e.g., Python) and alike (e.g., Julia, Matlab) 
languages are excellent for the expert programmer only who can understand 
what is going on. However, they are very misleading to the beginner. In 
other words, the strictness of compiled languages DOES help to learn 
computer programming. Furthermore, the tools for working with compiled 
language often take advantage of well-defined types. The shift towards type 
declaration is so apparent that new languages and strategies are being 
invented to overcome these issues. For example, TypeScript and Javascript 
(ES6) combined with FlowType have been recently developed and have a fast 
adoption among web developers. It seems that no new large project will use 
non-typed Javascript code.

Go is a modern programming language created by Google engineers in 2007, 
including Robert Griesemer, Rob Pike, and Ken Thompson. The language was 
later made public as open source in 2009. Go has since grown exponentially 
attracting a large number of co-developers and users. The primary goal 
leading to the introduction of yet a new language was the combination of 
efficiency (like C/C++) with ease of development (like Python). There are 
other several innovations and advantages in Go when compared with 
mainstream languages such as C/C++/C#/Java/Python/Ruby/Lua. 
Also, Go automatically detects Fortran and C files which helps taking 
advantage of good existing code.

The vocabulary in Go is quite small compared to other languages, making 
easy to have an overview of the syntax and available commands. Go avoids 
complexities such as generics (aka templates) usually available in other 
languages (e.g., C++). Go also tries to avoid unnecessary complexity by not 
taking `in the language` advanced OOP concepts such as polymorphism, 
multiple inheritances, and others. Moreover, Go is somewhat pragmatic in 
the sense that, if an operation can be made much more straightforward, 
although slightly orthogonal to the central paradigm, this operation will 
be carefully defined and adopted in the language specification. These 
features, thanks to the unquestionable expertise of the core developers, 
made Go an enjoyable language to work with.

One limitation of some other languages is code organization and package 
development. For example, C/C++ require the use of `#ifndef`, `#define`, 
`#endif`, or `#pragma once` everywhere to prevent code being included more 
than once. In fact, it is frustrating at times to find how to deal with 
this situation in C/C++, noting that the developer has to worry about what 
code goes in the header (.h, .hpp) or in the (.c, .cpp) files. Moreover, 
the cyclic nature of `imports` using C/C++ can be a nightmare.

In Python, the organization of packages sometimes lead to situations where 
the naming becomes very confusing. For example, we cite the case with 
matplotlib.pyplot or pylab or other packages called mypackage.mypackage 
that we find around. As another example, in Julia, module definition is 
messy, because the user (programmer) has to decide among the files to be 
included versus module definition. In summary, package definition is not 
simple in Python or Julia.

On the other hand, Go was designed from the beginning to be multi-modular, 
prevent cyclic dependency, and made package definition simple. In Go, the 
solution is based on how the directories are organized. For example, each 
directory is a package, and all files in the same directory belong to that 
package. When importing code from other packages, the full path (like URL) 
of that package is used. There is no need for `header` files in Go! 
Moreover, the coding of one feature can span multiple files in the same 
directory. Go comes with a set of tools to build applications and even 
download third-party code.

Go also has a strict convention for code formatting. In other words, there 
is only one way to format your code in Go---using braces starting at the 
end of the line with the `standard` indentation. In this way, a true 
`standard` exists for Go codes which makes sharing straightforward and 
quite pleasant; e.g., no one argues about the positioning of braces 
anymore! Moreover, the strict code convention and specification in Go 
largely facilitates the development of auxiliary programming tools to 
process code. For instance, the import field in source code can be 
automatized as is done with the excellent goimports tool. Many other tools 
(e.g., vet, lint) take advantage of Go conciseness.

Because files and directories in Go follow a well-defined specification, it 
is very easy (and fast) to find definitions, code lines, files, and 
packages (libraries) in Go projects. The compiler in Go benefits from this 
organization and indeed helps with Go being very fast to compile code---you 
can run Go code as if it was a scripting language! Furthermore, the 
excellent specification and organization in Go helped with the creation of 
many other tools to assist in Go code development.  For instance, we 
mention the `goimports` and `gorename` that automatically import all 
dependencies as you type and rename a variable in all code derived from a 
particular library.

Furthermore, also thanks in part to how well the Go specification and 
conciseness were invented, there are several other useful and fast commands 
for handling Go code. For instance, we mention the commands `go run,` `go 
build`, `go install` and `go get` that perform the operations of running 
the code, building the code, installing the code and downloading (and 
compiling) external dependencies automatically.

One particular innovation in Go is the concept of concurrency that can lead 
to easy-to-write parallel algorithms. Also, Go is a garbage-collected 
language that makes easier the code development with fewer worries about 
dangling pointers. Go is in part compiled in Go language and has a 
reasonably comprehensive standard library, including tools for sorting, 
templating, encodings, cryptography, compression algorithms, mathematical 
functions (e.g., for complex numbers), image tools, and even web servers. 
Furthermore, Go uses the concept of unit tests very well and even includes 
tools to assist in benchmarking. Also, Go comes with tools to prepare 
examples and to automate the documentation---there is no need for Doxygen!

The Go language syntax resembles that of C/C++/Java (C-class) but has 
significant differences. One fundamental difference is the way variables 
are declared. The type definition comes after the variable name. This 
difference seems strange at first to C-class programmers, but it makes 
sense. In fact, it makes reading easy, where one would read `variable and 
anotherVariable` are `float64` in `variable, anotherVariable 
float64`---there is no need to type float64 twice (or ten times...). The 
syntax is particularly convenient when declaring multiple function 

Go uses curly braces to define scope but has a strict rule regarding where 
the braces can be put and how to deal with indentation. This approach makes 
the code consistent and easy for collaborations.  Also, with the help of 
the tools called `goimports` and `gofmt`, the workflow is straightforward. 
Go allows some constructions similar to the `range` command in Python and 
does not require the use of parentheses in repetition commands as in 

There is only one repetition command in Go: the `for` keyword. Compared to 
C-class languages, the syntax of the `switch` command is simpler and more 
powerful. Because of that, the programmer is induced (positively) to use 
`switch` over `if` when there is more than one decision branch.

Go code can be directly executed as in: `go run hello.go`. The code could 
be built first with `go build hello.go' and executed (Linux) with 
`./hello`. But this last approach is only necessary when deploying the 
final application. In fact, Go can be used as scripting (using `go run` 
like `python`).

Variables are defined in two ways: the first one requires the command `var` 
and the second one uses the assignment operator `:=` which automatically 
understands the data type. Another great advantage of Go when compared to 
many other languages is the standardized auto-initialization of all 
variables to their `zero` default value. For instance, numeric variables 
declared with `var` are always zero and strings are always empty. This 
feature can be exploited with advantage by the programmer who may consider 
variable names such that everything starts zeroed already. For instance, 
instead of creating a `silent` variable that needs to be set to `true` all 
the time, it's more convenient to use a `verbose` variable that is always 
`false` already.

One type that is extensively used in Go is the `slice` of integers or real 
numbers represented by float point numbers (64-bit version; aka `double` in 
C-class). Slices in Go are a view to an internal sequence of values; i.e., 
slices record the start and end positions in memory. Therefore, slices can 
be passed into functions with minimal overhead. There is hence no need for 
constantly worrying about `by reference` or `by value`. Pointers can also 
be used in Go. We use pointers whenever a user-defined structure is to be 
modified by the called function. In Go, the slice notation `S[s:E]` means a 
view to array `S` starting at `s` and ending at `E-1`, inclusive.

In conclusion, code written in Go is beautiful, concise and with a very 
clear logic.

You received this message because you are subscribed to the Google Groups 
"golang-nuts" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to golang-nuts+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Reply via email to