HN Theater @HNTheaterMonth

Rob Pike actually defined it exactly this way when it was introduced -- a simpler systems language, in contrast to Java.

It's funny -- I actually just watched this video yesterday: https://www.youtube.com/watch?v=5kj5ApnhPAE

⬐ Rochus

Is Java really a systems language?

⬐ mustache_kimono

That's not what I said. Pike described golang as a systems language, and specifically contrasted it with Java. Perhaps you should watch the talk.

⬐ Dylan16807

> That's not what I said.

Okay, but it's a pretty reasonable interpretation, right?

"Simpler X, in contrast to Y" makes it sound like Y is a less simple X.

⬐ mustache_kimono

What the heck is wrong with people on this site?

I thought it was a trolly comment because of course we don't think of Java as a systems programming language. I was polite and suggested the troll move on. Just as I suggest you move on. You should watch the video if you want Rob Pike's reasoning as to why golang is a systems language, and why he contrasts it with Java.

⬐ Dylan16807

> of course we don't think of Java as a systems programming language

It's not "of course" when we're in the middle of conversation about different definitions of "systems".

> You should watch the video if you want Rob Pike's reasoning as to why golang is a systems language

I might do that later, but either way you wrote an ambiguous comment and I don't know why you're lashing out so badly that people try to explain that. Such things happen.

⬐ mustache_kimono

I'm sorry you were confused. Buck up. It'll get better. I promise.

⬐ philosopher1234

I think I agree with the point you are trying to make but I think the form in which you are making it is alienating people.

⬐ aozgaa

> a simpler systems language, in contrast to Java.

I read this as saying the contrast between go and java is that the former is simpler. The confusion maybe comes about because "simpler" is a comparative adjective (as opposed to, eg, "simple", which is a descriptive adjective), and because there are up to two qualities being contrasted -- simplicity and "being a systems language".

Take it or leave it but I personally was a bit confused by the wording.

⬐ twic

"systems language" and "systems programming" are terms whose interpretations vary widely across the industry. At one extreme, it means kernels, drivers, and embedded, the stuff where you need to precisely manipulate bytes with no infrastructure and minimum overhead. At the other extreme, it means any software whose users are other programs rather than people, so API services and so on. My first job was as a "systems engineer", writing database middleware (kind of) in Java.

Go is not suitable for the kernels etc kind of systems programming, but it's highly suited to the API services kind.

⬐ codeflo

Maybe it's a regional thing, but I don't know anyone who calls that "systems programming". I'd personally use the term "backend programming".

⬐ Rochus

In fact, the terms are becoming more and more diluted. "Systems Engineering" is a good example; it actually used to be a well defined discipline (see EIA-632, IEEE 1220, ISO 26702, etc.) until some non-US universities started to use the term for disciplines like system administration or computer network engineering. Similar confusion e.g. exists on the question of whether C is a high- or low-level language. The funny thing is that Go is even used as a low-resource embedded system programming language, e.g. for the micro:bit.

⬐ jjtheblunt

Wasn't Go essentially Limbo from Bell Labs, like Rob Pike and others who moved to Google?

https://en.wikipedia.org/wiki/Limbo_(programming_language)

⬐ pjmlp

Limbo + some touch of Oberon-2

⬐ anthk

Go is like what C++ should been long ago, from the creators of C.

Ditto with plan9/9front and the original Unix.

Now, QT/C++ is the new Motif/C, but not just for Unix, but for doing cross plataform tools everywhere.

I think the future will be shipping static Go binaries with GIO everywhere.

INB4 "disk space", today's compilers and linkers should strip away all cruft from linking by removing any useless library function.

⬐ unfocussed_mike

> I think the future will be shipping static Go binaries with GIO everywhere.

I would like to add a GUI to a little (very little) mysql database updater tool I have in customer hands. GIO is interesting and impressive but I am not as optimistic as you that it will develop into anything big.

In Go you use the pattern of prefixing enum constants with the enum category to indicate that the enums are related to each other (e.g. StatusOk, StatusNotFound instead of status.OK, status.NotFound). Which is funny because today I came across this quote that "patterns are a demonstration of weakness in a language" in a Go talk https://youtu.be/5kj5ApnhPAE?t=276. I wish enums will eventually be implemented, generics are coming after all.

⬐ H1Supreme

I write Go nearly everyday, and enums are the #1 thing I'd like to see. Honestly, it's kind of surprising that the language lacks this feature.

⬐ tleb_

See here for an explanation. Not sure it's up to date though. https://golang.org/doc/faq#variant_types

⬐ tsimionescu

Variant types are very different from enums. Variant types allow you to define a type that is "one of these N types". Enums are the same thing at the value level: they allow you to define a type that is "one of these values". You can't implement one in terms of the other.

Variant types do have some similar use cases with interfaces, but I don't see any relationship with enums in terms of use cases, so I don't think that applies.

Also, let's not forget that even C has enums, so their lack of inclusion in Go is baffling (especially since they went and implemented the much more arcane yet limited `iota` feature).

⬐ cellularmitosis

Yeah, I think the confusion stems from the word "enum" being used to mean different things in different langs.

A great illustration lies in comparing enums in Objective-C (essentially just named integers), whereas the associated values in Swift enums make them "Sum" types.

⬐ masklinn

> Also, let's not forget that even C has enums

Not in any useful sense of the word. A C enum is a typedef and a few named constant, it's absolute shit, and if the choice was restricted to "C enum or nothing" then "nothing" was absolutely the right call.

Go's typedecl + iota is actually a step up from C's enums, because (aside from "untyped constants") you need an explicit conversion from "any random integer" to your typedecl. It's not any more reliable or any safer at point of use, but it will prevent some misuses, or at least force the developer to consider what they're doing.

Public Static Void, Rob Pike: https://www.youtube.com/watch?v=5kj5ApnhPAE

I guess I'm thinking mostly about the talk Rob Pike gave called "public static void" [1], where he probably describes pretty well what "lightness" means to him, or at least what it meant to him 7 years ago. It seems largely about verbosity.

[1] https://www.youtube.com/watch?v=5kj5ApnhPAE

Please watch this. https://www.youtube.com/watch?v=5kj5ApnhPAE

> I wonder what rob pike has to say about OOP or java, I wish I could listen to it.

12 minutes where Pike talks about a few things, that seem to be wrong in our software world: https://www.youtube.com/watch?v=5kj5ApnhPAE

"Public Static Void"

Rob Pike (Bell Labs, Plan 9, Google Go) gave this short speech at OSCON 2010 about what's wrong with programming languages, their thinking, and their recent direction, with a lot of focus on C++/Java/C#, and how Go was a response to that.

https://www.youtube.com/watch?v=5kj5ApnhPAE

Apple Swift seems to share much of the thinking, and the huge enthusiasm for Swift this week suggests developers seem to at least subconsciously recognize there is a problem.

⬐ klibertp

But you do realise that .NET is not only C#? And that F# had many (maybe even most, but I didn't research enough to say this) features that Swift has?

(And, on the related note, that Swift has not even one (or maybe? as I said, I didn't do enough research yet) novel, unique feature which wouldn't be already explored and implemented in other languages.)

What you're saying is an equivalent of "there's many things wrong with JVM, for example lack of type inference".

⬐ dottrap

This is addressed to. Not all languages compile cleanly to the CLR. Running in the VM has serious tradeoffs as well. Garbage collection is a serious problem for soft/hard real time apps. Understanding performance is difficult too because the VM may be doing stupid things behind your back and you can't directly control things like CPU cache locality with this many layers.

Porting the VM is also difficult. It is a really complicated piece of machinery, and if you are in truly cross platform environments, getting the VM up on new systems is a massive engineering challenge in by itself. Often these other environments are CPU and memory constrained too which isn't great for the .NET VM.

⬐ chc

I'm not sure these are actually problems with the Microsoft stack, though. Most mainstream languages run in VMs these days — JavaScript, Ruby, Python, Lua, PHP, all JVM languages. Off the top of my head, the ones that don't are pretty much the three C's and Go.

⬐ chc

F# is really cool, but the fact that it isn't the primary .NET client language does show. For example, Swift's mandatory option types are fantastic, and they're so integral to the language that they get special syntax support. Meanwhile, F# has an option type, but non-F# code doesn't know anything about it, so any actual use of the system frameworks litters your code with unexploded null mines.

⬐ grexican

This is a great point, and I think it's one of the most powerful things about .NET. You can compile most (many) other languages and use it all interchangeably. Build in one language, use in another.

Each language has its pros/cons, and depending on the project you're working on, you can pick which language is best for the task at hand.

>PHP is horribly inconsistent, breaks all the rules about programming language design, and is infuriating.

Some say that rules are made to be broken. In the context of Go, Rob Pike argues exactly that in this short talk on why they made Go: http://www.youtube.com/watch?v=5kj5ApnhPAE

The "Talks and Videos" page (http://go-lang.cat-v.org/talks/) is outdated as well. Here's my personal list:

Why Learn Go? http://www.youtube.com/watch?v=FTl0tl9BGdc Short interview with Rob Pike, OSCON 2012

Get Started with Go http://www.youtube.com/watch?v=2KmHtgtEZ1s Andrew Gerrand

A Tour of Go http://www.youtube.com/watch?v=ytEkHepK08c Russ Cox

Go Concurrency Patterns http://www.youtube.com/watch?v=f6kdp27TYZs Rob Pike, Google I/O 2012 Goroutines, Channels

Meet the Go Team http://www.youtube.com/watch?v=sln-gJaURzk Panel (Pike, Thompson, Griesemer, Gerrand, Fitzpatrick, Simons), Google I/O 2012

Computing Map Tiles with Go on App Engine http://www.youtube.com/watch?v=sPagpg0b7no Chris Broadfoot, Andrew Gerrand, Google I/O 2012

Go in Production http://www.youtube.com/watch?v=kKQLhGZVN4A Gustavo Niemeyer, Google I/O 2012

Go: Code that grows with grace http://vimeo.com/42146678 (Contains some audio glitches) Andrew Gerrand

Interview with Rob Pike http://www.infoq.com/interviews/pike-google-go/ Rob Pike, GOTO Conference

Lexical Scanning in Go http://www.youtube.com/watch?v=HxaD_trXwRE Rob Pike

Cuddle, A Go AppEngine Demo http://www.youtube.com/watch?v=HQtLRqqB-Kk Andrew Gerrand

Building Integrated Apps on Google's Cloud Platform http://www.youtube.com/watch?v=Mo1YKpIF1PQ Andrew Gerrand, Google Developer Day Japan 2011

Real World Go http://www.youtube.com/watch?v=7QDVRowyUQA Andrew Gerrand, I/O BootCamp 2011

Go: it's that simple?! http://www.youtube.com/watch?v=LWpm1qpWRwA Andrew Gerrand, OSDC 2011

Practical Go Programming http://www.youtube.com/watch?v=2-pPAvqyluI Andrew Gerrand, FOSDEM 2011

Writing Web Apps in Go http://www.youtube.com/watch?v=-i0hat7pdpk Andrew Gerrand, Rob Pike, Google I/O 2011

Go Programming http://www.youtube.com/watch?v=jgVhBThJdXc Rob Pike, Google I/O 2010

Another Go at Language Design http://www.youtube.com/watch?v=7VcArS4Wpqk Rob Pike, Stanford University

Public Static Void http://www.youtube.com/watch?v=5kj5ApnhPAE Rob Pike, OSCON 2010

The Go Programming Language http://www.youtube.com/watch?v=rKnDgT73v8s Rob Pike, Google Tech Talk

⬐ thebigshane

I haven't 'diff'-ed these two lists but a similar listing of Go-related talks can be found on Go community's unofficial wiki: https://code.google.com/p/go-wiki/wiki/GoTalks

See Rob Pike's talk: http://www.youtube.com/watch?v=5kj5ApnhPAE to understand Go in relation to Java.

⬐ acqq

Every time I see news about Go I go and read again the http://golang.org/doc/go_spec.html to see if something got better. The first version I've read still needed ";" separators.

Still, D looks to better by the order of magnitude. I think Go solves less problems than D: What I like in D is that it moves in the direction of letting the programmer interact with the "knowledge" the complier has when it processes the code, much more successful than the C++ template clumsiness. Compared to that Go has much more "old" feeling even if Rob claim it's "modern." Even more important, D allows even writing "classic C level" of code if needed -- and for some critical places it's always needed. As far as I understand, the whole D (the compiler and libraries) can be written in D, which is not the case with Go which certainly needs good-old C.

Video of his talk: http://www.youtube.com/watch?v=5kj5ApnhPAE&feature=playe...!

⬐ papaf

That's a short and inspiring talk. I found myself at http://golang.org/ for the first time after seeing it.

⬐ runT1ME

"Why do languages look like this[Ugly]?"

Because they have generics and Go doesn't. That is a good thing?

⬐ lukesandberg

the main complaint was about having to say the same thing multiple times, Generics does imply at least some additional syntax but the degree to which java or C++ requires it is excessive.