Comments on: Google “Go” become “issue 9″

By: EvereQ

EvereQ — Thu, 03 Dec 2009 15:28:06 +0000

Yes, sure I understand your point – thanks a lot – it make sense to exists!
Unfortunately for me it NOT looks like something new (at least in languages I know same concepts already exists and used widely), more so personally I prefer approach with extra type annotations like in C# 4.0 to support Duck typing only in places where developers explicitly want to do this (just take a look how Go “support” Unit testing (http://golang.org/doc/go_faq.html#How_do_I_writ...) and absence of assert keyword! Not sure developers will write “safe” code, at least before Go will get own JUnit analog or Google think up some new testing methodology for testing as well??? ).
And again – for me it looks like better approach to support full featured class / interfaces hierarchies with dynamic features / Duck typing when developers want or to choose strategy like Groovy – extend already existed language with ability to run all existed frameworks / tools from old language (Java in case of Groovy).
Also If developers really want to make less coupled hierarchies (in places where it make sense, like different aspects, services etc), they can use DIP (IoC) to inject at run-time what they want and where they want! Look for example into Grails framework and the way how Groovy + Spring give you ability to inject services (http://grails.org/doc/latest/guide/8.%20The%20S...) – I think this is EXACTLY what developers want in programming languages in addition to classical / interface hierarchies, inheritance etc – ability to do injection quickly and declaratively. Why? Because developers can CONTROL this process (using DSL or even XML if needed), instead of “fixed, but not safe injection” like in Go structs
Again, as always it's just my personal opinion – same like exists thousand developers that does not like static typed languages or dynamic typed languages and seems there is no sense to “argument” around this
Sure also I agree with you that in most cases “we only see something being 'new' when we don't see a large portion in between”, but sometimes people invent something SO unique that developers / regular people start real BUZZ around this… It was like this with Ruby on Rails for example (now Grails does not made same buzz for some reason, even so for me it looks little more promised because of ability to reuse of all Java stuff that we already have) or with iPhone or with Gmail long ago etc.
And sure I also agree with you that Google invent some “unique” combination of “fusion” – If they do not do this they will be really in big trouble (i.e. if in addition to usage of already existed language name “Go” they also reuse same syntax, libraries from another language… but it will be not Google I think…).
The question and problem only is that this “fusion” for me can be much better and can have much better name
That was idea around my post actually!

By: SteveMcQwark

SteveMcQwark — Thu, 03 Dec 2009 13:20:25 +0000

My point about the inheritance was that they implemented it in spite of themselves A struct type containing an anonymous object behaves like it inherited from the type of that object. They just also put effort into reducing the need for massive class hierarchies by loosening up interfaces a bit to better resemble duck-typing while remaining type safe.

I think they believe they've come up with something new with their particular fusion of high level and low level elements, and in their implementation of goroutines, their typing system, etc. Of course, an original idea doesn't usually exist, but rather, a progression, and we only see something being “new” when we don't seen a large portion in between

And I do agree the name 'Go' is a bit dumb, being a common two letter word

By: EvereQ

EvereQ — Thu, 03 Dec 2009 06:28:06 +0000

Sure also I agree with you that in most cases “we only see something being
'new' when we don't see a large portion in between”, but sometimes people
invent something SO unique that developers / regular people start real BUZZ
around this… It was like this with Ruby on Rails for example (now Grails
does not made same buzz for some reason, even so for me it looks little more
promised because of ability to reuse of all Java stuff that we already have)
or with iPhone or with Gmail long ago etc.

Sure I also agree with you that Google invent some “unique” combination of
“fusion” – If they do not do this they will be really in big trouble (i.e.
if in addition to usage of already existed language name “Go” they also
reuse same syntax, libraries from another language… but it will be not
Google I think…). The question and problem only is that this “fusion” for
me can be much better and can have much better name That was idea around
my post actually!

By: SteveMcQwark

SteveMcQwark — Thu, 03 Dec 2009 04:20:25 +0000

And I do agree the name 'Go' is a bit dumb, being a common two letter word

By: evereq

evereq — Wed, 02 Dec 2009 04:24:11 +0000

Hi Steve! Thanks a lot for your comment!
Here are some my arguments:
1) System language in my point of view does not need to be “low level” like you describe… It MUST include low level constructs (pointers, memory allocations etc) – this I agree, but it can be high level in other functionality, simply because current software is really complex and using high level language simplify development of COMPLEX system applications.
2) About inheritance and other stuff – take a look into Groovy way for example! It include ALL high level (and low level sure thing) functionality from Java (like abstract classes, class inheritance etc) PLUS flexibility of dynamic language! For me seems it much better way, than restrictions that currently exists in Go language design… Think about huge class hierarchies like used in Spring or in .NET framework for example! How you will construct them in Go? Sure maybe Google currently does not want to implement “rich” language library (framework), but in future it for sure will be big limitation that prevent usage of language in many projects! Even in case if you will use Go to develop RIA applications (and this is what Google want as initial step – embed Go into Chrome), rivals like JavaFX or Silverlight support HUGE class / interface hierarchies powered by high level languages like Java or C#. I don't see any sense again to invent language with LESS functionality then Java or C# with only one exception if you invent some new paradigm after procedure, OO or functional paradigms! Unfortunately for me seems Google does not invent new paradigm in Go language
3) Regarding language name. long time ago, most used language construct was “goto” (I not sure maybe it was invented in Basic first maybe not), but languages was not called “goto” anyway And it was right, as now seems nobody actually use this keyword It's joke sure thing, and “go” keyword will be used in in Go language with better idea than “goto” in Basic, but for me it looks not so right to call language “Go” just because of keyword name! A lot of people complain that name “Go” will made search too complicated and it looks correct. Regarding “Go!”… Let's take a look into another example. Some big company decide to invent new language and without any goggling they call it “Jav”. What will be reaction from Sun? In this case, it is not Sun owner of “Go!”, it's simple “small” man who try to made something and even publish BOOK! (think about it!!! He publish Book!!! Not everybody who invent some language for educational purposes publish book about it) … I don't tell that Google can't call language “Go”, I just think first they need to ask this small man “can we call our language same way like you call yours” – and for sure this “small” man will tell “yes” (probably after get some “not” small money, probably for free if he is really enthusiast – does not meter). The problem that Google DO made mistake and now DO need to do something with it! And looks like Google need to fix this issue 9 the way that now not only this “small” man will be happy but also about 1000 people that made own comments on issue 9!

Anyway, I was glad to hear another opinion and probably a lot of people will agree with you!
In any case Google do Good job, they try to invent something and this is very important – as more alternatives we developers will get, the better will be our everyday job

By: SteveMcQwark

SteveMcQwark — Tue, 01 Dec 2009 23:32:48 +0000

Making it a high level language would defeat the purpose. The whole point is that its a systems language. Which means its lower level. That said, it contains many high-level-inspired constructs, and has shortcuts for common applications that have developed since C and C++ were formulated.

You comments about inheritance show that you didn't look into how the language works. Basically, you don't have to worry about inheritance. You just program your object (which is declared as a struct type) with the functions it needs. Then, when you want to use a variety of different types of objects, you just create an interface defining what members the type needs to have, making it a lot easier to create of objects that behave similarly in certain ways, since you don't have to set up an inheritance structure.

Interfaces exist in other languages, but they tend to be explicit, which means that each time you need to use a different subset of functions, you need to add an interface to all the different types you want to use, which can get clunky. Instead, in Go, you just define the interface when you need it. It makes it somewhat of a compile time explicit duck-typing, which allows the development process to flow more smoothly as in high level languages while still being type safe.

When you want your new type to be some other type plus some, you can just declare an anonymous (no name) object of that type in your new type. Then, if there's no ambiguity (I don't know how the language deals with ambiguity), you can treat all the members of the anonymous object as members of your new type.

As for the name, its appropriate, because one of the main features of the language is the 'go' keyword, which executes the following command concurrently with the code in which it was called. The concurrent computation is called a goroutine, and the compiler decides whether/when it needs to be a thread, or whether it can just be multiplexed (pretty much meaning it coexists with other routines in the same thread, which takes less resources).

Pretty much every suitable name has been taken by some pet project somewhere that never went everywhere. And McCabe's language didn't show up in search results until recently, since its become a hot topic. Besides "Go" and "Go!" are no more identical than "C" and "C#". Further, the guy named his book "Lets Go!" (note the bad grammar), which is almost identical to a multitude of other books titled "Let's Go" so he clearly didn't give a bother to name collision. Finally, he clearly never intended his language for widespread usage, since you have to buy his book for 15$ in order to decide whether its worth learning. There is no other way of assessing the practicality of his language, which means it will always be overlooked beside the heap of alternatives that you can evaluate for free, or are already established.