I am c++/C expert, I like because it is easier than C++ and more powerful
and flexible than C
with Golang , you would not need consider create/destroy/monitor pthread
, crazy pointer is not problem also .
as far as I know , most of golanger is original user of C/C++
在 2018年3月3日星期六 UTC+8上午5:29:45，dorival...@gmail.com写道：
>
> Hi, I could be wrong (please correct me ;-), but here you are what I think
> about Go:
>
> INTRODUCTION
> 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
> computing.
>
> 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 LANGUAGE
> 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
> arguments.
>
> 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
> C-class.
>
> 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.
