Not at all!

Go was designed at Google in 2007 to address the efficiency of C and motivated to improve some of the qualities of C++. On the one hand, the main purpose of the language was relative simplicity attained by omitting some of the features that are common in similar languages. On the other hand, it was built with preserving their most useful characteristics in mind, such as static-typing and run-time efficiency, readability and usability, high-performance networking, and multi-processing. Go has quickly become the standard language for the new generation of coders at Google.

According to Go Developer Survey 2020, Golang usage is expanding in the workplace and enterprise with 76% of respondents using Go at work, and 66% saying Go is critical to their company’s success. Furthermore, Go continues to be heavily used for APIs, CLIs, Web, DevOps, and Data Processing. One of the cases where Go has shown excellent results is bidding in real time.

I hope my answer helped you!

If you think of one thing when you think of Go, it ought to be concurrency. Go's concurrency mechanisms make it easy to implement systems that take advantage of today's multicore machines. The language was designed for writing large, distributed web systems.

Go's concurrency moto is,

Do not communicate by sharing memory; instead, share memory by communicating.

That is, make the communication the synchronizer. You can think of Go's concurrency primitive, the goroutine, as a type-safe generalization of the classic Unix pipe. Goroutines are like coroutines, but different: They execute a function to completion in a shared address space, but they run concurrently, with the Go runtime multiplexing goroutines onto threads as needed, achieving not just concurrency but parallelism.

Goroutines are powerful and do a great job hiding the complexities of thread management. But by themselves they have limited applicability: You need a way to communicate beyond just function parameters. Channels combine communication with synchronization, allowing goroutines rich communication with their invokers or even other goroutines.

Thread management, memory management, highly-scalable server software: These are among the most difficult tasks in modern system programming, and Go can make them feel effortless. There is a lot more than I covered, of course. This is just the basics. Here is a fantastic Google I/O talk by Rob Pike, "Go Concurrency Patterns:"

The best thing about GoLang is concurrency. As much as I hate its lack of object orientation and hatred of parentheses in syntax, Go offers an ideal method of handling server side interaction. While Node is fast, it can't do you intensive tasks because it runs on,a single thread. While Java is able to handle cpu intensive tasks, it has to create a huge individual thread for each request, eating up resources exponentially faster than Node. However, Go gives the best of both worlds. Proccesses get their own “threads” (goroutines), but they are kilobytes in size. Thus, you have a fast app with independent requests. Imagine Node as a large, but single highway where traffic jams (cars are metaphors for requests) can occur. Java is several of those highways; one for each car. Go is a multitude of small roads which take little space but don't have “jams”.

I am going to speak from my personal perspective. About one month ago I started to code the prototype for an in-memory web service in Python. I really like the elegance of Python and the ability to prototype things quickly in it. I was implementing the necessary algorithms and when I started to benchmark the performance, I soon realized that my service is going to be CPU bound. In spite of my hard work trying to optimize the Python code it was soon clear that I was enable to make it run fast enough.

I needed to switch to a faster language and the alternatives where: C, C++, Java, Scala and Go. I really did want to write the whole thing in a garbage collected language so that I can get rid of some of the headaches which both C and C++ gave me so many times. I also wanted to write concurrent code without much of a trouble so at this point C and C++ were pretty much out. I was left with Java, Scala and Go. I hate Java and I was afraid of Scala precisely because I could embed Java code into it. Scala also seemed like it had a steeper learning curve.

The solution ? GO! Go was the perfect language for me. It was garbage collected and it seemed to be the perfect candidate for what I had to do. The syntax isn't so exotic as you would expect it to be. Of course, Go has some peculiarities such as the lack of polymorphic functions (although if you come to think of it this only makes you design cleaner code) and generics. But it doesn't matter because I was almost as productive in Go as I was in python and I was able to see a 10x improvement in the speed of the service by just porting it to Go. Afterwards, I have managed to scale that up to 40x by writing concurrent code using the awesome goroutines.

I also do have the feeling that the tools that come with Go do not get their fair share of attention. The Go profiler is an amazing tool and it has helped me more than I could realize in my journey of optimizing the algorithms.

Overall, to answer your question, Go is right now a viable alternative to writing C++ or Java services. If the majority however doesn't take that into consideration it's a completely different story.

A couple, I guess.

Ask me a year ago, and I would have said the #1 problem with Go was a lack of generics, but they have generics now.

I’d say most of the “problems” in Go stem from not paying attention to what anyone else is doing. There are lots of new languages to come out before Go that had these features, and most of them are features which programmers today value quite a bit, but Go lacks.

• nil is the biggest problem in Go. Most new languages either don’t support empty values or force the programmer to unwrap possible empty values. Ever had a NullPointerException in Java or a segmentation fault in C? Was it fun to debug? Modern programming languages don’t think it’s fun to debug either, so they make it impossible. The creators of Go seem blissfully unaware of the problems created by `nil` because they ignore the various strategies used to make these problems disappear.
• if err != nil { return err, nil }. Go doesn’t make you unwrap nil, but boy howdy, do they ever make you unwrap errors! I’m not the biggest fan of unchecked exceptions: they are fine for some kinds of work and not so much for others. If an operation has the possibility of creating a non-fatal error, I do think it should be explicit and you should have to check for it—just like I think you should have to check for nil. But this constant pattern of `if err != nil { return err, nil }` is just a bit too much. Give us some kind of shorthand for throwing errors up the stack to the point we want to deal with them! It should be explicit, but could definitely be tidied up.
• Everything is mutable in Go. The trend is towards making immutability the default these days and marking mutability explicitly. This is because, just like nil, mutation can be a source of bugs that are difficult to track down. Not only does Go default to mutability, but the language actually has no notion immutability. What Go does have is privacy, so library users cannot mutate objects which shouldn’t be mutated—because they can’t see what’s in it at all. The trend in modern languages is the opposite: transparent objects with immutable properties. I’m all in favor of privacy when it makes sense, but not as a form of protection against mutation—and I’m certainly not a fan of making private properties and then just exposing them again with getters.

So here’s a story, I was recently tasked with doing something (a small task) which I figured I’d easily do in bash with awk/grep. I did it and in a test environment it worked great, but on our live servers it took something like 15 seconds to run at 100% CPU load (processing, parsing and searching through log files and tallying up the result).

I’ve never programmed in Golang before, but the time to rewrite the script in C++ reliably would have taken too long, and I heard Golang was awesome for stuff like this. In only about 6 hours I learned and rewrote the bash script in Golang, and it reduced the runtime of this script on our live servers from 15 seconds to ~0.1 seconds, and seeing as how this script was intended to run anywhere from once every 15 minutes, to as low as once a minute, it’s crucial that its runtime is low.

I know a wide number of languages, and Golang is one of those that is very easy to do a lot of lower-level things very quickly. If I would have written this in C++ it would have probably taken me a few days to do the same.

Best tool (or in this case, language) for the job is basically always what I am for. Golang is great when you need raw speed for processing data, files, etc. It’s really the new “hotness” but honestly I see why. In C++ it takes lines and lines of code to simple open a file and start reading from it, in Golang it’s a single line of code. A lot of big companies that have a decoupled architecture are converting their critical-path services to use Golang because of its speed, and they are not using C++ because of how difficult it is to do complex (or even sometimes simple) things with it.

Another great reason to use Golang is that it cross-compiles without any modifications, very easily, and even on the same machine you develop on. I developed and tested the above script I described on a Mac, but it was cross-compiled and deployed (with no modifications) on Windows and Linux servers. Java and Node and many other languages do that, and technically C++ does (mostly) but it doesn’t do it as well as Golang and none of them execute at the raw speed that Golang does.

People like the Go programming language because it is not difficult to understand this language. Reading and writing this programming language is equally easy. Now, this programming language considers the factor of scalability. This is why it has got built-in features that can deal with concurrency. For example, the Goroutines functions can run concurrently with the other functions.

The benefit of the Goroutines is that they have a fast startup time. The best part is that a single GoRoutine can run on multiple threads. Another aspect that you will love about Go is that error checking is not a problem.

The Go compiler has the ability to detect the unused variables. It can also identify the missing imports and packages. These errors are identified when the program build process takes place. This language also allows cross compilation. For example, the Go compiler makes use of simple commands for creating executable binaries for varying operating systems. You will not have to install Go on a foreign machine as well. The source code can be cross-compiled so that it can run on different machines. This is why deployment is also easy for this programming language.

When you use the Go language, then you get a lot of control over the memory allocation. Another aspect that is important to mention here is that Go does not support inheritance. This is why you will notice that it will become much easy for you to modify your code. When there will be no inheritance, then you will not need any constructors as well. You will not have to deal with any exceptions as well.

It is also important to mention that you get the same level of performance with Go as you get with C and C++. This is why you should try exploring Go by all means.

Go is a good choice because it's a small language which gives you a huge amount of power to understand what's going on. In otherwords, here are some examples of what you can do with the toolchain:

1.) You can easily look at the generated assembly: Notes on exploring the compiler flags in the Go compiler suite

2.) You can generate graphs to understand the performance characteristics of your program: Profiling Go Programs

3.) The Go Oracle gives you the ability to deeply understand your program. go oracle: user manual

4.) Spend more of your time worrying abou real problems by letting go format worry about style issues: go fmt your code

5.) Easily write benchmarks to test your program's performance: How to write benchmarks in Go

6.) See where you are lacking unit test coverage with Go cover: The cover story - The Go Blog

You can’t do hard real time. The GC is still a pause the world and no matter how much that pause gets reduced it can cause non deterministic behavior that can be problematic for some applications. The thread scheduler is also non prioritizing which could also cause problems with deterministic response. Basically, the language, like many modern ones, doesn’t worry about these concepts and in that allows them to build in a lot of niceties that most other problems can take advantage of.

For the follow up question, Go has a really nice concurrency concept at the heart of the language. While you can do similar things with almost any other language out there, the tight coupling with the CSP-like message passing between processing is very liberating for certain tasks.

Go is the first new System-Programming language in decades. It is fully compiled like C and therefore efficient. Its main superiority over other system languages is, that it caters for loading multiple CPU’s efficiently and transparently. The same program will run just as well on a single CPU computer as on a machine with 16 CPU cores - just more slowly. Since multiple CPU’s are the norm today it is very important to be able to harness this extra computer power without too much hassle for the programmer.

The trick in Go are goroutines and channels. goroutines are distributed over multiple CPU’s if available. Channels are like pipes in shell programming, which link the output of one goroutine (shell process) to another, which automatically ensures proper sequencing and thus synchronisation. It allows making each goroutine do a specific task simply and cleanly, which follows the now historic principle of linking Unix shell processes with pipes, which allows each process to do one job well. This is an old paradigm newly applied to systems programming.

Answering: “Are there any problems with Go as a programming language?”

I can name a few:

Terrible interoperability with other languages. If one wants to make calls between C and Go, the hoops they have to jump through are horrific. It seems like creators of Go disregarded existence of other languages, presuming that all software will be written in Go.

Terrible interoperability with itself - a program written in Go can only load a library written in Go when both not only use the same Go SDK version to compile both of them, but also same flags. If one wants their Go code to be compatible with itself, they better compile all sources in the same tree.

Go only supports source code interoperability; this is why all 3rd party libraries come from version control systems like Git, in form of source code.

Go does not have stable ABIs. To be fair, many languages do, but Go is notorious at that.

The only mature (ish) module system in Go again relies on source control and only works if the source code of all modules is available.

I can continue this list, but for fairness sake, Go as a language and runtime are both excellent tools. The list above mainly blames Go ecosystem, and the language is only a part of it.

Some of my team members became productive coding in Go after only ~3 months working with it. Without even knowing about Go before. Had we chosen C, C++ or Rust, I would not expect any reasonable productivity for at least 6 month, and likely more than that.

Go’s type system, compiler and generics are very well designed.

Garbage collector is much better than one found in Java, although it’s been a while since I compared the two.

Again, I can continue the second list. But you got the idea - if Go is a suitable tool for your project, and deficiencies and limitations do not affect your project, you won’t regret using Go and possibly deliver before deadline and under budget.

Look at this device. If you press a few of these buttons they will connect you to another person. Tell them you are Phil from IT and you are doing a research on password quality, ask the person what their password is, if they refuse, tell them the passed the test. But out of curiosity ask them what passwords they used in the past.

Keep doing this for a while, you will end up with plenty of passwords, security clearances and much much more.

The more you use the above device, the better you will be.

This is by far the best technology you can use to be a hacker. You can get free phone calls, you can wiretap other such devices and you can do a lot of cool and stupid things. You can call a radio station and win every call in and be number 7 or whatever you need to be in order to win. Just don’t win all the contests, that will trigger interest from the wrong people, the police.

You see, in front of most equipment is a bag full of water, meat and bones mostly, you can get that bag of blood and bones to do pretty much everything if you are good.

Trying to hack computers, so boring and you won’t get really anywhere.

Go (often referred to as golang) is a free and open source programming language created at Google in 2007 by Robert Griesemer, Rob Pike, and Ken Thompson.

The language was announced in November 2009. It is used in some of Google's production systems, as well as by other firms.

Two major implementations exist:

• Google's Go compiler, "gc", developed as open-source software. It targets various platforms including Linux, OS X, Windows, various BSD and Unix versions, and also (since 2015) mobile devices (including smartphones).[16]
• A second compiler, gccgo, is a GCC frontend.[17][18]

The "gc" toolchain has been self-hosting since version 1.5.

[19]

Go originated as an experiment by Google engineers Robert Griesemer, Rob Pike, and Ken Thompson to design a new programming language that would resolve common criticisms of other languages while maintaining their positive characteristics. The developers envisaged the new language as:

[20]

• statically typed, scalable to large systems (as Java and C++)
• productive and readable, without too many mandatory keywords and repetition[21] ("light on the page" like dynamic languages)
• not requiring integrated development environments, but supporting them well
• supporting networking and multiprocessing

In later interviews, all three of the language designers cited their shared dislike of C++'s complexity as a primary motivation for designing a new language.

Hey, I am Harshed abdulla, founder of system shack and i am 16 years old.

Check out my page - fb/sytemshackp

I like the simplicity of the language, and the simultaneous robustness. The standard library does 90% of what I need it to do (assuming I’m not doing a GUI interface). Network tasks, math, string manipulation, image manipulation (basics), file io, and most general purpose needs are handled without 3rd party libraries.

The lack of dependencies makes it great for writing small, single focused programs. I’ve wrote all types of small network programs that need to move files around, create archives, and other small tasks that I might have wrote a using a scripting language or batch/bash file before. The great part about using Go is I can cross compile these little programs so easy for different OS’s.

Web backends are great with Go. It’s my go to (pun!) language for and web api work. Again, the standard library has so many tools built in for this. I use a 3rd party router, user auth library, and that’s it. I haven’t found a need for an ORM at all.

While it is easy to pickup, you’ll have to adjust to the style of writing applications if you’re coming from Java, C#, or something more class based. It’s not terribly dissimilar, but it is different. The Go website has lots of useful info for people new to the language.

C is hard python is slow so use Go

Benefits off using go

1. It is developed by Google
2. It is almost fast as C
3. Its syntax is similar to C
4. It is also Compiled language
5. It is easy to understand like python
6. It is used of audio and video editing
7. It is used in problem solving and machine learning
8. It can be used to create bots

It has many uses so learning it does’t harm so everyone must learn it If they have some spare time.

Please follow Let's Write Some Code.

Computers used to be programmed using a series of 1s and 0s. That proved to be a pain, so they switched to Assembly Language. This sped up programming and debugging.

After a few years, and a few other languages, C was invented, along with a compiler to convert human readable code into machine readable code. A programmer writing in C was faster and the bugs were less frequent.

Then after a few years, BASIC was created. BASIC was much like naturally spoken English, but it was interpreted by a program written and compiled by somebody else.

These days, on a stand alone computer, speed isn't nearly as much of an issue as it was when you would start a build when you left work for the day and hoped it would be done when you returned the next day. Interpreted code isn't the anathema that it once was.

Each new language is created for a purpose. C#, to increase speed of development, Java to run cross platform, Python works really well on Single Board Computers, like the Raspberry Pi, Java Script to drive developers insane. This holds for GO.

No language is a one size fits all solution. Look into what different languages are good at and find one that fits your problem.

Go is a beautiful thing. To answer your first question “When is Golang the best choice?” I would say anything where there is a need for high performance and/or distributed systems.

“What are the reasons I would choose Go over anything else?”

Go has easy to use concurrency and multi core processing. You don’t have to deal with constant Async(NodeJS) I really like NodeJS btw but that can be annoying at times if your new to the concept.

Go is a beautiful blend between a strongly typed and dynamically typed language. You get the best of both worlds.

The type system supports OO but doesn’t force it. You can do functional or procedural programming if you like.

Also, I like that it compiles down to a single binary. That gives me a fuzzy feeling inside lol

Basically go gives me the secure feeling of Java/C# with the flexible feeling of JavaScript or Python.

One of the goals of developing the Go language was to simplify across the board in comparison to languages such as C, C++. The implementation of pointers is different in Go. There is no pointer arithmetic and certain errors that can lead to security flaws in C or C++ are eliminated in Go. Memory is automatically managed by a garbage collector so the programmer does not have to manually free memory. In general about 70% of programming errors that lead to security holes are due to errors in memory management. Automatic memory management does come at cost in terms of slower speed in comparison to C, C++, and Rust in general, but the safety it provides is particularly useful for cloud/server applications where security is paramount. Go’s concurrency implementation provides alternatives to more complex thread management paradigms as well as complex ones if needed. Unlike Java and .Net platforms, Go compiles to a single executable file which does not require in the installation and perpetual updating of a virtual machine. Previously Go did not provide generics. This was a deal breaker for some programmers, but now it is officially implemented in the language standard. Because of these benefits Go has gained a solid presence in cloud/server environments. I think it is good fit for a server backend for a progressive web app (PWA) that can run on mobile as well as desktop/laptop platforms. However, It does not a have a GUI toolkit in the language standard and is not an officially supported platform to develop Android or iOS apps.