News for hackers. Stuff that matters.
Re:Go 1.1 beta 1 Released by dvt on Thursday April 04, 2013 @02:22AM (#5491273)
I think this is an amazing milestone; I contributed to Go in the early phases and was very excited about the project. I even had Rob Pike OK some of my patches (which was a huge nerd ego boost, obviously).

However, the direction the language took ended up being quite predictable and somewhat of a bore. The problem with Go is that it doesn't seem to fit any particular niche. Some other design decisions were questionable (no exception handling, for one).

I kind of like Go, but I haven't used it for years. There's no real reason to NOT write something in C (or, rarely, C++) or Java, or if I need some serious scaling, Erlang (or just use either something like libevent for C or Kilim for Java).

Go is very D-like. D, like Go, can't really find its niche. If Go or D were more idiomatic, perhaps they would be adopted in early programming classes (high schools and colleges -- like Python, for example), but even though goroutines, channels, and fast compilation are interesting concepts, they aren't really enough to detract from writing in the many other languages that do just about the same thing (and are a lot more popular).

Re:Go 1.1 beta 1 Released by enneff on Thursday April 04, 2013 @02:35AM (#5491318)
Have you used it since 3 days after it was launched, more than three years ago? (That's when you contributed.)

The language, libraries, and ecosystem are miles ahead of where they were back in 2009.

Why not use C? Because C has no sensible packaging system, is unsafe, requires manual memory management, and offers a degree of control that is unnecessary for most tasks. Why not use Java? Because it is verbose and picky and basically forces you to use an IDE to get anything done, etc etc. If there were nothing wrong with these languages (they're the main ones we use at Google) we wouldn't have developed Go.

Use Go more! You'll see why people love it, and why we created it.

Re:Go 1.1 beta 1 Released by tezza on Thursday April 04, 2013 @05:39AM (#5491732)
I'd love to use Go to replace some projects I've written in C and Java.

I evaluated Go last week (2013-03), but there is no meaningful Eclipse IDE support. goclipse doesn't work half as well as CDT, and not a patch on JDT.

I won't move away from eclipse workflows and project management, the context switch is more expensive than any language benefit.

I'll keep checking for comprehensive Go support in Eclipse, but until then it is a showstopper.

Re:Go 1.1 beta 1 Released by laumars on Thursday April 04, 2013 @09:17AM (#5492400)
I use GolangIDE[1] after getting fed up with Eclipse. It's really nice as it's a much lower memory footprint, yet basically does everything you need an IDE to do (ie edit code, debug, etc)

[1] http://code.google.com/p/golangide/

Re:Go 1.1 beta 1 Released by voidlogic on Thursday April 04, 2013 @10:11AM (#5492736)
I second the recommendation for LiteIDE

More common main page: http://code.google.com/p/liteide/ Downloads: http://code.google.com/p/golangide/downloads/list Code: https://github.com/visualfc/liteide

Re:Go 1.1 beta 1 Released by jksmith on Thursday April 04, 2013 @01:19PM (#5493816)
Third. It works and is actively being developed.
Re:Go 1.1 beta 1 Released by sanderjd on Thursday April 04, 2013 @12:51PM (#5493660)
Obviously you're free to make your tool choices however suits you, but I think you are putting a pretty severe artificial limit on what tools you'll be able to use by basing so much of your analysis on deep Eclipse compatibility.

You're letting your tool own you rather than you owning your tool.

Re:Go 1.1 beta 1 Released by carbocation on Thursday April 04, 2013 @06:15AM (#5491809)
I write go in eclipse and the experience is pleasant. What is the showstopper for you?
Re:Go 1.1 beta 1 Released by tezza on Thursday April 04, 2013 @08:03AM (#5492128)
Debug attach points are basically just gdb (okay for a simple app, but needs to be in debug perspective to compete with CDT, JDT )

Autocomplete / suggest broken on Windows. There is something about a fix by running an external server. I gave this a go, sending a few hours piecing together forum comments, but couldn't get it to work 100%.

Re:Go 1.1 beta 1 Released by sesteel on Thursday April 04, 2013 @09:49AM (#5492594)
I am one of the owners of the GoClipse plugin you are referencing. I apologize if you feel frustrated by the user experience on windows and I am glad you found a workable alternative. I always hoped to make GoClipse more of a community project where developers would improve it as they ran into issues, but most of the time people seem to be too busy. That has been my problem as well; too much to do with too little time.

edit: oops, I misread your comment. At first, I thought you found an alternative. I'd be open to working with you to improve the experience. I do not use windows personally.

Re:Go 1.1 beta 1 Released by voidlogic on Thursday April 04, 2013 @11:12AM (#5493107)
"There is something about a fix by running an external server"

It is called gocode (https://github.com/nsf/gocode). Pretty much all Go environments require gocode - the directions for Eclipse (which I don't use anymore) are pretty clear too: http://code.google.com/p/goclipse/wiki/GocodeIntegration

Re:Go 1.1 beta 1 Released by tezza on Thursday April 04, 2013 @11:35AM (#5493231)
Those are the instructions that I followed... look at the bottom and you'll see 27 confused comments. It works for some, not others (myself included)

At some stage the context switch becomes too high and you give up. As I said "meaningful Eclipse Support", and digging around to get gocode working harms this effort.

Re:Go 1.1 beta 1 Released by derefr on Thursday April 04, 2013 @02:49AM (#5491361)
You addressed two of those questions, but what I really, really want to know is the answer to the third one. Why not use Erlang? It seems like the kind of thing Google would like, and yet I'm not familiar with any Google projects done in it.
Re:Go 1.1 beta 1 Released by dsymonds on Thursday April 04, 2013 @02:53AM (#5491372)
Erlang is a very different paradigm of language. It's much easier for someone familiar with C++ or Java to learn Go than it would be to learn Erlang.

Erlang has a great concurrency model, but it's fairly clumsy for writing procedural code of any complexity, which makes it harder to pick up too.

Re:Go 1.1 beta 1 Released by jzelinskie on Thursday April 04, 2013 @02:57AM (#5491377)
While I do like me some Erlang, anybody would admit it has some rough spots. The big two that come to mind are awkward syntax and the inability to number crunch. Lest we forget, Erlang is declarative/functional and is a significant paradigm change for most programmers.
Re:Go 1.1 beta 1 Released by ternaryoperator on Thursday April 04, 2013 @03:43AM (#5491489)
The error messages are an additional rough spot.
Re:Go 1.1 beta 1 Released by coldtea on Thursday April 04, 2013 @05:57AM (#5491770)
>The language, libraries, and ecosystem are miles ahead of where they were back in 2009.

The libraries maybe (and the runtime). The language, as per semantics and syntax, is more or less the same.

>Why not use C? Because C has no sensible packaging system, is unsafe, requires manual memory management, and offers a degree of control that is unnecessary for most tasks.

But is absolutely essential for most tasks C is used. For all the others, why not use a higher level language like Python?

>Why not use Java? Because it is verbose and picky and basically forces you to use an IDE to get anything done, etc etc.

Some people are not "forced": they choose to use an IDE, and wouldn't have it any other way. It is like telling some Smalltalk guy: "Smalltalk forces you to use the smalltalk image editor/environment" -- so what? He is perfectly fine with it. Heck, lots of people even like using dynamic languages with an IDE (and more would, if there was better type inference and assistance).

>If there were nothing wrong with these languages (they're the main ones we use at Google) we wouldn't have developed Go.

Well, the main reasons for Go, as stated in the official pages (the Golang FAQ), are not very convincing or exciting: No header files, faster compilation, parallelism, garbage collection, lighter type usage.

Re:Go 1.1 beta 1 Released by enneff on Thursday April 04, 2013 @06:39AM (#5491876)
>But is absolutely essential for most tasks C is used. For all the others, why not use a higher level language like Python?

What C programs are you thinking of? Thinking of significant C programs that I have used (bash, apache, gcc, and many more), I can only think of a few that wouldn't be easier to write and maintain were they written in Go, without suffering a meaningful performance penalty. Funnily enough, a lot of the uptake of Go has been from former users of Python, Ruby, and other dynamic languages; they attracted to Go's simplicity, safety, and speed.

But really there's a lot more to Go the faulty dichotomy of "dynamic vs static" (or Python vs C, whatever). This is worh reading: http://talks.golang.org/2012/splash.article

>lots of people even like using dynamic languages with an IDE

Agreed, and I have nothing against IDEs. I have just found that I can't comfortably write Java code by hand. There's way too much boilerplate. In my experience an IDE is essential writing Java code efficiently, and I don't think that's a good thing.

>not very convincing or exciting

Depends on your definition of exciting. Since I've been writing Go code I've been more excited about programming than ever before.

Re:Go 1.1 beta 1 Released by quatrevingts on Thursday April 04, 2013 @11:18AM (#5493135)
You'd really be OK with gcc being 2-3x slower?

As much as I love high-level programming, many of the most interesting and important problems are ones where a "small" constant factor is the difference between great and mediocre.

Re:Go 1.1 beta 1 Released by enneff on Thursday April 04, 2013 @03:29PM (#5494724)
I don't think it would be 2-3x slower.
Re:Go 1.1 beta 1 Released by coldtea on Thursday April 04, 2013 @05:44PM (#5495503)
Why thought? By all we know, it would be.

On most algorithmic benchmarks Go is 2-3 or more times slower than C/C++.

And parsing something like a large C++ codebase with a GC language like Go would result in tons of memory used (and slowness).

Heck, even Go compiling Go programs gets OOM'ed sometimes in Linux.

Re:Go 1.1 beta 1 Released by dvt on Thursday April 04, 2013 @02:39AM (#5491333)
To be fair, I haven't used it since 2011 and I'm sure a lot has changed. I've read plenty of valid criticisms however which (after having used it for several projects) deterred me from using it again.

For a project a couple of years ago, I needed to use OpenCV and the Go bindings were quite immature. I just switched to C++ (for that project) and never really returned.

But now that I think about it, whenever people that are interested in being introduced to coding (it happens a lot on campus) ask me "what language should I learn?" I've never answered Go. I'm not sure if most people would.

Re:Go 1.1 beta 1 Released by NateDad on Thursday April 04, 2013 @07:34AM (#5492037)
While I don't think it's really a harsh criticism to say that Go shouldn't be your first language... I'd be interested to know what you think a good first language would be.

Certainly not C or C++, if you're discounting Go. I'd also discount Java and C#, since they're syntactically quite similar to Go. Certainly not erlang.

So... python? ruby? While I like those languages, I feel that the lack of a compiler is a pretty big hindrance to new programmers. Statically typed languages can catch many errors that produce some truly strange error messages in dynamic languages.

Re:Go 1.1 beta 1 Released by vladev on Thursday April 04, 2013 @02:45AM (#5491347)
Honestly, I mostly share(d) your opinion, but am starting to see Go in a different light. The problem is that the community pitches it against C/C++, where Go, with its GC, just doesn't fit well, and Java, whose runtime and libraries is still miles ahead (fast GC, for one).

However, Go seems to be very good at what Python/Ruby/Node.js/Perl are good at. It provides a simple, clean language with more guarantees and better runtime (mainly the cheap goroutines). I see Go taking some of their role for web development, simple tools (Go programs produce a single binary - very easy to distribute).

Re:Go 1.1 beta 1 Released by dvt on Thursday April 04, 2013 @02:59AM (#5491379)
I think you may be right, and I completely understand the problematic benchmarks that always crop up. I don't pretend I'm smarter than the people at Google (because I'm not), but some questionable decisions were made (there's plenty of literature out there written by reputable people) -- and I think that's why Go hasn't seen more of the lime light.

Apart from Google (who uses it for Youtube), Go hasn't really been used in large projects. Maybe 1.1 will change that. I might give it another shot, too!

Re:Go 1.1 beta 1 Released by mseepgood on Thursday April 04, 2013 @03:19AM (#5491425)
> Apart from Google (who uses it for Youtube), Go hasn't really been used in large projects.

I don't know how large each of these projects is, but a growing number of companies are using it for serious projects:

Iron.io: How We Went from 30 Servers to 2 with Go http://blog.iron.io/2013/03/how-we-went-from-30-servers-to-2...

Behind the Scenes: Big Data at Torbit http://torbit.com/blog/2013/02/19/big-data-at-torbit/

pool.ntp.org DNS server in Go http://news.ntppool.org/2012/10/new-dns-server.html

Juju at Canonical http://www.reddit.com/r/programming/comments/18atce/juju_can...

Go at bitly http://word.bitly.com/post/29550171827/go-go-gadget

CloudFlare blows hole in laws of Web physics with Go and Railgun http://arstechnica.com/information-technology/2013/02/cloudf...

dl.google.com now served by Go https://groups.google.com/forum/?fromgroups=#!topic/golang-n...

Go At Conformal https://www.cyphertite.com/blog.php?/archives/7-Go-at-Confor...

Go at Novartis https://plus.google.com/114945221884326152379/posts/d1SVaqkR...

Go at the BBC http://www.quora.com/Go-programming-language/Is-Google-Go-re...

Go at SoundCloud http://backstage.soundcloud.com/2012/07/go-at-soundcloud/

Go at CloudFlare http://blog.cloudflare.com/go-at-cloudflare

Go at Heroku http://blog.golang.org/2011/04/go-at-heroku.html

Building StatHat with Go http://blog.golang.org/2011/12/building-stathat-with-go.html

Re:Go 1.1 beta 1 Released by VeejayRampay on Thursday April 04, 2013 @03:31AM (#5491462)
Has a claim as coarse-grained as "There's no real reason to not write something in C" ever made any sense past the immediate attention-bait value? I mean, different languages have different use cases and you can't pretend to make a case for a language on your own perception of it, let's be serious a second.
Re:Go 1.1 beta 1 Released by afhof on Thursday April 04, 2013 @02:28AM (#5491286)
I suspect that the kind of scaling Go was intended for was programming scale. A lot of the design of the language seems specific for large scale projects (statically compiling everything, not having unused variables, explicitly naming all imports, fast compiler, test and benchmarking as builtins, code changing via go fix).

These are problems I have seen with larger java projects with unused imports, unused variables, library dependencies, long compile times, etc. I think that Go's niche is for extremely large projects, but it remains to be seen if it will work.

Re:Go 1.1 beta 1 Released by enneff on Thursday April 04, 2013 @02:35AM (#5491320)
> I suspect that the kind of scaling Go was intended for was programming scale.

Your suspicions are well-founded! http://talks.golang.org/2012/splash.article

Re:Go 1.1 beta 1 Released by mseepgood on Thursday April 04, 2013 @03:23AM (#5491436)
> Go is very D-like.

I think it's very D-unlike. It's very small and simple.

Re:Go 1.1 beta 1 Released by pkolaczk on Thursday April 04, 2013 @04:55AM (#5491646)
I agree Go and D really can't find its niche. They both are very interesting languages, but is there any really impressive application where those languages would rock? Something that when asked for, the only obvious answer would be "use Go"? Being a better C or a better C++ is IMHO not enough.

Want high performance and full control? Use C (or C++). Want your code to be easy to maintain by an average Joe? Use Java or C#. Want your code to be concise? Use Clojure. Want extreme typesafety? Use Haskell. Need to use both OOP and FP? Use Scala. What question to ask so the obvious answer would be "Use Go?"

Re:Go 1.1 beta 1 Released by polshaw on Thursday April 04, 2013 @08:32AM (#5492208)
>What question to ask so the obvious answer would be "Use Go?"

I basically see it as a midpoint between C and python, that offers most advantages of both.

From C: Low memory use, fast execution, type safety/ compiled.

From python: Easy/fast to learn/read/write, no slow compile, GC, memory safety, good standard libraries

It also does concurrency better than python (/anything else?). What would you say better fits these criteria? Certainly not the JVM languages (memory) or Haskell (accessibility).

Re:Go 1.1 beta 1 Released by dons on Thursday April 04, 2013 @09:16AM (#5492397)
Go is a low level language compared to Haskell though. It's like walking back to 1982.
Re:Go 1.1 beta 1 Released by ansible on Friday April 05, 2013 @09:09AM (#5498143)
Go is a low level language compared to Haskell though. It's like walking back to 1982.

I was immediately dismissive of Go when I first heard of it a few years ago. I only started looking at it again a couple months ago when I ran across the 'splash' article. [1] The attention to detail with regards to the language, the standard library and the tooling really impressed me.

Yes, in many ways Go is low level. It doesn't break much new ground from a programming language design perspective. It doesn't provide a lot of features, but what it does have is well integrated. At every turn, language features were added or left out based on the larger software engineering perspective, rather than what can produce the most succinct or elegant code.

[1] http://talks.golang.org/2012/splash.article

Re:Go 1.1 beta 1 Released by redbad on Thursday April 04, 2013 @09:55AM (#5492637)

    What question to ask so the obvious answer would 
    be "Use Go?"
Writing services in a SOA tech stack.
Re:Go 1.1 beta 1 Released by pjmlp on Thursday April 04, 2013 @07:36AM (#5492045)
Go is C programming for the average Joe.
Re:Go 1.1 beta 1 Released by polshaw on Thursday April 04, 2013 @08:41AM (#5492235)
I kind of agree with you (being an 'average Joe'?), but surely Go offers some advantages over C even for a C programmer; faster to write and compile, more readable code, concurrency, memory safety.
Re:Go 1.1 beta 1 Released by pjmlp on Thursday April 04, 2013 @08:54AM (#5492290)
Except those advantages were already possible back in 1978 with Modula-2, nothing new.
Re:Go 1.1 beta 1 Released by bishop_mandible on Thursday April 04, 2013 @11:58AM (#5493363)
If it helps bringing these advantages to modern day programmers then I'm all for it. A lot has been lost during the 90's with the rise of C++ and Java.
Re:Go 1.1 beta 1 Released by pjmlp on Thursday April 04, 2013 @12:05PM (#5493402)
I agree, but I see Rust, D or even C# better suited for that purpose as Go, since it throws too much away.
Re:Go 1.1 beta 1 Released by RickHull on Thursday April 04, 2013 @10:41AM (#5492924)
What's the Modula-2 equivalent of the goroutine concurrency primitive?
Re:Go 1.1 beta 1 Released by pjmlp on Thursday April 04, 2013 @12:03PM (#5493390)
Co-routines, Modula-2 was one of the first languages to have native support for such constructs.

The only things that Go has over Modula-2 are interfaces, single declaration modules and GC.

Single declaration modules and GC were part of Modula-2 successor, Oberon in 1986, while Active Oberon in 2001 added Tasks and Interfaces to the Oberon language family.

All of these languages were used to built operating systems used for real work at Zurich's Technical University.

Re:Go 1.1 beta 1 Released by jksmith on Thursday April 04, 2013 @05:35PM (#5495447)
Yep, I miss me some M2. That's the most satisfying programming I've experienced so far.
Re:Go 1.1 beta 1 Released by kyrias on Thursday April 04, 2013 @05:31AM (#5491719)
"easy to maintain by an average Joe" and "Java" don't belong together
Re:Go 1.1 beta 1 Released by coldtea on Thursday April 04, 2013 @06:12AM (#5491803)
Seen any other language used and maintained by more average Joes?

Because that's exactly one of the niches of Java -- enterprise programming by average Joes. It was even a stated design goal of the language back in the day.

Re:Go 1.1 beta 1 Released by trailfox on Thursday April 04, 2013 @05:48AM (#5491753)
Lack of exception handling is the biggest reason I haven't used Go for much. The other reasons are that it's just so plain/boring (yes, I know that's subjective), nothing about the syntax is interesting. Learning go is like eating cardboard. The other issues are that IDE support is very primitive and that Java and Scala are both faster and better supported in terms of tooling. Go seems rather nice, just very boring and not very compelling vs. many other tools.
Re:Go 1.1 beta 1 Released by NateDad on Thursday April 04, 2013 @07:16AM (#5491969)
I thought lack of exceptions was a deal killer for me, until I started using Go... and then I realized how much better multiple returns is. You never have to worry about your code suddenly exiting out of the middle of a function if you don't want it to. If something returns an error... it's just a value returned. Hi error! How's it going?

In languages with exceptions, potentially any function call you make could throw, and you don't know, because it could be 6 levels deep in the call stack. (Even Java's checked exceptions don't help, since someone down the line inevitably just rights "throws exception" and the screws everyone up the stack).

Go is really fast to pick up, it's pleasant to write code in, and yes... it's boring. I think that's it's biggest feature. It gets out of your way so you can produce a product. Why does the language need to be interesting? Isn't it more important that it can build interesting things quickly and reliably? Go does that.

Re:Go 1.1 beta 1 Released by trailfox on Thursday April 04, 2013 @07:25AM (#5492007)
It seems silly to have to check the error return code with an if for every method I call. Surely a try { } catch around a block makes more sense than littering my code with if (errorHappened) in every second line.
Re:Go 1.1 beta 1 Released by NateDad on Thursday April 04, 2013 @08:30AM (#5492198)
How do you know what failed, then? A try/catch around the entire function simply tells you "something failed". Often times that is not good enough in a real program. You can't handle the error, since you don't know what function call it came from, so you're probably just logging it and swallowing it.

It also means that you don't know how much of your code executed. Have you written that file to disk yet? Maybe you need to clean it up now? Is that socket still open? or maybe you didn't get that far in the code?

In code that cares about handling errors, you end up with a lot of try/catches around individual functions that you know can throw... this is no different than go's if err != nil code.

  try {
    v = ThisCanThrow()
  } catch (Exception ex) {
    // handle this specific failure
  }

  v, err := ThisCanError()
  if err != nil {
    // handle this specific failure
  }
Because Go forces you to handle the error at the site where it is produced, error handling ends up being much more robust and specific. You can't just "let 'em fly" and make someone else deal with random exceptions up the stack. This almost always produces better code in the end.

Believe me, I understand where you're coming from. I've been using exceptions for 13 years in production code. I initially skipped Go pretty much solely because of the lack of exceptions. But I am really glad I gave it a second chance, because, damn, it is good.

Re:Go 1.1 beta 1 Released by drbawb on Thursday April 04, 2013 @09:37AM (#5492529)
This is a fairly minor point: but I also like how idiomatic error handling in Go only indents the block that handles the problem.

Because of multiple returns, the normal flow of execution isn't indented. I find that this makes it easier to skim Go code in practice.

Re:Go 1.1 beta 1 Released by trailfox on Thursday April 04, 2013 @09:04AM (#5492333)
Thanks for the explanation. In most cases cleanup is handled in finally blocks and the unit of work fails if any of N calls fails, in most case it makes no difference which one failed. Where the difference does matter it's probably in a different method etc.

Your explanation does seem to make the case for this type of error seem somewhat sensible, maybe I'll give Go another try. Are methods which return errors and the types of errors returned clearly documented/visible?

Re:Go 1.1 beta 1 Released by carbocation on Thursday April 04, 2013 @09:36AM (#5492525)
Methods' declarations indicate which ones return an error value. E.g.:

    func Demo (s string) (string, error){...}
When called, that is guaranteed to return a string and an error value (OR nil).
Re:Go 1.1 beta 1 Released by redbad on Thursday April 04, 2013 @09:53AM (#5492625)
It seems silly, but it's simple, powerful, and removes a large class of ambiguity from your programs.
Re:Go 1.1 beta 1 Released by EdiX on Thursday April 04, 2013 @06:32AM (#5491857)
> Lack of exception handling is the biggest reason I haven't used Go for much.

Go does exception handling with panic, recover and its reflection syntax.

Re:Go 1.1 beta 1 Released by NateDad on Thursday April 04, 2013 @08:32AM (#5492207)
Using panic and recover is strongly discouraged, and in the rare cases where it makes the code significantly simpler, panics should never cross package boundaries (which is to say, you should never have a public API that can panic, unless you fully expect the panic to take down the process).
Re:Go 1.1 beta 1 Released by EdiX on Thursday April 04, 2013 @11:12AM (#5493103)
Using panics for control flow or having panics cross library boundaries is strongly discouraged, otherwise they are fine. Go's own standard library uses them internally in several places.

Even then discouraging panics is very different from not having them.

Re:Go 1.1 beta 1 Released by trailfox on Thursday April 04, 2013 @06:45AM (#5491887)
So if I'm reading from a file I should use panic recover and not return code checking?? That's not what I've seen in the docs.
Re:Go 1.1 beta 1 Released by jlgreco on Friday April 05, 2013 @12:02AM (#5496714)
You seem to be missing the difference between "can you do it" and "should you do it". The reason that you should not is because doing so is not idiomatic Go. You are completely able to do so though.
Re:Go 1.1 beta 1 Released by obilgic on Thursday April 04, 2013 @02:35AM (#5491319)
Of course it has it's niche. It is fun, organized and simple to write like ruby, but It is a statically typed, compiled language. There you go.
Re:Go 1.1 beta 1 Released by smegel on Thursday April 04, 2013 @04:07AM (#5491538)
Of all the languages you compared to Go, only 1 has native green threads: erlang. So why didnt google just use erlang? Well Go solves lots of problems that erlang doesnt, and maybe they also didn't want an interpreted functional language with no variables.
Re:Go 1.1 beta 1 Released by drivebyacct2 on Thursday April 04, 2013 @03:27AM (#5491446)
I can't really agree with a single word of this and I've been writing Go weekly for 8 months.