13 ms·

Learn Go in five minutes

203 points by tate 6y ago

37ef_ced3 6y ago
Go can be understood as an improved C that keeps much of C's simplicity but adds small, powerful features like interfaces and channels and garbage collection Go fixes C's well-understood flaws (declaration resembling use, unintuitive operator precedence, unrestricted address math, silent casting, zero-terminated strings, etc.) Go puts essential C idioms directly into the language (pointer/length is formalized as slices, packages are part of the language instead of just being naming convention, etc.) Go is mature, stable, widely-used, well-supported, and well-understood. C++ is a clumsy mess, but C is quite elegant and Go is a continuation/modernization/enhancement of that If you like C, you will love Go
- Lariscus 6y ago
  I like C but strongly dislike Go. They share nothing other than having a small(ish) feature set.
  - BoorishBears 6y ago
    I agree. Go feels like it's aimed at creating applications that run at a level above where C traditionally runs while keeping the pared down feature set of C, and it just doesn't work well imo. I loved playing with Go, but eventually it feels like you're conditioning yourself to be ok with a lot of "bad" code. Tons of repetition, tons of boilerplate by other names. It's like the simplicity gets in the way of itself. - My take is, use Go for a bit, take the "less is more" mentality with you to a language more suited for real work. ps: I'm not saying you can't use Go for real work before someone flies at me. I'm just saying that Go's strength is the mentality people have when using it, as a language it's not particularly enabling, and that's by design if anything...
    - bak3y 6y ago
      Meanwhile the place I work writes all microservices in go and all of my team's (DevOps) tools are also written in go...
      - BoorishBears 6y ago
        I explicitly added the "ps" to avoid the situation where all the replies are fairly empty comment saying "Well we use it!" I get that you can use it for real work, I'm not saying you can't. I'm saying, even by design to some degree, it's not particularly enabling compared to other languages. That's meant to be a strength if anything, but I did not find the tradeoff of simplicity was able to overcome the additional effort it took to deal with what was missing There's an implicit ymmv here of course, because I'm not saying no one can find Go useful, I can see how in certain worlds with certain teams with certain priorities it'd all work out. It's just not for me.
        murukesh_s 6y ago
        I have used Go in production. I found it roughly takes 2-3x additional time it takes to develop the same functionality in Node.js (with typescript). But it runs faster. If you want to write code that is probably not going to be thrown away it may be wise to invest the additional time in Go. However can't recommend that for building experimental code/APIs etc which are time bound and may/can get replaced (or split into micro services) in future if it becomes massively successful..
        AlchemistCamp 6y ago
        And that's saying something give that neither Node nor TypeScript have ever had productivity as a main selling point! Imagine evaluating the time to market for an experimental back-end written in Rails, Laravel, Phoenix, etc vs Go! The difference is staggering.
        konart 6y ago
        >Rails, Laravel, Phoenix, etc vs Go! Comparing frameworks and a language, really?
    - Thaxll 6y ago
      The last couple of years are showing that Go delivers, it's pretty easy to find dozen of "real" software written in Go that are weidly used.
      - BoorishBears 6y ago
        Sometimes I don't know why I bother talking about Go. It's proponents are so quick to go defensive that no one is capable of reading any complaint in an even mildly charitable light. I mean I shouldn't literally have to say "I'm not saying you can't use Go for real work before someone flies at me." When talking about a language as widely used as Go right? Like that's common sense! And yet of course I'm getting replies that do exactly that because of how darn defensive people need to be about it.
        Thaxll 6y ago
        Maybe don't use things like " to a language more suited for real work."
        BoorishBears 6y ago
        There is a literal full paragraph dedicated to explaining it, maybe don't ignore the oodles of context I left to avoid exactly what you did. Saying other languages are more suited to real work doesn't mean Go isn't suited at all, it literally means other languages are more angled towards the "end product" or the "real meat and potatoes" of just making a thing work than Go. It's literally a strength of Go. Go doesn't want to include the kitchen sink or even confine you to having a kitchen at all and I respect that. But I'm saying that other languages that include more in the way of affordances can help one be more productive, and I believe combining a language that includes more, with the mindset of not abusing the buffet is a winning combination. Ymmv, I'm not an oracle, I just expect people to read things in a reasonably charitable way which usually works fine as long as they're not being defensive.
    - steve_adams_86 6y ago
      I agree about becoming okay with bad code. But I think if you understand and embrace that, there’s a place for it and it can be quite powerful and easy to use at times. It’s a trade off that makes sense sometimes. I think the problem appears when people treat Go like it doesn’t have any problems. All languages do. As I’ve mentioned recently though, I don’t think I’d ever want to use Go as a forever solution to a complex problem. I’m sure some people could do it and do a great job, but I’m not one of those people. I need the ability to abstract and ensure more safety, or I’ll never feel secure with what I’m building.
    - blablabla123 6y ago
      > I loved playing with Go, but eventually it feels like you're conditioning yourself to be ok with a lot of "bad" code. Tons of repetition, tons of boilerplate by other names. Not well or hastily written Go is easily like that. I can only guess why you point out the repetition but when you look at well written Go code like in the Go std library, there isn't much repetition happening and it looks rather elegant. At the same time it can be quite some effort to create such code and might take several iterations. Documentation-wise I like the official documentation, it gives a lot of pointers why Go is how it is. Also obviously it's not for every use-case. Where it works really well IMHO is where error handling is a vital part of the application. (And of course anything concurrent is quite a breeze)
      - BoorishBears 6y ago
        Not having generics, by definition, invites a lot of repetition and boiler plate. I know generics are overrated and coming soon, but right off the bat that stuck out. I recall a point where I had written a function that needed to return a channel, but of course had to forgo types due to the lack of generics. The end result was having to wrap that channel in another channel that added typing at each call site. I asked around in go circles if that made sense, and called out how bad the felt but the answer was "no that's great! channels are cheap! the repetition is good because it's simple!" - The error handling has some sore points to that end too, and the implicit shadowing with shorthand assignments on one hand makes it easier to deal with multiple errors, but on the other hand introduced subtle logic bugs on one than more occasion where "err" was silently shadowed, which I greatly disliked. I'm actually suprised Go didn't forgo shadowing for the shorthand operator and force people to label their errors when dealing with multiple, it seems very "in brand", but I guess even Go draws the line somewhere lol - Then there's the whole stack trace situation. Which after plenty of reading still just wasn't making sense. I mean the idea of logging a stack of wrapped messages sounds very nice, but man proper stack traces not being the first class citizen of error handling just did not make sense to me in a language I hear referenced for systems work so much (and I realize they can be had) I saw proposals to rework Go's error handling, I don't know if any progress has been made to that end, but it's another example where simplicity can get in the way of itself - And I'll balance this all out by saying it was still fun to write, I don't want to seem like I'm just shitting on Go for existing. It's just these little warts that I kept getting over with just a little bit of "idiomatic Go" which I often found was just writing a little bit more code than you're used to, started to add up. And eventually I realized I was creating something that, while very easy to reason about, had a lot more to reason about than it needed to. That's where I kind of petered out in my personal usage.
    - skrtskrt 6y ago
      I will take sometimes-tedious boilerplate over many-many-layered abstractions. You can write any language any which way, but some languages just have a culture of boilerplate vs abstractions. The most popular Python and Java libraries seem to love endless layers of indirection, and when it doesn't fit exactly what you need, you bang your head against the wall monkeypatching it to make it work since your whole app is already written in X mega library. Go culture seems to be quite a bit more boilerplate-y and uses smaller more composable libraries. It's just refreshing. Really I just need to buckle down on Rust, but I think it's a fair bet that teams and shops that bring in a lot of young programmers and want to ramp them up fast may cringe a bit at the learning curve of Rust. That's why for now in terms of a bet on employability, I am prioritizing experience with Go.
  - 37ef_ced3 6y ago
    Take Go's slices, for example Realize a Go []int ("slice of int") is just a C struct like this, passed by value: struct intSlice { int* addr; int len; int cap; }; The memory at addr is not owned by the slice. All the slice operations are simply notation for manipulating the struct. Go's garbage collection makes the whole thing work well This can be confusing if you're used to C++'s std::vector (which owns the memory) or Python's slices. Go's slices are a shallow pointer/length system exactly like is used in C all the time. For example: void sort(int* addr, int len); becomes func sort(a []int) A Go slice is just a formalization of C's pointer/length idiom, with terse notation for manipulation
    - traes 6y ago
      I'm not really sure saying that features in Go can be modeled in C really suggests that they are similar as languages. Syntax is very important.
    - nyanpasu64 6y ago
      Go's slices don't act like what I thought were called "non-owning references"(Rust's &/&mut [T] or C++'s std::span<T/T const>), which reference memory whose lifetime is bounded by something else (like a vector or array or shared pointer). Instead it's "shared ownership" where memory is referenced by one or more slices (and no single owner) which can reference and mutate the slice simultaneously, and it's freed by the GC sometime after all the slices are gone. This reminds me of Numpy's ndarrays, which act more like "owning containers" (which may sometimes share ownership and alias) than "non-owning references".
      - erik_seaberg 6y ago
        Slices are kind of a mess. They should either be uniqueness types or passed by reference (the way maps and channels are, and NIO buffers from Java). Instead they’re passed by value so multiple copies exist whose sizes and sometimes contents aren’t in sync.
    - mhh__ 6y ago
      Slices should be the absolute bare minimum for a modern systems language, it's not really a reason to switch in my case If I want to write flat/simple code I'll just C, Go doesn't really offer anything to me because I want to be relatively low-level and able to make the compiler save my time.
- alpaca128 6y ago
  I'm not a C fan but isn't Zig much closer to C's philosophy while fixing bad parts than Go? Especially due to the garbage collection, at which point Go suddenly competes with many more simple languages.
  - jerf 6y ago
    It depends on your definition of "C's philosophy", no sarcasm, and no implied preference by me for any particular definition, as I believe many have merit. Language philosophies evolve, and C, being so many decades old, has evolved a lot. The original philosophy is probably little more than a seed crystal at this point for the several philosophies that have been loaded on to it over the years. It is probably reasonable to say that Zig is closer to C's current philosophy in practice, which encompasses many additional developments over the decades to deal with various aspects of C and programming real machines that have arisen as both have changes, and Go closer to C's original philosophy of simplicity and relative ease of use. (In modern times, C is not one of the easier languages to use any more, due to significant advancements in the field of making easy-to-use languages. But it was originally intended to be an advancement there itself.) By similar logic, I can say with a straight face that all of Go, C++, Zig, Rust, and Swift (and more) are "evolutions in general-purpose programming languages like C", despite their wild differences, because the world has gotten larger, and there is room for a lot of variations like that, each addressing different aspects of the newer, larger world.
- Jnr 6y ago
  If I would have to replace C with anything, I would choose Rust and not Go.
  - simias 6y ago
    To me Rust is more like "C++ done right". It's massively bigger, more complicated and slower to compile than C. The C ABI is also the de-facto lingua franca for language interop, something that's not easily achievable with Rust or C++ (or Go, for that matter).
    - Jnr 6y ago
      Have you tried Rust? The ABI in Rust is doable: https://people.gnome.org/~federico/blog/rust-stable-abi.html https://people.gnome.org/~federico/blog/rust-stable-abi.html And it doesn't feel like C++ when writing it. The syntax and language features are nice and feel modern. It does require more attention because of what it compiles down to, but the compiler is there to help with it. I haven't been excited about any programming languages in years, but Rust has certainly taken my attention lately.
      - simias 6y ago
        I love Rust so dearly that I wish I could marry it, but I still feel that it's a massively more complicated language than C.
- deleted 6y ago
  [deleted]
- cute_boi 6y ago
  I like C but I would prefer Rust over Go. Go may be simple but I really hate using conventions like init(), comments working like syntax, captial letter means published etc.
  - steve_adams_86 6y ago
    Do Go comments work like syntax? Do you mean that they need to be formatted a certain way like they’re language syntax?
    - grey-area 6y ago
      The Go authors have (ab)used comments to extend the language in experimental ways for code generation, build pragmas and recently file embedding. They’ve done this to avoid breaking the language stability guarantee, not sure if there were other reasons. I think it’s a mistake personally to create this sort of metalanguage in comments (now you have two problems!) but it’s easy to avoid using this most of the time as the uses are pretty esoteric.
      - skrtskrt 6y ago
        File embedding is a common enough use case (HTML templates, config files) that it really makes me cringe that it's being done with comments.
        grey-area 6y ago
        I just keep my templates and config in separate files. There are good reasons to keep them separate anyway (allows config without recompile for example) and for the apps I work on distribution isn’t a problem. So I haven’t really had to use comments as code in 7-8 years of go. Perhaps it’ll become more common with the embed stuff. But then I don’t use struct tags either so I guess I’d prefer Go to be even simpler.
    - _ph_ 6y ago
      No, Go comments are just comments. They have been used though to add meta-information to special tools. So unless you use those tools and require to add the specific meta-information, you can treat comments as plain comments. Hiding certain meta-information, like exporting a function with a C-compatible signature when building a shared library is not a great way of doing things, but on the other side, it is a special usage which isn't part of the language itself, so not part of its syntax.
- simias 6y ago
  My main small day-to-day usability gripes with C are lack of type inference, lack of destructors and terrible ergonomics for error handling. Go solves two out of three, but it really dropped the ball hard on error handling which is very disappointing IMO. Things like generics and garbage collection involve some deep tradeoffs, so I get Go's take on them, even if I don't necessarily agree with it. On the other hand IMHO Go's crappy error handling boilerplate is not something I find acceptable in a modern programming language.
  - enw 6y ago
    How would you design the error handling? Personally I'm glad Go has stayed out of exceptions (panics don't count), at scale it's so much easier to reason about flow.
    - bmn__ 6y ago
      Monadic error handling like in ML work-alikes, Rust etc. would be a good start. Adopt: • https://github.com/rebeccaskinner/gofpher https://github.com/rebeccaskinner/gofpher • https://speakerdeck.com/rebeccaskinner/monadic-error-handling-in-go https://speakerdeck.com/rebeccaskinner/monadic-error-handlin... I've been talking to the local Go user group. No one even knows about that concept. This continues a pattern of general ignorance/lack of looking beyond one's horizon I've noticed.
  - steve_adams_86 6y ago
    The error handling feels deeply wrong to me too. I love the explicitness and how hard it is to ignore errors - all languages should make it so easy to expect and handle potential errors - but other features (or lack thereof) of the language make it so you can’t handle any of it in concise or sane ways. Code is plastered with the same boilerplate, everywhere, always. It makes up a significant mount of all Go code.
  - autarch 6y ago
    I agree that the error handling is terrible, but I'm not sure how much better it could be without generics. For me, the gold standard in error handling is Rust, where the type system simply does not allow you to ignore errors. This means that the existence of error handling is checked at compile time. Of course, this doesn't mean your error handling is _good_, but I think that's beyond any language design to enforce. But the Rust system is entirely built around a generic Result type, where both the non-error result (an int, string, struct, etc.) _and_ the error type itself are both generic.
- xscott 6y ago
  > Go fixes C's well-understood flaws (declaration resembling use This seems to be a common belief, but since Go kept pointer syntax as prefix, you're still stuck needing parens in some unfortunate cases: https://blog.golang.org/declaration-syntax https://blog.golang.org/declaration-syntax (see the part about pointers near the bottom) As Rob Pike writes in that link, they could've fixed it and still had declaration resembling use if they had chosen a suffix operator for pointers. He notes that Pascal uses ^, but it seems like @ might be a better choice: int foo // an integer int foo@ // pointer to int int foo[10]@ // 10 pointers int foo@[10] // pointer to array int foo()[10]@ // function that returns an array of 10 pointers In my opinion, they almost fixed it and then punted. As such, it's just different, but not really better.
- burnthrow 6y ago
  I thought this sounded familiar https://news.ycombinator.com/item?id=25622389 https://news.ycombinator.com/item?id=25622389 https://news.ycombinator.com/item?id=25555457 https://news.ycombinator.com/item?id=25555457 https://news.ycombinator.com/item?id=25531118 https://news.ycombinator.com/item?id=25531118
  - booleandilemma 6y ago
    So the account was created 34 days ago and he's posted that same message 4 times already.
- dpryden 6y ago
  I'd like to chime in and say that I also like C but really dislike Go. C is simple, to what today is nearly an absurd degree, but it at least integrates well with an enormous ecosystem of existing tooling and libraries. Go, by contrast, feels the need to re-invent every possible wheel, often with a seemingly intentional effort to be different just because. C ABIs are rock solid on every platform. Any language or tooling in the world can load functions from a C library. By contrast, try calling Go from another language. You will quickly give up and use network protocols or subprocesses instead. The converse is true too: on major platforms, the C library defines the operating system more than the kernel does. (I mean, in a Unix sytem, the entire libc is documented in the man pages. Documentation for writing C is literally built into the operating system.) By contrast, Go decides to avoid the standard platform ways of calling every operating system function, and instead implements syscalls directly into the kernel, basically just because Go hates interoperating with anything that's not Go. C is a good language not because it is a good language, but because it is a good ecosystem. Unix and C are closely intertwined. (Even Win32 and C are pretty closely intertwined!) I could imagine a Go-based Plan9-like system -- if that existed, and had decades of engineering behind it, I could see the argument being made that Go's ecosystem compares to C's. But while Go may aspire to that, it isn't anywhere near there yet. And when you start comparing Go with other languages on the basis of language features, I think Go fails laughably more often than not. (I'll give you "C++ is a clumsy mess", though.) But compare Go with Rust, with C#, with Haskell -- for that matter, compare Go with Java and I think Go is a less powerful, less useful language to write real code in. If I want a lightweight, quick-and-dirty program, I'll use Python. If I want to write a reusable library that gets plugged into other software, I'd go with C (or at least write the interop layer in C). If I want a high-performance server, these days I would probably go with Rust. If I want a pragmatic, well-rounded language to write a large project in, I think C# would probably be my first choice. What space does that leave for Go? Outside of microservices (where I contend that Rust is a much better choice, and there are lots of other options), Go's niche seems to be command-line tools. I sort of understand that, because Go's static linking makes redistributing binaries relatively easy (although Go by no means has a monopoly on that). But in the space of command-line tools, Go's argument handling is frankly bizarre: it looks at decades of precedent about what users expect from argument syntax and behavior and decides to throw it all away and reinvent the wheel. I guess that means this comment (rant?) has ended up where it started: Go defies convention, basically "just because". By contrast, C defines convention. "If you like C, you will love Go"? Nope, not at all.
- kevbin 6y ago
  > If you like C, you will love Go That may be true. But if you love C you’re going to hate Go like you’ve never hated any thing ever before.
runjake 6y ago
Good stuff. There is another >5 minute tutorial here: https://learnxinyminutes.com/docs/go/ https://learnxinyminutes.com/docs/go/ This website has something similar for nearly every language: https://learnxinyminutes.com https://learnxinyminutes.com
- adriancooney 6y ago
  I love this website! I use it every time I find a new language to get a basic understanding of it. It's an incredibly valuable resource.
potta_coffee 6y ago
I think this is pretty good but I think you ought to commit a paragraph to pointers as well.
kissgyorgy 6y ago
Don't trust a tutorial which intend to tech you the basics of Go, but forget to include the most important idea: interfaces...
postalrat 6y ago
Where are channels?
ducktective 6y ago
Is this a response to that "learn rust in half an hour?" ;) https://fasterthanli.me/articles/a-half-hour-to-learn-rust https://fasterthanli.me/articles/a-half-hour-to-learn-rust
- goodoldneon 6y ago
  Someone make "Learn Haskell in 50 seconds"
  - jerf 6y ago
    [Ancient Aliens Guy Picture Here] FUNCTIONS I've gotten it down to about two seconds here....
    - ducktective 6y ago
      https://imgflip.com/i/4snpcr https://imgflip.com/i/4snpcr
- bla3 6y ago
  It says so in the first line of the article, so probably yes.
- st1x7 6y ago
  If only we had known that all of these Rust vs Go arguments could be resolved by learning both languages in 35 minutes.
bkovacev 6y ago
Is there something like this for Golang API development, that also incorporates best practices? Even a solid book recommendation would be helpful.
- cfors 6y ago
  The repository and structure is free here, but I highly recommend the actual course for API development, which is not free but very valuable. https://github.com/ardanlabs/service https://github.com/ardanlabs/service
cfors 6y ago
This is neat, and a testament to the simplicity of Go. I normally point people to this tutorial if they want to learn Go quickly, it is interactive (able to navigate straight to go playground) and very well done in my opinion. https://gobyexample.com/ https://gobyexample.com/
- mynameisash 6y ago
  > the simplicity of Go As someone who's not written any Go, I found fasterthanlime's critique of the language[0] damning enough that I likely won't ever touch the thing. Maybe he's cherry-picked examples, but his article was thorough and technical enough to convince me that the Go mantra of simplicity is just surface-level. [0] https://fasterthanli.me/articles/i-want-off-mr-golangs-wild-ride https://fasterthanli.me/articles/i-want-off-mr-golangs-wild-...
  - jrockway 6y ago
    How is this damning, exactly? It's a very specific set of library quirks that are kind of expected -- Chmod doesn't do much on Windows. Arguably, maybe Chmod shouldn't be in the core library if it can't do everything on every OS/architecture combination, but I am not sure that damns the language. It does the best it can, but doesn't deliver a POSIX overlay for Windows. (The complaint continues into a discussion of build tags, to make Windows-only code compile only on Windows. Again, what's the alternative here? If you want your program to do different stuff depending on the platform, there's going to be some sort of conditional to apply that.) There is then a discussion about monotonic time. The author immediately knows they want monotonic time, but there is no method that specifically returns that. Instead, go embeds the wall clock and monotonic time into a time.Time when you create one with time.Now. It uses the wall clock time for display, and monotonic time to compute the difference between two timestamps. This is not what the author expected, but it ultimately allows them to do what they want. (There is then a complaint about how when you boot a Raspberry Pi without giving userspace any time to start up, the time is set incorrectly, and Go doesn't help. Well... yeah. You can add a hardware RTC if you want the time to be correct as soon as the i2c subsystem comes up, or you can wait for NTP, or you can live with the wrong time. Not sure how any of this involves Go -- it does expect the OS to do OS things for it.) If you were going to write a damning critique of why to never use Go, it would probably be something like "this dumb library uses channels, sync.Mutex, and atomic.AddInt64 all in the same code and it deadlocks and runs out of memory" or "I installed the most popular ORM on Github and it prints colored text to the console when there is a database error rather than returning an error from the function". I think the linked article totally misses the mark on what problems people are likely to encounter with Go. Let's be honest -- 99% of programmers have no idea that their OS has a monotonic clock, and are quite surprised (and have no idea how to fix it) when start := time.Now(); time.Sleep(time.Second); fmt.Println(time.Since(start)) prints a negative number. But... with Go they don't have that problem. Pretty interesting.
aabhay 6y ago
All of the details but with none of the heart. I would much prefer a ‘wow’ example utilizing concurrency than a primer on how to write a function
Elgolfin 6y ago
My 2 cents without seeming harsh with the author. Articles with a title `Learn <programming language> in 5 minutes` are misleading. They should be renamed `Discover <programming language> in 5 minutes`. Replace the verb Discover by Introduce or something similar if you like. There is a lot of difference between learning a new programming language and discovering one. You will not learn any programming language in 5 minutes. This introduction to Go is quite nice, though.
- capableweb 6y ago
  > There is a lot of difference between learning a new programming language and discovering one. Yeah, discover just lasts the moment you stumble upon it. Once you sit down to learn the syntax and basics, you're learning the language. - discover - find unexpectedly or during a search. - learn - gain or acquire knowledge of or skill in (something) by study, experience, or being taught. I don't think anyone is reading the title and thinking "Huh, I can learn _all_ of Go in just 5 minutes?!". The time is an indicator that you'll just scratch the surface, not become a master gopher.
- falcolas 6y ago
  Remember when we used to yell at 21 day books (Learn C++ in 21 Days) as being mis-leadingly short? It's becoming a meme now.
- harrisonjackson 6y ago
  Way less clicks for "Discover" than "Learn" My expectations were low enough because of the "5 minutes" part, and I actually found it to be better than expected.
jug 6y ago
This looks like it was written with the intent to “win” the simplicity battle in mind. Nothing on interfaces or goroutines.
jonnycomputer 6y ago
Learn linear algebra ... in just 5mins! Learn the lambda calculus ... in just 5mins! Learn how to write a novel ... in just 5mins! Learn how to be a stand up comedian ... in just 5mins! Learn kung fu ... in just 5mins! Learn how to be a world class lover in bed (or out!) ... in just 5mins! Man, that was the best half-hour I've ever spent in my life. Sorry, I couldn't fit in Go, though.
- adenadel 6y ago
  This seems like a good place to recall Peter Norvig's article "Teach Yourself Programming in Ten Years" https://norvig.com/21-days.html https://norvig.com/21-days.html
- falcolas 6y ago
  Remember "Learn C++ in 21 Days" and the furor around how silly it was to try and learn a programming language in less than a year? It's become a meme now.
- brickmort 6y ago
  should have opted for the four minute courses ;)
ibraheemdev 6y ago
Nice article! I wrote a more comprehensive version a while ago. Estimated reading time: 20 minutes [0] [0]: https://ibraheem.ca/posts/go-in-twenty https://ibraheem.ca/posts/go-in-twenty
ike77 6y ago
According to Firefox reader view it should take 11-14min to read it
deleted 6y ago
[deleted]
unethical_ban 6y ago
It glosses over a lot of nuance, which I can tell by not explaining that you can't use the implicit assignment := operator outside a function. And since this has turned into another "referendum on golang" argument, I'll say that I appreciate what it has to offer on my team at work. We historically write in Python, and we are a team of system engineers writing 100-500 line automation code that uses APIs. Static typing helps. Our enterprise has tooling that makes importing 3rd party code a lot easier in our bureaucracy. The linting and checks are more robust. From a language perspective, forcing linting and conventions makes the code a lot easier to write with a team. I may not like camelCase, but damnit if everyone doesn't learn how to read it quickly when the language/linter forces us to use it. The VSCode plugin is completely essential. Being able to type an import, and then quickly hop to the complete API documentation and expected inputs/outputs of everything, is so much help that I, a Python "skilled tradesman", gladly hopped on the golang train. My only gripe is that a lot of documentation seems to be third party, or very strictly an API reference. Nuanced, helpful docs are scattered in gobyexample, stackoverflow, etc. --- Bottom line, it is a great language/ecosystem for reasonably self-documenting, readable code for novice/intermediate "scripters" and coders who are not CS majors. Tooling is amazing.
alexellisuk 6y ago
The only thing this missed, and sorely missed was unit testing. Disclaimer: I wrote this post a few years ago and it still seems to help folks, although I'm sure if I wrote it again it may look different. https://blog.alexellis.io/golang-writing-unit-tests/ https://blog.alexellis.io/golang-writing-unit-tests/
- cweill 6y ago
  You can save yourself a minute and generate the test case boilerplate for your with https://github.com/cweill/gotests https://github.com/cweill/gotests :)
svnpenn 6y ago
I maintain a bunch of Go examples here, with links to standard library as well: https://89z.github.io/autumn/tags/go https://89z.github.io/autumn/tags/go
diehunde 6y ago
Something it's missing in the CS teaching industry is material (and probably a method too) for experienced programmers who want to learn a new language. It's so hard to find resources to learn the spirit and philosophy behind a language and at the same time learn the syntax without spending time on basic stuff like declaring variables or functions.
- djeiasbsbo 6y ago
  I don't think that there is a lack of material, almost every new language has an extensive documentation. I did have to learn how to read something that takes more than a couple days/weekends though, but now I mostly have no problem with documentation. I do still have trouble with standards or other huge documents, e.g. the Arm Architecture Manual. The kind of documents that are huge, yet assume a lot of previous knowledge so a lot of googling has to be done.
whalesalad 6y ago
No offense to the author here ... but I need to vent some personal frustration. Every tutorial goes through these exact same motions for learning a new language. It sucks! Programmers can figure out what a variable is, or how to use an array or a map. Those things really don't change a whole lot between languages. What about how to import code from different modules? Best practices for organizing code? How your language differs from its competitors as far as usage. Testing practices (which often influence how your code is written), etc... Learning Elixir was tough for me until I found Dave Thomas' "Elixir for Programmers" where he skipped all of the basic stuff that every programmer is assumed to know and went right to what makes Elixir unique and how to leverage it correctly. (https://codestool.coding-gnome.com/courses/elixir-for-programmers https://codestool.coding-gnome.com/courses/elixir-for-progra...) I have been hunting for the same thing for the Go language for years because frankly I haven't been able to grok the appeal. I am hoping to find a 'Go for Programmers' one day. I asked on Reddit a while back and was pretty much handed the "what are variables" document.
- url00 6y ago
  This 100x. If you find it please share with the rest of us!
- nickelcitymario 6y ago
  > How your language differs from its competitors as far as usage. Yes! I'm always tempted to ask "How is this different or better than XYZ lang?" I don't have the time/inclination to learn every new fangled language that comes by, so it would be nice to have an easy way to understand what scenarios any given language is best suited for. For example, every time I read about Go, I'm left wondering: How is this better than C or Java? Presumably it's better in some ways I'm not perceiving, otherwise why would it be built and used?
- dpc_pw 6y ago
  Seconded. Especially for Go, because it's mostly a lowest common denominator of language features it's not hard to write the code itself. The problem is that the module system is different and had plenty of changes along the years, What I would really like is an up to date "learn how to handle Go project in 30 minutes" tutorial (initialize new project with all best practices, add modules, publish, fork&clone&submit&pr including 3rd party submodules, test, CI, profile, debug).
codenlearn 6y ago
Absolutely no offense to the author, but IMO for an experienced programmer the five minute intro does not make any sense. They will be better served by using the documentation (or) go by example in this case. If someone is new to programming this in no way does any justice. Programming is way too complex to be fit in 5 minutes intro. https://norvig.com/21-days.html https://norvig.com/21-days.html
eecks 6y ago
I'm a fast reader so I learnt Go in 4 mins. Who's hiring?
hda111 6y ago
A slice isn't like a list in Python. Python lists can contain different typed variables.
sys_64738 6y ago
No mention of co-routines?
_TA_12_ 6y ago
Most comments here don't seem to see the context. It's done as companion or reply to the highly celebrated post "A half-hour to learn Rust", which was posted several times at HN and many people got overly excited how easy Rust is. The takeaway is: The HN community is highly biased. So if you're looking for advice regarding technology choice, take it with a large grain of salt.

203 points by tate 6y ago

Go can be understood as an improved C that keeps much of C's simplicity but adds small, powerful features like interfaces and channels and garbage collection Go fixes C's well-understood flaws (declaration resembling use, unintuitive operator precedence, unrestricted address math, silent casting, zero-terminated strings, etc.) Go puts essential C idioms directly into the language (pointer/length is formalized as slices, packages are part of the language instead of just being naming convention, etc.) Go is mature, stable, widely-used, well-supported, and well-understood. C++ is a clumsy mess, but C is quite elegant and Go is a continuation/modernization/enhancement of that If you like C, you will love Go

Lariscus 6y ago
I like C but strongly dislike Go. They share nothing other than having a small(ish) feature set.
- BoorishBears 6y ago
  I agree. Go feels like it's aimed at creating applications that run at a level above where C traditionally runs while keeping the pared down feature set of C, and it just doesn't work well imo. I loved playing with Go, but eventually it feels like you're conditioning yourself to be ok with a lot of "bad" code. Tons of repetition, tons of boilerplate by other names. It's like the simplicity gets in the way of itself. - My take is, use Go for a bit, take the "less is more" mentality with you to a language more suited for real work. ps: I'm not saying you can't use Go for real work before someone flies at me. I'm just saying that Go's strength is the mentality people have when using it, as a language it's not particularly enabling, and that's by design if anything...
  - bak3y 6y ago
    Meanwhile the place I work writes all microservices in go and all of my team's (DevOps) tools are also written in go...
    - BoorishBears 6y ago
      I explicitly added the "ps" to avoid the situation where all the replies are fairly empty comment saying "Well we use it!" I get that you can use it for real work, I'm not saying you can't. I'm saying, even by design to some degree, it's not particularly enabling compared to other languages. That's meant to be a strength if anything, but I did not find the tradeoff of simplicity was able to overcome the additional effort it took to deal with what was missing There's an implicit ymmv here of course, because I'm not saying no one can find Go useful, I can see how in certain worlds with certain teams with certain priorities it'd all work out. It's just not for me.
      - murukesh_s 6y ago
        I have used Go in production. I found it roughly takes 2-3x additional time it takes to develop the same functionality in Node.js (with typescript). But it runs faster. If you want to write code that is probably not going to be thrown away it may be wise to invest the additional time in Go. However can't recommend that for building experimental code/APIs etc which are time bound and may/can get replaced (or split into micro services) in future if it becomes massively successful..
        AlchemistCamp 6y ago
        And that's saying something give that neither Node nor TypeScript have ever had productivity as a main selling point! Imagine evaluating the time to market for an experimental back-end written in Rails, Laravel, Phoenix, etc vs Go! The difference is staggering.
        konart 6y ago
        >Rails, Laravel, Phoenix, etc vs Go! Comparing frameworks and a language, really?
  - Thaxll 6y ago
    The last couple of years are showing that Go delivers, it's pretty easy to find dozen of "real" software written in Go that are weidly used.
    - BoorishBears 6y ago
      Sometimes I don't know why I bother talking about Go. It's proponents are so quick to go defensive that no one is capable of reading any complaint in an even mildly charitable light. I mean I shouldn't literally have to say "I'm not saying you can't use Go for real work before someone flies at me." When talking about a language as widely used as Go right? Like that's common sense! And yet of course I'm getting replies that do exactly that because of how darn defensive people need to be about it.
      - Thaxll 6y ago
        Maybe don't use things like " to a language more suited for real work."
        BoorishBears 6y ago
        There is a literal full paragraph dedicated to explaining it, maybe don't ignore the oodles of context I left to avoid exactly what you did. Saying other languages are more suited to real work doesn't mean Go isn't suited at all, it literally means other languages are more angled towards the "end product" or the "real meat and potatoes" of just making a thing work than Go. It's literally a strength of Go. Go doesn't want to include the kitchen sink or even confine you to having a kitchen at all and I respect that. But I'm saying that other languages that include more in the way of affordances can help one be more productive, and I believe combining a language that includes more, with the mindset of not abusing the buffet is a winning combination. Ymmv, I'm not an oracle, I just expect people to read things in a reasonably charitable way which usually works fine as long as they're not being defensive.
  - steve_adams_86 6y ago
    I agree about becoming okay with bad code. But I think if you understand and embrace that, there’s a place for it and it can be quite powerful and easy to use at times. It’s a trade off that makes sense sometimes. I think the problem appears when people treat Go like it doesn’t have any problems. All languages do. As I’ve mentioned recently though, I don’t think I’d ever want to use Go as a forever solution to a complex problem. I’m sure some people could do it and do a great job, but I’m not one of those people. I need the ability to abstract and ensure more safety, or I’ll never feel secure with what I’m building.
  - blablabla123 6y ago
    > I loved playing with Go, but eventually it feels like you're conditioning yourself to be ok with a lot of "bad" code. Tons of repetition, tons of boilerplate by other names. Not well or hastily written Go is easily like that. I can only guess why you point out the repetition but when you look at well written Go code like in the Go std library, there isn't much repetition happening and it looks rather elegant. At the same time it can be quite some effort to create such code and might take several iterations. Documentation-wise I like the official documentation, it gives a lot of pointers why Go is how it is. Also obviously it's not for every use-case. Where it works really well IMHO is where error handling is a vital part of the application. (And of course anything concurrent is quite a breeze)
    - BoorishBears 6y ago
      Not having generics, by definition, invites a lot of repetition and boiler plate. I know generics are overrated and coming soon, but right off the bat that stuck out. I recall a point where I had written a function that needed to return a channel, but of course had to forgo types due to the lack of generics. The end result was having to wrap that channel in another channel that added typing at each call site. I asked around in go circles if that made sense, and called out how bad the felt but the answer was "no that's great! channels are cheap! the repetition is good because it's simple!" - The error handling has some sore points to that end too, and the implicit shadowing with shorthand assignments on one hand makes it easier to deal with multiple errors, but on the other hand introduced subtle logic bugs on one than more occasion where "err" was silently shadowed, which I greatly disliked. I'm actually suprised Go didn't forgo shadowing for the shorthand operator and force people to label their errors when dealing with multiple, it seems very "in brand", but I guess even Go draws the line somewhere lol - Then there's the whole stack trace situation. Which after plenty of reading still just wasn't making sense. I mean the idea of logging a stack of wrapped messages sounds very nice, but man proper stack traces not being the first class citizen of error handling just did not make sense to me in a language I hear referenced for systems work so much (and I realize they can be had) I saw proposals to rework Go's error handling, I don't know if any progress has been made to that end, but it's another example where simplicity can get in the way of itself - And I'll balance this all out by saying it was still fun to write, I don't want to seem like I'm just shitting on Go for existing. It's just these little warts that I kept getting over with just a little bit of "idiomatic Go" which I often found was just writing a little bit more code than you're used to, started to add up. And eventually I realized I was creating something that, while very easy to reason about, had a lot more to reason about than it needed to. That's where I kind of petered out in my personal usage.
  - skrtskrt 6y ago
    I will take sometimes-tedious boilerplate over many-many-layered abstractions. You can write any language any which way, but some languages just have a culture of boilerplate vs abstractions. The most popular Python and Java libraries seem to love endless layers of indirection, and when it doesn't fit exactly what you need, you bang your head against the wall monkeypatching it to make it work since your whole app is already written in X mega library. Go culture seems to be quite a bit more boilerplate-y and uses smaller more composable libraries. It's just refreshing. Really I just need to buckle down on Rust, but I think it's a fair bet that teams and shops that bring in a lot of young programmers and want to ramp them up fast may cringe a bit at the learning curve of Rust. That's why for now in terms of a bet on employability, I am prioritizing experience with Go.
- 37ef_ced3 6y ago
  Take Go's slices, for example Realize a Go []int ("slice of int") is just a C struct like this, passed by value: struct intSlice { int* addr; int len; int cap; }; The memory at addr is not owned by the slice. All the slice operations are simply notation for manipulating the struct. Go's garbage collection makes the whole thing work well This can be confusing if you're used to C++'s std::vector (which owns the memory) or Python's slices. Go's slices are a shallow pointer/length system exactly like is used in C all the time. For example: void sort(int* addr, int len); becomes func sort(a []int) A Go slice is just a formalization of C's pointer/length idiom, with terse notation for manipulation
  - traes 6y ago
    I'm not really sure saying that features in Go can be modeled in C really suggests that they are similar as languages. Syntax is very important.
  - nyanpasu64 6y ago
    Go's slices don't act like what I thought were called "non-owning references"(Rust's &/&mut [T] or C++'s std::span<T/T const>), which reference memory whose lifetime is bounded by something else (like a vector or array or shared pointer). Instead it's "shared ownership" where memory is referenced by one or more slices (and no single owner) which can reference and mutate the slice simultaneously, and it's freed by the GC sometime after all the slices are gone. This reminds me of Numpy's ndarrays, which act more like "owning containers" (which may sometimes share ownership and alias) than "non-owning references".
    - erik_seaberg 6y ago
      Slices are kind of a mess. They should either be uniqueness types or passed by reference (the way maps and channels are, and NIO buffers from Java). Instead they’re passed by value so multiple copies exist whose sizes and sometimes contents aren’t in sync.
  - mhh__ 6y ago
    Slices should be the absolute bare minimum for a modern systems language, it's not really a reason to switch in my case If I want to write flat/simple code I'll just C, Go doesn't really offer anything to me because I want to be relatively low-level and able to make the compiler save my time.
alpaca128 6y ago
I'm not a C fan but isn't Zig much closer to C's philosophy while fixing bad parts than Go? Especially due to the garbage collection, at which point Go suddenly competes with many more simple languages.
- jerf 6y ago
  It depends on your definition of "C's philosophy", no sarcasm, and no implied preference by me for any particular definition, as I believe many have merit. Language philosophies evolve, and C, being so many decades old, has evolved a lot. The original philosophy is probably little more than a seed crystal at this point for the several philosophies that have been loaded on to it over the years. It is probably reasonable to say that Zig is closer to C's current philosophy in practice, which encompasses many additional developments over the decades to deal with various aspects of C and programming real machines that have arisen as both have changes, and Go closer to C's original philosophy of simplicity and relative ease of use. (In modern times, C is not one of the easier languages to use any more, due to significant advancements in the field of making easy-to-use languages. But it was originally intended to be an advancement there itself.) By similar logic, I can say with a straight face that all of Go, C++, Zig, Rust, and Swift (and more) are "evolutions in general-purpose programming languages like C", despite their wild differences, because the world has gotten larger, and there is room for a lot of variations like that, each addressing different aspects of the newer, larger world.
Jnr 6y ago
If I would have to replace C with anything, I would choose Rust and not Go.
- simias 6y ago
  To me Rust is more like "C++ done right". It's massively bigger, more complicated and slower to compile than C. The C ABI is also the de-facto lingua franca for language interop, something that's not easily achievable with Rust or C++ (or Go, for that matter).
  - Jnr 6y ago
    Have you tried Rust? The ABI in Rust is doable: https://people.gnome.org/~federico/blog/rust-stable-abi.html https://people.gnome.org/~federico/blog/rust-stable-abi.html And it doesn't feel like C++ when writing it. The syntax and language features are nice and feel modern. It does require more attention because of what it compiles down to, but the compiler is there to help with it. I haven't been excited about any programming languages in years, but Rust has certainly taken my attention lately.
    - simias 6y ago
      I love Rust so dearly that I wish I could marry it, but I still feel that it's a massively more complicated language than C.
deleted 6y ago
[deleted]
cute_boi 6y ago
I like C but I would prefer Rust over Go. Go may be simple but I really hate using conventions like init(), comments working like syntax, captial letter means published etc.
- steve_adams_86 6y ago
  Do Go comments work like syntax? Do you mean that they need to be formatted a certain way like they’re language syntax?
  - grey-area 6y ago
    The Go authors have (ab)used comments to extend the language in experimental ways for code generation, build pragmas and recently file embedding. They’ve done this to avoid breaking the language stability guarantee, not sure if there were other reasons. I think it’s a mistake personally to create this sort of metalanguage in comments (now you have two problems!) but it’s easy to avoid using this most of the time as the uses are pretty esoteric.
    - skrtskrt 6y ago
      File embedding is a common enough use case (HTML templates, config files) that it really makes me cringe that it's being done with comments.
      - grey-area 6y ago
        I just keep my templates and config in separate files. There are good reasons to keep them separate anyway (allows config without recompile for example) and for the apps I work on distribution isn’t a problem. So I haven’t really had to use comments as code in 7-8 years of go. Perhaps it’ll become more common with the embed stuff. But then I don’t use struct tags either so I guess I’d prefer Go to be even simpler.
  - _ph_ 6y ago
    No, Go comments are just comments. They have been used though to add meta-information to special tools. So unless you use those tools and require to add the specific meta-information, you can treat comments as plain comments. Hiding certain meta-information, like exporting a function with a C-compatible signature when building a shared library is not a great way of doing things, but on the other side, it is a special usage which isn't part of the language itself, so not part of its syntax.
simias 6y ago
My main small day-to-day usability gripes with C are lack of type inference, lack of destructors and terrible ergonomics for error handling. Go solves two out of three, but it really dropped the ball hard on error handling which is very disappointing IMO. Things like generics and garbage collection involve some deep tradeoffs, so I get Go's take on them, even if I don't necessarily agree with it. On the other hand IMHO Go's crappy error handling boilerplate is not something I find acceptable in a modern programming language.
- enw 6y ago
  How would you design the error handling? Personally I'm glad Go has stayed out of exceptions (panics don't count), at scale it's so much easier to reason about flow.
  - bmn__ 6y ago
    Monadic error handling like in ML work-alikes, Rust etc. would be a good start. Adopt: • https://github.com/rebeccaskinner/gofpher https://github.com/rebeccaskinner/gofpher • https://speakerdeck.com/rebeccaskinner/monadic-error-handling-in-go https://speakerdeck.com/rebeccaskinner/monadic-error-handlin... I've been talking to the local Go user group. No one even knows about that concept. This continues a pattern of general ignorance/lack of looking beyond one's horizon I've noticed.
- steve_adams_86 6y ago
  The error handling feels deeply wrong to me too. I love the explicitness and how hard it is to ignore errors - all languages should make it so easy to expect and handle potential errors - but other features (or lack thereof) of the language make it so you can’t handle any of it in concise or sane ways. Code is plastered with the same boilerplate, everywhere, always. It makes up a significant mount of all Go code.
- autarch 6y ago
  I agree that the error handling is terrible, but I'm not sure how much better it could be without generics. For me, the gold standard in error handling is Rust, where the type system simply does not allow you to ignore errors. This means that the existence of error handling is checked at compile time. Of course, this doesn't mean your error handling is _good_, but I think that's beyond any language design to enforce. But the Rust system is entirely built around a generic Result type, where both the non-error result (an int, string, struct, etc.) _and_ the error type itself are both generic.
xscott 6y ago
> Go fixes C's well-understood flaws (declaration resembling use This seems to be a common belief, but since Go kept pointer syntax as prefix, you're still stuck needing parens in some unfortunate cases: https://blog.golang.org/declaration-syntax https://blog.golang.org/declaration-syntax (see the part about pointers near the bottom) As Rob Pike writes in that link, they could've fixed it and still had declaration resembling use if they had chosen a suffix operator for pointers. He notes that Pascal uses ^, but it seems like @ might be a better choice: int foo // an integer int foo@ // pointer to int int foo[10]@ // 10 pointers int foo@[10] // pointer to array int foo()[10]@ // function that returns an array of 10 pointers In my opinion, they almost fixed it and then punted. As such, it's just different, but not really better.
burnthrow 6y ago
I thought this sounded familiar https://news.ycombinator.com/item?id=25622389 https://news.ycombinator.com/item?id=25622389 https://news.ycombinator.com/item?id=25555457 https://news.ycombinator.com/item?id=25555457 https://news.ycombinator.com/item?id=25531118 https://news.ycombinator.com/item?id=25531118
- booleandilemma 6y ago
  So the account was created 34 days ago and he's posted that same message 4 times already.
dpryden 6y ago
I'd like to chime in and say that I also like C but really dislike Go. C is simple, to what today is nearly an absurd degree, but it at least integrates well with an enormous ecosystem of existing tooling and libraries. Go, by contrast, feels the need to re-invent every possible wheel, often with a seemingly intentional effort to be different just because. C ABIs are rock solid on every platform. Any language or tooling in the world can load functions from a C library. By contrast, try calling Go from another language. You will quickly give up and use network protocols or subprocesses instead. The converse is true too: on major platforms, the C library defines the operating system more than the kernel does. (I mean, in a Unix sytem, the entire libc is documented in the man pages. Documentation for writing C is literally built into the operating system.) By contrast, Go decides to avoid the standard platform ways of calling every operating system function, and instead implements syscalls directly into the kernel, basically just because Go hates interoperating with anything that's not Go. C is a good language not because it is a good language, but because it is a good ecosystem. Unix and C are closely intertwined. (Even Win32 and C are pretty closely intertwined!) I could imagine a Go-based Plan9-like system -- if that existed, and had decades of engineering behind it, I could see the argument being made that Go's ecosystem compares to C's. But while Go may aspire to that, it isn't anywhere near there yet. And when you start comparing Go with other languages on the basis of language features, I think Go fails laughably more often than not. (I'll give you "C++ is a clumsy mess", though.) But compare Go with Rust, with C#, with Haskell -- for that matter, compare Go with Java and I think Go is a less powerful, less useful language to write real code in. If I want a lightweight, quick-and-dirty program, I'll use Python. If I want to write a reusable library that gets plugged into other software, I'd go with C (or at least write the interop layer in C). If I want a high-performance server, these days I would probably go with Rust. If I want a pragmatic, well-rounded language to write a large project in, I think C# would probably be my first choice. What space does that leave for Go? Outside of microservices (where I contend that Rust is a much better choice, and there are lots of other options), Go's niche seems to be command-line tools. I sort of understand that, because Go's static linking makes redistributing binaries relatively easy (although Go by no means has a monopoly on that). But in the space of command-line tools, Go's argument handling is frankly bizarre: it looks at decades of precedent about what users expect from argument syntax and behavior and decides to throw it all away and reinvent the wheel. I guess that means this comment (rant?) has ended up where it started: Go defies convention, basically "just because". By contrast, C defines convention. "If you like C, you will love Go"? Nope, not at all.
kevbin 6y ago
> If you like C, you will love Go That may be true. But if you love C you’re going to hate Go like you’ve never hated any thing ever before.

runjake 6y ago

Good stuff. There is another >5 minute tutorial here: https://learnxinyminutes.com/docs/go/ https://learnxinyminutes.com/docs/go/ This website has something similar for nearly every language: https://learnxinyminutes.com https://learnxinyminutes.com

adriancooney 6y ago
I love this website! I use it every time I find a new language to get a basic understanding of it. It's an incredibly valuable resource.

potta_coffee 6y ago

I think this is pretty good but I think you ought to commit a paragraph to pointers as well.

kissgyorgy 6y ago

Don't trust a tutorial which intend to tech you the basics of Go, but forget to include the most important idea: interfaces...

postalrat 6y ago

Where are channels?

ducktective 6y ago

Is this a response to that "learn rust in half an hour?" ;) https://fasterthanli.me/articles/a-half-hour-to-learn-rust https://fasterthanli.me/articles/a-half-hour-to-learn-rust

goodoldneon 6y ago
Someone make "Learn Haskell in 50 seconds"
- jerf 6y ago
  [Ancient Aliens Guy Picture Here] FUNCTIONS I've gotten it down to about two seconds here....
  - ducktective 6y ago
    https://imgflip.com/i/4snpcr https://imgflip.com/i/4snpcr
bla3 6y ago
It says so in the first line of the article, so probably yes.
st1x7 6y ago
If only we had known that all of these Rust vs Go arguments could be resolved by learning both languages in 35 minutes.

bkovacev 6y ago

Is there something like this for Golang API development, that also incorporates best practices? Even a solid book recommendation would be helpful.

cfors 6y ago
The repository and structure is free here, but I highly recommend the actual course for API development, which is not free but very valuable. https://github.com/ardanlabs/service https://github.com/ardanlabs/service

cfors 6y ago

This is neat, and a testament to the simplicity of Go. I normally point people to this tutorial if they want to learn Go quickly, it is interactive (able to navigate straight to go playground) and very well done in my opinion. https://gobyexample.com/ https://gobyexample.com/

mynameisash 6y ago
> the simplicity of Go As someone who's not written any Go, I found fasterthanlime's critique of the language[0] damning enough that I likely won't ever touch the thing. Maybe he's cherry-picked examples, but his article was thorough and technical enough to convince me that the Go mantra of simplicity is just surface-level. [0] https://fasterthanli.me/articles/i-want-off-mr-golangs-wild-ride https://fasterthanli.me/articles/i-want-off-mr-golangs-wild-...
- jrockway 6y ago
  How is this damning, exactly? It's a very specific set of library quirks that are kind of expected -- Chmod doesn't do much on Windows. Arguably, maybe Chmod shouldn't be in the core library if it can't do everything on every OS/architecture combination, but I am not sure that damns the language. It does the best it can, but doesn't deliver a POSIX overlay for Windows. (The complaint continues into a discussion of build tags, to make Windows-only code compile only on Windows. Again, what's the alternative here? If you want your program to do different stuff depending on the platform, there's going to be some sort of conditional to apply that.) There is then a discussion about monotonic time. The author immediately knows they want monotonic time, but there is no method that specifically returns that. Instead, go embeds the wall clock and monotonic time into a time.Time when you create one with time.Now. It uses the wall clock time for display, and monotonic time to compute the difference between two timestamps. This is not what the author expected, but it ultimately allows them to do what they want. (There is then a complaint about how when you boot a Raspberry Pi without giving userspace any time to start up, the time is set incorrectly, and Go doesn't help. Well... yeah. You can add a hardware RTC if you want the time to be correct as soon as the i2c subsystem comes up, or you can wait for NTP, or you can live with the wrong time. Not sure how any of this involves Go -- it does expect the OS to do OS things for it.) If you were going to write a damning critique of why to never use Go, it would probably be something like "this dumb library uses channels, sync.Mutex, and atomic.AddInt64 all in the same code and it deadlocks and runs out of memory" or "I installed the most popular ORM on Github and it prints colored text to the console when there is a database error rather than returning an error from the function". I think the linked article totally misses the mark on what problems people are likely to encounter with Go. Let's be honest -- 99% of programmers have no idea that their OS has a monotonic clock, and are quite surprised (and have no idea how to fix it) when start := time.Now(); time.Sleep(time.Second); fmt.Println(time.Since(start)) prints a negative number. But... with Go they don't have that problem. Pretty interesting.

aabhay 6y ago

All of the details but with none of the heart. I would much prefer a ‘wow’ example utilizing concurrency than a primer on how to write a function

Elgolfin 6y ago

My 2 cents without seeming harsh with the author. Articles with a title `Learn <programming language> in 5 minutes` are misleading. They should be renamed `Discover <programming language> in 5 minutes`. Replace the verb Discover by Introduce or something similar if you like. There is a lot of difference between learning a new programming language and discovering one. You will not learn any programming language in 5 minutes. This introduction to Go is quite nice, though.

capableweb 6y ago
> There is a lot of difference between learning a new programming language and discovering one. Yeah, discover just lasts the moment you stumble upon it. Once you sit down to learn the syntax and basics, you're learning the language. - discover - find unexpectedly or during a search. - learn - gain or acquire knowledge of or skill in (something) by study, experience, or being taught. I don't think anyone is reading the title and thinking "Huh, I can learn _all_ of Go in just 5 minutes?!". The time is an indicator that you'll just scratch the surface, not become a master gopher.
falcolas 6y ago
Remember when we used to yell at 21 day books (Learn C++ in 21 Days) as being mis-leadingly short? It's becoming a meme now.
harrisonjackson 6y ago
Way less clicks for "Discover" than "Learn" My expectations were low enough because of the "5 minutes" part, and I actually found it to be better than expected.

jug 6y ago

This looks like it was written with the intent to “win” the simplicity battle in mind. Nothing on interfaces or goroutines.

jonnycomputer 6y ago

Learn linear algebra ... in just 5mins! Learn the lambda calculus ... in just 5mins! Learn how to write a novel ... in just 5mins! Learn how to be a stand up comedian ... in just 5mins! Learn kung fu ... in just 5mins! Learn how to be a world class lover in bed (or out!) ... in just 5mins! Man, that was the best half-hour I've ever spent in my life. Sorry, I couldn't fit in Go, though.

adenadel 6y ago
This seems like a good place to recall Peter Norvig's article "Teach Yourself Programming in Ten Years" https://norvig.com/21-days.html https://norvig.com/21-days.html
falcolas 6y ago
Remember "Learn C++ in 21 Days" and the furor around how silly it was to try and learn a programming language in less than a year? It's become a meme now.
brickmort 6y ago
should have opted for the four minute courses ;)

ibraheemdev 6y ago

Nice article! I wrote a more comprehensive version a while ago. Estimated reading time: 20 minutes [0] [0]: https://ibraheem.ca/posts/go-in-twenty https://ibraheem.ca/posts/go-in-twenty

ike77 6y ago

According to Firefox reader view it should take 11-14min to read it

deleted 6y ago

[deleted]

unethical_ban 6y ago

It glosses over a lot of nuance, which I can tell by not explaining that you can't use the implicit assignment := operator outside a function. And since this has turned into another "referendum on golang" argument, I'll say that I appreciate what it has to offer on my team at work. We historically write in Python, and we are a team of system engineers writing 100-500 line automation code that uses APIs. Static typing helps. Our enterprise has tooling that makes importing 3rd party code a lot easier in our bureaucracy. The linting and checks are more robust. From a language perspective, forcing linting and conventions makes the code a lot easier to write with a team. I may not like camelCase, but damnit if everyone doesn't learn how to read it quickly when the language/linter forces us to use it. The VSCode plugin is completely essential. Being able to type an import, and then quickly hop to the complete API documentation and expected inputs/outputs of everything, is so much help that I, a Python "skilled tradesman", gladly hopped on the golang train. My only gripe is that a lot of documentation seems to be third party, or very strictly an API reference. Nuanced, helpful docs are scattered in gobyexample, stackoverflow, etc. --- Bottom line, it is a great language/ecosystem for reasonably self-documenting, readable code for novice/intermediate "scripters" and coders who are not CS majors. Tooling is amazing.

alexellisuk 6y ago

The only thing this missed, and sorely missed was unit testing. Disclaimer: I wrote this post a few years ago and it still seems to help folks, although I'm sure if I wrote it again it may look different. https://blog.alexellis.io/golang-writing-unit-tests/ https://blog.alexellis.io/golang-writing-unit-tests/

cweill 6y ago
You can save yourself a minute and generate the test case boilerplate for your with https://github.com/cweill/gotests https://github.com/cweill/gotests :)

svnpenn 6y ago

I maintain a bunch of Go examples here, with links to standard library as well: https://89z.github.io/autumn/tags/go https://89z.github.io/autumn/tags/go

diehunde 6y ago

Something it's missing in the CS teaching industry is material (and probably a method too) for experienced programmers who want to learn a new language. It's so hard to find resources to learn the spirit and philosophy behind a language and at the same time learn the syntax without spending time on basic stuff like declaring variables or functions.

djeiasbsbo 6y ago
I don't think that there is a lack of material, almost every new language has an extensive documentation. I did have to learn how to read something that takes more than a couple days/weekends though, but now I mostly have no problem with documentation. I do still have trouble with standards or other huge documents, e.g. the Arm Architecture Manual. The kind of documents that are huge, yet assume a lot of previous knowledge so a lot of googling has to be done.

whalesalad 6y ago

No offense to the author here ... but I need to vent some personal frustration. Every tutorial goes through these exact same motions for learning a new language. It sucks! Programmers can figure out what a variable is, or how to use an array or a map. Those things really don't change a whole lot between languages. What about how to import code from different modules? Best practices for organizing code? How your language differs from its competitors as far as usage. Testing practices (which often influence how your code is written), etc... Learning Elixir was tough for me until I found Dave Thomas' "Elixir for Programmers" where he skipped all of the basic stuff that every programmer is assumed to know and went right to what makes Elixir unique and how to leverage it correctly. (https://codestool.coding-gnome.com/courses/elixir-for-programmers https://codestool.coding-gnome.com/courses/elixir-for-progra...) I have been hunting for the same thing for the Go language for years because frankly I haven't been able to grok the appeal. I am hoping to find a 'Go for Programmers' one day. I asked on Reddit a while back and was pretty much handed the "what are variables" document.

url00 6y ago
This 100x. If you find it please share with the rest of us!
nickelcitymario 6y ago
> How your language differs from its competitors as far as usage. Yes! I'm always tempted to ask "How is this different or better than XYZ lang?" I don't have the time/inclination to learn every new fangled language that comes by, so it would be nice to have an easy way to understand what scenarios any given language is best suited for. For example, every time I read about Go, I'm left wondering: How is this better than C or Java? Presumably it's better in some ways I'm not perceiving, otherwise why would it be built and used?
dpc_pw 6y ago
Seconded. Especially for Go, because it's mostly a lowest common denominator of language features it's not hard to write the code itself. The problem is that the module system is different and had plenty of changes along the years, What I would really like is an up to date "learn how to handle Go project in 30 minutes" tutorial (initialize new project with all best practices, add modules, publish, fork&clone&submit&pr including 3rd party submodules, test, CI, profile, debug).

codenlearn 6y ago

Absolutely no offense to the author, but IMO for an experienced programmer the five minute intro does not make any sense. They will be better served by using the documentation (or) go by example in this case. If someone is new to programming this in no way does any justice. Programming is way too complex to be fit in 5 minutes intro. https://norvig.com/21-days.html https://norvig.com/21-days.html

eecks 6y ago

I'm a fast reader so I learnt Go in 4 mins. Who's hiring?

hda111 6y ago

A slice isn't like a list in Python. Python lists can contain different typed variables.

sys_64738 6y ago

No mention of co-routines?

_TA_12_ 6y ago

Most comments here don't seem to see the context. It's done as companion or reply to the highly celebrated post "A half-hour to learn Rust", which was posted several times at HN and many people got overly excited how easy Rust is. The takeaway is: The HN community is highly biased. So if you're looking for advice regarding technology choice, take it with a large grain of salt.