Now the blog post "A new way to bring garbage collected programming languages efficiently to WebAssembly" written by the team of V8 (JavaScript and WebAssembly engine) on the official website of Google has appeared.
https://v8.dev/blog/wasm-gc-porting
When I saw in the first paragraph of the blog that "we will get into the technical details of how GC languages such as Java, Kotlin, Dart, Python, and C# can be ported to Wasm" the question "Why people in Google hate Go?" arose
Go excels in tooling and code sharing, and onboarding developers with Go is efficient.
It also has an extremely small runtime footprint, reducing ecological footprint and server costs :) An average JVM needs 500+ MB of RAM, whereas our average Go microservice hovers around 25 MB.
Last but not least, it is not tied to the existing C ecosystem, which is a HUGE value add in containerized environments where in the majority case you can make a Docker image that is based on `scratch`.
Of course there are some quirks (lack of try syntax for example), but Go programs are also simpler to comprehend due to intentional exclusion of AOP, try-catch, etc.
Lastly, the interface system is probably the most straight forward and simple for general programming :)
They also provide their own crypto within the standardlib. No openssl needed.
We are running small services with heap size under 100 MBs and is absolutely possible with new JVM versions. If you want ever smaller without JIT, native image is also an option. Moreover in most scenarios, JVM provide better peak performance. So here is a tradeoff
First of all, I can't really parse your question, but I'll try to answer what I think you're asking.
Go isn't hated at Google – there's just a lot of other code in other languages. C++ and Java are the two most popular, with Python probably rounding out the top three. Go would probably be number 4 (discounting Javascript, because I'm really focused on backend or infra tech).
Go's performance is not as good as LLVM derivatives, but that's not what it tries to be. It's a simple language, that tries to be as helpful as possible to the programmer. I describe it as a big-boy python, but think of it as "the C I always wanted."
Generally, I don't need the performance of C++. I think lots of people that think they do are probably wrong, but I try to not argue on the internet. If I need to get something done, and get on to the next thing, I use Go. Do I leave cycles on the floor and have (very small) GC pauses – yes, but I get my stuff done, and IMO it's a small price to pay.
Use whatever language helps you get your stuff done. Stop arguing over languages.
--
Having said that, if the question is, "why aren't the WebAssembly people mentioning Go?" I don't know. Go's supported WASM for a long-time, and the people inside Google who care about WASM care about Go. There is new stuff in WASM not really taken advantage of in Go, but Go is also a strange animal with a strange stack model, and it takes time. I would think, as with all things Go, it'll be there, but it will take a little time, be thorough, complete, well thought out, and maintained roughly forever.
Quote from Ian Lance Taylor (Google Principal Engineer)
"Now a bit of personal history. The Go project was started, by Rob, Robert, and Ken, as a bottom-up project. I joined the project some 9 months later, on my own initiative, against my manager's preference. There was no mandate or suggestion from Google management or executives that Google should develop a programming language. For many years, including well after the open source release, I doubt any Google executives had more than a vague awareness of the existence of Go (I recall a time when Google's SVP of Engineering saw some of us in the cafeteria and congratulated us on a release; this was surprising since we hadn't released anything recently, and it soon came up that he thought we were working on the Dart language, not the Go language.)"
https://groups.google.com/g/golang-nuts/c/6dKNSN0M_kg/m/EUzc...
It is an order of magnitude faster than Python. So it is well suited for performance in many cases.
It is a lot easier to pick up than C/C++. So it is well suited for smaller programs.
I can see Go as a very good middle-ground.
That's why corporations like Google invent "middle-ground" languages.
Go from Google
Java from Oracle
C# from Microsoft
These companies need some performance, but they can't hire enough C/C++/Rust devs (not enough exist). They're flush with JS/Python devs, but those languages are too slow.
So they invent these abominable "middle-level" languages, with their insane bloat.
For myself, I'm not interested in mediocrity to serve corporate interests, so I don't touch them. :p Extremes only: Python and C; Ruby and Rust; JS and C++.
I would say, "it is a lot easier to pick up than C++" as the language specification is much smaller. I wouldn't be so sure about the comparison to C, though.
Go excels in that it is so simple. As the saying goes, you mostly read code, not write it. Go is very easy to understand and review. Which is what you do mostly when working on complex systems in teams. It's extremely easy (and fast) to build and deploy unlike the languages above. That's why companies use go. Not for personal projects, not for drivers, and also probably not for corporate monoliths that require a suit and a tie to contribute.
You will never have an issue with missing dependencies or outdated runtime.
The bigger problem is the weak and inexpressive type system, which is no better for C or Python.
What "stuff" is that exactly? Because Go is designed primarily for backend services and microservices. Considering how much backend software is powered by Python, Java, or *retching sounds* PHP, I highly doubt that is a major consideration in that area.
And even when performance actually does matter to an extend where it becomes a more pressing issue than network latency, Go code performs incredibly well and is more than a match for most requirements.
> No OO
How do you figure? I can write in a completely object oriented style in Go. Also, OO is not a prerequisite for large complex systems, and quite often strict adherence to it can make code much harder to maintain than it needs to be. Maintaining large complex systems requires, first and foremost, code that is easy to grok and maintain. And regarding that particular area, Go runs circles around any major contemporary language, including Python.
> It seems that its popularity exceeds its scope
Considering how widespread it is by now, I highly doubt that.
A Rust program is by default going to be CPU and memory efficient. It is not likely to negatively surprise you in production with weird bottlenecks and unexpected behavior.
The time invested in producing a solution which is statically typed, pays of in spades when it is time to refactor or change something (which is pretty damn often if it is your product). Refactoring a Python/Erlang/Elixir/C/PHP solution is a major PITA and fraught with new bugs.
The time spent optimizing solutions in high level languages when they are falling on their face in production is generally ignored and extremely common. You do not have to be github to face performance problems in Ruby.
* Easier/safer than C
* Less dangerous than Javascript (statically typed and a good standard library)
* Much faster than Python
I think it's an excellent middle ground, compromise language. It's the centrist candidate of programming languages. Not the best at anything, but on average better than most.
I can compile my go application down to a single, static binary that can run in a distroless container. The packaging/deployment simplicity of Golang appeals to me much more than Python, TypeScript, etc.
Also the developer tooling is first class and sustained backwards compatibility is top-notch. I can pretty much always upgrade the version of Go 1.x I target and have 0 worries in the world. Meanwhile in Python and JS land, the dependency management problems are a nightmare.
Performance is good enough for most jobs, we're not all working on the bleeding edge, a lot of jobs are more akin to code monkeying basic CRUD
The language also seems to be built for the kind of people who think C has no downsides and everyone should write everything as explicitly as possible, which are an audience that normally doesn't get aimed at.
Now it is kind of unavoidable in DevOps space for some cenarios.
My only complaint is their approach to language design.
Inferno with Limbo, Android, Windows Phone, show that there is GC hate, and shipping products to millions of users.
I don't get the GC hate. If its done properly (like Go) its invisible for 99% of applications and dramatically simplifies things like business logic that don't need to be that complicated or fast.
The real culprit is usually Java's slow startup and memory bloat from the JVM.
Are you referring to Object Oriented programming? And if so, why not?
Also, unless inheritance is what you mean by oop, it supports the other usecases of oop
There are a lot of values that goes into "performance critical stuff". For me, it can mean a chat app / money transfers etc that is performance critical but is is of course not as critical as in flight software or other system control software where GC could mean deaths.
Golang does not have this and it makes me feel like programming with only one hand. In particular when working with data and aggregations.
I am prepared to be corrected, I have only looked briefly at golang, so I am happy to give golang proponents a chance to shine!
What I also found was that there was a whole class of errors that I hadn't seen in years due to mutable state and poorly written for loops/ranges when compared to map/filter/reduce usage.
We introduced `samber/lo`[1] which provides a lodash-like library, generics compatible, to Go. This has been a big step-up and has improved my experience with writing Go immeasurably.
My colleagues now (kindly) joke every time they see a PR from me that includes a lot of samber/lo usage that I'm slowly replacing every for loop I encounter.
I am with you. Ever since working extensively with SQL for a while my go-to paradigm has been "programming without for-loops". It just magically removes the bugs.
The problem here, as you also hint, is that there will be a clash with the existing culture and codebase. And that may not be a small thing, even though you co-workers seem to treat you in a good way.
Go is far from perfect, but I’m productive with it, it’s expressive enough that it’s both easy to write AND read, it’s performant enough, easy to build and deploy, and most importantly, it gets shit done. I don’t need more, but the Go team still delivers great updates every 6 months or so.
I just did. Here are my top10 results:
https://en.wikipedia.org/wiki/Go_(programming_language)
https://de.wikipedia.org/wiki/Go_(Programmiersprache)
https://www.geeksforgeeks.org/go-programming-language-introd...
https://www.geeksforgeeks.org/go-programming-language-introd...
https://www.freecodecamp.org/news/what-is-go-programming-lan...
This continues down for dozens of results. Articles, Frameworks, Tutorials, Projects.
Onboarding of new people is extremely fast, but lack of features will result in seniors hitting a wall on what they can do and guarantee with the language.
While go tooling great, you still have to test for most of the edge cases that C and python have: nullpointers, lack of proper enums/typesafety. This is commonly reflected in the tests that have to check for lots of trivial things.
Rust is much more difficult to learn, but the amount of things you need to test is drastically reduced, and seniors appreciate that.
What we see in our company is that juniors will find go wonderful, seniors dream of switching to Rust.
The hate probably comes from high expectations (especially coming from python/C), followed by hitting a feature wall due to how opinionated (and slow to adopt new features) golang is.
Go might be type unsafe compared to Rust but its staggeringly more type safe than any of the interpreted languages. Then you also have about the same speed of Java with instant startups and no memory bloat as a general purpose backed language its great.
I would sell my first born to get the ? operator for error handling that Rust has though. The "if err!= nil" stuff bugs the hell out of me.
I don't see this article in the first page when searching for golang. Maybe the results is personalized based on your search history?
> Why people in Google hate Go?
I really doubt that. Most developers I know, that worked with Go for a while, love it for its simplicity and tooling.
What does this mean? Where do you see this? Also, I don't believe that question comes up verbatim, since it's not grammatically correct.
When you search reddit golang, the title continues to come first.
https://blog.scottlogic.com/2023/10/18/the-state-of-webassem....
Closest seems something like Zig but it doesn’t seem to be getting much velocity.
I really wish TypeScript had an official native code compiler. It did have one but only for microcontrollers and I’m not sure even that still exists.
* Poor modeling ability (lack of default interface methods, no records, pattern matching, exhaustiveness checks, etc.).
* Error handling is error prone. * Generics are half baked.
* No short hand syntax for passing functions as lambdas.
* No annotations.
* Implicit interfaces make it hard to navigate large code bases because it is very easy to accidentally implement another interface. There are better solutions for the problem they tried to address with structural interfaces. * No string templates.
* The GC not being tunable does not obviate the use cases where it needs to be. Furthermore, Java's ZGC only has a couple of knobs anyway, while giving you the option to use a more tunable GC when your use case calls for it. golang's GC is only tuned for latency at the expense of throughput.
* goroutines are half baked, see Java's virtual threads + structured concurrency for a more manageable approach.
* Observability way superior on the JVM.
* No proper enums.
* No const/final variable declarations.
* Visibility rule are crude. Only public or package private.
* Probably more things I didn't think of at this time.
I'm just as fast/productive in Go (8 years of experience) as I am in Python (13 years of experience), but the resulting code is:
* more maintainable (enforced typing vs typehints+mypy)
* faster (compiled vs interpreted)
* consistently structured / opinionated (until recently we didn't have generics, which meant that engineers often had to do things the "boring and verbose way" instead of the "clever and concise way" which, though frustrating short-term, has proven to be much better for maintainability long-term.