OSNews

Actually it probably does:

http://en.wikipedia.org/wiki/Type_inference

Sorry, I'd forgotten how literal one has to be on osnews. Of course they're related, but the statement:

That was probably supposed to say the type of variables don't have to be defined before they're used.

He means that the blurb is wrong to say that static typing MEANS type inference. You can have strong static typing but not type inference (look at Java <= 6 and C++ < 0x).

While it is true that you can't have type inferencing in a meaningful way without strong static types, the other way around is not true.

Yes, you said this better than I did.

Static typing bring so much information to the compiler, it both enables very good type inference (just look at F# or other functional languages doing), and pretty good compiler time checks.

Gosu is like Matlab/Octave/Scilab. Type inference boosts productivity but it is a double edged sword.

For people who don't know, gosu means a skilled game player or athlete in Korean. Literally means a person with an upper hand.

I was about to describe the meaning as well.. actually doesn't need to be a game player or an athlete. "gosu"(고수) is just like "guru". You can be a "gosu" on any kind of work, play or something non physical; e.g. gosu of love, gosu of chess, gosu of typing, gosu of wasting time

Anyway, it is quite exciting for me(Korean background) to see some of projects adopting Korean words like suhoshin of php and this gosu language and etc. I am about to go and have a look at the syntax and referecen if there are any.

No. You're thinking about dynamic typing. Type inferencing in this case is really just getting rid of redundancy.

So instead of saying:
Arraylist<int> blah = new ArrayList<int>();

Just say:
val blah = new ArrayList<int>();

Which is *okay* because by looking at the right side of the equal sign, the compiler can statically figure out the type of the variable.

If you insist on figuring out the exact type of every variable, then perhaps.

If you don't, then less types in the code means less overhead for your brain.

Understanding variables is part of stepping through code.

With type inference there is less for new programmers to learn but when it comes to reading code your brain ends up doing more work especially as a program increases in size.

This is where the "if you insist" part comes into play.

We live in different worlds. I'm used to dynamically typed languages, and very seldom have a problem with not having any type information what so ever in the code. I think static typing has benefits in the tool support department, but not so much for me understanding the code. Perhaps once in a while I would like to see the type of a variable. Ultimately, I would then be able to ask the IDE and it would come back with the inferred type. The rest of the year, explicit types in the code only stand in the way and mean extra work for me as a developer.

I find "dumbassEnterpriseyNamedClass= new DumbassEnterpriseyNamedClass()" _far_ easier to read then "DumbassEnterpriseyNamedClass dumbassEnterpriseyNamedClass = new DumbassEnterpriseyNamedClass()", especially when that is nestled in the middle of 20 other similar statements. It's not so bad when classes don't have names that stretch on forever, but for some reason people who use verbose languages tend to love to embrace that aspect and run with it.

Well it sounds like you have been reading Java which is one of the worst in that regard.

The readability issue becomes apparent when skimming through code to figure out what it does. Type deceleration makes it easier to quickly focus on and keep track of important variables. I've stepped through VB.NET code (DIM DIM DIM DIM) that would have taken me half as long in C# or C++.

The other thing that caught my eye was the increment operator... which isn't REALLY an increment operator at all, but a complete assignment statement in function.

So i++ really translates to i = i + 1 (it is not really an unary operator to Gosu). It cannot, therefore, be used in the middle of an expression.

I think that is confusing - why even offer it?

I for one will stay with Scala/Clojure/Groovy for the JVM, nothing new to see here.

But it is nice to see people investing on the JVM anyway.

Javascript already runs on the JVM. The implementation is called Rhino.

And Gosu looks nothing like Javascript, other than both have the "C" heritage, and share some features.

My experience with Open sourced code from a company that just has one huge customer, is that the really obscure features that are needed for that app for the giant customer are added, but none of the ones that would make sense for more general purposes.

Full disclosure, I'm one of the guys at Guidewire. One of the things that we've done right over the 9 years that we've been building enterprise software, is that we've never built a language feature just for one customer. GEICO, Liberty Mutual, and about 80 other insurance companies have been convinced that our software is solid, and that they're going to invest in training 100's of their own developers to use Gosu.

I totally understand why you'd be skeptical, but we're very pragmatic about the features we do put in. They can't be just useful to a couple language nerds.

Why bother? Simple. So you can use those goodies on other platforms besides Windows, or .Net. I'm not knocking those, but lots of people prefer choice of platforms as well as vendor.

And give credit where credit is due. Ander Hejlsberg and his team at MS have done a fantastic job of designing and evolving C#.

And unfortunately, Java (the language) has fallen behind.

However, the JVM itself is a fantastic, wonderful feat of software engineering, and a great platform to run on, and loaded with huge, fantastic, libraries.

Java (the Language) being behind the times, + the JVM (the runtime/platform) being a wonderful platform and great engineering = need for other JVM languages. Enter Scala, Groovy, JRuby, Jython, Clojure, and now Gosu. And some of these are already well into large production environments - Groovy and Grails, Scala + Lift, JRuby, etc.

This is where the excitement of Java lies - JVM + newer JVM languages.

Edited 2010-11-12 16:41 UTC

You're right, I agree that there is still value in the Java platform.

However with the real thing, I mean the thing itself. You can actually use C# with JVM. For example:

* Grasshopper lets you use C# to directly write JVM code. It was expensive, but I think it became free: http://dev.mainsoft.com/Default.aspx?tabid=29

* Stab (another open source project) is already an implementation of a C# like language on the JVM: http://code.google.com/p/stab-language/

* As a side note, IKVM lets you do the reverse: Java JAR -> .Net DLL conversion, thus you can employ Java libraries in .Net project

And there could be others. That's why I'm questioning the novelty of this new language.

Hi Guys,

I'm one of the gosu developers, the guy who gave the presentation to the SacJUG.

So, yeah, Gosu isn't revolutionary in many ways: it takes good ideas from C#, Ruby, etc. and then tries to be a very smooth lateral transition for java developers. It is statically typed mainly to support tooling (code competion, etc.) It has a few interesting features, such as a delegate keyword that allows you to implement interfaces with a field, which allows for easy compositional programming ("Favor composition over inheritance" the experts always tell me.)

It also has automatic downcasting after a type test:

var foo : Object = "foo"
if( foo typeis String ) {
print( foo.capitalize() ) // <-- automatically downcast to String
}

These are small things, but nice.

The core innovation of the language is the Open Type System, which allows frameworks to generate Domain Specific Type Systems. It's effectively a formalized and simple to understand metaprogramming system that gives library and framework developers a heck of a tool. Scott McKinney, the father of the language, will be putting a post up on this concept soon here:

http://guidewiredevelopment.wordpress.com/

If you are a JVM programmer or someone who likes to dabble in lots of languages, Gosu is worth watching.

Also, for the concerns that this language might be too oriented towards a particular client: don't worry. Gosu is a general programming language that used in all sorts of ways by Guidewire. The commercial support increases the chance that it won't go away. (Guidewire actually makes money, this isn't a vanity project.)

I'm happy to answer any questions or comments.