Shulou(Shulou.com)06/02 Report--

This article introduces the relevant knowledge of "what are the pros and cons of learning Go language?" in the operation of practical cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

Why develop the Go language

Purpose

The Go language, developed by Google, aims to make multi-process development more efficient and secure, so as to improve the maintainability, reliability and effectiveness of the server for a long time. For Google, the language can solve the problem of long compilation time and large-scale data processing that has been widely used in production. Google wanted to develop a language that focused on scalability, readability and concurrency, and other languages could not meet these requirements, so the Go language was born. Google developers extracted the simplest and most straightforward concepts from existing languages and improved and combined them to form Go. Take fmt packets, an efficient database for handling strings, as an example:

"the fmt package uses functions similar to C's printf and scanf to implement formatted Imax O. the verb form comes from C, but it is simpler."

This is an example of extracting functionality from a successful and common language (in this case, C) and improving it.

The concurrency mechanism of Go language is based on CSP modeling; using channels can avoid synchronization errors in shared data, which is simpler and more secure for information exchange.

Another focus of the Go language is simplicity. Using the go language requires the development of a recognized unique code style within its framework and consistency in the development of different projects to reduce the time spent configuring linting rules and learning different code styles during development; time is an element of working on a team.

In theory, this will reduce developers' differences in code styles and programming methods, just like the JavaScript language that contains many Eslint rules.

Method

The method adopted by Go combines the programming simplicity of interpretive dynamic languages with the efficiency and security of compiled static languages. Its built-in mapping defines basic types such as int, byte, and string. There are pointers. In addition, an important principle that should be paid attention to when using the go language for development is orthogonality, which is also the basis of the functional approach.

Go uses structure (struct) to represent data and user interface to represent abstraction. There has always been controversy about whether the Go language is object-oriented, and it was difficult for Java developers to understand why it was controversial at first. The focus of the dispute is that there is no type hierarchy in Go, and the general judgment of object-oriented is based on type hierarchy. Some structures cannot be inherited, but do conform to the object style. Go tends to combine rather than inherit. Polymorphism can be achieved through interfaces. Any type of object that satisfies the interface can be docked with it.

In addition to these core concepts, Go implements the modern need for concurrency through multicore processing. Strong concurrency is in the form of goroutines and channels. In large concurrent programs, automatic garbage collection is very important as an effective means of memory management. Unit testing is as simple as using the prefix _ test.go, which is declared in the same directory as the source file.

Reasons for learning Go language

1. Simplicity

The Go language is developed by minimalist method. There are no classes or inheritance. This part of the functionality in popular languages such as Java and Python has been replaced by constructs in Go. Go is a strongly static type and encourages the use of interfaces in a variety of situations. Static typing is designed to reduce compilation errors and make Go easier to learn.

When using other languages such as JavaScript, a variety of inherent methods, examples, and conventions are embarrassing, and Go provides a method as a general style guide. From a team point of view, personal code analysis and reasoning are easier and integration is smoother.

Although there is no implicit conversion, the work spent on syntax is still very small. This makes the code more readable and easier.

2. Rapidity

Statically linked compilers generate binary executables by compilation without having to deal with external dependencies. Executable binaries have been compiled into native code without the need for a virtual machine, and although the amount of data has increased, it is faster and more portable.

In addition, as mentioned earlier, Go has fast compilation time and production time. Because of its simplicity, when using the go language, the developer's productivity has been paid attention to, that is, the process from the initial concept / idea to the finished product is faster.

3. Concurrency

In the go language, concurrency is a core concept and has a high priority, just as it is easy to prefix a function with the go keyword. Goroutines is a simple lightweight thread of execution. It is very easy to implement concurrency in Go. Use the go keyword to generate a new thread that is shared among multiple cores of a set of threads. The Goroutines is only a few thousand bytes and is handled by the Go runtime, which moves the go-routines to a different runnable thread to avoid blocking the channel. This method makes asynchronous execution almost as fast as C / C++. You can use channel to control the number of goroutine, which appears to be synchronous, but is essentially asynchronous.

The runtime of the Go language uses a resizable bounded stack, making the stack smaller. The runtime changes the memory size to automatically store the stack. Hundreds of thousands of goroutine can run in the same address space.

Existing problems

There is no paradigm.

This issue is controversial. In languages like Java, the use of paradigms improves code reusability while ensuring type safety. Users of Go have raised this "question" and thought about it. The suggestions here can be used for reference. However, the mainstream view is that the benefits of using paradigms do not outweigh the benefits of simplicity and readability (without paradigms).

Competitive situation

"Don't communicate by sharing memories; instead, share memories through communication."

This concept brings advantages and makes Go vulnerable to competitive conditions.

Due to the variability of go structures (and the lack of immutable data structures), shared variable data is forced to be implemented across multiple concurrent processes. For example, sending pointers along a channel without deep replication essentially leads to a competitive situation. Channels may improve concurrent programming, but there is a real risk of competition, in which case channel is powerless.

However, a race detector is built into Go CLI to help detect race conditions.

Error check

Error checking is very clear, there is no try … Catch statement. When dealing with errors, we must change the original method and way of thinking, especially the way we have become accustomed to other languages. The Go development team believes that reducing exceptions prevents code complication and return value overloading. This is consistent with its need for simplicity. However, in the case of a real exception, panic and recover can be used to handle the exception and recover. Go also has a standard error interface type that returns an error string with error ().

Go developers use multiple-valued returns to check for error values to handle errors. You can return an error from a function that produces an error by default. If err! = nil is usually used to identify errors from the code base.

It is too simple for some problems

The simplicity of the Go language comes at a price. Go is not as expressive as JavaScript. There is no default value. The lack of abstraction and paradigm makes it more difficult, complex and unintuitive to implement DRY principles.

It is worth noting that Go is still very young. The development team is considering using paradigms, and there is a lot of room for improvement as Go matures. The team worked very hard to continuously develop and improve Go. Like any language, Go has its strengths and weaknesses. What is certain is that if enough Gophers (Go programmers) feel the need for some functionality, it will be achieved.

Although some features seem to be missing, you can see how to implement functions that seem to be missing in Go from another perspective.

There are usually different ways to achieve the same thing, the more friendly Go method.

When to use

It can be said that Go does not solve all problems at this stage; especially when it comes to GUI and complex systems that require a lot of abstraction.

But which language can solve all the problems?

Take advantage of Go. If you find the language too simple and difficult to add complexity in a concise way, you can use Go to build simple micro-services rather than complex systems. Use Go as a tool for building networks and systems, rather than as an alternative to a language that is more suitable for the current task.

So the most important thing is to use the right tools to get the job done. If the tool is Go, then Go should be good at solving the problem.

Be sure not to get the wrong person and seek medical advice in a hurry.

As an open source programming language, Go can easily build simple, reliable and efficient software.

This is the end of the content of "what are the pros and cons of learning Go language". Thank you for your reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.