Coffeehouse Thread

14 posts

Forum Read Only

This forum has been made read only by the site admins. No new threads or comments can be added.

Jetbrains developing a new programming language

Back to Forum: Coffeehouse
  • User profile image
    Ray7

    Jetbrains have developed (arguably) the best IDE on the planet, so this is definitely something to watch with interest.

    It'll be JVM-compatible so the framework support is definitely there. Looking at the examples, I'd say they're aiming somewhere between Groovy and Scala.

    Kotlin

  • User profile image
    Ray7

    Yes, this is Scala for beginners.

    Clever, very clever.

     

  • User profile image
    Maddus Mattus

    If it sux just as much as reSharper,. I will not be using it Smiley

  • User profile image
    Ray7

    ,Maddus Mattus wrote

    If it sux just as much as reSharper,. I will not be using it Smiley

    Don't know anything about ReSharper, but I imagine it can only be as good as the foundation it's built on ... Smiley

     

  • User profile image
    vesuvius

    I think it has a crap name

    I also think Resharper is excellent but they are too greedy. After acquiring licenses in January, they released a new version a few weeks ago with a cut off of April, otherwise cough up another £200. I did not even get a stable bug free version, before they tried to cash in on their new Reflector version

    Note sure what Maddus is non-plussed about (citation needed) but hope the new C# compiler as a service with result in a version that is not trying to fit square pegs in round holes

     Edit

    http://beust.com/weblog/2011/07/20/five-reasons-why-should-rejoice-about-kotlin/

  • User profile image
    Harlequin

    I don't know. Every time I see a new language that has the word "print" in it, I'm just going to think it's just a rehash of 40 year old langauges.

  • User profile image
    cbae

    http://confluence.jetbrains.net/display/Kotlin/Basic+syntax+walk-through

    fun main(args : Array<String>) {
      if (args.size < 2) {
        print("No number supplied");
      }
      val x = parseInt(args[0])
      val y = parseInt(args[1])
    
      // We cannot say 'x * y' now because they may hold nulls
    
      if (x != null && y != null) {
        print(x * y) // Now we can
      }
    }

    a. Semicolon line terminators are optional.

    b. Syntax error due to Java on the brain.

    c. Typographical error by editor of the web page.

    ?

  • User profile image
    cbae

    ,Harlequin wrote

    I don't know. Every time I see a new language that has the word "print" in it, I'm just going to think it's just a rehash of 40 year old langauges.

    At least it's a print function and not a print "command" or print "message" with bracket notation.

  • User profile image
    exoteric

    ,Ray7 wrote

    Yes, this is Scala for beginners.

    Clever, very clever.

    It's kinda less clever than Scala tho', innit? Wink

    I do like the null-safety aspect of the language. And it also has "extension functions" a la C# extension methods.

  • User profile image
    Bass

    I think the new, more advanced JVM languages have good intentions but won't go anywhere anytime soon. The network effect of Java is so huge. I'd love to get a job coding Scala or some other JVM language but they are few and far between compared to Java and C#.

    Personally I think Java the language itself is good enough. But it needs to evolve faster, unfortunately even with Oracle at the helm there seems to be no improvement in this.

     

  • User profile image
    Ray7

    @Bass:

    JetBrains are the Apple of developer tools. They have survived and flourished against IDEs that are free, though not quite as good (IMO). In the same way Apple uses the MacOSX to drive hardware sales, JetBrains is going to use Kotlin to drive sales of their IDE. (Since it's free and open, there is nothing to stop Eclipse building a plugin for it. They probably won't, and if they did it wouldn't be as good). 

    I think they've hit the right spot between Groovy and Scala. I was really pleased to see that they've opted for proper operator overloading instead of the Scala 'call a method name whatever you like' approach, which seems to encourage folk to build incomprehensible frameworks simply because they can. Program statements like this:

    x ! y

    are holding the language back because folk like to look at a line of code and know exactly what it means without too much effort. Most of the examples I run into seem aimed at proving mathematical prowess rather than actually explaining how the language works. 

    I agree that Java is going to be pretty hard to displace. Java is good enough, so there is little reason for most companies to replace it. However, I've been doing Groovy/Grails developments for the past year (on a Linux box too) and the number of jobs asking for it in the UK has been on the rise (recession permitting) for the past two years. So the work is out there.

    I think Kotlin will overtake Scala eventually and (if Jetbrains play their cards right) sit alongside (or just behind) Groovy. Why? Because languages created by businesses rather than academia always seem to do better in the marketplace. 

    But I don't see it displacing Java anytime soon. However, as Jetbrains and Apple have proved, you don't need to have the biggest marketshare to be a success.

  • User profile image
    Blue Ink

    @Ray7: while I agree that operator overloading is dangerous, I must say that I still have to see it seriously abused in C#, so I'm optimistic that developers learned their lesson.

    In general, the language has a number of interesting features, but none of them seems compelling enough to make me invest in a different syntax (not really that unfamiliar... more of a jumble of other old languages). If I were so inclined, I would probably go for the real thing (i.e. Scala) rather than what looks like a subset. Hard way to gain mindshare.

    That's the problem with languages: it's hard to survive in a niche as businesses will be weary of investing in a language that is backed by exactly one company and for which there are virtually no expert programmers around. This could have been said of C# and Microsoft back then, but JetBrains is no Microsoft...

  • User profile image
    Ray7

    @Blue Ink: Actually, I don't really have a problem with operator overloading. The problem I have is that Scala doesn't actually support it. What it allows you to do is use just about combination of characters as a method name. Combined with infix notation this is really powerful stuff. For a class Person, you can define an surname setter like this:

    def surname_= (value:String):Unit = _surname = value

    which you call like this:

    person.surname = 'Smith'

    with = being the method name.

    Great, until folk forget that code should be self-documenting and decide that 

    server.send(message)

    is to hard to type, so we should have

    server ! message

    instead. 

    This is the kind of thing that puts developers off Scala. Most of them are not mathematicians so won't take the time to read through convoluted examples strewn with weird symbols and notations that only make sense the original developer. 

    As to the success of Kotlin, I wouldn't want to hazard a guess either way. Jetbrains managed to survive and thrive against an IDE that is free and backed by IBM. That's pretty good going.  The language runs on the JVM so it already has the biggest framework infrastructure on any platform. It's similar enough to Java that developers (of which there are many) can pick it up by just reading a single page of documentation. It will have the best support from the best IDE. It's being developed with input from the same developer base and it'll be free and open under the Apace license. All of this is not enough to guarantee any traction, but it's a good start.

     

     

     

  • User profile image
    Blue Ink

    @Ray7: True, "operator overloading" is a somewhat inaccurate term to describe what Scala (and F#, to a lesser degree) offers. Yet, even the tamer mechanisms offered for instance by C# and C++ are powerful enough to create unreadable code if abused and I have yet to see any serious offence in that area.

    The only case where I saw a gratuitous use of operator overloading are the infamous "<<" and ">>" operators in iostream (as in std::cout << "Hello World") which is pretty similar to the example you made; while I still think there was no compelling need for such a feature, I must admit that it was at least designed with readability in mind. So, again, I am confident that nobody will abuse the feature just because they can.

    As to the success of Kotlin, we'll see how it goes, but I'm not sure that success of an IDE is any indicator of the potential for success of a language, as they constitute different kinds of investments.

Conversation locked

This conversation has been locked by the site admins. No new comments can be made.