What do you think of new languages, like Nim, Crystal or Elixir? Which one has the best chances to get popular...

What do you think of new languages, like Nim, Crystal or Elixir? Which one has the best chances to get popular? Which one is your favourite and why?

Other urls found in this thread:

elixir-lang.org/
ziglang.org/
twitter.com/SFWRedditImages

pls respond

Crystal I really want to like, I can get stuff done in it really quickly and it feels natural, but I whenever I use it I find myself writing unreadable crap that's 75% keywords.

Also, it feels like learning C++ again, it's packed to the gills with obscure features and syntax constructs.

Haven't tried the others.

Nim seems nice, but it has really weird syntax for OOP and inheritance

Elixir is nice and also has biggest community and most libraries of those three.
But I doubt any of those will be more than niche languages

Elixir has a big solid foundation of Erlang behind it, so it's safer choice, but it's bad general-purpose programming language, shifted a lot by it's goal being of stable server language and pretty fucking slow. Seriously, why it's so slow? For how much it enforces pattern matching, recursion and functional purity, I would expect compiler to have a lot of assumption for optimizations. But it's not even comparable to Java.
Not sure what to think about crystal. I just hate few things about ruby syntax and crystal copied them all.
Nim... is that meme? I've never seen anyone using it, only few gtards shilling it.

Could more research make elixir faster?

>I doubt any of those will be more than niche languages

Why?
>easy syntax (ruby or python like in case of crystal and nim) - better than ruby
>multi-threaded, high performance
>more expressive structure than go

Perl 6

>better than ruby
i mean rust

unfortunately thats not how it goes, we got already plenty of languages/choice and inertia is strong, Node.js, Python, Java etc will be dominating server side for a long time, only language which can rival them in the coming decades will be Go, maybe Rust

Get over it. Perl 6 was dead on arrival.

>Node.js
slow, not best syntax for long term maintaining

>Python
slow

>Java
not as slow, but not as fast as nim or crystal can be, also vanilla java syntax is boilerplate as fuck

>Go
It is already quite popular, but its too simplistic and not as fast as crystal or nim can be

>Rust
worse syntax for fast development, i think it will stay as low level C replacement but not for general purpose

screencap my post and see you in 5 years to see who was right

Nim
>write initial implementation in nim
>debug-edit-test cycle
>transpile to C
>optimise performance critical code
>C compiler wraps up the loose ends
Seems like a decent balance between productivity and performance.
>what was Cfront

Newbie here. What language should I learn that is not outdated and does not have these same issues (obscure features and syntax constructs) like c++?

you should get a job as a burgerflipper

fuck off

Elixir is already popular.

Crystal is really nice, but has no corporate sponsor and is still limping along as a toy language.

Never seen Nim beyond reddit-grade sperglord comments

I've used elixir for some simple stuff, it's nice.

I think it's gonna take over, it seems like a natural step-up from ruby or python. Phoenix also helps make it stupid fast to setup your bad CRUD app with blazing speed.

Rust is fun, but hard to get right at first and has poor bindings to most things you might want to use it with. Go is ez as fuck, but still performant and honestly fine for a lot of applications, but (intentionally) lacks advanced features. C# is even easier but requires a JIT like mono or .NET Core on non-windows platforms, but has a very rich ecosystem and honestly just werks most of the time. It's also used in a lot of game engines as a scripting language. Javascript for general purpose computing is an excellent choice if you want to deal with the clusterfuck that is NodeJS and npm, and is the fastest way to make you want to neck yourself for poor choices in your life.

>rust
>elixir
no decent, easy to use FFI that doesn't want to make you neck yourself
>js
no FFI whatsoever

Ponylang.org

doing things in crystal after using something restrictive like Rust or Haskell really makes you feel super free
I love it

i'm thinking about making browser based card game, and i wonder what language would be best
i'm most comfortable with c# and python, but i thought i can go with something faster and more modern
can you recommend any of those?

Elixir and Nim are both good. I have not personally tried Crystal. Elixir will probably catch on faster as it's used for webdev. is right though, they'll always be behind the big and widely supported languages like Python and JavaScript.

ONLY RUST

use elixir. there's actually a great tutorial for it that has you simulate blackjack. google for it

>Ponylang.org
Why?
There's barely any references to mlp in the github, so they're hiding their power level well, too.

>it's literally called Ponylang
>they're hiding their power level well

Literally who?

The hell is nim.

>t. nu-netscape shill

Nim is nice. I use it.
## **Stack API**
##
## This stack is implemented with ``seq`` data structure.

type
StackObj*[T] = object
values*: seq[T]
StackRef*[T] = ref StackObj[T]
Stack*[T] = StackObj[T] | StackRef[T]

template makeStack(): untyped =
result.values = newSeq[T](args.len())
for i in args:
result.values[i] = args[i]

proc newStackObj*[T](args: varargs[T]): StackObj[T] =
## **O(n)**
##
## Constructs and returns a new ``Stack[T]`` in the stack.
## The values themselves are stored in the heap because of
## the underlying data structure, ``seq[T]``
makeStack()

proc newStackRef*[T](args: varargs[T]): StackRef[T] =
## **O(n)**
##
## Constructs and returns a new ``Stack[T]`` in the heap.
makeStack()

proc pushBack*[T](stack: var Stack[T]; value: T) =
## Unless reallocations happen, **O(1)**
##
## Append a value to the end of the stack.
stack.values.add(value)

proc popBack*[T](stack: var Stack[T]): T =
## **O(1)** Because it doesn't have to shift any value of the underlying value seq to the left
##
## Delete the first item of the stack. Return a copy of the said item.
result = stack.values[0]
# stack.values = stack.values[0 .. stack.values.len()]
# Well, apperently doing this doesn't really help. Dumb code ahead:
stack.values.delete(stack.values.len() - 1)

proc isEmpty*[T](stack: Stack[T]): bool =
return stack.data.size == 0

proc `$`*[T](stack: Stack[T]): string =
## **EXPENSIVE OPERATION**
##
## Returns the Deep Copy the string representation of the value seq
return $stack.values

proc size*[T](stack: Stack[T]): int =
## **O(1)**
##
## Return the length of the underlying sequence of values
return stack.values.len()

transpiled language, ruby like syntax, its IR is C, which allows performance-critical code to be read over before passing through the C compiler
>what was Cfront

>ruby like syntax
That's crystal. I used crystal too. They are working with Scala core devs to port their immix GC to crystal.

shit
>s/ruby/python

Erlang's VM isn't "slow", it's optimized for low latency instead of throughput. With this "it's le slow!!" meme you get people who write large systems in go because it's "fast" and then realize they have shit latency under load. Ever since I learned erlang and read about its VM I realized it's a language about which a lot of misinformation is spread, it's even worse than perl 5 in that regard.

biggest issue with crystal is how fucking wonky static compilation is.

you can get it working, but compared to everything else in the language, it just feels way too difficult

Not only is it slow, but its ridiculously scalable.
You can throw an OTP based application at a group of servers, and with minimal configuration have a system which is extremely performant.

For truly mission critical stuff, or things that require a lot of numerical heavy lifting, use something like Crystal or go as a microservice, but control it over a message bus from elixir. Pure bliss

>Crystal
Meme
>Nim
Meme
>Elixir
Actually useful, Erlang is insanely powerful but its syntax is obtuse as fuck. Elixir is just Erlang with better syntactic sugar, and it is fucking SLICK.

Because they're idiots who look at single-threaded benchmarks and say IT TAKES TOO LONG TO COMPUTE THE FIRST TEN MILLION PRIMES ITS A SHIT LANGUAGE without ever considering its designed purpose.

Addendum to my previous post I doubt any language other than oldfag shit like C or COBOL/FORTRAN has seen as much field use as the BEAM VM and Erlang. Elixir is just a neat syntax on top of this. The Telecom industry use of Erlang is incredible

>COMPUTE THE FIRST TEN MILLION PRIMES
did they sum them too?

isn't elixir too slow when i have low resources and need performance?
scalability is not an issue for a shitty ccg prototype

bump

Elixir is already used and has proven that it's a very solid language made for large-scale webshit. It's already popular.
Crystal is basically ruby so its potential for becoming popular is huge.
Nim is a fun toylang.

We already have like a million languages already

Adding new ones is retarded as fuck

Existing languages can do literally anything the new ones can and just a good because they already have massive variety

We will end up like phones at this rate

A cute girls asks you for a charging cable for her phone and you have 10 of them and not a single one fits her port

Non of those languages are nice to use on Windows. Windows-support is the single most important criteria that people ignore.

It's why Python succeeded much more than Ruby.

>Existing languages can do literally anything the new ones can
Show me language with C-like performance and Python- or Ruby-like syntax simplicity

>10 of them and not a single one fits her port
are you talking about actual charging cables or your dildos? because from some time there are only two commonly used port types

I think Crystal has potential but Nim is going nowhere. It is much older and they haven't even sorted out the basic 1.0 spec yet.

AFAIK Nim has better Windows support and are closer to 1.0 than Crystal

ATS, It's brilliant for both low and high level programming and reads like ML for the most part. The detail in the syntax allows for exact control over where things are stored (e.g stack allocated closures over heap allocated), what effects it can have, if it must terminate, and as far as how the input relates to the output.

It's also on par with C/C++ if one knows what they're doing.

I really like crystal and learned it even though I don't have any experience in ruby. I feel like it still has some problems, especially regarding error reporting during compile time and some documentation. I often found myself reading through ruby documentation trying to understand what the hell was going on

here.
I've used both Nim and Crystal but Nim gives you much more freedom imo. Crystal's memory management is still unfolding, they are working with Scala core devs to port the immix GC to Crystal. Crystal, unlike Nim, however completely self hosted. But Nim is far superior than Crystal in almost every aspect I can think of.

>Elixir
Don't do webdev, so no idea. Sorry.

Why did they have to choose such a shit name? The language is really good but nobody will use it because they don't want to be associated with bronys

>10 of them and not a single one fits her port
My cable will fit into her port if you know what I mean

None. They're memes.

Well I can tell you right now that Elixir is beyond worthless. All it does is attempt to solve a problem with Erlang's syntax where no problem actually exists. On top of that, you need to be proficient with Erlang to use Elixir anyways since doing anything meaningful with the language requires you to drop down to native Eralng syntax to interopt with the Erlang/OTP modules.

And beyond that, people seem to have a lot of misconceptions about what Erlang is actually useful for. The lightweight threading built into the VM 1) isn't that unique and you can find frameworks providing similar functionality even for native languages and 2) isn't useful for the kinds of scenarios people seem to want to use it for (like parallel number crunching). But the threading isn't the primary selling point of Erlang, it's simply a requisite of the way the language/VM operate, and people seem to overlook its actually strengths.

>Nim
They need to build a proper compiler.
>Crystal
They need to finish their compiler.
>Elixir
Looks good, but wrong niche to be useful for me. I also dropped Erlang for the same reason.

>Which one has the best chances to get popular?
If I had to place bets, it's Crystal. Because:
>Crystal can also cater Ruby users for the most part
>Nim on the other hand doesn't cater Python users
>Elixir, see above.

That said, is right and you basically need maximal shill power to get people to use your language, like Google, Mozilla and Apple have. Quality isn't - and was never - an argument with anything related to IT.

>Which one is your favourite and why?
Crystal, because I already used it for more than a hello world and even in it's current state it was relatively painless.

here

I don't agree 100%, but I have to admit that there are cases when flow based type detection sucks.

Fucking source.

Keri sable don't know which

syntax looks like shit

Jai is coming out soon and is going to be really popular.

Maybe, but it uses the same bytecode as Erlang, so they don't have the excuse of being a rather new language

>coming out soon
it doesn't even have a compiler

>Jai

The name alone makes it go straight into the trash.

>For how much it enforces pattern matching, recursion and functional purity, I would expect compiler to have a lot of assumption for optimizations.
Actually those aren't necessarily fast semantics.

hmm, at least from when I've used it, it's bizarrely scimpy on resource use.

I believe it's because it's based on erlang. joe armstrong said something cute to the effect of "erlang on a raspberry pi? you mean a supercomputer?". The whole erlang world is a bunch of Serious People, and they seem to have kept resource usage at like 1995 levels.

I'd say give it a try, it may surprise you.

>pls respond
sums up the community of each lang

Oh you haven't even seen all of it. It's ML for the most part but adding refinement types (seen at the top), linear types (more syntax), data props (enjoy prolog?), and more.

Though some of it can be cleaned I'm not sure the rest can as a lot of it is extra information for either the type system or the compiler.

for example:
fn - non recursive
fun - recursive
fnx - mutual recursive tail call, safe to convert to jumps
case - non exhaustive cases are warnings
case+ - raise warnings to errors
case- - suppress warnings
val, val+, val- - same as above
: - pure function
: - closure no side effects
: - closure all side effects
: - may throw an exception
: - returns a reference
t@ype - unboxed (can be cleaned up)
type - boxed
,. - termination metric, variable here must be strictly decreasing
a @ l - there's a type a stored at location l
{a:ty} - for all quantifier
[a:ty] - there exists quantifier
Are all common

>elixir-lang.org/
>Elixir is a dynamic
fuckin dropped

Nim has a better thing going on w.r.t. typing, niggas can do useful shit like statically differentiate between fun(ptr, size) and fun(ptr, ptr)
Still a stagnant niche lang tho

any good guides to ATS? Seems like a natural step for going full autismo after haskell

>>Rust
>will stay as C replacement

>supports 2.5 platforms
>C replacement
ISHYDBT

There's the official book which goes well for the most part and a few blogs. I'm currently writing a short Learn X in Y minutes for it (the pic in my post) to capture most of the things missed by the official documentation.

You might want to follow through SICP with it after grasping the basics and reading through prelude and contrib. Plus watch the StrangeLoop talk on it to get a clearer picture of what you're going in to.

>working with Scala core devs to port their immix GC to crystal.
good shit t-b-h

>statically typed lang
>"meme"
>dynamically typed shit
>not meme
typelets, when will they learn

Adding to this, I might also include the syntax file I use since the ones I've found don't really cover enough / are broken.

makes sense
>originally a language within Ericsson, developed by Joe Armstrong, Robert Virding and Mike Williams in 1986,[6]
>was released as open source in 1998.[7][8]
>Erlang/OTP is supported and maintained by the OTP product unit at Ericsson.
nordic niggas know how to produce non-shit tech

>Existing languages can do literally anything
point me to a non-shit GUI toolkit
"fuss around with semi-manual memory management" Qt don't count

>closer to 1.0
ho ho ho

ur mom looks like shit
>not recognizing superior ML sum type syntax

Go for D.
Niche but stable and with the best community.

Creators are two c++ dev that are very famous

>Keri sable
Isn't that the "Go crazy on me" scene?

>jai
>pet project of famous-by-proxy guy

>"going to be really popular"
>falling for the cult of personality meem

Everyone's first language should be C. It's dead simple and most languages are built from it. You can learn everything unrelated to memory and pointers within an hour, and the rest over a weekend.

Everyone's first language should be Assembly. It's dead simple and most languages are built from it. You can learn everything unrelated to memory within an hour, and the rest over a year.

ziglang.org/

no, you completely misunderstood what programming is about.

what programming is about sensei?

sicp:
Our design of this introductory computer-science subject reflects two major concerns. First, we want to establish the idea that a computer language is not just a way of getting a computer to perform operations but rather that it is a novel formal medium for expressing ideas about methodology. Thus, programs must be written for people to read, and only incidentally for machines to execute. Second, we believe that the essential material to be addressed by a subject at this level is not the syntax of particular programming-language constructs, nor clever algorithms for computing particular functions efficiently, nor even the mathematical analysis of algorithms and the foundations of computing, but rather the techniques used to control the intellectual complexity of large software systems.

Elixir is comfy as fuck for webdev/concurrent programs especially if you're into functional programming.

Nim is also neat, readable and performant but it lacks stability(its really stable for a pre1.0 but I'm talking more about vision and featurecreep) and wants a lot even though it doesnt have the manpower.
Kotlin Native and Go are the biggest reasons why Nim, Crystal etc will fail. A big company needs to support this sadly.

I would actually argue ATS being better for this as students can make use of refinement types to ensure their algorithms terminate and produce correct results. Given slightly more complex behaviours they can use dataprops to capture the exact behaviour in a declarative prologish style at the type level.

As for resource management ATS makes all pointer arithmetic and usage explicit at the type level making common mistakes such as losing a reference to allocated memory, double free, and even access out of bounds of a memory region a type error making it much easier to detect and handle rather than having to run valgrid and gdb for hours on end to find the origin of the memory leak.

Looking past C, the language is also perfect for learning concepts outside of procedural imperative with the encouraged style being that of ML (functional programming) with the option to create and pass objects if one so desires (through closures or records). Students have a chance to learn about closures (GC / manual management), lazy evaluation (GC / manual management), manipulating AST through lisp and C style macros, pattern matching, GADTs, optimisation of recursive function calls, continuations, and much more.

Then there's learning C alongside ATS, since there's direct support for embedded C in ATS source and ATS sharing it's unboxed types with C, there's quite a strong case for using it from a student and teaching perspective. Writing refinement for C code can help in making sure you never pass a NULL pointer to a C procedure which requires a non NULL pointer and even constraints on the range of inputs to reduce the possibility of passing a value not covered by the procedure's specification.

With the ability to run with or without a GC and performance on par with C, I believe ATS should be the first for any student learning systems programming and possibly for the more general programming courses.