Julia 1.0 released

julialang.org/blog/2018/08/one-point-zero

If you're in a scientific/math/machine-learning field, you have no reason not to give this a go for your projects.

>Rivals the speed of C
>Easy to use with syntax similar to Python
>Eliminates the need to make prototypes in a high level language and then have to re-write in a low level language for performance
>Open source
>Born at MIT

Plenty of talks here:
youtube.com/user/JuliaLanguage/videos

Attached: julia.png (280x180, 3K)

Other urls found in this thread:

github.com/JuliaNLSolvers/Optim.jl/blob/master/src/Manifolds.jl
github.com/svaksha/Julia.jl/blob/master/Programming-Paradigms.md
youtube.com/user/JuliaLanguage/featured
pypi.org/project/multimethod/
juliaimages.github.io/latest/index.html
juliaimages.github.io/latest/
github.com/JuliaLang/julia/tree/master/src
github.com/JuliaLang/julia/tree/master/base
github.com/JuliaLang/julia/blob/master/base/math.jl
julialang.org/publications/
twitter.com/SFWRedditImages

What? A 1.0 release?
Will Femanon posts now be less braindead? The previous versions where rather shit.

>The previous versions were rather shit
Why do you think so?
I thought 0.5 and 0.6 were rather good

>You have no reason no to give it a go
>syntax similar to Python
Pick one.

What do you find objectionable about this kind of syntax?

github.com/JuliaNLSolvers/Optim.jl/blob/master/src/Manifolds.jl

>end keyword
>indentation

Why do you dislike them

Because he is brainlet who had never written anything besides his i3 config

Some more info on programming paradigms in julia
github.com/svaksha/Julia.jl/blob/master/Programming-Paradigms.md

>Plenty of talks here:
talks are being streamed live right now from the JuliaCon
youtube.com/user/JuliaLanguage/featured

Someone redpill me on why this is horrible. I literally have heard nothing bad about Julia and I don't know why nobody is using it.

How about a quick rundown, why would I use this instead of:
R
MatLab
Python/Perl with huge libraries for my specific field.

indentation is optional

Kek

Julia would be better if it used s-expressions.

>If you're in a scientific/math/machine-learning field, you have no reason not to give this a go for your projects.
So I don't have a reason to use it.
>Slow and limited
>Proprietary botnet
>Slow and knowing Perl/Python ecosystems probably buggy pieces of shit as well

>I don't know why nobody is using it
Plenty of people are using it in my field. Whenever someone gets introduced to it, they tend to convert right away saying things like "why wasnt I using this earlier"

Are you kidding user
MatLab is insanely slow

And Julia has wrappers/support for a fuckton of python libraries

Julia is actually good. It's one of only a handful of languages with multiple dispatch (and not as a hacky library like python's decorators version of it.)

Single dispatch is for ghetto peasants.

Lisp would be better if it used m-expressions.
>multiple dispatch
this, quads confirm

It's another diversity hire language for brainlets.

>>Lisp would be better if it used m-expressions.
It really wouldn't. Many people have implemented it, nobody has adopted it. Why is that? Because despite what your intuition says (and you're not alone in this) it's not actually better.

The problem I'm seeing is that in my field, which is not computer science, nobody knows what the fuck Julia is. I just asked and nobody knew or gave a shit, and these are people that write code on the daily.
Anyone who does any serious large programming projects uses C++ right now.
This is a real problem in the real world, not having anyone to collaborate with is what it comes down to.
Personally, I'm interested in Julia and I'm going to play around with it for a few hours. I like what I see so far, so maybe I'll start using it for my own stuff and shill it around.

And you're not wrong about buggy pieces of shit, but it's what you get unless you want to spend all your time figuring out how to parse the million different file formats people use for data in my field.

Look up the company, they're all pajeets. This is just the latest flavor-of-the-month ML pooware.

It really would. Many people have implemented it, nobody has adopted it. Why is that? Because despite what your intuition says (and you are pretty much alone in this) not being lazy when designing the grammar of the language in the first place is actually better, so only the handful of mentally defective sperglords that actually use Lisp cling to minimalistic, half-assedly implemented garbage like Scheme whereas true chads use properly designed languages for their domains with no middleground for m-expression'd Lisps.

>no reason not to give it a go
I value my time. Julia is just another abstraction layer on C like R and Python, but without the academic pedigree or the massive ecosystem of packages.

>nobody knows what the fuck Julia is
Neither did they know what Python or R are.
With enough propaganda that naturally changes, since scientific code for the most parts is throw-away code anyway, either by intention or by quality.

With the advance of Racket and Clojure, lisp is set to become more popular than ever before. It might be already.

Alternative syntaxes are trivial to implement for s-expression languages since s-expressions are glorified ASTs. Nobody is using an alternative syntax with any lisp-family language because once you actually learn how s-expressions work you stop wanting anything else.

That's the simple fact. Lisp was never meant to have s-expressions in it's final form; s-expressions were just a stop-gap implementation detail. Except after they were created, people who actually use the language stopped wanting anything else.

>Julia is just another abstraction layer on C like R and Python
Much of Julia is written in Julia.

gee user all of those guys with PHds in multiple scientific fields sure look like diversity hire pajeets amirite

>Half the world uses commas to separate large number; the other half uses periods. In Julang you can use underscores. Yay!

Oh, I guess they're giving us another option. Let's try it out.

println(1_000_000 + 999_999)

>1999999

println(1,000,000 + 999,999)

>10999999

println(1.000.000 + 999.999)

>ERROR: syntax: invalid numeric constant

So, in actuality it's
>half the world does one thing, the other half another thing, but we've decided you'll do it this way because of reasons.

>clojure
Clojure was more or less killed off by Scala, but it definitely could have a renaissance if enough people in the data world were to get on board with it.

R came from lispstat and most of the AI research was done in CL. Python was heavily influenced by LISP. So, Clojure has the potential to bring everything back together.

The base types are C. All Julia does is provide an AST for those types and data structures which gives the appearance that it's something different from other languages that have already done this.

>With the advance of Racket and Clojure, lisp is set to become more popular than ever before. It might be already.
They aren't. Clojure is the next thing to go the way of Groovy and Racket is a meme, even in academics. And the rest is wishful thinking without the numbers backing it up. Nobody cares about memes. Racket might provide the best reader macro facilities of current Lisps, but it's still all Lisps brings to the table. And DSLs are fucking garbage. DSLs are the reasons that Python is popular in academics and has killed a lot of DSLs in this field. It may be garbage, but at least it is that crippled that you can't have another half-assed DSL implemented in it that easily, so at least you get APIs.

Because underscores are the common way to do it.
In every language I can think of right now(sml, ocaml, pony), underscores are used.
I for one can't think of a reason to break the convention.

The problem with language oriented programming is the friction involved in creating a new DSL. Powerful macro systems, whether in racket or another system, solve that.

Traditionally you've only had half of the equation, a DSL was easy to use, but not easy to create. So it's no wonder they've only been moderately successful.

>so at least you get APIs.
APIs are degenerate DSLs.

Their documentation claims the base is written in Julia

>>The base types are C. All Julia does is provide an AST for those types and data structures which gives the appearance that it's something different from other languages that have already done this.
Multiple dispatch gives you very real productivity gains over all the other single dispatch systems you're comparing Julia to.

Actually, it's the other way around. Every retard can create a DSL, but 99.99999% of all times it's actually just some shitty, non-coherent textual wrapper over some logic where a native API would be less lines, type-safe, faster to execute and better to maintain. With the exception of regular expressions and xpath in some limited scenarios. But other than that, everyone sane hates DSLs, everyone flees DSLs (think of ORMs and such) and knows that DSLs mostly happen because some wanker that is too incompetent to create a proper programming language wants to play with the big boys, too and soon we suffer for it by having to use that crude ad-hoc textual interface.

DSLs are degenerate programming languages.
APIs are proper engineering.

Google 'Julia Internals'.

>productivity gains
No one is going to invest time in learning something that is in essence Python without the packages.

>No one is going to invest time in learning something that is in essence Python without the packages.
No one is going to invest time in learning something that is in essence R without the packages.

>Rivals the speed of C
>Easy to use with syntax similar to Python
every week

Lots of people use systems other than Python.

And you conveniently dodged the matter of multiple dispatch. In the future people will look at single dispatch with amazement; amazement that people thought it was good. Python is now playing catch up; the next chance to see (proper first class) multiple dispatch in python will be python 4 I suppose, but I doubt we'll see it even then desu.

Julia has been around for a while now, this isn't the new hip language of the week. It's a known quantity that got a major update recently.

But I did user. And indeed most of Julia is written in Julia. are you sure you aren't reading old documentation/codebase?

It's been in development for nearly a decade, you dumb dumb.

ChadLab user here. What is multiple dispatch? How is it different from just e.g. checking the type of an input argument?

You have no idea what you're talking about. Go compare performance and library availability before talking out your ass

no, it's legit

Attached: serveimage.png (227x222, 9K)

you do realize most scientific/math libraries for python are written in C or fortran?

Yes. Go compare their speed to Julia native code.
Many of those devs are jumping ship over to Julia, plus there are wrappers for multiple libraries in multiple languages

The image processing library is a fucking mess to work with.
Skip.

>How is it different from just e.g. checking the type of an input argument?
In single dispatch, only the type of the first argument is checked dynamically when deciding which implementation to invoke, the dispatch is dynamic off the first argument but static off the remaining arguments. With multiple dispatch the first argument is no longer arbitrarily privileged, dynamic dispatch can happen off any or all of the arguments.

For example, in a system like java:

foo.process(i, j);

The first argument here is foo. The runtime type of foo determines which implementation of process is invoked. i and j also have runtime types, but the implementation of process chosen is based only off the static analysis of i and j. Sometimes you'll see this limitation causing ugly branching code in the implementation of process to handle the different runtime types of those arguments. e.g.:
void collideWith(Thing& other) {
// dynamic_cast to a pointer type returns NULL if the cast fails
// (dynamic_cast to a reference type would throw an exception on failure)
if (Asteroid* asteroid = dynamic_cast(&other)) {
// handle Asteroid-Asteroid collision
} else if (Spaceship* spaceship = dynamic_cast(&other)) {
// handle Asteroid-Spaceship collision
} else {
// default collision handling here
}
}
};


With multiple dispatch foo is no longer a privileged argument, so it's special snowflake syntax can be eliminated:
process(foo, i, j)
The implementation of process which is picked at runtime depends on the runtime type of ALL of those arguments.

CLOS and Julia have this. Python has it as a terrible hack using decorators. Because python is for hacks. pypi.org/project/multimethod/

Which .jl?
How so?

>botched formatting
The implementation of process which is picked at runtime depends on the runtime type of ALL of those arguments.

CLOS and Julia have this. Python has it as a terrible hack using decorators. Because python is for hacks. pypi.org/project/multimethod/

Images.jl
Go take a look at the documentation, it's full of bloat for something that should just do operations on multidimensional arrays.
juliaimages.github.io/latest/index.html

julia> a1p, a2p = paddedviews(0, a1, a2); # 0 is the fill value

julia> a1p
2×2 PaddedViews.PaddedView{Int64,2,Tuple{Base.OneTo{Int64},Base.OneTo{Int64}},Array{Int64,2}}:
1 0
2 0


>PaddedViews.PaddedView{Int64,2,Tuple{Base.OneTo{Int64},Base.OneTo{Int64}},Array{Int64,2}}

I mean, this family looks pretty reasonable
juliaimages.github.io/latest/

Did you try opening an issue?

People have given up on R because Python has its core functionality plus everything else.

>And you conveniently dodged the matter of multiple dispatch
Because it's completely irrelevant. No one is going to drop their codebase and retrain their coders because of some new programming feature.

>github.com/JuliaLang/julia/tree/master/src
Sure looks like a lot of .jl files in there.

Go shill your meme, garbage language somewhere else or better yet, build something with it that hasn't been done before and maybe it won't be dead in 5 years.

>People have given up on R because Python
>No one is going to drop their codebase and retrain their coders
hmmmmmm

frankly it's clear you have no clue what you're talking about. R is more popular than ever.

>I sure home they don't look here! github.com/JuliaLang/julia/tree/master/base

>Born at MIT
So it's trash developed by MIT niggers that glow in the dark. HolyC is the answer to all your needs.

>r is more popular than ever
I'm not doubting that, but it's not what it was.

All of the new ML and DS libraries are going to Python first then R as an afterthought later. Look at things like LightGBM or Vowpal Wabbit (to save you a google search, they are massive ML APIs by F500 companies that have been open-sourced), I am not sure if there is even a proper port to R yet. I'm not sure if TensorFlow even has R support yet.

So, it's an abstraction layer on C? That was my point. Both Python and R do the same thing.

So, it brings nothing to the table that hasn't been done earlier elsewhere. Sure, this language is an improvement but it's not enough of one to warrant people quitting something which does essentially the same job with a dip in performance.

>so it's an abstraction layer on C
Are you really this dumb or just pretending?

Do you know what native LLVM compilation is, you rube?

People have not given up on R, sorry. People write very specific packages for producing figures for very specific methods in R, and nothing like that exists in Python.

>>So, it's an abstraction layer on C?
At this point it's clear you are pretending to be retarded. Approximately fucking nobody uses C for scientific computing. "Just use C for everything" is an autistic Jow Forums meme.

I get it you have no reading comprehension and you are autistic enough to bring up shit like native LLVM compilation to justify why this language is 'the next big thing'.

That isn't my problem.

>>I get it you have no reading comprehension and you are autistic enough to bring up shit like native LLVM
Evidently you have no reading comprehension because not once have I mentioned LLVM.

I was the one that mentioned LLVM ya daft cunt. Julia is advertised as "Julia was designed from the beginning for high performance. Julia programs compile to efficient native code for multiple platforms via LLVM." So of fucking course it has some dependencies with C. That is completely different from being just an abstraction of C.

bruh it's all just abstraction for the x86-64 ISA. Programming languages are so lame lmao

To be fair ROOT is a thing
But I agree that Jow Forums is retarded when they say "use C for everything"

I hope people outside of science stop sleeping on Julia. I feel like its applications could extend far beyond its original purpose. High performance with a high level language is never a bad thing

Its syntax is similar to Matlab. Actually it is Matlab improved.
Where Python comes from? If you said Fortran you will have been closer.

>just another abstraction layer on C like R and Python

Attached: abstracted_brain.png (300x168, 8K)

Have you ever used any other programming language?

I really really like this picture, user. May I save it?

Sure, but it is just another abstraction layer over C.

There is a pretty easy way to check this.

Attached: 18.08.09-22.38_sel_maim.png (555x256, 20K)

>People have given up on R
R is out-of-box ready for data analysis and statistics contrast to Python
Why learn using a dozen different packages rather a single language?

Absolutely blown the fuck out
I'm always amazed at the capacity of a person to be so smug and arrogant while being completely wrong

>a phD in the 2010s
what are the requirements to get one, besides paying a tuition fee?

Yulia will be pleased :)

>R is out-of-box ready for data analysis and statistics contrast to Python
>Why learn using a dozen different packages rather a single language?
R and Matlab are languages that do nothing but work on matrices. Thats fine if all you are doing is feeding it pre-formatted table data but we live in the world of the web now where we need to clean and process data into tables that then can be processed. Julia does both, its a general purpose language that can handle any kind of data but it is also optimized for working with matrices/tables. Python simply fails as its an OO language that has shitty implementation of OO. OO works well for static data that doesnt change like game engines, but for data you need a language that is not stuck with a pre-set static data but is able to morph data into useable datasets. So Julia being non-OO is perfect for that.

I'd like to know more about Julia's Internals, if you know what I mean ;)

I don't know user why don't you look up their papers on scientific journals and find out, you might learn something

a requirement is not being a brainlet, but I believe in you.

he's so stupid he thinks he's clever

grow some pubes and then come back, babby

stupid burgers, we get paid to do phD here

Well, Julia's internals are pretty sexy so I dont blame you.

github.com/JuliaLang/julia/blob/master/base/math.jl

Honestly all Julia needs now is a Julia-tan and the brainlet side of Jow Forums will start paying more attention

Just start Julia threads with pictures of the JAV idol.

Why? Isn't a major part of Julia written in Julia?

Yes user thats the point
The naysayer was talking out of his ass

Just read all the posts making fun of his
>just an abstraction of C
comment

I would think said Jow Forums-brainlets might be intimidated by a 3D girl. So maybe a regular off-brand anime waifu tan is what they need.

3D women is for brainlets.

Really? I've done a lot of simulation, and data fitting using 0.5 and 0.6, including some pretty fiddly maths. I've found it fun and easy to use.

I'm going to wait a few weeks before moving to 1.0 though, as I tried 0.7 yesterday and… stuff broke. Some of the packages I use (including JLD and Plots) did not work properly. Still, it worked before, so I'm confident they'll have it fixed soon, just a shame things might not be totally smooth for people trying v1.0 on the day it's released.

>end keyword
>indentation

I love the end keyword, when compared to Python's just stop and hope like hell that someone noticed and didn't mess up the indentation.

And Julia's indentation is optional, but gg=G (or your preferred text editor's equivalent) will make your whole file nicely indented for you (sorry Python).

>made by pajeet
No thanks.

Yes user, look at all of these spooky scary pajeets.

julialang.org/publications/

Julia is mainly written in Julia (just a few thousand lines of C at its core, and femtolisp for the parsing). And its pedigree (MIT mathematicians who studied under Abelson and Sussman) is actually pretty good.