GHC 7.10.1 Brings New Compiler Features

[phoronix]

Phoronix: GHC 7.10.1 Brings New Compiler Features

Version 7.10.1 of the Glasgow Haskell Compiler (GHC) is now available as a major release for this open-source project...

http://www.phoronix.com/scan.php?page=news_item&px=GHC-7.10.1-Released

[caligula]

To each their own, I guess. I'm just wondering why people keep improving C++14 and Haskell when obviously most people are focusing on more modern languages like: Python, JavaScript, CoffeeScript, Clojure, Groovy, PHP, Hack, Rust, Swift, Dart.

Is there really anything to achieve with these legacy languages? Especially statically typed languages seem obsolete now that people do continuous integration and run test suites. Static typing won't mix well with BDD and TDD.

[CrystalGamma]

To each their own, I guess. I'm just wondering why people keep improving C++14 and Haskell when obviously most people are focusing on more modern languages like: Python, JavaScript, CoffeeScript, Clojure, Groovy, PHP, Hack, Rust, Swift, Dart.

Is there really anything to achieve with these legacy languages? Especially statically typed languages seem obsolete now that people do continuous integration and run test suites. Static typing won't mix well with BDD and TDD.

Python and PHP are also more than 20 years old AFAIK and I think JS will reach 20 years this year.
So 'being modern' ultimately comes down to having a living ecosystem, and this news seems like a good sign.

Also, Rust is statically typed, and my experience has told me, that this leads to many programs working at the first try, and handling all special cases right out of the gate.
Add to that special compiler support for testing, even though I feel there is a lot less need for it.

I don't know what BDD is, though.
Anyway, as you said, to each their own. I, for one, will continue looking for an opportunity to try Haskell out.

[crymsonpheonix]

To each their own, I guess. I'm just wondering why people keep improving C++14 and Haskell when obviously most people are focusing on more modern languages like: Python, JavaScript, CoffeeScript, Clojure, Groovy, PHP, Hack, Rust, Swift, Dart.

Is there really anything to achieve with these legacy languages? Especially statically typed languages seem obsolete now that people do continuous integration and run test suites. Static typing won't mix well with BDD and TDD.

I work with Python and Ruby for work. I like them, there are a lot of nice things aboout those languages. But other than Rust, you haven't listed a language that is as fast or powerful as C/C++ or Haskell (when compiled).

Like it or not C at least (if not C++ as well) is going to be around for a long time.

And why can't you use static typing with CI? Because all sorts of errors I have to write tests for in python or ruby are irrelevant and cant happen with strong typing (or, will get caught during compile rather than at run time)?

Python and PHP are also more than 20 years old AFAIK and I think JS will reach 20 years this year.
So 'being modern' ultimately comes down to having a living ecosystem, and this news seems like a good sign.

Also, Rust is statically typed, and my experience has told me, that this leads to many programs working at the first try, and handling all special cases right out of the gate.
Add to that special compiler support for testing, even though I feel there is a lot less need for it.

I don't know what BDD is, though.
Anyway, as you said, to each their own. I, for one, will continue looking for an opportunity to try Haskell out.

BDD = Behavior Driven Development
TDD = Test Driven Deveolpment

[Ropid]

To each their own, I guess. I'm just wondering why people keep improving C++14 and Haskell when obviously most people are focusing on more modern languages like: Python, JavaScript, CoffeeScript, Clojure, Groovy, PHP, Hack, Rust, Swift, Dart.

Is there really anything to achieve with these legacy languages? Especially statically typed languages seem obsolete now that people do continuous integration and run test suites. Static typing won't mix well with BDD and TDD.

If you seriously want to know and understand, you should learn enough Haskell to be able to develop not-very-small toy projects in it. The language does have its place. Concepts developed there and proven awesome are slowly seeping into the rest of the languages. The language can also absorb ideas developed somewhere else (like in the OOP world) just fine, and people can mostly do the implementation themselves so there's no limits trying to combine ideas from different worlds. While this is happening, things still continually move forward in Haskell. There's new ideas showing up all the time.

You don't have to worry about static typing and how that mixes with testing behaviour. The first papers about seriously neat ways of testing in Haskell showed up around 15 years ago. :P

[rdnetto]

To each their own, I guess. I'm just wondering why people keep improving C++14 and Haskell when obviously most people are focusing on more modern languages like: Python, JavaScript, CoffeeScript, Clojure, Groovy, PHP, Hack, Rust, Swift, Dart.

Is there really anything to achieve with these legacy languages? Especially statically typed languages seem obsolete now that people do continuous integration and run test suites. Static typing won't mix well with BDD and TDD.

Probably because it's easier to port a program already written in C++ to a newer version than to a completely different language.
Newer isn't necessarily better - languages have different niches, and no language can cater to all of them. For example, there's no way in hell Javascript or Python are about to replace C++.

Also, static typing is completely different from strong typing. e.g. Python has both strong and dynamic typing. Static vs. dynamic is when the type check is performed, strong vs. weak is whether you try to automatically convert if the types are wrong.
In addition to that, strong, statically typed languages have the major advantage that you can catch typos at compile-time, instead of at run-time. That means you don't need to test for an entire class of errors. Haskell is in a realm of its own compared to most other languages in this regard (except maybe Rust and Clojure, which were directly inspired by it) because its type system is so much more sophisticated - you can literally eliminate null pointer and out of bounds errors.

TDD and BDD can be applied to any language - it doesn't matter what its type system is. (Actually, I suspect they're probably easier to apply to statically typed languages, because they make it easier to verify you haven't broken anything by adding an argument to a function, etc.)

[caligula]

Python and PHP are also more than 20 years old AFAIK and I think JS will reach 20 years this year.
So 'being modern' ultimately comes down to having a living ecosystem, and this news seems like a good sign.

JS was reinvented as a general purpose language only later once browsers started adopting JIT engines for JS. Before HTML5 JS was mostly a toy for showing dialogs on scam sites. JS is actually less than 10 years old in general purpose Web app work.

Also, Rust is statically typed, and my experience has told me, that this leads to many programs working at the first try, and handling all special cases right out of the gate.
Add to that special compiler support for testing, even though I feel there is a lot less need for it.

There is always the problem with compiled languages that compilers are much more complex than interpreters for dynamic languages. Rust compiler is new, buggy and the language seems hard (my thoughts). For example most people nowadays want classes and objects.

[caligula]

I work with Python and Ruby for work. I like them, there are a lot of nice things aboout those languages. But other than Rust, you haven't listed a language that is as fast or powerful as C/C++ or Haskell (when compiled).

The thing is, when all apps run in HTML5/JS cloud, the performance is secondary. Also the performance problems are different. Often you just buy bigger hardware and set up proxies. The real problem is scalability, not traditional performance.

[caligula]

If you seriously want to know and understand, you should learn enough Haskell to be able to develop not-very-small toy projects in it. The language does have its place. Concepts developed there and proven awesome are slowly seeping into the rest of the languages. The language can also absorb ideas developed somewhere else (like in the OOP world) just fine, and people can mostly do the implementation themselves so there's no limits trying to combine ideas from different worlds. While this is happening, things still continually move forward in Haskell. There's new ideas showing up all the time.

The problem with Haskell is that it takes so much time to learn it that most people don't want to invest the time. If you learn OOP, you can easily switch between PHP/Python/Ruby/Java/C#/Groovy and many other mainstream languages. It's a really good investment to learn OOP. With functional mindset you get F# (closed Microsoft alternative), Swift (closed Apple alternative), some legacy compilers nobody uses, Haskell and maybe some research stuff nobody uses outside academia. Haskell might have web support, but nowadays most app development is for mobile and the cloud. Haskell generates 2 MB binaries (hello world). It's a big issues with mobile development. Without proper JS backend it's also difficult to consider it on the cloud.

[CrystalGamma]

JS was reinvented as a general purpose language only later once browsers started adopting JIT engines for JS. Before HTML5 JS was mostly a toy for showing dialogs on scam sites. JS is actually less than 10 years old in general purpose Web app work.

Except Netscape tried to do a JS server back in 1995 already.

There is always the problem with compiled languages that compilers are much more complex than interpreters for dynamic languages. Rust compiler is new, buggy and the language seems hard (my thoughts). For example most people nowadays want classes and objects.

And JITs are not complicated behemoths of a program? 'Real' interpreters are not really used anywhere anymore (least of all JavaScript).

I'm always tempted to direct people who cry out for classes everywhere to this blog post.
Meanwhile, I really like Rust's trait system, which can give you much more than classes ever did.
And I think Rust took that from Haskell's typeclasses, which is one reason I am interested in it.

There are basically two sources of complexity in Rust: the trait/generics system and the ownership/lifetime/mutability system.
They are both just concepts that are used everywhere in JS/Python/what have you, and thus have to be considered in order to write good software anyway, just made explicit, and checkable by the compiler.
Also, the language won't even be in beta until April 3rd ...
I'd say the compiler is about as buggy as I would expect the nightly builds of any language in active development to be.

The problem with Haskell is that it takes so much time to learn it that most people don't want to invest the time. If you learn OOP, you can easily switch between PHP/Python/Ruby/Java/C#/Groovy and many other mainstream languages. It's a really good investment to learn OOP. With functional mindset you get F# (closed Microsoft alternative), Swift (closed Apple alternative), some legacy compilers nobody uses, Haskell and maybe some research stuff nobody uses outside academia.

Lazyness should never be an excuse for not learning another paradigm if you have aspirations to do good work. It can really widen your horizon.
You can use a lot of useful ideas from FP languages, even if you are programming in C# ...