Rob Pike on the reasons for Go’s success
changelog.com
changelog.com
There are a lot of very nice languages out there. However, if you look at compiled languages, they largely need a company backing them. Java had Sun. C and C++ had AT&T and later Microsoft for C++. Objective-C had Apple. FORTRAN had IBM.
Don’t underestimate the amount of resources and press that Google’s support brought to Go.
Dynamic languages are more generally used and often have been favoured by small companies and teams, so the barrier is lower.
I was playing a little lose with language because the OP was talking about interpreted and compiled languages, and not all interpreted languages are necessarily dynamic, but in practise the fault lines are about the same.
It's no accident that Python and Ruby were both the work of one guy in their early years: very, very simple to implement incrementally.
However, implementing an efficient garbage collector in an AOT compiled program is still challenging compared to an interpreter where the stack and each object is just an array of object references. With raw memory you don't know whether something is a number or a reference unless you store extra information that describes the memory layout of every single function or object.
The nice thing about GraalVM and modern gradual typing techniques is you can actually start by writing an interpreter, fully dynamic, no type system at all. Graal turns the interpreter into JIT compiled code on the fly, you can even create a standalone (no JVM) AOT compiled binary containing your language runtime, all with one command. Then as your language evolves you can add interpreter hints to gain extra performance, but, it's totally pay-as-you-go. There are no walls of effort facing you: you do a little work to get a little benefit, and a lot more to get to V8 type speeds. You can also introduce a type system gradually these days, as CoffeeScript/TypeScript or Groovy style languages do, again incrementally as your language evolves and gains usage.
Also with Graal you get the world's best GCs for free, plus access (if you want it) to the JDK class libraries for things like files/sockets/time&date handling. Oh, and language interop with other languages for free, no complex FFIs. It's pretty neat.
That said, are there lots of programmers itching to write dynamically typed scripting languages these days? Probably not. Languages like Kotlin deliver most of the benefits with very few of the downsides.
That is why I specifically called out compiled languages. Perl, PHP, Python, and Ruby are all interpreted languages. For some reason, interpreted languages seem to be able to do ok without a big company backing them, but compiled languages seem need a big company to back them.
A lot of the benefit of statically typed languages are the tooling around them (IDE integration/autocomplete/error messages). These represent a fairly expensive (resource wise) area of investment and so the resources of a large company has high ROI.
But on the other hand, I think it is unfair to attribute Go's success solely to Google. If that was the case, where's Dart's massive success? This isn't like Swift either, where Swift is the key to modern iOS development; Go is just another option for a few types of targets.
I don't understand the unwillingness of people to accept the success of Go as being more or less natural. There's articles from entities like Digital Ocean explaining how Go naturally invaded their stacks. There's a lot of merit in Go. It being backed by Google is actually going to deter some from wanting to use it, no doubt.
Google is one of many companies that had the resources to create Go. I don't believe it was out of reach of many larger tech companies. Including Mozilla. Nobody attributes Rust's appeal or success to Mozilla, because they are comfortable pointing to its many benefits as reasons. And that is correct in my mind. But when it comes to Go, people are unwilling to admit that it is simply an appealing option with its own merits, and I think that is unfortunate.
Full disclosure: I speak as someone who works for Google now. But, I adopted Go before joining Google, back in around 2013, where it went to take over many important roles we'd otherwise had used Python or Node.JS for. I did not learn it was a Google product until later down the road.
There are dozens of interesting languages out there. D, for example, seems like an interesting language, and I would love to try it out in a professional project. But if I wanted to use D at work, it would probably take weeks of convincing my team to try it in production. Go already seems like a safe choice, largely because of the "seal of approval" granted to it as coming from a tech giant like Google.
(I am not talking down Dart - I think it’s underrated. But it’s a good counter example to the “it’s Google so it’s OK” logic. I suspect people say Google is the reason Go is OK even when it’s actually more word of mouth.)
1. It got the *initial push* from its Google pedigree which allowed it to gain attention and traction
2. It meets the *merit threshold* so that when people gave it a try, they wanted to continue using it
3. It had a good *product market fit*: in the world where Go was released, *a lot* of server-side software was being written in scripting languages and there was a clear value proposition for a fast, compiled, statically typed language with good tooling for handing server work.
I think that's why something like React or Typescript could really explode in that space: they could be added incrementally to a project while still keeping most things familiar.
No language has usurped Javascript for frontend, and the only two approaches that may work are:
a) Typescript, which intends to be very close to javascript
b) Webassembly, which has taken years to get off the ground
Go didn't have that problem to contend with. I don't think it's fair to say that because Dart failed to take off quickly that proves that Google isn't the main reason for Go's success.
edit: I see lots of "Dart is a counterexample" posts. It really shouldn't be considered one.
I think Dart is, in fact, an excellent example of how much power Google is willing to throw behind a language. Dart was constantly marketed on the Chrome blog, for example.
https://developer.android.com/jetpack/compose
Do you think Android team would just stand still with people nagging them about Flutter?
Of course Dart adopts a lot of concepts people love from other languages. But to me it feels really artificial and disconnected from what developers successfully used in the past. It maybe worked in the 70s that people came up with a completely new language and people used it because there was nothing else.
Basically, the point being, it was Google _developers_ that made the “backing” grow via demand, not some official “initiative”. Initially, this gave me some initial trepidation, but Go has gotten more and more outside engagement each year it’s existed, which is definitely making things just better.
Thus, I don’t really think Google has “backed it” like Sun backed Java. It’s just that Google hires lots of smart people, and those smart people backed it. I’d say Dart is more of an official “google backed” tech. Go is like the language that is succeeding despite their management objectives.
It doesn't have to. For a lot of programmers the very fact that Google (or Rob Pike) made it is enough for them to switch to it or bet that it'll do well and at least take a closer look and try it out, compared to the dozens or hundreds of new languages that come out by completely unknown authors which virtually no one takes a second look at, not because of any deficiencies in those languages since the people that ignore them usually don't even know anything about those languages to begin with.
Also Dart is a counterexample.
I think the biggest reason for Go's success is that is it incredibly accessible. Everything around and in Go is ergonomic, well documented, easy to understand and clean. It is a language that cares about the tooling and social aspects as first class concepts.
I think OP might have meant that big backing is a necessary condition, not necessarily a sufficient one.
Also when Go was quite new, many projects had no dependencies or at best a handful. I think that was a learning from other languages with large package repositories, namely Rubygems. People would create gems put them on Github and Rubygems with useful functionalities but abandon them after a few months. So many larger code bases were sometimes rendered unusable because the package became incompatible with new language releases or did even get removed from Rubygems.
Nowadays, since Go has risen so much in popularity and adopted habits from other Programming ecosystems, there are now Go modules which are on par or even better than solutions from other languages.
You should have a look at the release notes of the last three Go releases.
And most programmers probably wouldn't even know about it having any of those features if it didn't have a famous backer like Google and a famous name like Rob Pike attached to it.
Marketing definitely makes a difference. Whether it made a critical difference in this case is certainly debatable, however, as some languages (like Python) succeeded even before they had buy-in and support from big names. Though, there again, Python had a lot of help from marketing.. it was just that it was marketing of a different kind, from its users rather from any company backing it.
Perl, Tcl, Python (all scripting, I know) are (iiuc) examples that came to be without a juggernaut behind them, but then to say they had a different kind of marketing behind them is sort of tautological, no? People liked those languages and talked about it. That’s just human nature.
That's a different sort of marketing, though, from the buzz created by having famous/respected names attached to the languges, like Go had in Google and Rob Pike.
- Tcl, was backed by Active State and Sun for a long time
- Python, all the renowned companies Guido worked for
There was never any money behind Python, or C++. Both paid their own way, all the way: people actually using one put in sweat because they believed it made things better for them.
That is the diametrical opposite of marketing.
The contrast is against Sun spending literally $billions on Java puffery. Go has put a lot more support into Go, by that standard, but still barely $millions, if that.
In fairness there is a category of systems for which it was about the least-worst fit at the time: distributed concurrent systems where a JVM was unwelcome. Pascal and its progeny were seen as passé, C/C++'s deficiencies well-known by this point, the scripting languages woefully underperformant, the JVM was the punchline of many jokes despite being a phenomenal engineering achievement, D still mired in some kind of civil war over standard libraries and I imagine thousands of other contenders for an undiscovered throne.
But without Google? Pike? There's no chance any of this would've mattered enough.
[0] Of course, it's never "just".
Or Self at Microsystems. Or Dylan at Apple.
Every sufficiently large and profitable technology company eventually sprouts compiler projects. It's as if they hire from an academic pipeline where compilers are a capstone project.
There are now thousands of artificial languages. The sample size for "languages that succeeded and originally came out of Google" may be tiny, but the effect size is pretty bloody spectacular. Considering that the null hypothesis for all programming languages is be swallowed up by a memoryless void, I'm prepared to wager heavily that without the Google halo, Golang would've been no more influential than Newsqueak, Alef or Limbo were.
No, but it's larger than most independent contender languages (D, Crystal, Pony, Ziq, Nim, and tons of others).
Dart was abandoned by Chrome and Angular teams, it almost closed down if it wasn't for AdWords team being so heavily invested into Dart that they kind of rescued the project.
Many Google projects that could benefit from Dart ended up migrating to TypeScript instead, oh and all original Dart designers ended up leaving Google.
Naturally in such scenario there is hardly any external confidence to believe in Dart.
Then Flutter came along, decided to pick up Dart from its burning ashes, reboot the type system and add AOT compilation to native code, but the damage to its public image is already done.
However it managed to annoy the Android team enough that now JetPack Compose is a thing.
Very, very true. Sun not only publicized Java heavily, it also invested heavily in a massive library.
> C and C++ had AT&T
Who did no marketing, because they couldn't sell either one. The thing about C and C++ is that you could get them for free, and they were good enough. For many people who had a computer (or at least computer access), but didn't have money yet from a product because they were trying to produce Rev 1, that was magic.
> Objective-C had Apple.
Absolutely.
> FORTRAN had IBM.
This was before my time, but I think that IBM put a lot of technical resources into FORTRAN, but I don't know that they did much marketing. They didn't need to, because the alternative was assembly. Once you knew that FORTRAN existed, that was enough.
> The number one reason for Go’s success is that Google backed it.
Google certainly did not back Go in the way that Sun backed Java. I'm old enough to remember when Java came out. Sun did a lot of marketing that was aimed at managers rather than engineers. I have never seen Google do that for Go. If they have, it has escaped my notice, which is possible, but I'm still going to claim that they haven't done it on anything like the scale that Sun did with Java.
You can claim that holding a conference is marketing. It could be considered so. But getting non-technical puff article after puff article in the trade press is marketing on another level, which, to my knowledge, Google has not done.
What Google has done is put technical effort behind Go. They've written libraries and tools. They've let people give the language direction. Go probably would not have gone far if it was just Rob Pike's side project.
That was the marketing, an almost free OS, with free compilers out of the box, adopted by universities trying to avoid paying for mainframes.
Clearly there's a massive difference between what Sun did and what AT&T did.
Universities wanted Unix and C, and not because AT&T spent so much on advertising. Not because AT&T forced it on them. The universities wanted it because, from their perspective, it was better than the other options. That's not marketing. It's not invading. It was pull from the universities that made it happen, not push from AT&T.
Producing something that people want is not the same as marketing, no matter how much you want to conflate the two.
UNIX was the process to reach that goal.
Getting something to be adopted is marketing, no matter the process.
I can recommend some business books, if you feel inspired.
Yes, AT&T shipped them a tape. Yes, technically that falls under the grounds of "marketing". The impression you are giving of how this played out, though, is totally false. You're making it sound like AT&T was aggressively pushing UNIX. It wasn't. It was much more passive - shipping a tape when requested. People were coming to them; they weren't going to people.
> The Unix operating system was first presented formally to the outside world at the 1973 Symposium on Operating Systems Principles, where Ritchie and Thompson delivered a paper. This led to requests for the system, but under a 1956 consent decree in settlement of an antitrust case, the Bell System (the parent organization of Bell Labs) was forbidden from entering any business other than "common carrier communications services", and was required to license any patents it had upon request.[6] Unix could not, therefore, be turned into a product. Bell Labs instead shipped the system for the cost of media and shipping.[6] Ken Thompson quietly began answering requests by shipping out tapes and disks, each accompanied by – according to legend – a note signed, "Love, Ken”
Looks like marketing actions to me.
Which technically makes your claim true. But if you define marketing that broadly, it also makes your claim completely uninteresting. It boils down to "Things that are developed in house, and never talked about to anyone outside, and never shipped to anyone outside, do not take over the outside world". That's true, but it's trivially uninteresting.
You seem to be much more focused on the technical definition of marketing than on the very real differences between the "marketing" of C and UNIX vs. that of, say, Java.
And back to the original point: The marketing of Go has been much closer to the "marketing" of C than to the slick sales job of Java.
Word of mouth, being associated with idols are doing, feeling part of a community, feeling part of a counter culture, are all tools of the trade.
Which would not have taken place if those Google dollars weren't coming into Go's team salaries, conference talks, books and blog posts.
Money spent developing compilers and libraries to sell at a profit is not marketing, even if the compiler is marketed: that money comes from users already committed.
C didn't need marketing. It rode on Unix, which also got hardly any. Unix rode on workstations, which had to be marketed hard against all the minicomputer and, later, mainframe competition.
C++ got no marketing either. It still has none, yet the number of C++ programmers is growing faster than ever before. Complaining about it is always popular, but as Bjarne says, there are only two kinds of language : the ones people complain about, and the ones no one uses.
Go may be counted a success when it is complained about as much as C++ or Python.
C++ had plenty of marketing, being adopted by all major C compiler vendors, it was adopted by the GUI frameworks used by Apple, IBM, Microsoft, alongside Borland, Zortech, Symantec, Watcom, Microwerks.
Plenty of marketing they had.
I.e., no marketing, just actual use and companies responding to actual use: The diametric opposite of marketing.
https://www.oxfordreference.com/view/10.1093/acref/978019959...
On my phone so I can’t find a link to the “would not use again” stat, but there are a few surveys with similar results that are easy to find
Facebook created Hack, which I have yet to see in the wild (mind you I'm not really in the PHP bubble at the moment).
Apple used Objective-C and created Swift, but you don't see either of those outside of the Apple bubble and as far as I know Swift is just not used for back-end.
So I mean I hear what you're saying, but there's plenty of counterexamples.
Rob Pike was famous before its creation (within the relevant community). The language was designed within Google, and gained much hype from that. The effort to foster a community paid dividends.
Writing Go code for a living, I find it a very mediocre language. It's largely redeemed by its library ecosystem, which reflects not on the language, but the enormous size of its community and commercial backing.
If anything is noteworthy about its design, it's that it's simple (crucially, to those already familiar with C-like languages), and easy to bring people on board. What is lost for want of features and abstractions, is gained in human resource.
JavaScript has changed a lot as a language over time -- ECMAScript 2019 makes it a lot easier to write good code than the original JavaScript. It's now better understood how to write JavaScript code, and how not to.
For an experienced developer that might feel a bit like handcuffs: like you have to write more redundant code and handle things at a more literal level than you could get away with in other languages.
However, it tends to result in a codebase that's more resilient to turnover: if someone new joins the team there's going to be less specific understanding about the inner workings of the codebase they need to sit down and understand what they're looking at. It also limits the damage a mediocre developer can do through overuse of bad abstractions.
And that's fine. As a software system gets bigger, the organizational issues come to outweigh the programming ones.
I'm not making a value judgement over whether that priority is a good or a bad thing, just an observation about the nature of Go.
I cannot agree more, and I am writing Go for living too. Thank you very much for expressing it so accurately.
Limbo did not went far, even though you can still play around with it.
WithStmt is easier to parse, more general and it doesn't need the Primary "." "(" "type" ")" at the beginning which appears only needed to distinguish Go ExpressionSwitchStmt from Go TypeSwitchStmt.
wgator2
The size of binaries isn't that big of a deal for servers any more. On the other hand, setting up a python or whatever env can be a pain, especially before docker really took off. Being able to push a Go binary and it Just Works is awesome.
https://engineering.fb.com/data-infrastructure/xars-a-more-e...
With minimal training every programmer can learn go very quickly and be productive in it.
This is very important for companies because you don't hire a Java, C# or whatever dev but someone who is a good fit for the company. And then you have him trained in no time.
That fact alone was the easyest sell I ever made to my boss.
As opposed to what? I can't see another possible interpretation of the title.
Things someone attributes to Go's success would be things caused by Go's success. For example, the proliferation of stuff written in Go, the number of people making money as Go experts, the appearance of a Go entry in Wikipedia.
Things to which someone attributes Go's success (i.e. so-and-so attributes Go's success to these things) would be things that caused Go's success - such as the things in the article.
Headline could've been done correctly, but perhaps the problems started with digesting something by Rob Pike and turning it into a listicle. Which then has to have both its listicleness ("five things") and the presence of Rob Pike, advertised in the headline. But I might be being cynical.
I suspected the former but the latter was still a possibility. The likelihood of one over the other doesn't excuse the poor wording.
By being highly opinionated and predictable, it makes it easier to digest. I especially like the reformatting capabilities so everyone's code looks the same. The more people program the same, the more predictably the code behaves and the less overall problems.
By that I mean it isn't the best in any criteria that you'd use to evaluate a programming language: not the best type system, not the fastest, not the safest, not the best concurrency, not the best package manager, not the largest ecosystem, not the easiest, and so on.
However, it's very good, sometimes great, in many of these criteria. Many languages try to be the best at one thing, while Go is good enough in many things.
I think that's the main reason for its success.
It made Go a very effective language for "just writing some code".
I'm not sure I'd agree though; Swift shares this position with its predecessor Objective-C. Swift's success versus Objective-C can be attributed to its relative merits as a programming language.
Or even "Rob Pike on the reasons for Go's success"
Can't emphasize that enough!
For example:
- is errors on unused variables/imports really such a bold new stroke or that controversial? - is a formal spec that unusual? how many Go developers have ever looked at the spec? - was getting Docker that big of a deal other than having a good dogfooder (vs it being "killer")
I agree with the open source process, kudos for them for allowing the community to help them get things right (well, some things, Go has a bunch of rough edges).
IMHO, its:
- Good runtime perf - Great built in libs - Built in cross-compilation and shrinkwrap binary that does not require a runtime installed on target machines - Good use of opinionated tooling (go fmt, go test, etc) that take a bunch of concerns off developers plates
Thought they did things in the article right.
Having formal spec, and focusing on code stability is important, and puts them apart from 9 out of 10 of every new programming languages, but that is only one item on the long "not suck" list.
The lack of proper package management at the start left too much of a bad aftertaste.
I believe they must have knew that shipping go with git as a makeshift package manager was a bad idea, but for some reason did it anyway. I think this alone turned away half of early adopters.
Then golang went through a long epopeia of making the package ecosystem work outside of a single company deployment, and lost a lot of developers along the way again.
Yours is not criticism, it's just ignorant bashing of a perfectly productive language that people adopted not because they're more stupid than you but because it made them more productive for whatever reason.
No one forces you to code in Go if you don't like it. Fine, but don't belittle others if you're not prepared to understand why it's got so popular. Ignorance is bliss.
that's either reductive or a strawman, if not both. afaict golang doesn't lack for criticism on hn, but most people do so without being insulting or hostile.
Apart from "They should have done it the way I like!", the main criticism I have seen is lack of generics. That's a pretty common complaint, from a lot of different people.
On the other hand, Golang is a much simpler language. It's relatively easy to learn and understand.
They are quite far apart in many spectrums.
They're both statically typed compiled system programming languages; both trying to provide solutions for safe memory and concurrency.
But this doesn't necessarily mean that these languages share a great deal of sensible usecases.
Rust and Go make very different tradeoffs.
It's a fairly simple language, which makes it relatively easy to grasp and understand the majority of Go code. This is particularly useful for group development (i.e. in companies), where you want everyone to understand each others' work.
Anecdotally, although I prefer to write Rust, and consider it a better language in many ways, it took me a lot longer to learn the language, and longer still to write idiomatic Rust code. I was up to speed with Golang relatively quickly.
It is way, way too early for him to proclaim Go a success.
The time for that is ten years on. Imagine reading something so self-congratulatory, today, if the creator of Ruby had written one back when Ruby was only as old as Go is now. It would be poignant.
Go will be a success when it is complained about as much as other languages, by people who would really rather be using something better. It is nowhere near that point.