Learn X in Y minutes where X = Go

by realrocker • 13 years ago

199 88 13 years ago

pjungwir• 13 years ago

Wow, I'm not really interested in learning Go, but I was drawn in and made it all the way to learnInterfaces. Congrats!

One question: why have named return values (in learnMemory) if you return something different? If you didn't have a return statement at all, would the function return the final value of p and q?

jdiez17• 13 years ago

why have named return values (in learnMemory) if you return something different?

Probably to avoid declaring the function as `func learnMemory() (int, int)`.

If you didn't have a return statement at all, would the function return the final value of p and q?

No, you have to do that explicitly. You can do `return`, though, which will return the variables whose names match the definition.

arnehormann• 13 years ago

To describe what you are returning. An int tells you a lot less than status404s int.

stock_toaster• 13 years ago

  > One question: why have named return values (in learnMemory) if you return something different? If you didn't have a return statement at all, would the function return the final value of p and q?

Kinda. You still have a return statement, but you may omit the arguments. See: http://golang.org/doc/effective_go.html#named-results

pothibo2• 13 years ago

Because the variable are already declared and ready to be used. Difference can be seen here → http://play.golang.org/p/IVPiw_2Uph

thenonameguy• 13 years ago

My hungarian translation of it: http://learnxinyminutes.com/docs/hu-hu/go/

NKCSS3• 13 years ago

I think one of the string format examples missing the type formatter:

fmt.Println("it's a", i)

Should be something like:

fmt.Println("it's a %T", i)

See http://golang.org/pkg/fmt/ for more options.

[update]

Forgot they allowed to send pull requests; done :)

ivanvanderbyl• 13 years ago

I just tried it, both seem correct as fmt.PrintLn takes multiple inputs

enneff4• 13 years ago

Println does not take format strings. You're thinking of Printf.

NKCSS3• 13 years ago

Yup, forgot to edit that :-/

JulianMorrison• 13 years ago

Are you mixing up Println and Printf?

mseepgood4• 13 years ago

No, it's correct. It's meant to print "it's a 84".

NKCSS3• 13 years ago

Would't you expect either "it's 84" or "it's a(n) int|decimal|other_type"?

I figured they ment to do the latter, since the next print function outputs: "it's a string".

cthackers• 13 years ago

That should be Printf. With Println you get "it's a %T 43". With Printf you get "it's a int"

kunil• 13 years ago

    // If statements require brace brackets, and do not require parens.

Even if it is single line?

nanofortnight• 13 years ago

Yes

kilburn• 13 years ago

Yes, but you shouldn't ever see single-line ifs in go, because gofmt forces all of them to be multi-line.

This is one of the strong points of go (whether you like it or hate it): gofmt imposes the same formatting rules for everyone using the language. It's not a choice for you (or your project) to make. Period.

omaranto2• 13 years ago

It's easy enough to never run gofmt, so there is still a choice. :) In fact, not running gofmt requires less effort than running it.

coldtea• 13 years ago

Yes. After all that's the best style in C and other brace languages too.

This way you can't go wrong adding another statement inside the if.

enneff4• 13 years ago

I really love this format. Such a nice document.

buro92• 13 years ago

This is the way I like to learn a language.

Instantly, and progressively, by starting at the top and working through a single document that is both a reference and a guide.

Beautiful work.

Edit: One change I would make is to change p := pair{3, 4} into p := pair{x: 3, y: 4} which helps your declarations keep working in the future when you extend or modify the definition of `pair`.

mseebach4• 13 years ago

when you extend or modify the definition of `pair`.

Well, pair is an anti-pattern anyway, but what exactly would you add to "Pair"? "File not found"? :)

http://thedailywtf.com/Articles/What_Is_Truth_0x3f_.aspx

buro92• 13 years ago

Too true.

Perhaps a var named "brillant"

acuozzo2• 13 years ago

Well, pair is an anti-pattern anyway

So cons is an "anti-pattern" as well, then?

Your comment is the most original dis of Lisp I've ever read. Bravo!

arms• 13 years ago

Agreed. Diving in to examples is the best way to learn. I'm usually wary of these "Learn X in Y minutes" posts, but this one is great - maybe due to Go's succinctness?

dan004• 13 years ago

Is the documentation of go regarding the 'map' data type and the usage of the function 'make' out of date?

Because I can't see any difference in:

    package main
    
    import (
        "fmt"
    )
    
    func main() {
       m1 := map[string]int{}
       m1["a"] = 1
       fmt.Printf("%d\n", m1["a"])
    
       m2 := make(map[string]int)
       m2["b"] = 2
       fmt.Printf("%d\n", m2["b"])
    }

pothibo2• 13 years ago

I think the 2 are generally equals. make is used when you want to initialize a map, slice, channel with a given size.

http://golang.org/ref/spec#Making_slices_maps_and_channels

dan004• 13 years ago

Thanks, that makes sense. So the 'make' function is more about the reserving of memory.

mseepgood4• 13 years ago

Both are equivalent and none is out of date. The first is just the short-hand literal syntax. Same with &Foo{} and new(Foo).

jerf3• 13 years ago

Compare with:

    func main() {
        var m1 map[string]int
        m1["a"] = 1
        fmt.Printf("%d\n", m1["a"])
    }

http://play.golang.org/p/JJQ7dSZLeA

which yields

    panic: runtime error: assignment to entry in nil map

dan004• 13 years ago

Well, but this again works:

    type pair struct {
        x, y int
    }
    
    func main() {
       var p pair
       fmt.Printf("%d\n", p.x)
       fmt.Printf("%d\n", p.y)
    }

That's just wrong, that declaration and initialization behaves differently depending on the type.

zenocon• 13 years ago

Just out of curiosity, I ran format in play.golang.org, and it creates tabs with 8 spaces -- really? Is that what the command "go format" will do, too? Is standard go formatting tabs with 8 spaces?

cliveowen4• 13 years ago

I'm tired of reading that this or that language/framework is "easy-to-understand" and "fun" to use. That's a subjective statement and mostly not true. Writing code is a means to an end, you want the output of a program not a bunch of lines, so I don't see how it could be fun (which is repeated over and over again in the official documentation and various slides and talks). And the concept of easy-to-understand is determined by the level of experience of an individual plus a whole lot of factors that are beyond us, not least of which is the sheer brain power.

enneff4• 13 years ago

What we mean: All of us on the team have a lot of fun writing Go. We often show each other little pieces of code that delight us. This seems to happen more when we work in Go than in the other languages we use (or have used), and so we attribute the fun-ness to Go. Pretty straightforward. I'm sorry you're so tired of it.

cliveowen4• 13 years ago

Wow, I didn't expect to get a response from an actual Googler, working on Go no less. Anyhow, I also remember when people were saying that Java was a fun language to work with, but I still have to find a single engineer who doesn't think of it as slightly more than a pain in the ass. It's all a matter of right-sizing expectations; using and objective language keeps you from being called out should those expectations fail to be matched.

That said, I've already professed my love for the Go language, which I consider the spiritual successor of the C programming language.

sbarlster• 13 years ago

time for a new job?

RogerL• 13 years ago

I've come across many people that program as a means to an end. They don't enjoy it, it is just what they need to do to get the machine do what is fun, which is folding proteins, modeling ocean currents, driving the CNC, or what have you. For me, the actual application is fairly incidental to the programming and design part, which is where the fun is for me.

ovi256• 13 years ago

Thanks! Inspired by you, just wrote the Romanian translation for Python. Maybe I'll do Go next :)

Seriously thinking about writing the Django equivalent of Michael Hartl's tutorial for Rails. Intimidating as it's a lot of work, over 100k words. Any people would like this? I really could not find a Django/Python equivalent.

jamesjporter• 13 years ago

That would be awesome, I've found the existing Django tutorial rather wanting.

defly• 13 years ago

Need for Clojure.

Posibyte• 13 years ago

I believe they have one: http://learnxinyminutes.com/docs/clojure/

NoodleIncident• 13 years ago

That was one of the first languages covered by this site.

cliveowen4• 13 years ago

This is very well useful and very well done, may I suggest to keep things consistent and actually use the syntax /* */ for multi-line comments?

EDIT: Also "// x == 1 here." should be "// x == 2 here.", those are 3 iterations.

mseepgood4• 13 years ago

I suggest to keep things consistent and actually use the syntax /* */ for multi-line comments

Idiomatic Go code almost never uses multi-line comments, see: http://golang.org/src/pkg/net/http/request.go

Also "// x == 1 here." should be "// x == 2 here."

No, it's correct. := declares a new variable. The newly declared, inner x shadows the outer x only within the block scope of the for loop:

http://play.golang.org/p/cP2dWyg0qw

cliveowen4• 13 years ago

Yeah, right, I didn't see the external variable. I might as well go ahead and delete the comment :P

reyan• 13 years ago

This is great. I suggest adding fallthrough statement in one of the switch cases.

gutsy4• 13 years ago

MULTIPLE return values?! My mind is BLOWN. That's awesome. My work is all in Java and there are so many times on my last project where that would have been helpful (I know I can do it by creating a map or an array or something, but that's stupid and extra code that I shouldn't need to write).

I really hope to be able to write Go professionally at some point, it is a really nice language to write in.

dllthomas4• 13 years ago

If that blows your mind, check out Haskell - you can dispatch on type of return value.

samatman• 13 years ago

This is the first one-liner I've read that actually explains something useful I can do with higher-order type inference. Preventing errors at compile time doesn't count; doing something is run-time by definition.

Thanks.

th0114nd• 13 years ago

Care to elaborate?

gutsy4• 13 years ago

Interesting, hadn't even considering looking at Haskell at all.

tibbon• 13 years ago

You can do multiple return values of mixed (and non-predetermined) types in Ruby too.

gutsy4• 13 years ago

I did not know that, but then I've only played around with Ruby a little bit.

jurre• 13 years ago

Meh, not really. In ruby `return x, y` is just syntactic sugar for `return [x, y]`, ie returning an array. It's also an indication that you probably need a class.

dbaupp• 13 years ago

Any language with tuples automatically gets "anonymous" multiple return values. (e.g. Python's `(1, "foo", None)`.)

(Go's multiple return values seem to just be simulating a single use case of proper tuples.)

gutsy4• 13 years ago

Well, all I've written since college has been Java, so this is all new to me. I've only briefly checked out Ruby and Python, and not enough to really know that much about either language.

lelf• 13 years ago

multiple-value-bind. Old as Lisp

chollida1• 13 years ago

This looks very similar to the "easter egg" that the F# team put into visual studio.

When you create a new F# project you can select F# Tutorial and it generates a working project with a source code file that is an introduction to the language and its features.

I wish more IDEs did this.

prezjordan• 13 years ago

It's killing me that no one has made an APL version yet!

munchor• 13 years ago

Really great way of learning the overall concepts of Go, but that code should have been gofmt'd!

mrcwinn• 13 years ago

Hm, would it not be where x := Go?

emehrkay• 13 years ago

Where exactly does the struct pair implement the Stringer interface? Is it when the String method was added to it? What if you have interfaces with similar names?

thisishugo• 13 years ago

Is it when the String method was added to it?

Yes, that is how you satisfy an interface in Go.

What if you have interfaces with similar names?

The problem of interfaces with similar names is actually no different than the problems of, for example, packages or functions having similar names. It's down to you to avoid naming things in a confusing manner.

ominous_prime• 13 years ago

There is no "implements" in go. A type either provides the methods to satisfy an interface, or it doesn't. The name of the interface doesn't matter, and it can satisfy an many interfaces as it wants.

antimatter• 13 years ago

Loved this. Can someone point to a relatively simple open source project written in Go that I can dig into to learn further?

cwills• 13 years ago

Does it bother anyone else that Go supports the GOTO statement? I would've thought GOTO an obvious construct to leave out when creating a new language, to protect programmers from themselves? (See Dijkstra on 'GOTO statement considered harmful')

Tloewald• 13 years ago

I thought the comment "x == 1 here" could use a little more explanation (I figured it out, though, so maybe not.) I also found the function signatures confusing, especially the function with a local variable q that is nothing to do with its returned value q -- seems like a bit of a wart in Go. (Being able to assign return values vs. using return, as in Pascal, seems like an obvious reason to declare return values this way. Perhaps this feature exists but is not explained.)

cldr• 13 years ago

It’s not the latest trend in computer science

Uh, I think it is. I can't go three articles without seeing Go mentioned.

I'm going to get downmodded to gray, but either this tutorial is missing something or Go is way over-hyped. I saw nothing special in the language at all, I have no idea what all the obsession is about lately.

gtani2• 13 years ago

I've been reading Chisnall's Phrasebook and Summerfield's Programming in Go books. Both are well done as far as descriptions of language features and standard lib go (covering 1.0), but are a little short on extended code examples.

And the usual amazon pricing: new $26, used $35.

Learn X in Y minutes where X = Go

Related Stories