Go becomes more stable
blog.golang.org
blog.golang.org
An important thing to note is that, while Go is a great general purpose language, we're building it to make systems development easier. That's what we're using it for at Google, and also how it's being used at other companies like Canonical and Atlassian. In that sense Go is already successful.
Having been at Google (but not associated with Go in any way while there) when Go was announced my question then, as now, was "What was the problem again?"
The basis of that question is that languages that have been successful often, but not always, have a strong correlation with solving a painful problem.
Java solved a number of problems; the problem of connecting across architectures (I thought of it as the 'system libraries' problem), the C++ is too complicated problem (which would be the too complex;didn't learn (tc;dl) problem), and the interactive content from an untrusted source problem (which, in all fairness was a problem it self created when being able to run in a browser).
The only problem that I have ever heard as being at least in the sights of Go was the 'building parallel applications' problem (which is huge, but why ignore millions of man hours in HDLs which also solve this problem but with the caveat that you have to be able to infer hardware from the compiled code)
So unless there is something that is much easier to do in Go that you both need to do, and is so much better that doing it in your current language is too painful, it will join the ranks of languages like Lisp, APL, Modula-n, and Eiffel which all have things to recommend them but nothing to compel them into wide spread adoption and use that we associate with a 'popular' language.
"An important thing to note is that, while Go is a great general purpose language, we're building it to make systems development easier. That's what we're using it for at Google, and also how it's being used at other companies like Canonical and Atlassian."
Historical reference see the design, development, and use of the best language you've never used Mesa [1].
[1] http://en.wikipedia.org/wiki/Mesa_%28programming_language%29
So I think it's interesting to have a language that is finally being built with the primary purpose of being better than C at systems programming. My main issue however is the lack of support for Windows. One of the main points of a system language and the reason C dominates is that with enough hacks you can make it portable to anywhere. I can understand the Go folks probably don't have much interest in or use for Windows (or resources to support a port) but honestly, in my mind that's just incompatible with the stated goal of being a "systems programming language".
That's only a small part of it. It's also designed to be less confusing than C++, and more flexible and faster than Java. As a result, it's actually a very different kind of language. Feels like a scripting language, but you get static typing and the performance of a compiled language.
Lots of smart programmers are finding good use for Go, so your comments seem like unnecessary and misplaced negativity to me.
Exactly. I'm a longtime enthusiastic Python programmer and reluctant C++ programmer, and for me Go is the first language that could realistically replace both Python and C++ for my programming.
For me the killer features of Go are:
- Go code is almost as compact as Python but--especially for numeric code--much, much faster.
- You never have to wait for the compiler! Everything I've written compiles and links in a fraction of a second.
- Easy CSP-style concurrency: goodbye races and deadlocks w/ threaded code.
Note too that, apart from the C runtime and low-level OS interfacing stuff, the entire Go standard library is written in Go itself. Contrast this w/ "scripting"/dynamic languages like Python or Ruby where much of the standard library has to be written in C for performance.
(FWIW I have published some open source Go code on Github at http://github.com/jbarham and the beginnings of an AWS library at http://code.google.com/p/goaws/.)
It feels like a scripting language, incredible performance, extremely compact code when you need it to be, actors.
>Easy CSP-style concurrency: goodbye races and deadlocks w/ threaded code.
I actually disagree with this, CSP style, actors, message passing, you still have potential race conditions and deadlocks. What you gain is a nice separation between what is shared and what isn't. Just don't think Go's concurrency is the many-core silver bullet anymore than locks or Tx Memory is...
The work I do in C++ I could do in Java, but the extra memory and compute overhead would cost us on the order of another engineer. Go interests me because it might let me escape C++ without the cost of Java. (Go may still prove too expensive, my experiments aren't done yet.)
Also: Go developers have the Python ethos of short names and simple interfaces. Take a look at the Go standard library[1]. I may get the safety of Java and the productivity of Python in one go.
Go's main feature is what it removes. I got stuck with C for a long time because nothing better with the same simplicity came along. Languages march forward with increasing complexity while offering very little in return for it. Go is a reaction to that and a solution to that problem.
That is simply not true. Yes, Go occupies a small niche, but there are growing numbers of people using Go for real things at Google.
The big problem with parallel/concurrent/distributed programming is that it is very hard to do both correctly and efficiently and scalable with current languages (and at the same time, keep the code maintainable). It has been bolted on, so to say, in may different ways. OpenMP, OpenCL, IPP, the list goes on. All those abstractions serve a certain purpose, and are useful at a certain scale, but are less useful outside of that, and generally you need to worry about way too many low-level details.
OpenMP: loops are easily parallelized, but due to data sharing, writing code that scaled to a large number of cores is very hard. Supports some other primitives like task parallelism, but in a limited way. At least you don't need to manage threads manually.
OpenCL: designed for huge numbers of cores, but very much focused on GPU-based development, makes it very inflexible on general purpose CPUs.
IPP: Work queue primitives to automatically distribute load over multiple cores. This is the most advanced approach, but fits very clumsily into C++ using arcane template syntax, which quickly results in macaroni code.
A language that would truly support scalable high-performance parallelization without having callbacks all over the place would be great. I'm not sure how far Go delivers on this promise, but it's certainly a step in the right direction. Which is expected from a company like Google, which understands these problems.
Before java was even officially released colleges were teaching Java classes. I remember it, cause I took the class and I still have the book that says covers beta. That's how popular java was. We were wowed by animations (feels funny to think about it now) and how easy it was to write screen savers, moving robots and shooting games. This is not the 90s. Look at the success of Android development (different topic). It came from freakN no where wowed everybody. Made stupid HTC (who knew about it before Android) a huge competitor of Apple. We are wowed not by what a programming language can do (this is what we are getting from Google) but by it's demo implementation. Again, look at Android, App Inventor and google has tons of such examples. Go marketing team (if there is one) failed miserably in my opinion.
There's no reason to label go as simply a systems programming language in the same way you can't just label python or ruby scripting languages.
E.g. Go can be used in making of the JVM, the way the Sun/Oracle JVM is made in C, or IBM's JVM is made in Smalltalk.
Sure, people can try to replace Java with Go, but they can also use them both, each for the purpose it fits better.
I'd expect Go to replace Java in the academic context relatively quickly, which should precipitate a shift in business' center of gravity over time. I already suggest Go to people who are serious about learning.
----
It's not a full replacement for Java, as most of the APIs are currently inaccessible via the NDK. But it's getting there.
Comments like this bug me. Sure, some languages aren't terribly different from others, but there's always something new and valuable to be learned from a programming language, even if it's what not to do. At this point in my career, I can switch between languages almost seamlessly. Sure, you spend some time on syntax, but once you understand the concepts behind a language, you're running.
And with Google Go specifically, they're incorporating good ideas that aren't making it to existing languages. The Java guys can't agree on how to do closures, or even if they're a good idea, and the changes to C++ are making it more baroque. It's like they're having a contest to see how many meanings they can have for the const keyword.
I'm excited to see a new language designed by smart people with great track records, incorporating lots of cool new ideas, and from an organization powerful enough to make sure it's done right and supported long term. Is that not good enough for you?