New programming languages that have a bright future

>I meant that you don't have to specify types if you don't want to or don't have a reason to.
Actually it's only partial type inference - for good reasons - and flow based type inference gets annoying often enough. Ideally they would made function/method signatures forced manifest, but I can understand that this would drive away Ruby weenies.

>The overall state of the language is not bad at all
as long as you do fizzbuzz/web shit, that may be true, but as soon as you do "advanced" stuff, a lot of things break in surprinsing ways, like type inferrence.

>>windows port
>Yeah no we don't need that
Ironically this is probably the first thing to be finished.

this

What about Julia? Is that shit the bomb, seems pretty fast at least.

Attached: Julia_prog_language.svg.png (1200x811, 43K)

The only newish langs I'm hype for are purescript and Elm.

I love Nim!

Seems like a feasible way to fill this particular niche, at last. That said, I'm a little bit worried about the implementation itself, like all scientific software they will find a way to botch it.

Julia is nice, but they mainly focus on scientific computing. Main problem will be convincing people to fuck off from Python or R. They have great arguments to switch but their ecosystem is weak.
Nim's biggest contender(currently Go) will be Kotlin Native

>Main problem will be convincing people to fuck off from Python or R.
This. Scientist give less than a fuck about the quality of their tools until one of those tools make them publish false data that will make their pyramid citation system crumble.

we could use more monitors

Why would I use it instead of R for statistics or Python for machine learning? Being serious, I'm really interested but don't see the advantage yet.

How is it for learning to program ?

If youre just a casual programmer youre not going to see a huge difference between Julia and Python. Julia has better higher order functions, better module system, cleaner syntax (no double underscore built-in functions everywhere), its all about reducing friction and making data programming easier and more intuitive. And since most data science jobs are centered around web data, using R is no longer practical as it is very clunky to use in a web context.

Nim's GC is not thread safe, you have to use generic bdwgc to accommodate this. Good luck.

Has anyone tried Pony, I saw it mentioned and I dont know if it is legit or just another experimental language
ponylang.org/

In theory, unlike R it doesn't look like a shotgunned face and unlike Python it isn't slow as fuck and doesn't require you to drop to C and take performance hits every time you call a binding or write shitty just-in-time compilers for special DSLs.
In reality, most scientists probably most likely won't care, but Julia could pose an advantage to some fields like the machine learning meme, biocomputing, computer vision and geospatial modelling.

any zi/g/ fans here?

>using R is impracticle in a web context

library('jsonlite’)
payload = fromJSON("my.hipster.com/webapi?call={args}")

OMG so hard

If you start with c# or python it'll be a great second language, for beginners its not there yet

why is everyone trying to make and shill c++ replacements recently

1. Obviously people are dissatisfied with C++. From what I am reading though C++14 (or something like that) is a nice lang to work with.
2. Compile times only should make you want something better
3. Nim isn't for C++, I think. Nim is for people that want a performant lang, fast compile times and expressiveness(with it's almost Lisp macro system and templates). Currently using a realtime gc so you can make games etc without dropping fps. So unless you're working on _really_ constrained embedded stuff, you'll be aight.
Nim might drop it's GC in the future: nim-lang.org/araq/destructors.html

Can someone tell me what the up and up on
Scala
F#
Ocaml
Haskell

are?
I guess as you can tell the functional bug has bit me.

Attached: magoo.png (842x472, 552K)

Common Lisp already exists. All these new hipster languages are unecessary.

>I can import web data into Excel
>btfo huuuur

Because C++ can't get better.

I tried all of these except Haskell.
Between Scala and F# you're basically choosing between the JVM or the .NET environment. Scala also has more jobs. I prefer F# because it's cleaner and has a lot less concepts and in repos I've seen it can get messy unless you're a Scala-master.
If you know F# the learning curve for Ocaml is like 6 hours or something max. ReasonML makes OCaml a lot more comfier. You'd choose OCaml/ReasonML if you want to webdev(Bucklescript and it's community is great!)
Can't tell you much about Haskell sorry I do not want to go full functional, cause I noticed myself writing less code and more arguing bout monads etc.

Quick shill for Nim: nim has some nice fp support and third libs that provide fp data structures. Try it hueheuhe.

>too-big-to-fail
>new
are you retarded?

no, you are
Not every company is a shitty startup at day one.

this comes pre-sjwd so no

>I give you: Crystal. Extremely comfy to write programs in, safely yet dynamically typed, con throw it through the llvm stack to get extremely fast binaries. What's not to love?
Its a compiled version of Ruby...like why would anyone use a compiled scripting language. Crystal was originally interpreted, if they would make a fork of Crystal that ran interpreted the language might actually take off

They don't have a CoC, hell even the BDFL can be a rude dude from time to time(he's reasonable though), so can you tell me what drugs you on so I can be retarded too?

Haskell is the best
Scala is almost as powerful as haskell but is bogged down by its standard library and language design making some things that are simple in haskell painfully complex in scala.
I've never used ocaml.
F# lacks typeclasses and some of the other higher level abstractions of scala and haskell.

If you're getting into stuff now and don't have platform constrains haskell is the easy winner.

Kind regards from a professional scala developer.

>Can someone tell me what the up and up on
>Scala
failed experiment to combine OO and FP

>F#
subset of Ocaml that runs on .NET, whats not to love

>Ocaml
>Haskell
Rust has all the features of Ocaml, type inference, optional types, immutable variables by default. Using a FP language that forces you to use recursion for looping is just idiotic. Extra autism points for anyone who thinks that monads actually do anything.

Anyone here have an opinion on Dart? Ive heard it can compile to binary

Doesn't F# have type providers( docs.microsoft.com/en-us/dotnet/fsharp/tutorials/type-providers/) that somewhat compensate the lack of typeclesses?

Also most of those `higher level abstractions` in Scala I've seen in the wild lead to spaghetti code.

Underrated language somewhat(it does Java really well). If you know any OOP lang you should be able to learn it in a weekend. But you'll probbly won't use it for anything beside client-side webdev or flutter(flutter.io/)
Flutter is awesome.

That's mainly owing to how I referred to things as being needlessly complex to express.

I've seen some serious abuse of the power of scala too.

Type provides sadly aren't on the level of true type classes.

>Crystal was originally interpreted, if they would make a fork of Crystal that ran interpreted the language might actually take off
what did he mean by this

My bad, get your point now.

I want to learn a fp programming language but I have trouble deciding

Haskell, idris, agda, scala, common lisp.
It's all so nutty
Maybe I should just learn bash

name one single company that was too-big-to-fail within the first quarter of its conception

Several mining companies. Heavy metal works factories. Canonical.

Haskell.

It teaches concepts perfectly. Moving to the others means only learning how to implement those concepts.

Trust me on this. Haskell is way easier to learn to do things and do them well than scala for instance.
. Again for context I write scala for a living. We might be bringing in haskell soon though.

In that case yeah Haskell.
Maaaaaaaaayyybbeeeee OCaml first but I think Haskell will be better.

Is haskell really used in industry ?

lisp>haskell.
Lain uses lisp.
Haskell is for brainlets

Attached: fea5525fb750753327f16e41667de861_full.jpg (450x338, 53K)

Not widely but there is a growing community and general recognition of what it offers in terms of static analysis and maintainability.

what's with the pic?

>what did he mean by this
this is what I meant:
crystal-lang.org/2013/11/14/good-bye-ruby-thursday.html

What makes lisp so much better

Lain uses it.

I like it. Wrote a small program last month.

Lisp is a metaprogramming language to the extreme, its homoiconic syntax allows very deep levels of macro programming. Most people who learn Lisp, especially Clojure, never bother to learn how to metaprogram in Lisp and use Lisp like a regular scripting language, hence the Lisp/Clojure hype died out

>Rust has all the features of Ocaml

And a shit syntax.

You act like recursion is bad.

It's so much simpler.

Also confirmed for having no idea what monads are or what they are for.

Scala>Haskell

It really isn't better at all. Once you do a deep enough dive into scala you'll see.

Fucking trampolines and shit yo.

what does your program do?

Haskell is for spoiled academics, soyboy language

Scala is for real workers, real true hackers.
Lisp is for geniuses true OG

>You act like recursion is bad.
>It's so much simpler.
Its not, its even more complicated and error prone than for/while loops with explicit iterator variables. You should avoid recursion the same way you avoid loops by using iterator/mapping functions

>Scala is for real workers, real true hackers.
what little use of Scala there is will be completely erased by Kotlin

D is the best C++ killer

>professional scala developer.
So how about those compile times?
I keed, I keed.
What are the parts you love and hate the most about working with picrel, and how long have you been doing it?

Attached: CAQi-bOUwAAUPQ3.jpg (768x1024, 92K)

Kotlin is too hard to learn

>Lisp is a metaprogramming language to the extreme, its homoiconic syntax allows very deep levels of macro programming
Is that a good thing? Doesn't that lead to the problem of unreadable codebases where every source file is essentially written in its own domain specific language?

>Haskell is way easier to learn to do things and do them well than scala for instance.
Not claiming this for everything, right?
I'm thinking the impedance mismatch between a lazy, pure language and most (messy) real life tasks might give a more pragmatic (and less pure) language an advantage quite often.
Conversely, CS papers and Haskell compilers are definitely better served by Haskell than by Scala.

google "haskell tax" for a hint
shit b8 m8, they've each got their pros and cons

t. russki
>Scala is for real haslel wannabes, real Java++ pajeets
>Lisp is for true le wrong generation autists
ftfy

Nothing, it's a meme.

I can't tell if lisp is a meme or not
Ahhh

Do I learn kotlin or haskell if I found java intolerable

>Python implicit bracketing style
>Ruby 2-space indents
>Unnecessarily obtuse keyword and syntax for no conceivable gain
Nim has potential but it has a lot of really fucking stupid decisions.

metaprogramming does have practical application, pic related is good at explaining how to take advantage of it in a language like Ruby. But Lisp is just pure metaprogramming, very few people say theyre Lisp programmers really understand this

Attached: ppmetr2.jpg (2250x2700, 1013K)

Good things are that there are pure fp libraries that can give you the majority of the tools you need to do things.
Bad thing is that the lack of purity in the language and the level of bullshit that's possible leads to some really nightmarish codebases when written by people who aren't as principled about their design choices.

Giving myself nightmares again about our one html parser.

Once well versed and practiced in fp there is real problem to solve messy problems in a pure way. It's no harder than the nature of the problem itself.

Most of our code is strictly pure scala that could easily be expressed haskell much more succinctly.

Clojure is neat but I personally would say to go the route of a language supporting solid static analysis out of the box.

Haskell is still the king here for usability.

>can't tell if lisp is a meme or not
protip: if Jow Forums's meeming it, there's a pretty decent chance it's a meem
>kotlin or haskell if java intolerable
give kotlin a shot, to make use of your pre-existing conditions^Wknowledge - their sales pitch is that java pajeets can be productive in it in under a day/afternoon/whatever
learn haskek for the same reason you'd learn Lisp or Prolog - to get a more well rounded education of the different points in PL design space, and get access to different POVs for solving shit. Don't expect it to be a pragmatic language, although it's the most pragmatic one out of the academic wank roster.

Oh yeah, if you lads are going strict purity, it does seem like Haskell would be the better choice.
Hope you can gradually (and successfully, business-wise) transition.

>ctrl+F pony
>no discussion
It looks unique, at least. Any thoughts?

Seems to be a rust tryhard

where the /kotlin/ shills at

And does the future look bright?

Attached: android_kotlin_logos.jpg (1200x600, 35K)

To be honest we should all give up, the next gen languages are Go and Rust

I get the feeling that with "worse is better" in full swing decade-on-decade for over half a century now, the best proglangs will not reach significant uptake and be left to iconoclasts and mad geniuses.

In that case you should learn them because they're the best, not because they'll get you a job. Or if they get you a job, it'll be a rare job but a better job. Who wants to compete with the literal army of third-world Java programmers?

Unfortunate name.

>2-space indents
>stupid decision
say that to my face in real life

Please, share

I really hate that it uses unions types where it should use sums.

Maybe when it's stable... I'd miss RAII a lot though.

It borrows a lot from Pascal and Python.
Those aren't stupid design decisions, you just can't handle change.

>New programming language
>Bright future

Attached: 1471759028551.gif (640x636, 359K)

>1 / 0 == 0
I want to like it, but...