91–100 of 249 posts
I built a very simple neural-network app a few years ago with Julia, and while the project was fun and I didn't think the language was bad by any means, as someone who does software for a living I had trouble seeing why compsci people really got into it. I could totally see someone like my dad using it (he's an aerospace engineer, not software), but I have friends who work in compsci in academia trying to evangelize…
Earlier quoted context omitted.
It's extremely expressive. Notably, Julia is homoiconic, with full lisp-style macros. It also has multiple dispatch, which is a far more general technique that OO single-dispatch. This makes it very easy to define modular interfaces that work much like statically-typed type classes in Haskell. This allows you, for example, to define a custom matrix type for your bespoke sparse matrix layout and have it work seamlessl…
Please don't vilify Python or R thinking that will help with Julia's adoption or popularity. If Julia is as awesome as its evangelists say, it will gracefully displace its competitors without the need of a smear campaign
With computational power becoming cheaper and cheaper - will we have two-language problem anymore?
The target of julia is computional sciences. Sure for a web apps you don't care if your language is 30x slower, 1ms or 30us who cares, you can just rely on the raw speed of your overpowered computer and enjoy your favorite language. But when it's between waiting 1 day or 1 month for your results you start caring quite a lot
Earlier quoted context omitted.
I had a job about 7 years ago doing Coldfusion and Flash. Coldfusion is 1 indexed and Actionscript is 0 indexed...this threw me off enough to the point of having a near-religious aversion towards explicit indexing, and while I've largely drunk the functional Kool-aid where I almost exclusively use maps and filters and reduce. I really do with the 1 indexing had stayed around, since I feel like it's more natural to sa…
>> I really do with the 1 indexing had stayed around, since I feel like it's more natural to say the 1st element, instead of the 0th. It's not the 0th element. It is the 1st element and has an offset of 0 from the beginning of the array. Not saying it's better or worse, but that if you change the words you use to describe it, you may find it easier to use. To my surprise, I just learned that ranges in Rust don't incl…
https://doc.rust-lang.org/std/ops/struct.RangeToInclusive.ht...
Earlier quoted context omitted.
I'm not sure how I feel about multi-dispatch...I've had a few headaches chasing down problems with multimethods in Clojure...I'd have to try using Julia full-time to see how it feels. I was unaware that Julia was homoiconic...I'm somewhat of a Lisp fanboy so I might need to give the language another chance.
There's pretty big differences in usage between multimethods in Clojure and Julia. I've used both a decent amount. All functions in Julia are multimethods by default. If you don't use type annotations, a new method will be generated whenever you call the function with new argument types. This explicit type specialization is a very important part of why Julia can have such a consistently fast JIT despite its dynamicit…
Damn. That's a pretty clever trade off between dynamic and static types.
Multi-methods really are a lot of fun, but I'm missing the Trait system (instead of the object hierarchy) that makes Rust so modular. I know that there are some tries to put it into Julia, but none of them is well supported.
I thought Tim Holy's Trait Tick was considered the de facto way to use traits in Julia? https://github.com/mauro3/SimpleTraits.jl
Earlier quoted context omitted.
It's the difference between numbering the contents of the list (1 indexing), and measuring the distance from the beginning of the list to the start of the item (0 indexing). Personally I'm happy to switch between both, and they both have positives and negatives when I actually write code. 0 indexing is not incorrect, or incompatible with maths, it is just a different way of conceiving of lists/arrays by considering t…
> It's the difference between numbering the contents of the list (1 indexing), and measuring the distance from the beginning of the list to the start of the item (0 indexing). The problem is that one is indeed an indexing (numbering the contents 1...X...N and asking for item X, customers[X]), whereas the other is not, but is used as an indexing (e.g. customers[5] is not getting the 5th item but the sixth).
If I had to give a name to the concept you're talking about, it would be an "ordinal index".
Problem with Julia is not (only) 1-based array indexing, but their uses of ranges. Closed ranges are not composable. For Python-style ranges for a lot of operations (mean, sum, ...) I could define monoid, provide composition rules and be done with it. WTF I supposed to do with Julia ranges?!
What do you mean by closed ranges composition ?
s = 0 for k in range(0, N): s += a[k]
Ok, I have more cores/CPUs, could I do it in parallel? Sure
v1 = Sum(0, N/2) v2 = Sum(N/2, N) s = v1 + v2
I even could do it on asymmetric cores (like most phone CPUs today)
v1 = Sum(0, K) v2 = Sum(K, N) s = v1 + v2
I could do a bit more complicated things, like calculating means. For that, I have to make a monoid
def mean(from, to, a): m = 0 for k in range(from, to): m += a[k] N = to - from return (m/N, N)
Here I'm returning tuple, and for that to be a monoid I have to state composition law:
def compose(M1, M2): A1, N1 = M1 A2, N2 = M2 N = N1+N2 return ((A1N1 + A2N2)/N, N)
If my identity is (0,0) tuple, it is quite easy to verify that indeed I have a monoid. Nice, simple, composable ranges.
For closed [1...N] ranges this is NOT nice, NOT simple, just plain fugly exercise. Sorry, looks like code samples are screwed up a bit, don't know how to fix it
I personally don't like the fact that you have structs but no classes and no instance methods, but I know this is personal and don't want to start a religious war this morning
Earlier quoted context omitted.
What do you mean by closed ranges composition ?
Suppose I have to compute sum for array of length N. In python it is something like s = 0 for k in range(0, N): s += a[k] Ok, I have more cores/CPUs, could I do it in parallel? Sure v1 = Sum(0, N/2) v2 = Sum(N/2, N) s = v1 + v2 I even could do it on asymmetric cores (like most phone CPUs today) v1 = Sum(0, K) v2 = Sum(K, N) s = v1 + v2 I could do a bit more complicated things, like calculating means. For that, I have…
@threads for i in eachindex(object)