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.
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.
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.
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...
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.
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.
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.