Is there anything like Julia, but with strong typing and pure FP?
addendum: read 'static' for 'strong', please
Julia 0.5 Highlights
31–40 of 64 posts
Re: Julia 0.5 Highlights
#32Is there anything like Julia, but with strong typing and pure FP? addendum: read 'static' for 'strong', please
That depends on what "like Julia" means. It's not a functional language, so the short answer is "no". Given that it lacks a true static type system and supports macros it's philosophically LISP-like; notably the Julia compiler includes a sizeable chunk of LISP code. But it's also clearly not a LISP.
Re: Julia 0.5 Highlights
#33Regarding the vectorized function calls (sorry if I misunderstood something): but how is this generic?
if I have a function:
``` function addone{x Wouldn't it be natural that `addone.` is dispatched when I call `addone([2 3])`?
Re: Julia 0.5 Highlights
#34Is there anything like Julia, but with strong typing and pure FP? addendum: read 'static' for 'strong', please
That depends on what "like Julia" means. It's not a functional language, so the short answer is "no". Given that it lacks a true static type system and supports macros it's philosophically LISP-like; notably the Julia compiler includes a sizeable chunk of LISP code. But it's also clearly not a LISP.
I realize that your use of the phrase "functional language" seems to entail having a static type system and purity, but most people seem to consider Lisp to be the original functional language and it doesn't have either property. If one considers Lisp to be functional then it seems like Julia should be as well. Do you not consider Lisp to be functional? Real question, not a rhetorical one – I'm trying to assess where people fall on this terminology.
Re: Julia 0.5 Highlights
#35Is there anything like Julia, but with strong typing and pure FP? addendum: read 'static' for 'strong', please
Julia is very strongly typed, much more so than most dynamic languages. Because the type inference can remove type checks in performance-sensitive code, the language and standard library are much more willing to throw type checks around all over the place, which means that errors get caught much closer to where they were caused compared to most dynamic languages.
julia> xs = ["foo", "bar"]
2-element Array{String,1}:
"foo"
"bar"
julia> push!(xs, 42)
ERROR: MethodError: Cannot `convert` an object of type Int64 to an object of type String
This may have arisen from a call to the constructor String(...),
since type constructors fall back to convert methods.
in push!(::Array{String,1}, ::Int64) at ./array.jl:479
julia> xs = Any["foo", "bar"]
2-element Array{Any,1}:
"foo"
"bar"
julia> push!(xs, 42)
3-element Array{Any,1}:
"foo"
"bar"
42
Re: Julia 0.5 Highlights
#36Earlier quoted context omitted.
That depends on what "like Julia" means. It's not a functional language, so the short answer is "no". Given that it lacks a true static type system and supports macros it's philosophically LISP-like; notably the Julia compiler includes a sizeable chunk of LISP code. But it's also clearly not a LISP.
I realize that your use of the phrase "functional language" seems to entail having a static type system and purity, but most people seem to consider Lisp to be the original functional language and it doesn't have either property. If one considers Lisp to be functional then it seems like Julia should be as well. Do you not consider Lisp to be functional? Real question, not a rhetorical one – I'm trying to assess where…
"Functional language" is ill-defined, hence my specific question about static typing and purity. I would really like to have a language for scientific computing that had good scalable performance as well as static types and referential transparency.
Re: Julia 0.5 Highlights
#37Why does the returned value (100, 100) consume 208 bytes?
The counter reports all heap-allocated memory, not just memory that persists after the function call, and the description in the post doesn't look quite right. The 208 bytes come almost entirely from calling the function from the global scope. Inside a function, there would only be 16 bytes of memory allocated on the heap, for the generator itself (which we desperately want to get rid of, but that is still WIP) and the return value would live in registers or on the stack.
Re: Julia 0.5 Highlights
#385 years ago I thought for sure I would be using Julia today. (I mostly use R) I have found that news tools have come into play that I haven't really felt the need for a faster language then R for my work. I'm interested in people's everyday use of Julia and how it has impacted your workflow. I don't work with "Big Data" most of my data sets are bellow 100k in size. Anyone using Julia for medium and small data sets?
Not to be snarky, but we announced Julia in Feb 2012, which is less than 5 years ago. Unless you happened to be in the MIT class that used Julia in the Fall of 2011, you're probably overestimating how long you've been following the project. If you're comfortable using R and the tooling and performance it offers, you should probably keep using it. Julia isn't just about big data, but it does tend to appeal to people w…
Okay 4.5 years :) I really was wowed by the promise of Julia and the road map you presented for it, great job by the way. I just am surprised I haven't picked it up yet personally. I have a feeling that my R ecosystem wouldn't be as strong as it is right now if it wasn't for the friendly Julia competition you have provided.
I guess I am seeking the one "pet project" that would get me to jump in and give Julia a test drive.
Thanks for all your work even though I don't directly benefit from your work.
Re: Julia 0.5 Highlights
#39Earlier quoted context omitted.
I realize that your use of the phrase "functional language" seems to entail having a static type system and purity, but most people seem to consider Lisp to be the original functional language and it doesn't have either property. If one considers Lisp to be functional then it seems like Julia should be as well. Do you not consider Lisp to be functional? Real question, not a rhetorical one – I'm trying to assess where…
"Functional language" is ill-defined, hence my specific question about static typing and purity. I would really like to have a language for scientific computing that had good scalable performance as well as static types and referential transparency.
As far as I know, no such system exists. Strict static typing and numerical computing are, I suspect, more at odds with each other than they casually appear to be. The seemingly simple `+` operator is the most polymorphic and overloaded function-like entity in many static languages (and often can't be defined as a normal function for that very reason). And `+` doesn't hold a candle to the polymorphism of array indexing and slicing, which is pretty crucial for productive numerical work.
Re: Julia 0.5 Highlights
#405 years ago I thought for sure I would be using Julia today. (I mostly use R) I have found that news tools have come into play that I haven't really felt the need for a faster language then R for my work. I'm interested in people's everyday use of Julia and how it has impacted your workflow. I don't work with "Big Data" most of my data sets are bellow 100k in size. Anyone using Julia for medium and small data sets?
I've used Julia for prototyping Monte Carlo and data assimilation algorithms, and also solving simple (1d) nonlinear PDEs (Fourier-spectral code with exponential RK timestepping -- not very complicated as these things go). It's also more or less completely replaced Matlab for me in terms of plotting and visualization (most of what I need is very simple). So far it has been very pleasant, so long as one remembers that…
I taught myself Racket and that was the single biggest changer in terms of my programming in R and enjoyment of the language. After digging around I learned that scheme was a major influence in R's creation. Your comment now makes me excited to give Julia a spin.