17 ms·

Go is Google's language, not ours

• RcouF1uZ4gsC 7y ago
  To determine how open a language really is look at how many widely used implementations of the compiler there are for the language. If there is only a single implementation of the compiler/interpreter than it is not really open but controlled by that core compiler team.
  • lgierth 7y ago
    Afaik GCC's Go has been pretty complete and up-to-date for a couple of years.
  • dataking 7y ago
    I don't think that is necessarily true. Rust has only one compiler (and I think adding a second one would be a huge effort with no clear win) yet it is developed by a community that is very welcoming to newcomers. At least, that's been my experience.
    • Conan_Kudo 7y ago
      It is definitely true. There's virtually no room for improving the underlying compiler toolchain because there's no allowance or support for an alternate implementation (using GCC, for example). Go at least has gcc-go, which is a compliant implementation that gets some benefits from being part of GCC (like not completely broken support for dynamic link libraries!). Having a second compiler implementation forces the language grammar and behavior to be specified in a formal manner that allows anyone to understand how it works.
      • the_mitsuhiko 7y ago
        How is there no allowance? A lot of people in the community would love a rust compiler that can compile down to C for instance.
        • anoncake 7y ago
          Maybe the tool chain is hardcoded to use the standard compiler? But that's more likely because of YAGNI, not because the rust community hates freedom.
          • the_mitsuhiko 7y ago
            The toolchain is built on top of rustup which very purpose is managing multiple compilers. If one were to build a different rustc it could be swapped in even in the world we have today.
            • anoncake 7y ago
              That's cool. I haven't used Rust yet so I didn't know.
      • Tor3 7y ago
        I haven't thought consciously about that, but it turns out that I've been doing that kind of validation unconsciously. I didn't get interested in actally using D, for example, until the GDC variant arrived (Dlang-support in the GCC collection).
    • ncmncm 7y ago
      Gcc compiles Rust fine. Its borrow checker won't bark at you, but that doesn't affect code generation. OCaml and Haskell are one-horse towns, with substantial history, that are not going away. But as Stroustrup says, there are languages people complain about, and languages no one uses. You generally end up better off investing your time in mastering a language people complain about. Bitterly. Once that meant FORTRAN.
  • adrianN 7y ago
    Most languages I can think of have one very dominant implementation and maybe another one or two that few people use. Python, Ruby, Java, C#, Go, Rust, Haskell... C/C++ are the only exception since Clang became serious competition to GCC and Visual Studio. Even Javascript only really has Chrome and Firefox.
    • ncmncm 7y ago
      So, there's your answer right there.
    • tannhaeuser 7y ago
      That's "consumerization of IT" for you. Millenials and younger are used to looking at pretty websites of "language ecosystems" and blogs about trivial programming problems to assess languages, rather than independence, maturity, and long-term viability as they used to before, and as demonstrated by having language specs and multiple interworking implementations, pluralism of APIs, etc.
      • adrianN 7y ago
        I don't think the number of implementations correlates strongly with long-term viability. As long as there is at least one FOSS implementation available the language won't die as long as it remains useful.
    • 72deluxe 7y ago
      What about Intel's compiler for C++? Or Borland's? Or EDG's? Or DigitalMars? They were around for a long time.
      • adrianN 7y ago
        They fall under "almost nobody uses them".
    • roca 7y ago
      JS has Safari (JSC) as well.
  • zik 7y ago
    There are at least four Go compilers: the original one from google, GCC go, gollvm and GopherJS.
  • sjellis 7y ago
    The TinyGo project are implementing a Go compiler on top of LLVM, to use Go on very small devices: https://tinygo.org/ https://tinygo.org/ The Go language is defined by a spec with compatibility guarantees, but beyond embedded systems and WASM, there don't seem to be a lot of use cases for alternate implementations.
    • erik_seaberg 7y ago
      I haven't looked into compiling Go to JVM bytecode, but a solid way to do that would resolve an ongoing tug-of-war at work, and avoid a lot of résumé-driven development of stuff maven central already had.
  • neop1x 7y ago
    You mean for example various versions of java which are incompatible?! Or java programs said to be mtiplatform loading .so libraries of fixed Ubuntu versions? Well, that's exactly what I hate.
• dis-sys 7y ago
  Seeing Huawei got recently blacklisted for all US made chips, parts and some Android services from Google, an interesting question to ask is whether the US government will one day force some foreign companies (e.g. Huawei, ZTE and DJI for example) to stop using programming languages invented & implemented by US companies.
  • dhkxh 7y ago
    That's not how open source works.
    • dis-sys 7y ago
      The license can change any time they want. They can change the license to prevent certain companies from using future releases and/or security patches. Let's don't forget the fact that Huawei had legally binding contracts with all those US suppliers.
      • majewsky 7y ago
        So? Just fork the last freely-licensed Version then.
        • dis-sys 7y ago
          then start to use clean room process to reimplement all future bug fixes? nice!
          • _ph_ 7y ago
            Where comes the expectation from, that someone else fixes your problems for free? If you clone Go now, you get a robust codebase for free, and you could do any maintenance on your own (as a reasonably large organization)
      • grumpydba 7y ago
        > The license can change any time they want. They can change the license to prevent certain companies from using future releases and/or security patches. Until then, it's a bsd inspired license. And you get code from Cox, Griesmer, Taylor, Pike, Hudson and Clements under those terms. It's a big team on several aspects. So you can remove your tinfoil hat and check the code for yourself. It is valuable.
• ncmncm 7y ago
  This. But Go is one in a long line of proprietary languages that those of us who have been around the block know to stay away from. Recently: Java was Sun's, C# is Microsoft's, Swift is Apple's, Go is Google's. With any luck, all will be footnotes in ten years. Those of us who knew better than to get invested in them will be fine. Everyone else gets a chance to learn something.
  • networkimprov 7y ago
    So what would you recommend?
    • nicklaf 7y ago
      Assembler^H^H^H^H^H^H^H^H^HMachine code: http://www.pbm.com/~lindahl/mel.html http://www.pbm.com/~lindahl/mel.html https://research.swtch.com/mel https://research.swtch.com/mel
      • saagarjha 7y ago
        What's wrong with C/C++?
        • nicklaf 7y ago
          Real Programmers write in Fortran. Maybe they do now, in this decadent era of Lite beer, hand calculators and "user-friendly" software but back in the Good Old Days, when the term "software" sounded funny and Real Computers were made out of drums and vacuum tubes, Real Programmers wrote in machine code. Not Fortran. Not RATFOR. Not, even, assembly language. Machine Code. Raw, unadorned, inscrutable hexadecimal numbers. Directly. (It's a joke...)
    • maksimum 7y ago
      For what purpose?
  • adrianN 7y ago
    There is a mind-boggling amount of Java running around the world and more is still being written. Java won't die for several decades at least.
• warent 7y ago
  "... can't we have something like OpenGo ..." > " ... this won't happen ... " I'm confused as to what's stopping someone from forking it, calling it OpenGo, and building a community around that.
  • majewsky 7y ago
    Momentum.
  • meddlepal 7y ago
    Momentum mostly.
  • cryptos 7y ago
    This could be done, of course. But how likely is such an approach to succeed? It would effectively create a new language and in turn to a new ecosystem. Why not just use a different language (Rust comes to mind) then?
    • _ph_ 7y ago
      First of all, Rust is quite a different language to Go, so I wouldn't consider it a drop-in replacement. But this also means, that those, who don't like too many features of Go might really be happier with Rust. But adding features to Go by popular demand would make it a new language and a new ecosystem. So if that is what people want, they should go ahead with it. Even if it just is an engineering prototype, which showcases features that Google should add to the Go main line.
    • weego 7y ago
      Sure, but that's a different issue. If it doesn't gain traction then the decisions made by Google are clearly considered the best approach, at which point what relevance does the openess have?
      • remus 7y ago
        > If it doesn't gain traction then the decisions made by Google are clearly considered the best approach I don't think this is necessarily true. There are a lot of fuzzy factors that go in to making a language successful and it's tricky at best to get these right, even if openGo was a better language. As a practical example, go effectively has one person who's full time job is keeping the testing infra happy. It'd take time and money to establish this in a go fork and going without it would make development of the fork much harder.
• pa7ch 7y ago
  Many like Go because it is an opinionated language. I'm not sure that a 'community' run language will create something like that because there are too many opinions. Many claim to represent the community, but not the community that doesn't share their opinion. Without clear leaders I fear technical direction and taste will be about politics which seems more uncertain/risky. I like that there is a tight cohesive group in control over Go and that they are largely the original designers. I might be more interested in alternative government structures and Google having too much control only if those original authors all stepped down.
  • theshrike79 7y ago
    In my opinion the way they are handling adding Generics to Go is proof of this model working. They are actually trying to pick the implementation that solves real world issues, not just trying to tick [x] Generics in the Go spec sheet.
    • crimsonalucard 7y ago
      Parametric polymorphism is a real world issue. The fact that it wasn't checked off indicates to me that they are of the opinion that it's not as important. It's ok to have this opinion, I just disagree with it. I do agree that it's important to think it through, I do not agree that the language should be brought to 1.0 without it.
      • nnq 7y ago
        > Parametric polymorphism is a real world issue. ...what in the world makes you thing that? I love parametric polymorphism, but nothing stops you from writing the most complex computer programs you can imagine without it.
        • masklinn 7y ago
          > ...what in the world makes you thing that? Go literally special-cases generic builtins because they couldn't be arsed to properly implement it but knew nobody would accept completely untyped core collections.
• movedx 7y ago
  So proprietary is bad? I have no issues with things being owned by a single entity, especially when they're financially backed by that (massive) entity. What is being proposed as the alternative here?
  • oaiey 7y ago
    I even think that for language and base class library design a strong ownership is key to success. They make the language consistent and the library easy to learn. In both aspects, just compare .NET/C# with PHP.
    • movedx 7y ago
      Exactly. I want my language to be crazy good and have an amazing library to tap into. In fact, it was Go's great standard library (JSON parsing, hardened prod' ready HTTPS server, SSH, crypto, etc) that formed a large part of why I love the language. And yeah, I'd rather go with .NET/C# over PHP any day (although I understand PHP is getting better and better, which is good to hear.)
      • oaiey 7y ago
        Well PHP and .NET do not play in the same league. But it is about consistent language and library design. Great failure in PHP and great success in .NET/C#. I developed PHP till 2007, then as a hobby project in 2013. Massive improvement. And I heard very good things about performance the last years. Swoole even can compete with the top tear languages
• jmtulloss 7y ago
  The article uses "Google" instead of individuals names to make the actions taken seem like sinister actions of a faceless corporation. My interpretation is that Google employs a tight-knit group of people that work on Go and collectively are the BDFLs of the language. This isn't that much different from most large OSS projects, although it does seem likely that this core team weights the opinions of those that they interact with daily (ie, other Google employees) over people they barely know.
  • silvester23 7y ago
    The last two paragraphs of the article address exactly that issue - that it's hard to tell whether the direction of Go development is decided solely by the Go core team or by Google as a corporation.
    • kkarakk 7y ago
      ...was this ever in doubt? i've always thought from day 1 that this is "Go as in made by Google". Even the name branding screams that
    • jon-wood 7y ago
      I don’t really get this distinction. “Google as a corporation” isn’t a thing, it’s a collection of people, some of whom happen to be the Go core team. It’s likely that due to being close to Go developers at Google there’s a bias towards implementing features that would help those people, but I very much doubt the subject of genetics in Go comes up at board meetings.
      • dx034 7y ago
        Google the corporation is represented by upper management, the people by developers. The question is if upper management at Google takes any influence on the development process.
      • fragmede 7y ago
        Implementing features Google needs sooner, rather than later, is one thing, but at some point, Google-the-profit-driven-corporation's needs will contradict the broader Golang community's needs, at which point the question is who "wins"? What will, on a long enough timeline, come up in board meetings, especially as Google fails to meet Wall Street analyst's expectations, and as the ad-tech space evolves, is how much of Google-the-corporation's money to continue plowing into broader community things, like Golang at all. Hopefully, by the time that happens, the community will be strong enough to persist, and I use Golang professionally, so I have personal investment for that to be true, but the possible eventuality that it'll end up being in the situation Java is currently in, makes me nervous.
• cryptos 7y ago
  Actually there are relatively few real (TM) open source projects driven by the community, at least if you look at important projects. Many open source projects are just commercial projects driven mainly by a single company. Look for example at Redis, MongoDB, MySQL, and Elasticsearch. They follow exactly the model described in the article. Technologies like these could have been developed by a community, too, but it is hard to form such a community and keep it alive. For a community-driven project from the size of a database some serious sponsors would be needed. Good examples are Rust, Linux, and PostgreSQL. I wonder why so many companies are happily paying Oracle (and the likes) tons of money instead of sponsoring an open source project like PostgreSQL.
  • ksec 7y ago
    If we look at the Top 10 programming languages, I think only Ruby is community driven that has very little cooperate backing. All the other languages are driven by one (Apple;Swift), or multiple, (Javascript, Java) cooperate sponsors. I think the balance is hard, you will need lots of resources from Documentation, VM expertise, Library, etc.
    • fnord123 7y ago
      The top 10 according to Red Monk[1] are JavaScript, Java, Python, PHP, C#, C++, CSS, Ruby, C, Objective-C, Swift, TypeScript, Scala, Shell, Go, R, PowerShell, Perl, Haskell, Kotlin. Of these, Javascript (w3), Python (Python Foundation), CSS (w3), C++ (ISO), Ruby (community), C (ISO), Shell (Posix), R (community), Perl (community), and Haskell (community) are not bound to a single company. [1] https://redmonk.com/sogrady/2019/03/20/language-rankings-1-19/ https://redmonk.com/sogrady/2019/03/20/language-rankings-1-1...
      • cryptos 7y ago
        Kotlin is also no longer in the hands of a single company. https://kotlinfoundation.org/ https://kotlinfoundation.org/
        • 7y ago
• mdale 7y ago
  It can be forked it if the opinions are widely shared and you think people will support you to run it better ? The tone of the article seemed to be casting shade relative to the institution funding it's development as the foundation of why there are problems ? It's normal in a large scale open lanuage there will be disagreement around direction of the project. Many models around how those disagreements are resolved exist across many projects. You can choose one of them or build your own project and make your own decisions :)
  • iends 7y ago
    I’m convinced that the people who just suggest forking an open source project with 100s or 1000s of man years behind it lack practical experience in building or maintaining large software systems. Dismissing valid criticism with “just fork it if you don’t agree” has got to be some of the most useless advice parroted around open source.
• Kovah 7y ago
  I am about to learn a new programming language and I decided against Go just because of this fact. I do not trust Google and reading this article just makes clear how critical the state of the language is in terms of control by the community. Python looks most promising and I already worked with it, but I am not sure yet. Can anyone recommend a viable alternative for Go? Any web-focused language that is performant, modern andalready well used?
  • smt88 7y ago
    C#, F#, Kotlin, TypeScript/Node (someday Deno) I wouldn't worry much about "performant" though.
    • hvidgaard 7y ago
      F# and Haskell are two very nice languages if you want to try something truly different.
      • neop1x 7y ago
        ... and if you are ok with investing to adapt newcommers coming to your team and fine with lack of people actively using it
        • hvidgaard 7y ago
          Both have helped myself and many other people write better code in "enterprise" languages. I don't mind my team using different languages for small bits and pieces that are one off things, or can be replaced without must effort. It keeps developers happy to have some autonomy. I only demand that it's well documented how to build it.
  • kmlx 7y ago
    you shouldn’t let an article decide what language you learn.
    • 7y ago
• networkimprov 7y ago
  To their credit, the Go team withdrew most of Error Values draft 2 [1] after a great deal of negative feedback. However, they've kept one unpopular change to fmt.Errorf(). We can hope that draft 2 of Error Handling [2] won't look anything like draft 1, for reasons such as [3]. [1] https://github.com/golang/go/issues/29934 https://github.com/golang/go/issues/29934 [2] https://github.com/golang/go/wiki/Go2ErrorHandlingFeedback https://github.com/golang/go/wiki/Go2ErrorHandlingFeedback [3] https://medium.com/@mnmnotmail/golang-how-dare-you-handle-my-checks-d5485f991289 https://medium.com/@mnmnotmail/golang-how-dare-you-handle-my...
  • ra7 7y ago
    From [1]: > The most contentious point of the original design was the special-case handling of a trailing ": %v", ": %s", and ": %w" in the format string, which did not follow the usual printf model in which the meaning of % verbs is context-independent and all non-% text has no meaning at all. We will remove those special cases from Go 1.13. At least, they removed the really ugly special cases! [1] https://github.com/golang/go/issues/29934#issuecomment-489682919 https://github.com/golang/go/issues/29934#issuecomment-48968...
• ephaeton 7y ago
  Oooph, from my perspective, this is the very same thing with clojure, and the single thing that drove me away from the language. Substitute spec/schema for vgo/dep, and you're telling the same story. I value individuals and companies sharing their developments with a community. One has to remember though, to own something is different from benefitting from other's work, and if you want to have a say, you'll need to get your hands dirty, fork, and work.
• kmlx 7y ago
  this is exactly one of the reasons i learned Go in the first place. without the backing of a major corp it’s damn hard to have major success. not impossible, or unheard of, just hard.
• z3phyr 7y ago
  I really like C and common lisp in that they do not seem to be owned/driven by a singular entity
  • tannhaeuser 7y ago
    And that they have two excellent, interworking implementations. And a language spec, by ISO even.
• willtim 7y ago
  Haskell is an excellent example of a community-driven language. It's more mature and advanced than most commercial offerings too, offering a superior type system, fast and efficient executables, lightweight fiber concurrency, software transactional memory, higher-kinded parametric polymorphism and many more features.
  • TylerE 7y ago
    Haven’t most of the top Haskell devs been on the Microsoft payroll for years and years?
    • masklinn 7y ago
      SPJ is a Microsoft Research Cambridge employee, but as far as I know that doesn't give Microsoft Research (let alone Microsoft itself) any undue influence over the language's direction, they can't gatekeep or ram things into Haskell or GHC.
      • TylerE 7y ago
        It would still be corporate sponsorship and not a true community effort though. Not having to work to pay bills makes it much easier to run a large project.
        • masklinn 7y ago
          Pretty sure SPJ does have to work to pay bills. It's just that they work for a research institution and can thus do part of their work in / on the project. In no small part because CS research was one of the use cases for creating Haskell.
    • pyrale 7y ago
      SPJ and a fe wothers work at microsoft, but they are few compared to the community. Likewise, several high profile haskellers were at Standard Chartered, but I don't believe this was significant. I would say the main drivers of Haskell these days are academics, PhDs and consultancies.
• nickm12 7y ago
  > Python has always been Guido van Rossum's language regardless of who he worked for at the time. (from the article) I think the high-level point that Python has not been tied to a company is true, but it's not been true that Python is "Guido's language" for decades. Python has a very effective community process. Guido has certainly served as a tie-breaker and of course as BDFL (no longer!), but I see the language being largely steered by the community and community leadership.
• Illniyar 7y ago
  Google are bad at building developer communities (or at the very least they don't care about it much). They build things for themselves and their way is the Ivory Tower way of running a community. The overlords decide and their word is set in stone, the plebs should just accept the fact that their concerns and use cases are just too trivial and they should listen to the smart people at google and do it their way, which is the only way. This isn't the first time google open sources internal tools, trying to build a community but really ignoring them completely. GWT, Closure compiler and of course Angular comes to mind. Angular built a great momentum and community, and the angular team at google basically ignored most ongoing concerns to work on their next big project that'll fix everything (first it was Object.observe, then dart then angular 2). Contrast google's handling of Angular to Facebook's handling of React (and react-native) - The routinely incorporate community influencers into the core team, they include other major corporations in their decisions and community, actively engage in developer relations to get feedback, explain controversial choices and build a community. Sun's model with Java is even more different - incorporating major stakehodlers in the language into the actual decision process via the JCP. Of course Google isn't the only ones who are bad at building developer communities around their open source. Apple and Amazon barely even try. If google is Ivory tower, Microsoft is the Herbalife way of building a developer community - actively supporting influencers, providing official seals of approval and using a top down hierarchy of advocates. They do listen to community input a lot more, but Microsoft is still the overlords of all their projects.
  • baby 7y ago
    Saying that they have failed to build a community around Golang is totally wrong
• revskill 7y ago
  I love Golang to some extend, the moment it's released, it's like new fresh air from Java. But because i don't like Google, i never adopt Golang. Thanks God, we have Javascript, and maybe Rust.
  • slezyr 7y ago
    > Thanks God, we have Javascript Best language to write multi-threaded apps.
  • neop1x 7y ago
    javascript, ah.... allright..
• tamrix 7y ago
  Golang solves a specific domain problem google has. They extended plan9s c compiler with some syntax Sugar for co routines and fixed some whacky c stuff then threw in some gc. There's new and innovated about golang. They just had to open source golang because they used the plan 9 c compiler which was open source.
  • ggm 7y ago
    A small group of programming language professionals with fifty+ years of shared experience developing compilers decided to keep on going with the language family they invented and extended.
    • pjmlp 7y ago
      Specially when one compares Limbo and Oberon-2 features to Go.
    • jacques_chester 7y ago
      I'd say they have fifty+ years of implementing the same language over and over. During the fifty+ years they studiously avoided learning what anyone else had been doing, and it shows.
• CraigAU 7y ago
  Rust is another choice ~
• piyush_soni 7y ago
  >> But Google is the gatekeeper for these community contributions; it alone decides what is and isn't accepted into Go. So ... much like Linux where Linus is the gatekeeper, and he decides what goes in and what doesn't, and also abuses people while at it?
  • rob74 7y ago
    But he's trying to be nicer, so cut him some slack :)
• CraigAU 7y ago
  Rust is your choice :)
• T3RMINATED 7y ago
  Sounds like Laravel
• fmajid 7y ago
  I've only followed the modules controversy tangentially, but I did go to a presentation by Sam Boyer, where he started getting emotional and muttering about organizing some sort of resistance movement. Russ Cox made it a point for Go's regex library to have bounded worst-case performance at the cost of worse average time, and Go's fast compilation times are a source of pride for the core team. That they would frown on a dependency management system like dep that is based on a NP-complete algorithm doesn't seem to have struck Sam as a total deal-breaker. In this respect I am fully behind Cox. As the OP says, the Go team has taste, and I want them to keep the language simple, sane and manageable, not a monstrosity like C++, Java and now sadly Python as well.
• orian 7y ago
  And for most of the SMB it's cool they can ride Google's horse for free.
• guggle 7y ago
  No matter how good it is, I won't invest personal time in Google's products because Google like to kill Google products.
  • mirceal 7y ago
    technically Go is not a product but your point still stands.
• lucb1e 7y ago
  C# unfortunately has the same issue, but the effect is much more visible. Few people (I'm sure you can find examples, but given how popular the language is on Windows, it's a tiny minority) use C# outside of Windows and it's a shame. There is no good open ecosystem so even as a former Windows dev I hardly use it anymore.
  • EnderMB 7y ago
    The limiting factor for me, as a long-time C# dev now working outside of Windows, is that many of the tools I used haven't been ported to .NET Core. Take Umbraco, for example. If someone were to port it to .NET Core and rewrite parts of it to use Postgres as a db option there would be zero reason to ever use WordPress again.
    • pjmlp 7y ago
      Other than like 90% of ISPs only offer cheap hosting for PHP.
      • EnderMB 7y ago
        You're right, although I'm not sure if people necessarily go to their ISP or to the cheapest host possible. Most of the time, in my experience at least, someone that wants cheap hosting and is using something like .NET or Python will Google "cheap python hosting" and see what is cheapest/recommended. PHP tends to be the outlier, because it's absolutely everywhere, but I think the web has matured to a point where people will look for specific hosting for their choice of tech. Hell, back in my freelancing days when I used to rebuild broken WP builds, most people that weren't given hosting by their client chose it from looking up "cheap wordpress hosts".
        • pjmlp 7y ago
          When time came to replace my XML/XSLT based website by something else, just to get up with the times, I resisted to touch PHP, but in the end having it at my ISP versus the trouble of using something else won. Nowadays I am able to use PHP 7.x, so I just keep using it there, and suggesting it for the less tech savy friends that want some kind of dynamic website. Because while I do build sites in Java and .NET, I do accept that they aren´t that easy to set up at most ISPs, and cloud based one click solutions tend to be more expensive.
• pjmlp 7y ago
  I pity the recent CS graduates that weren't able to attend a decent CS degree and need Go to fit their mental model.
  • tremon 7y ago
    That's not really a problem for computer science students, I think. Their area of focus tends to be on the algebraic, theoretical side of the spectrum. It's much more of a problem for computer (software) engineers.
    • pjmlp 7y ago
      Which boils down to the same issue. Back home CS means Informatics Engineering, a degree certified by the Engineering Order to practice, with enough theory and practice spread across 3 - 5 years. Those that want CS theory without programing have a major in Mathematics with a minor degree in computing.
      • iends 7y ago
        What country is this? It’s certainly not that way in the USA at most universities.
        • pjmlp 7y ago
          Portugal, and many European countries have similar offerings, at least the southern ones.
          • TomMarius 7y ago
            We have Theoretical Informatics as a field of bachelor study in the Czech Republic, software engineering is called Applied Informatics
    • repolfx 7y ago
      Be careful. Rob Pike asserted Googlers can't handle an "advanced language" or whatever his exact words were, but he provided no evidence this was true, or that others at Google agreed with him, or that this was even the reason Go was created to begin with. The most obvious evidence he's wrong is that Google's codebase is all C++ and Java, both languages that have generics and other more advanced features than Go. So apparently Googlers can use such languages just fine. What Pike was claiming was that Google had at some point dropped their hiring bar dramatically and somehow nobody had noticed this or commented on it, despite how controversial it'd have been inside the company. I rather think that this comment about Go is not reflective of any real strategy or decision inside Google. Go's creators were bored and wanted to make a new language, so they did. The justification for what it looks like was then retrofitted on top.
• divan 7y ago
  It's a dangerous type of articles that deliberately turns community against Go team, based on misunderstanding or plain false accusations. Go team said many times that generics are technical issue, not a political one. (see [1] by rsc (Russ Cox from Go team)) There are also stories like experience report of Cloudflare outage due to the lack of monotonic clock support in Go that led to introducing one. [2] The way how Go team handles potentially tectonic changes in language is also exemplary – very well communicated ideas, means to provide feedback, and clear explanation of how process works. [3] Plus, many people in Go community do not want generics in Go (at least, in a way they're implemented in other languages). Their opinion also matters. [1] https://news.ycombinator.com/item?id=9622417 https://news.ycombinator.com/item?id=9622417 [2] https://blog.golang.org/toward-go2 https://blog.golang.org/toward-go2 [3] https://go.googlesource.com/proposal/+/master/design/go2draft.md https://go.googlesource.com/proposal/+/master/design/go2draf...
  • brown9-2 7y ago
    In my opinion the monotonic clock example cuts against this argument - originally the core team was extremely dismissive of the idea, even though it had been shown to cause pain for a lot of people: https://github.com/golang/go/issues/12914#issuecomment-150754067 https://github.com/golang/go/issues/12914#issuecomment-15075...
    • Aissen 7y ago
      But the implementation that rsc came up with was much better than everything proposed by the community (no API change).
      • pas 7y ago
        Crisis is always a great opportunity as the pressure motivates people to ship, while also to do their best, to really consider any and all options, everything that might work. Sometimes, of course, this does not work out for the best.
    • divan 7y ago
      It's a great example, as it shows the complexity of the discussed topic and attempt to justify any changes to the language/stdlib. In the above-mentioned comment rsc replies to another Googler, not to "community". So we have a) Google having problems with lack of monotonic clock in Go b) Go team reluctant to break API and break promise of compatibility without really serious reason c) community feedback in form of well written experience report, explaining how serious the issue is for the community d) immediate reaction and efforts to find a solution (without breaking API) Even though team was dismissive of the idea, feedback from the community made them to change their minds.
• juststeve 7y ago
  Free as in, beer.
• doesnt_know 7y ago
  I'm going to risk being labeled an ~incompetent dev~ or whatever but learning golang was seriously a breath of fresh air compared to literally any language I have ever tried to grok before. Everything felt like it was there on purpose. It always seemed like there was a "proper" way to achieve something. Being told to use this opinionated formatter was like removing a 40kg bag after a bush walk. You never have to worry about if you're writing Go "the right way", because it's extensively documented what that way is. Generics is an awesome feature, writing C# is my day job so sometimes I miss it, but I have full faith in the designers when they say it will be in the language in a "Go appropriate way". The last thing I personally want to see is Go being handed over to the community to be designed by committee.
  • reflexer 7y ago
    wrt a "proper" way: adding item to a slice, uhmm?
    • naikrovek 7y ago
      A slice isn't an array. A slice is a view into an array. You don't look through a window in your house into the backyard, and plant a tree in the backyard by fiddling with the window. It's the same with arrays and slices in Go. If you want to insert an item into a slice, insert it into the array (by copying to a new array and adding your new element to it while copying), then creating a new slice which includes your addition. edit: (adding for clarity) In a lot of programming languages, whether they use slices or not, arrays are of a fixed size and must be copied to a new array if you want to add elements. Some languages have some syntax that makes it feel like you are modifying an array in-place, while doing the copy to a new array behind the scenes. edit-edit: for an implementation example of the above, see Java's ArrayList class: http://hg.openjdk.java.net/jdk8/jdk8/jdk/file/tip/src/share/classes/java/util/ArrayList.java http://hg.openjdk.java.net/jdk8/jdk8/jdk/file/tip/src/share/...
      • was_boring 7y ago
        I'm by no means a expert, but doesn't Go advocate using append with a slice which will create a new array? https://golang.org/pkg/builtin/#append https://golang.org/pkg/builtin/#append
• otikik 7y ago
  The problem I have with the article is that, as an outsider, it reads like this is not about Google. It reads like this is about features that the author liked which were not merged. In an alternative timeline where Go was not sponsored by Google, deciding what to merge into it and what to leave out would fall into some sort of "Core Team". In that timeline, if that Core Team decided to not include the features that the article author is describing, then we would have an article titled: "Go is The Core Team's language, not the community's". I can only offer one answer. Maintaining an open source project is a lot of work. If you care enough about those changes, make a fork, include those changes, and maintain it yourself. If that's too much work, then you are stuck with what others able to dedicate the effort decide.
  • ptd 7y ago
    Do managers of open source projects typically get paid? Seems like a lot of work for a volunteer...
• danielmg 7y ago
  For what it's worth I'm a semi-grey beard (20 years in) and I love golang. For me it was like going back to being 8 years old on my Commodore Plus/4 and really enjoying writing code again. It needs close parenting. Java has been ruined by the push to include everyone's pet feature.
  • akerro 7y ago
    >everyone's pet feature Isn't that C#? Java is very slow at adding new features, Java has only things that were proved to work in other languages.
    • th3iedkid 7y ago
      Generics was introduced in Java in 2004 with J2SE 5.0[0]. [0]: https://en.wikipedia.org/wiki/Java_version_history#J2SE_5.0 https://en.wikipedia.org/wiki/Java_version_history#J2SE_5.0
      • LeonidasXIV 7y ago
        The concept of generics/parametric polymorphism has existed decades prior to that in languages like SML and proven to work rather well.
        • raducu 7y ago
          Every time I get to edit pre-java 5 code is a reminder how useful generics actually are.
      • coldtea 7y ago
        Generics should have been in Java (and Go) from the beginning. Those surely are not the proof that Java adds "everybody's favorite feature". I think the parent means the newest Oracle projects (Valhalla, modules, value types, streams, and so on).
        • mcguire 7y ago
• mlang23 7y ago
  What a surprise (not).
• p0nce 7y ago
  This is the same thing with Rust, where original core team are Mozilla's employees.
  • jandem 7y ago
    Many (most?) people on Rust's Core/Governance Teams don't work for Mozilla (anymore). See https://www.rust-lang.org/governance/teams/core https://www.rust-lang.org/governance/teams/core
    • steveklabnik 7y ago
      (3 out of 9 people are Mozilla employees)
• amelius 7y ago
  I like Go's concurrency approach and its concurrent GC implementation, but I personally don't like the language that much. It would be awesome if the runtime system could be factored out, and targeted by other languages.
• IRLIamOffline 7y ago
  The post makes it sound as if Go being Google's language (not the community's) is a bad thing. I don't see where this sentiment is coming from as the strong opinions enforced by Go core devs is probably one of the defining features of Go. As with many open source projects under benevolent dictatorship, this can result in streamlined and consistent features with long-term success.
  • teddyh 7y ago
    Are you by any chance also a royalist? To quote the IETF: “We reject kings, presidents and voting. We believe in rough consensus and running code.”
• zulgan 7y ago
  I believe that solid (benevolent) dictatorship is better(faster, can make unpopular decisions, etc) than democracy. I don't like any language, but tbh I hate go the least, and I believe this is because few very very dedicated people with enormous amount of experience can simply make unpopular decisions.
• deleted 7y ago
  [deleted]
• wjwtywty 7y ago
  Fcuk the community, according to history and experiences.
• jasonhansel 7y ago
  I really wish Go had learned a lesson from Java: programmers will eventually want generics, and adding generics to a language that was not designed for them leads to new and unexpected obstacles. The lack of generics makes Go uniquely unsuitable for functional programming, an unfortunate outcome when functional programming is the New Cool Thing.
  • akarki15 7y ago
    > New Cool Thing See that's your issue. Go tries super hard to _not_ be that and evidently has succeeded.
    • apta 7y ago
      The original view of the golang authors was that it was made to replace C++. It obviously failed at that, and ended up being used as a faster Python.
• paulcarroty 7y ago
  Yeah, the same story with Typescript and other languages. People learned nothing from Oracle stories.
• fnord77 7y ago
  after using golang for a year, I thought it was limited but ok... then I switched to Rust once it was fairly matured - haven't looked back
• tzury 7y ago
  Does anyone stops the author from forking it and starting an "OpenGo" and implement anything he cannot wait for mainstream releases?
• smadurange 7y ago
  I wonder if the same thing that happened to Android OS, will happen to Golang. Starts off as opensource and free and slowly tie the users down to Google as they did with App Services, etc. "Look but don't touch" kind of opensource?
• primozdelux 7y ago
  ᒪᘯᒪ ᒥᒭᘯ ᕴᕮᘉᕮᖇᖍᑕᔕ
• cosmodisk 7y ago
  This is a difficult one. On one side we have a massive corp that is pushing it's own language and essentially steering it the way it wants.On the other, there's ever growing community that has its own ideas and suggestions on how the language should evolve. I'm too early in my journey woth Go to be able to have in-depth discussions on its functionality, however what I don't want to see it turning into another JavaScript,which is such a mess and free ride for everyone who thinks they have another good idea how to fix it.Unless there's a proper independent steering committee,I can't see this working too well without Google's ownership.
• skywhopper 7y ago
  Yeah, that’s the case with any coherently designed language or software package. I don’t really have a problem with it. Now that they’ve come up with a workable module system, the issues of it coming from Googleworld are minimal. I don’t personally care about generics, and I like the error system so I find Go to be a great language to work in. But that’s all just my personal opinions. What I found interesting was the callout of OpenJDK as a community-run language, but is it? I feel like OpenJDK is the worst of both worlds. Too much corporate overhang, and all the worst aspects of design by committee. But YMMV.
• betimsl 7y ago
  Go is designed with Unix philosophy in mind by people who created C and then wrote Unix in it. So lucky us that they are the gatekeepers. Having said that, Go's license allows everything and it would be interesting to see a fork and compare it with the mainstream a year from now.
• MagicPropmaker 7y ago
  Similarly Rust is Mozilla's language. If you want a real open Language, use the open source F# or C#.
  • steveklabnik 7y ago
    What makes you say that?
• snarfy 7y ago
  You could say the same thing about Linux. If Linus doesn't like what you made, it's not getting into the kernel.
  • teddyh 7y ago
    There is a significant difference: Linus is a real person with an actual personality which you can get to know and reasonably choose to trust. “Google”, as an entity, not so much. Even we grant Google personhood, they’ve shown themselves, shall we say, less than dependable in regards to long-term support of their offerings.
• Merovius 7y ago
  I'm so tired of people purporting to speak for "the community" - especially when they diametrically oppose my own views. It feels a lot like they are co-opting me for their own agenda while simultaneously excluding me. The things mentioned as evidence that community doesn't matter have a lot of buy-in from the community. Modules in particular are an effort that - at least from what I can tell - is heavily driven by non-Googlers (in particular Rog Pepe, Paul Jolly and Daniel Marti are people who put a lot of work into making modules actually work for practical workloads). These kinds of pieces only make sense if you have an extremely limited view of who is or is not part of "the community" - in particular, if you throw everyone agreeing with the Go team out of that bucket.
• craftoman 7y ago
  I think Microsoft or Apple for example, made their own programming languages in much more ethical way than Google's sceptical which is: "ohh we are going to make our own language and get the help from the open source community." Everyone knows that companies are "exploiting" open source today which is really sad.
  • dmitryminkovsky 7y ago
    > Everyone knows that companies are "exploiting" open source today which is really sad. Often enough it seems like companies go out of their way to deal with open source just for the "cred" and hiring opportunities that it brings. The open source itself is a just a drag on their internal team, which has to deal with tickets and contributions they don't want or need.
    • craftoman 7y ago
      They don't need what? Free testing and debugging from thousands of people running their software on completely different hardware and OS? You may see useless tickets but companies are paying millions for QA and testing.
      • dmitryminkovsky 7y ago
        My observation has been that the free testing they get is often for cases they never hit in their production use cases. For example, FB doesn’t use DraftJS on mobile, so it took a whole year long effort and a person who used to work for FB to fix mobile support. They just didn’t need it, didn’t have resources allocated to dealing wit it, and were understandably unresponsive on the subject. Now maybe they can use it in the future on mobile if they want, but they would have just fixed it if that need had ever arisen for them organically.
• Yaa101 7y ago
  There are 2 things I like about Go, 1. Compared to most compiled languages the toolchain is very easy. 2. Reduced ways of solving things in the language itself. My main dislike of C and C++ is that there are numerous ways of solutions for the same problems, this forces me to weigh the solutions constantly against things like "Is this a safe way, does it create fast code, will this way fit when my project is further or must I constantly refactor my code". The extreme flexibilty of C and C++ are more a burden for me than an asset.
  • neop1x 7y ago
    I personally also dislake C++'s standard library, lack of standard functionality in it and the difficulty of maintaining dependencies and the whole resulting build process with crosscompilers. GNU Make was not enough, CMake was not enough, GN is almost rocket science, then there is Meson. And choice of clang or gcc. Chrome/Fuchsia is an example of how complicated it can be. But does it have to be like that? There are definitely good reasons to use C++ or C in some cases (system, low-level, games etc) but C++ is a difficult language and it's not necessary for lot more other cases. Rust is yet another story, solving some problems but making new ones. Go made me enjoy the programming again. And of course, managing modules is a very difficult task so it had to be done somehow and somehow really, really good and I think they delivered the working solution. Various previous attempts were bad for various reasons (Kubernetes can tell you).
• knodi 7y ago
  wrong on so many levels.
• sebazzz 7y ago
  I'm not sure what this article is trying to say. Microsoft C# is a Microsoft project. Go is a Google project. There is someone who need to govern the project. This is a company in these cases. The only other option I see is some board like (in case of .NET) the .NET foundation to allow more control.
• grantseltzer 7y ago
  No shit Google has the final say, they're the maintainers. They pay developers millions of dollars to make the final call on what's best for the language. Even if someone were to start a community fork there would still have to be a central board of governance. Suggesting that we should split the community for a feature that you like in other languages is a dumb and lazy argument.
• ivolimmen 7y ago
  Nice to read all the comments on this story. The story is about the how Go is not truly open source and community driven and the flame war starts on how Java does not implement generics correctly etc. Guys: each language has it's benefits and it's shortcomings. If we want (need?) more control over the language, can't we just fork it? Start a new language that is based on the current implementation of Go?
  • neop1x 7y ago
    exactly. Or what prevents them from using beloved and 100% correct Java in the first place?
• baby 7y ago
  Security consultant here. I have audited many codebases in many languages. Go is by far the easiest language to audit: it always looks the same, it's not too verbose, there are no generics or OOP. Coincidentally it's always the most secure as well. My take on this is that it is easier to see logic problems because it is easier to read, understand and reason about. On top of that the standard library does so much for you with crypto and security. Generics and zero-cost abstraction can and are concepts that are often abused instead of used when it makes sense. I hope thay Go will never support generics because I sincerly believe it might mean the end of the language
  • logicprog 7y ago
    I'm curious, how will they end Go itself? My understanding is that they always planned to have generics, they just didn't make 1.0 and now the Go community has sort of adopted the lack of them like a badge of honor. Also, I have no expertise in your field so forgive me if this is a stupid question but wouldn't generics be easier to check over since they allow there to be only one implementation of something for all types versus in Go, a bunch of different implementations of the same thing that you have to check and might have subtle errors?
    • pkaye 7y ago
      I think there is generics proposal under discussion.
      • logicprog 7y ago
        There is! As soon as it is implemented in the language, I will consider Go.
    • darkpuma 7y ago
      > "My understanding is that they always planned to have generics, they just didn't make 1.0 and now the Go community has sort of adopted the lack of them like a badge of honor." As soon as Go adopts generics the community will turn on a dime and pretend they always loved generics (and perhaps even invented them.) That's how these sort of things typically play out. See also, copy/paste on iphones. When only android had it, copy/paste was a misfeature for idiots. When iOS implemented it, copy/paste became the best thing since sliced bread.
• catacombs 7y ago
  > In practice we'll only get a chance to find out who Go really belongs to if Go core team members start leaving Google and try to remain active in determining Go's direction. If that works, especially if the majority of them no longer work for Google, then Go probably is their language, not Google's, in the same way that Python has always been Guido van Rossum's language regardless of who he worked for at the time. This is laughable. Anything built within Google belongs to Google. There's no way the company will let anyone from the core team leave and take the language with them. Keep in mind, Google's version of Go and the community might be vastly different, as the former has different needs versus the latter.
• microcolonel 7y ago
  Projects are directed by those willing to put in the work. If you don't put in the work, it's not yours alone!
• miguelmota 7y ago
  Agree that generics are much needed but also wary that if you let the community take charge then you end up with a frankenstein language like PHP. Also a huge fan of go mod over vgo so I had no issues of them scrapping the community dependency manager and rewriting it to be part of the language
• tebruno99 7y ago
  Um, Yeah, GOOD! This demand for Generics is pure sheep brain garbage. Once you learn to write software properly you find only like 1 or 2 small use cases where Generics might actually help
  • tebruno99 7y ago
    Down vote me all you want. Been writing production software in Go for nearly 4 years and have never asked or needed Generics. Saying that there isn't a community because Generics are wanted by "some people" is daft. The whole point of Go is to be small and opinionated and committees can only produce outcomes that are large and inclusive of all opinions.
• skybrian 7y ago
  There is an assumption here that the community is unified, you are part of the community, and therefore if the community doesn't get what it wants, then you don't get what you want. Actually, the community disagrees on stuff, so you're unlikely to get what you want, regardless. The only way you always get what you want is if you write your own language. (Assuming you're skilled enough to implement it.) But a language nobody else uses is of little benefit. There needs to be some core team that makes coherent decisions. Unless the community is tiny, the core team is not the community. There are inherently tensions. However it's unclear that Go's core team is doing worse at listening to their community than other language's core teams?
  • meesles 7y ago
    100%. Look at Ruby's community. It's a pretty great community in my experience, but at the end of the day Matz, Kokubun, etc. act as gatekeepers. Democratic creation of software would be a disaster. There's so many philosophies of development and differing opinions that you wouldn't be able to make progress. At the end of the day the reason a language exists is to implement the vision of those who created it. The community is a labor force to implement, test, and verify the decisions made by the heads. I totally encourage people to write their own languages though. A language no one uses can be beneficial to computing at large as experiments in language implementation. We all know silly languages like Brainfuck that you would probably never use for work, but can be useful learning tools.
• jjdjr0odo7 7y ago
  This post seems to conflate implementation and specification. All the required bits (permissive license, specifications, etc) for writing a community tool chain (compiler, linter, fmt) are in the open. Won’t the oppressed community rise up for itself and end this programming language tyranny!
• stcredzero 7y ago
  There are many answers for why this won't happen, but one that does not usually get said out loud is that Go is Google's language, not the community's. More precisely, its design belongs to a small number of capable people who are on the same page, with regards to a pragmatic, minimal-ish design. This is better than a "benevolent dictator," in that there are some checks and balances. It's also better than design by mass committee from the public.
• ydnaclementine 7y ago
  Can the same sentiment also be shared for Swift/Apple? Or is Swift organized in a way that doesn't have these issues? Maybe this is just an inherent problem for all company focused languages/frameworks (react, golang, kotlin, etc), and we need a good example of how to make it work for everyone
• docker_up 7y ago
  I like Go a lot, but the fact that Google doesn't use it extensively in their own environment makes me wonder why that is. It almost feels like a Trojan horse.
  • hu3 7y ago
    Rewritting software is expensive. I'd be surprised if any new language becomes prevalent in less than multiple decades within Google's unfathomable scale.
• yarrel 7y ago
  Good. This is how you don't get C++.
• nippler 7y ago
  Falling for the go meme, EVER
• SamWhited 7y ago
  This is absolutely true. In general I feel like it's good when a language belongs to a core team, but they don't appear to be learning from past mistakes. The core team put out a proposal for modules and then immediately implemented it with very little community feedback except what could be done after the fact without breaking much. There was huge backlash and they claimed they would do better and seek community feedback earlier, but now they require that you use a Google web service when fetching modules (I've turned it off) and shoved that out between two versions without any community feedback as well. Strong central leadership is great, but leadership needs to actually listen to the people they're leading (and not just as an after thought).
• ChuckMcM 7y ago
  This is an important point that people need to keep in mind. From a psychological perspective it is also a little bit evil in that it "feels" like a community and people participate like its a community, but the reality is that it isn't a community at all in the communal action sense. Essentially Google gets "free" developer time as people work on problems and pitch in possible solutions. Google can influence what is worked on by whining about things, and they are free to take or discard the offerings. This isn't particularly surprising to me as it feels very similar to the way I felt when working there. Which is that people in engineering worked on projects that they were passionate about, but whether or not those projects got support, or were shipped, or released into products. That stuff was all done "elsewhere" by some group of people who were generally known, but not really part of the day to day. I tended to think cynically of them as 'class A' shareholders, or 'class B' shareholders[1]. I don't think there is anything wrong with managing a program this way, I do however think they go out of their way to create a community illusion to foster more participation. That tells me that if they were up front about things, they feel people might not be as eager to participate. To the extent that they are deceptive in their communications, that I would consider wrong. [1] Class B shareholders get to vote on shareholder issues, but there is always more voting power in the class A shares so that the class A folks can veto or reject any notion they dislike, no matter how popular with the class B folks.
• neop1x 7y ago
  It is actually a good thing. The more forks there are and more complicated ideas and toys, the more mess and chaos. It can eventually kill the whole ecosystem. I love open-source and libre software but there needs to be some central authority who oversees the changes and is forward-thinking. I actually love Go in the way it is and it wouldn't be it if you kept asking community what features to integrate. I am looking forward to generics as it solves some cases (containers holding items of a templated type sharing some common methods). But even if Go stayed the way it is, I would be fine. The point of open and libre in this project for me is that Google can't shut it down and that's enough for me in the case of prog language. Please, if you want to make super-crazy-new community-driven uber-language which will change the world, make yet another and truly yours language or join Rust or whatever more community-driven language you like. Thank you! :)
• claudiug 7y ago
  even if is baked by google, currently, they have a nice spot on the market, and I dont see any competition :)
• TheMagicHorsey 7y ago
  You want Go to be designed by the Internet equivalent of a cooperative? Isn't that how you get stuff like C++? For some things Democracy is excellent (governance of nations, because it might be the least bad option). For other things a dictator is good (Amazon seems to be providing a lot of societal value under Chairman Bezos) . For yet other things perhaps a motivated group of technocrats might be better (Go). I don't suggest I know the answer definitively. I could be wrong. But Go's results are good. Perhaps it would be fair for me to concede that I should examine this question again in 10 more years. What is good for 5-10 years might show problems in 20-50 years time. After all, even communist North Korea was a relatively functional place for a time.
• musicale 7y ago
  I am kind of OK with that. C# is Microsoft's language, Java is Oracle's, Swift is Apple's, Rust is Mozilla's.
• valyala 7y ago
  People don't care who owns Go. They just write awesome software in Go such as Docker, Kubernetes, Prometheus, Grafana and VictoriaMetrics [1]. Go authors created simple, clear and productive programming language. Community-driven design for programming language may be disaster - look at incomprehensible C++ Frankenstein. [1] https://medium.com/@valyala/open-sourcing-victoriametrics-f31e34485c2b https://medium.com/@valyala/open-sourcing-victoriametrics-f3...
• djingga_yosei 7y ago
  what matter at the end is the result. Some hard decision was made for the better of the language and its users at the end. Thank you for the courage taking the hard decision. If want to argue, argue that other package manager do better job than modules instead of community did effort and it goes for nothing but experimental.
• shizhiminger 7y ago
  As 2014, i submit same topic, ask google open source golang under an opensource foundation , they did not want do it https://groups.google.com/forum/#!topic/golang-nuts/OhhG5lu2Zno https://groups.google.com/forum/#!topic/golang-nuts/OhhG5lu2...