a) Absolutely and b) already done.
Go is stable. The language is battle tested. It works as advertised. It is open source. Even if google pulled all funding (unlikely, since alot of their architecture seems to use it), the language is maintainable.
And btw. Languages don't have to continuously evolve to remain viable. Modern languages seem to indicate otherwise, but that behavior is what Go actively avoids; adding everything and the kitchen sink into the language as soon as some other language has it. If Go showed one thing, it is that PLs don't need to add as many features as possible.
And just to prove that point: C is still a top rated language in terms of usage. When was it last updated? C17 came out in 2017, and did not add new features. It superseded C11, which came out 6 years before that, also mainly standardising things that were already de-factos in most compilers. Before that was C99 in 1999, and before that is only ANSI-C and K&R.
> Go is stable.
But, past isn't a guarantee of the future. It was stable before, but who's to say it will be in the future? The fact that it's "owned" by a single entity should make you scared that it wont, because the whim of that entity is what can change any property of the language.
Additionally, Go has no standard, no alternative implementations to speak of. All of this should have you concerned for the future (but you seem to ignore the obvious dangers).
> It works as advertised.
It's the opposite. Languages with single (or one primary) implementation advertise how they work. Go is implement first document later language. The public discussion is for show because public doesn't control how things are being implemented. The Go dev. team may listen to everyone's opinion, nod in agreement, and do something else entirely, and nobody will hold them responsible for the discrepancy.
> the language is maintainable.
By who? How did you come to this conclusion? There's only evidence to the contrary of your argument. There isn't any other organization that's interested in maintaining Go if Google were to go away. At least nobody expressed such an intention publicly.
> Languages don't have to continuously evolve to remain viable.
This is demonstrably false. Hardware changes, operating system interfaces change. If you don't keep up with these changes, eventually your language becomes irrelevant. To further illustrate this point: today, versions of Python 3.7 and older cannot be built from source on modern Linux with current GCC. Python's dependencies on libffi and libssl are incompatible with their current interfaces, and so the language can only be built with older libraries (but then the operating system needs to use the older ones too) or statically linked with those libraries, but in case of libffi that doesn't help because it will not work for its intended goal. And the further back you go, the less likely it is that you will be able to build and use any version of Python. Bet, the same is true for Go.
> When was it last updated? C17 came out in 2017
C standards don't get implemented on the year they are released. Bet you Microsoft probably doesn't fully implement this standard. (I don't know, it's a guess based on past experience using their tools).
In more broader terms, I have no idea why did you bring C into this argument. C is an entirely different language in terms of governance, support, standardization... It's basically all things that Go isn't. Standards and multiple interested vendors ensure the survival of the language. The whole argument against using Go for long-term projects is that it's not like C. You trying to point out that C is used successfully for long-term projects doesn't help to show that Go would too. If anything, you should suspect that it won't, because Go is the opposite of C.
If Python 3.8+ didn't exist, how difficult would it be to update cypthon to target newer GCC? Correct me if I'm wrong, but my sense is this would be a relatively minor maintenance task. No one has updated Python 3.7 because there is no need (and frankly the Python foundation would probably prefer to nudge everyone to update).
No, there really isn't, but I had fun answering :-)
> But, past isn't a guarantee of the future. It was stable before, but who's to say it will be in the future?
Whos to say C will be stable tomorrow? Well, the fact that things like GCC are standards unto themself, even without any official governance (Which C has in addition). Its the same for Go.
If anyone was to change that, all I have to do is check out an earlier version of this open source language, and use that. And since tons of code rely on this, that is what would happen.
Languages don't become unstable because they suddenly change trajectory. This rarely ever happens. Language instability requiring constant evolvement and developer effort (both from the languages devs, as well as the languages users) is the result of feature upon feature getting heaved upon a language, along with codebases relying on these features, necessitating constant maintenance effort to keep up to date.
Go, explicitly, has a completely different design trajectory. And as a result, Go code that was written in Go 1.8 will still compile today.
> Go has no standard
Here is the official spec of the language: https://go.dev/ref/spec
Which is a de-facto standard, even according to this listing: https://en.wikipedia.org/wiki/Comparison_of_programming_lang...
Btw. if you look at the listing, MOST languages, including commonly used ones, don't have an international or national standard. Many don't even have a de-facto standard. Among them are many tried and battle tested languages.
> and nobody will hold them responsible for the discrepancy.
Anyone unhappy with the implementation is free to fork the project and take it in a different direction. He who writes the code makes the rules. If people are unhappy with that, they can fork, or use another language. And people seem to be very happy with the language: https://madnight.github.io/githut/#/pull_requests/2023/3
> By who? How did you come to this conclusion? There's only evidence to the contrary of your argument.
What evidence is there for the assumption that Go would vanish if Google lost interest?
> This is demonstrably false.
No, it is not, as demonstrated by the example I gave regarding C. The language didn't change much from C99, which itself wasn't that big a step away from ANSI-C. C99 was a quarter century ago, and C remains one of the most used languages in existence.
> To further illustrate this point: today, versions of Python
I am pretty sure I never used Python as an example for this. If you disagree, quote where I did.
> In more broader terms, I have no idea why did you bring C into this argument.
For a very simple reason: To show that a language that is mostly feature-freezed, and so stable that I can run a modern compiler on decades-old unchanged code, and still get a runnable executable, can be, and are, incredibly successful. Go has been called "C for the 21st century", and for everything other than System-Programming, that statement holds true.
Just saying, Go is far from the only language that values backwards compatibility.
Many languages have pretty good or even excellent backwarsds compatibility. In languages that incude as many features as possible, that quickly becomes a burden that requires it's own fair share of developer attention.
The library and compiler specific extensions did.
Besides, a language that nowadays only matters on UNIX clones and embedded development, naturally doesn't need to keep changing all the time, anyway C23 is around the corner.
If you wouldn't mind reviewing https://news.ycombinator.com/newsguidelines.html and taking the intended spirit of the site more to heart, we'd be grateful.
First of all it’s not just an issue of maintaining the language itself, but all of the associated tooling as well. Second of all, it’s not just that Google could pull support, but that Google could choose to prioritize their own needs over the rest of the community.
And btw. Languages don't have to continuously evolve to remain viable. … If Go showed one thing, it is that PLs don't need to add as many features as possible.
Go advocates say this often enough that it’s honestly beginning to come off as an insecurity. And I would be concerned about cultivating a community around “less is more, Go should only evolve as a last resort”.
Moreover, keep in mind that the primary selling point of Go were goroutines. At the time Go was particularly well suited to exploit a gap left by other languages. Fast forward to today and Go has become a significantly less compelling option.
And just to prove that point: C is still a top rated language in terms of usage. When was it last updated?
Projects written in pure ISO C are relatively few and far between. In fact many high profile C projects are exclusively tied to one or two compilers. Furthermore, ISO C has delegated a lot of functionality to external standards like POSIX instead of giving them first class support, not to mention the plethora of nonstandard language extensions found in many compilers[0]. In other words, ISO C has stagnated, albeit C23 is a big update, while the C language has evolved.
Anyway, as I see it, golang is basically a dead end as a PL. It doesn’t interface well with other languages, it doesn’t substantially differentiate itself as a PL, any nuance you encounter with the language is likely to never be fixed, it’s a poor language for writing great libraries and/or abstractions, etc. That said, plenty of great businesses have been built on top of languages like PHP, so it can definitely work. Personally I don’t expect anything like another kubernetes coming out of the language again.
Which is part of the language core, and distributed alongside it.
> Google could choose to prioritize their own needs over the rest of the community.
Which they would do why, and how specifically? This isn't a server or a database, it's a PL. What specific scenario do you see for such a change? And even in that unlikely scenario, the language is open source, and the community can fork it.
> Go advocates say this often enough that it’s honestly beginning to come off as an insecurity.
How anyone choses to interpret this message, is their business. We say it because it's true.
> And I would be concerned about cultivating a community around “less is more
Why? It seems to work exceedingly well. And there are more than enough languages following the "everything-and-the-kitchen-sink" approach already. What benefit would there be in trying to secure a tiny portion of a niche that is already overfilled?
> that the primary selling point of Go were goroutines
They were one of the selling points. What anyone sees as "the primary" point is a matter of opinion. For many people, the primary selling point of Go is the simplicity of the language.
> Fast forward to today and Go has become a significantly less compelling option.
Really? What other mainstream language uses CSPs with the same syntactic ease and core-language support?
> Anyway, as I see it, golang is basically a dead end as a PL.
What data specifically supports that point of view? Because, going by usage metrics, like code contributed, Go is easily among the most used languages, and still growing.
If you have different metrics, please, do share them here.
What makes you so convinced "someone" will take over? Is there anyone who offered themselves in such capacity? I've heard a lot of people making similar bold claims about Python 2.X -- sure, someone will step in and maintain Python 2.X indefinitely... Well, no one did.
> and they say goodby to Go as a result? and they say goodbye to Java as a result?
> and maintain Python 2.X indefinitely.. Someone said that? Anyway 20 years of 2.x branch is pretty impressive.
So, ActionScript would be one example. Dylan would be another. There are probably many more of lesser known proprietary languages that died never making the news.
And, looping back to the original subject: parent believes there's no danger in using an almost-proprietary language, where the evidence is that owners of proprietary languages do kill them every now and then. Do they do it all the time? -- well, no, but I didn't claim anything like that...
---
As to your observation about Python 2.X -- you didn't understand in what context the argument was made. C, or any other language with a standard is warranted the lifetime that's as long as humanity is able to read and understand the standard as well as implementing it. So, 20 years will be essentially insignificant compared to the longevity of a language with a published standard.
Please don't confuse this to me advocating for every language needing a standard. Writing one severely restricts what a language can offer, while at the same time, immortalizing potentially harmful features. Going back to see, we wish today that all the str* stuff would be gone, or stuff like atoi()... but that's not an option anymore, because this stuff made it into the standard. Languages w/o one can shed their skin and remove bad decisions. But, this same feature makes them less viable for long-term projects.
Then Go is still an Open Source Project with massive community support, that everyoen is free to form and extend or maintain by himself.
> What makes you so convinced "someone" will take over?
Because tens of thousands of projects depend on the language? Because the people who developed go don't just vanish if Google suddenly did? Because OSS has a long history of maintenance changing hands?
> sure, someone will step in and maintain Python 2.X indefinitely... Well, no one did.
There is a simple reason for that: Py2 was obsoleted by it's successor, Py3. There is simply no point in maintaining an obsolete language, especially if it has a direct successor, that is both similar, and an improvement in every single way.
And even so, Python 2.7 was still supported for almost a decade after it's release.
But:
archive/tar breaks so often we've had to have a fork of it on and off for the last 10 years. One time it even caused a CVE due to it suddenly starting to dynamically link glibc (to preserve usernames in the tar header), which was being lazily relinked after chroot.
Go modules, whether I like them or you like them or not, are a breaking change. I've even had code I didn't touch cause other people break because some dependency (literally my only dep) switched go mods... I didn't even update the dependency just the fact of them changing broke downstreams.
More recently, it's behind an env var in go1.21 but will be default in go1.22, go is changing the loop semantics to scope loop variables to the loop. Now, I like and agree with this change, but it is a breaking change.
"Compiles" is not the same thing as "works". Behavior changes that are only apparent at runtime is where go makes breaking changes. Breaking compilation is often more preferable, to me.
How is asking for examples for a statement a "terrible comment"?
>go is changing the loop semantics to scope loop variables to the loop. Now, I like and agree with this change, but it is a breaking change.
Please explain what exactly that change breaks.
> Behavior changes that are only apparent at runtime is where go makes breaking changes.
Such as? And yes, I am asking for examples. Because I have personally compiled and run code that was written in Go 1.8, with a modern compiler. And the only change I saw so far, is better performance.
Demanding 10 examples is a terrible comment. It communicates hostility and disbelief rather than curiosity.
> Please explain what exactly that change breaks.
https://github.com/golang/go/issues/60078 is where this is discussed. Again, I _agree_ with this change, but I'm pointing out that it is a breaking change. rsc points out in the proposal that it is a breaking change.
> Such as? And yes, I am asking for examples. Because I have personally compiled and run code that was written in Go 1.8, with a modern compiler. And the only change I saw so far, is better performance.
I gave multiple examples already. If you are truly interested I'm sure you can find more either in the go issue tracker or on google.
It followed the same tone of your comment, where you claimed that they were doing frequent changes, without providing any examples, of which there should be numerous, if they really occur so frequently.
To me, it just asks for examples. I guess that's a matter of opinion then.
> https://github.com/golang/go/issues/60078 is where this is discussed.
We can discuss semantics here, but a breaking change, to me, is one that that breaks well-crafted existing code. Well, what kind of real world code would rely on the fact that closures over an iteration target examine a value that depends on runtime behavior instead of the actual value that, semantically, seems to have been closed over?
I have stumbled upon this issue myself when I first learned Go. I have used Go professionally and in private projects and since long before modfiles became a thing. I have NEVER seen code that relies on this completely unintuitive behavior. This is not a change that breaks something good, this is a fix that removes a footgun from the language.
Further down, rsc writes this (https://github.com/golang/go/issues/60078#issuecomment-15424...)
That's some of the real-world evidence in favor of changing 3-clause loops.
I have looked, and I found no evidence in favor of not changing them.
If you want to make the case for not changing them, the way to do that would
be to provide real-world examples of code that breaks with the new semantics.
So, semantics aside, no, I do not consider this a breaking change, because while it is, technically, not backward compatible, it doesn't break existing code.> I gave multiple examples already.
What exactly breaks in the archive/tar package? I looked it up, only found some bugs and issues, but nothing I would consider a change that breaks existing code.
What exactly did modfiles break? I can still compile code without modules. Yes, modern versions of the go-tool require a flag via envvars, but they are still compatible with old projects. And libraries changing is not the same as the language changing. If a build relies on a certain commit on the library, I can always check out that commit.
If it’s good enough for Kubernetes then it’s good enough for any business.
Pretty sure Internet and cloud will not go anywhere if Go vanishes tomorrow. Even if you need containers, there are plenty of tools that don't use Go, and give you similar service.
I've lived enough to see technologies with humongous popularity die in a matter of years (eg. Flash). Those who didn't believe Flash would die made very similar arguments about how certain things would be "impossible" w/o it. Not sure who am I quoting here, but there's this saying that "cemeteries are full of indispensable people".
lol
Like Java? Or c#? Go is hardly unique in that it's developed primarily by a single entity.
...but even if Google abandoned it, it seems like you're making the assumption that no one in the world would continue developing an open source project, and the source would just become unusable, or something? It's not like Google can just turn off go lmao
Go definitely has much more funding and developer hours put into it than open-development languages like Python - that’s got to be a good thing for the language.
On the other hand, would you choose to build a long-term business on top of Go, given that all that support comes from one company? What if Google decide that maintaining Go is no longer in their best interest?