19 ms·

Julia Language Co-Creators Win James H. Wilkinson Prize for Numerical Software

335 points by yarapavan 8y ago

deleted 8y ago
[deleted]
asimpletune 8y ago
Wow, congratulations to the Julia team!
azhenley 8y ago
From the interview with the award recipients: “A programming language cannot be derived from first principles alone. Language design is applied psychology—the computer program is the ultimate human-computer interface. Sometimes you have to try a design out and see how people interact with it and iterate based on that real-world feedback.” I wish more people viewed PL like this.
- sephoric 8y ago
  That's why C is the way it is, for all the hate it gets. I've been teaching my son the beginnings of C now that he's proficient in JavaScript and Lua, but making sure that every step of the way, we jump from a concept he already understands, to a new but related concept, and how they're connected. For example, when I explained signed and unsigned to him, since we already covered the concepts of groups of bits having 2^n possible values, he quickly understood that signed has just as many values as unsigned, but the upper half just become negative inverse of the lower half. C evolved from actual needs, and the fact that it's still widely used today shows how incredibly well designed it was for practical but relatively general problem solving. The C committee's job is mostly just a matter of saying "no" to every new feature request, because C has proven to be versatile enough to work in an extremely diverse array of situations. We've been using Lua's C API and the Win32 API[1] to make cool things, such as a primitive Love2d clone, and just last night he said "Wait, you're telling me this is the old way of programming Windows? It just makes so much sense and seems so well designed!" C isn't perfect, but if you start from where C started, and trace it until now, you'll learn all the reasons behind its decisions, and they make sense in practical situations. Kind of like the difference between metric and imperial measurement systems. Metric makes sense in an isolated mathematical world (i.e. science), bu imperial units make sense when you're working with real physical objects (e.g. construction). [1] http://laurencejackson.com/win32/ http://laurencejackson.com/win32/
  - renox 8y ago
    Well designed.. I'm not so sure, once you're used to something you're 'blind' to its defaults.. Big: signed/unsigned automatic conversion? Minor: conflating unsigned and modulo arithmetic (why not allowing signed modulo int?)? Huge: no way to pass an array but just a pointer? ...
- IA21 8y ago
  > I wish more people viewed PL like this. I wish less people abbreviated "programming language" to PL.
spot 8y ago
what good is philosophy if you choose arrays based on 1? https://groups.google.com/forum/?hl=en#!topic/julia-dev/tNN72FnYbYQ https://groups.google.com/forum/?hl=en#!topic/julia-dev/tNN7...
- baldfat 8y ago
  So does: APL, AWK, COBOL, Fortran, Lua, Mathematica, MATLAB, R, Smalltalk, Wolfram Because it is Mathmatics and have 1 be based on 0 makes no sense, you then have to switch between the two and it is easy to make a mistake. This is why I don't use Python and Pandas. I got burnt once and that was enough and switched to R. Sadly we are stuck with 0 based array in programming and due to a historical issue.
  - pjmlp 8y ago
    You have forgotten Algol, PL/I, Pascal, Oberon, Oberon-2, Active Oberon, Component Pascal, Mesa, Mesa/Cedar, Modula-2+, Modula-3, Eiffel, Basic,... Although in Wirth inspired languages, actually the indexes are flexible, but by convention 1 gets used.
  - nadam 8y ago
    0 based arrays is objectively the preferred way for me and not for historical reasons. I write a lot of low level graphics algorithm stuff, and 1-based arrays would complicate index arithmetic. like now with everything 0 based having something like: arr[offset1 * 32 + offset2] would be the following if all my offsets would be 1-based and arrays would be 1-based: arr[(offset1 -1) * 32 + offset2] which is pretty arbitrary...
    - syockit 8y ago
      You could reshape it (https://docs.julialang.org/en/v1/base/arrays/#Base.reshape https://docs.julialang.org/en/v1/base/arrays/#Base.reshape). But if you're interfacing with libraries written with C interface you'd still have to subtract for both offset1 and offset2.
    - baldfat 8y ago
linkingday 8y ago
Can't wait for the language to be as widely used as Python or R. Been playing around with it at home since the 1.0 release and it really is a joy to use.
- pjmlp 8y ago
  I wish that Python feels a bit of Julia's heat, as that might be the only way for more PyPy love.
  - Stubb 8y ago
    Python without GIL to provide real shared-memory threading would address 90% of my issues with the language.
    - civility 8y ago
      In my experience, CPython is 100 to 1000 times slower than C (or C++, Rust, Fortran, etc...). CPython would be better off fixing the speed (perhaps by embracing PyPy) and staying single threaded than removing the GIL. At least if you're choosing threads for performance gains. Think of it this way: A single threaded C++ or Rust program can do more work per second than a hypothetical GIL-free CPython with 64 cores...
      - viraptor 8y ago
        > CPython is 100 to 1000 times slower than C That's very context dependant. With annotations, typical calculations compile to C code roughly equivalent to native. The more of the actual runtime you use, the more you call into cpython which can't be sped up this way. Cython compiled code will be somewhere between C and cpython in terms of speed, but putting a single number to it will be always misleading.
        weberc2 8y ago
        >> CPython is 100 to 1000 times slower than C > That's very context dependant. With annotations, typical calculations compile to C code roughly equivalent to native. The more of the actual runtime you use, the more you call into cpython which can't be sped up this way. Cython compiled code will be somewhere between C and cpython in terms of speed, but putting a single number to it will be always misleading. OP said "CPython", not "Cython". CPython is pretty reliably 100X to 1000X slower than C.
make3 8y ago
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
- pjmlp 8y ago
  Multi-methods are much more powerfull than instance methods, but yeah lets agree to disagree. :)
  - veddox 8y ago
    Sorry to continue, but could you elaborate on that? I understand both concepts, but not their relative merits...
    - pjmlp 8y ago
      Instance methods are bound to a specific object definition, thus they can only be applied to instances of that specific object or its descendants. Also in static languages, the set of available instance is closed and extending it requires approaches like extension methods now available in a couple of OOP languages. Whereas multi-methods are dynamically dispatched taking into consideration the whole set of parameters, and can be defined after the fact. Meaning that they aren't necessarily written in the same module that defines the respective data structures, which opens the door to more extensible designs. Taking the Alan Perlis' quote "It is better to have 100 functions operate on one data structure than 10 functions on 10 data structures." to the next level. Because not only can you define all those functions that operate on one data structure, they actually apply to the tuple made by the dynamic type of all parameters at call site. Naturally it also might make it harder to follow what actually happens with a given method dispatch. This is my insight from having gone through "The Art of the Metaobject Protocol" and dabbling with multi-methods in Clojure, so I might not be 100% correct here.
  - yellowapple 8y ago
    I feel like they're a significant departure from the OO concept of sending a message to an object (for example, "Foo ! bar()" in Erlang or "Foo.bar()" in a more typical OO language would be interpreted as "send message bar() to object/actor/whatever Foo"). Julia's approach is more "call this function on this object", which is indeed perfectly useful, but is semantically different.
ArtWomb 8y ago
Congrats! JuliaCon 2019 registration also just opened (22 July, Baltimore) https://juliacon.org/2019/ https://juliacon.org/2019/
xvilka 8y ago
Julia needs something like IPython/Jupyter but without Python.
- marviel 8y ago
  I think this is what you're looking for: https://github.com/JuliaLang/IJulia.jl https://github.com/JuliaLang/IJulia.jl
- SiempreViernes 8y ago
  the "Ju" in Jupyter is for julia, do you mean you want Jupyter without the python support?
  - maxmouchet 8y ago
    I was curious about this and it turns out you're (partially) right: https://github.com/jupyter/design/wiki/Jupyter-Logo#where-does-the-name-come-from https://github.com/jupyter/design/wiki/Jupyter-Logo#where-do...
  - xvilka 8y ago
    Yes, this is why I said "without Python".
    - yellowapple 8y ago
      Wouldn't it be easier to just use Jupyter and not use the Python-supporting stuff? Just because Visual Studio supports Visual Basic doesn't mean I can't use it when I'm only interested in writing things in C#.
- coldtea 8y ago
  It already has it. Jupyter has been multi-language for ages...
- ihnorton 8y ago
  That might be possible with nteract (Javascript, not sure if pure) and the IJulia kernel.
amrrs 8y ago
With computational power becoming cheaper and cheaper - will we have two-language problem anymore?
- mac01021 8y ago
  Yes (if you're asking what I think you're asking). Computers are never fast enough. Even if they get 1000x faster, we'll want to squeeze every drop of performance out by using C or whatever.
  - pjmlp 8y ago
    As someone that remembers when C compilers for home computers weren't able to compete with junior devs hand writing Assembly, it always feels interesting to see this kind of remarks. Thankfully the changes in modern hardware architectures have triggered many runtime devs to start having another look at their compiler backends, improving vector instructions support and access to GPGPU features, instead of sticking with just good enough for CRUD apps.
- JustFinishedBSG 8y ago
  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
  - dnautics 8y ago
    Sometimes the wait isn't the computational time wait, but the developer time wait, too.
    - xiaodai 8y ago
      Truth. See http://www.stochasticlifestyle.com/the-nonlinear-effect-of-code-speed-on-productivity/ http://www.stochasticlifestyle.com/the-nonlinear-effect-of-c...
marviel 8y ago
If anyone is interested, I was snooping around and found one of the co-creator's PHD thesis that explains in detailed terms some of the ideology behind Julia: https://dspace.mit.edu/handle/1721.1/99811#files-area https://dspace.mit.edu/handle/1721.1/99811#files-area
- StefanKarpinski 8y ago
  Can be downloaded here (PDF): https://github.com/JeffBezanson/phdthesis/raw/master/main.pdf https://github.com/JeffBezanson/phdthesis/raw/master/main.pd... For a shorter read with many of the same highlights, this is a paper about the design and implementation of Julia (PDF): https://julialang.org/publications/julia-fresh-approach-BEKS.pdf https://julialang.org/publications/julia-fresh-approach-BEKS...
  - gfodor 8y ago
    congrats Stefan :)
  - marviel 8y ago
    Thanks! Awesome work on Julia!
- chappi42 8y ago
  Or its forerunner, the master thesis: https://dspace.mit.edu/handle/1721.1/74897 https://dspace.mit.edu/handle/1721.1/74897.
ForHackernews 8y ago
Julia deserves way more attention than it's currently getting. I'm hoping now that it's past 1.0, a few big-name companies will start using it and raise its profile.
- agumonkey 8y ago
  Attention is better in small doses, I think it's clear to many that Julia is a strong project, let it grow peacefully.
xiphias2 8y ago
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.
- vanderZwan 8y ago
  I thought Tim Holy's Trait Tick was considered the de facto way to use traits in Julia? https://github.com/mauro3/SimpleTraits.jl https://github.com/mauro3/SimpleTraits.jl
  - xiphias2 8y ago
    Maybe it works great, but the syntax doesn't feel native to me, and I don't see it used in the standard library, which means that it's not embraced by the language developers.
    - deleted 8y ago
      [deleted]
    - StefanKarpinski 8y ago
      Holy Traits are used extensively in the standard library (for iteration and collections among other things).
    - 3JPLW 8y ago
      Not many folks use the macros that those macro-trait packages define, but the technique itself is in widespread use throughout the core language and standard library. That's where it was first posited and implemented, in fact: https://github.com/JuliaLang/julia/pull/8432 https://github.com/JuliaLang/julia/pull/8432 (and see the link to the "trait trick")
      - xiphias2 8y ago
        Great, thanks!
tombert 8y ago
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 the language. Not trying to start a war here, but I'm curious what more-seasoned Julia vet might have seen that someone with only ~12 hours with the language wouldn't.
- montalbano 8y ago
  To name a few: beautiful type system, optional typing, multiple dispatch... edit: as another comment mentioned, metaprogramming is also great!
- lenticular 8y ago
  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 seamlessly with existing linear algebra types. I've done a lot of work in both Python with Scipy/Numpy, and Julia. Python is painfully inexpressive in comparison. Not only this, but Julia has excellent type inference. Combined with the JIT, this makes it very fast. Inner numerical loops can be nearly as fast as C/Fortran. Expanding on the macro system, this has allowed things like libraries that give easy support for GPU programming, fast automatic differentiation, seamless Python interop, etc.
  - tombert 8y ago
    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.
you_owe_me 8y ago
The authors claim Julia is a general programming language, but after a few tries I am not totally sure about that. Yes, it's a nice programming language for scientific computing but I am afraid its usefulness stops there. Matlab is (was?) the default tool for computational science, and Julia borrows lots from it. I'd say it's safe to put Julia in the same category with Matlab and Mathematica
- montalbano 8y ago
  https://discourse.julialang.org/t/not-only-for-technical-computing-changing-the-narrative-around-the-usecase-for-julia/19784 https://discourse.julialang.org/t/not-only-for-technical-com...
- krull10 8y ago
  What about the Julia 1.0 language design do you find prevents general purpose programming?
  - xiaodai 8y ago
    I think he's just trolling...
- h8hawk 8y ago
  People are using Javascript or python for real production. How those are general purpose and Julia is not?
- xiaodai 8y ago
  Conceivably you can see a backen server being built in Julia e.g. https://github.com/JuliaWeb/Mux.jl https://github.com/JuliaWeb/Mux.jl But I can't imagine anyone would choose Matlab or Mathematica to build a backend...
  - Recurecur 8y ago
    >Conceivably you can see a backen server being built in Julia e.g. https://github.com/JuliaWeb/Mux.jl https://github.com/JuliaWeb/Mux.jl >But I can't imagine anyone would choose Matlab or Mathematica to build a backend... Julia is a clean, concise language that has so far mainly been focused on numerics. People are looking at using it in many other areas, for instance real-time robotic control: http://www.juliarobotics.org/ http://www.juliarobotics.org/ This means that at least some Julia folk are looking at ways of avoiding garbage collection during critical code sections... Data center efficiency is a concern, and there is real interest in better languages for web applications. Rust and Swift both have projects exploring this area. Julia would fit well in that space, and in my opinion its syntax is much cleaner than either.
mruts 8y ago
Julia is interesting, but the block syntax is a little off-putting. I'm not sure why someone would design a language that uses 'end' to delineate a block. Curly brackets make sense. Tabs make sense. But 'end'? All it does is make code harder to read and harder to write.
- jampekka 8y ago
  Because MATLAB. And I don't think that's a very compelling argument.
- chappi42 8y ago
  Because Pascal. And as Pascal was used as a teaching language, I don't think your 'make code harder to read and harder to write' argument holds. But certainly nowadays 'end's are not seen often; maybe this has an influence in your statement?
  - mruts 8y ago
    Why do you think that "end" is superior to more lightweight syntax? One might argue that using "end" doesn't really matter, but I am extremely skeptical one could argue it is superior to a curly bracket or a tab in any way at all. PS: And in regards to your last statement, maybe "end"s aren't seen very much anymore is because language designers' agree with me, not that somehow my opinion is influenced by the syntax of modern languages. If you just think about it, that is much more likely than what you are proposing.
    - StefanKarpinski 8y ago
      Given the historical precedent of Pascal, Ruby, Matlab and others, using `end` to close blocks is not exactly controversial or uncommon. 5 of the current top 20 languages on the Tiobe Index use `end` to close blocks versus 11/20 for curly braces and 1/20 for indentation. Most of the `{}` languages are C descendants: using `{}` for blocks is popular because C has been wildly successful, not the other way around. Using `{}` for blocks wasn't some brilliant language design choice that caused the success of C—it was a fairly mundane choice that happened to be made by a language that succeeded for entirely unrelated reasons and the syntax spread from there. As to the benefits of not using `{}` for blocks, pairs of ASCII brackets are one of the most precious commodities in programming language syntax design. Wasting them on blocks is not ideal. For example, C++ was out of brackets to use for template parameters, and had to use `<>` instead—despite the syntactic clash with their meaning as less than and greater than operators. This has caused no end of parsing problems and irregularities in C++ and related languages and has only been made to work because they're all static languages with separate "expression context" and "type context" and inequality operators don't make sense in type contexts. In a dynamic language, there's only one context and you can't distinguish the use of `<>` as brackets from its use as inequality operators based on that. Julia uses `()` for function calls (pretty important), `[]` for array indexing (also pretty crucial), and `{}` for type parameters. Using indentation is a fairly clever choice but not without its drawbacks. It causes lots of problems with cutting and pasting code. It means that your IDE cannot generally autoformat or autoindent your code for you. There are also many people who find the "trailing off into space" visual appearance of Python code unsettling and prefer the symmetry and closure provided by `end` or other block delimiters.
francasso 8y ago
I'll say only one thing: 1 based indexing. Jokes asides, congratulations to Jeff Bezanson, Stefan Karpinski, and Viral B. Shah, well deserved!
- coldtea 8y ago
  >I'll say only one thing: 1 based indexing. You mean you'll say only zero thing?
- xiaodai 8y ago
  Oh well, can't let this pass... Introducing TwoBasedIndexing.jl (https://github.com/simonster/TwoBasedIndexing.jl https://github.com/simonster/TwoBasedIndexing.jl) The point is, n-based indexing isn't really that big a deal.
uptownfunk 8y ago
Want to drive adoption? Introduce it in schools.
- deleted 8y ago
  [deleted]
- giornogiovanna 8y ago
  Evil but true. I think the easiest way in would be to rally up some university students into starting a "Julia Club" or maybe even a "Julia Evangelism Strike Force".
  - uptownfunk 8y ago
    Even further than that, you need faculty to teach with it. I know I use R a lot primarily because that's what I learnt at Cal, it was easy, and it worked. Things are probably shifting towards Python in schools now, but I think that's the best way you're going to get a lot of users using it persistently in their careers.
Iwan-Zotow 8y ago
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?!
- maxmouchet 8y ago
  What do you mean by closed ranges composition ?
  - Iwan-Zotow 8y ago
    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 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
    - mcabbott 8y ago
      But why should you have to care, why not just sum(range)? Or @threads for i in eachindex(object) and let the details about how many cores be written once, correctly, elsewhere?
      - Iwan-Zotow 8y ago
        > But why should you have to care, why not just sum(range)? Sure, if you have single infinitely fast CPU. In real life, we have to decompose problem, run it in parallel and compose it back. > Or @threads for i in eachindex(object) & let the details about how many cores be written once, correctly, elsewhere? Here I'm explicitly talking about details, how it should be done, importance of composition, monoids etc. I understand, that if someone did it for you, you might not care - well, more power to you then. But some basics rules about Pyton ranges are pretty good: 1. [0...K) + [K...N) = [0...N) 2. Given range [K...N), number of elements in the range is N-K, in case of [0...N) number of elements is N-0=N. Simple, elegant, composable. I can't say the same about Julia
make3 8y ago
The fact that you have numpy like matrix manipulation directly out of the box is really cool, and it's even better than numpy because if the dot operator for element wise operation, which is just awesome
kkylin 8y ago
The prize lecture will be given at the SIAM Computational Science & Engineering conference in a little over a month (https://www.siam.org/conferences/CM/Main/cse19 https://www.siam.org/conferences/CM/Main/cse19). SIAM hasn't been doing live streams, but does sometimes put up video or audio+synchronized slides a little (a couple months?) after the conference, in case anyone is interested.
WhompingWindows 8y ago
As a current R user, and former SAS user, can someone give me an elevator pitch as to why Julia is worth my time? I use a lot of the tidyverse and some more niche epidemiology/stats packages in R, I'm also pulling in datasets on the order of 1-10 million rows from MS SQL.
- byt143 8y ago
  One usecase: Do you want to do interesting cutting edge modeling of disease propagation dynamics or other complex systems simulation? Then check this out: https://julialang.org/blog/2019/01/fluxdiffeq https://julialang.org/blog/2019/01/fluxdiffeq Here's context : https://jontysinai.github.io/jekyll/update/2019/01/18/understanding-neural-odes.html https://jontysinai.github.io/jekyll/update/2019/01/18/unders... There's nothing else like it. Also here's the julia equiv to dplyr: https://github.com/queryverse/Query.jl https://github.com/queryverse/Query.jl
- currymj 8y ago
  the elevator pitch is, it's an easy to use language, you can vectorize things if you want, but also if you hand-write loops it will be very fast. Whereas in R, hand-writing loops brings you to the 3rd circle of hell [1]. the more general version of the elevator pitch is that being in an environment where all the code is written in one high-level language that is still fast is qualitatively different. you can combine things in all kinds of strange ways with surprisingly little work. I.e. the DiffEqFlux package takes about a hundred lines of code to glue together a GPU neural network library and some very advanced differential equation solvers. realistically, it sounds like you are hitting all of R's strongest points currently, though. I suspect right now you would be pretty dissatisfied with Julia. 1: https://www.burns-stat.com/pages/Tutor/R_inferno.pdf https://www.burns-stat.com/pages/Tutor/R_inferno.pdf
- vanderZwan 8y ago
  On top of what else has been said: you can call R from within Julia with almost negligible overhead via RCall.jl[0], so you can still use code you have already written. https://github.com/JuliaInterop/RCall.jl https://github.com/JuliaInterop/RCall.jl
antpls 8y ago
I'm ready to burn a part of my karma to say the following : - Naming a PL "Julia" is sexist and creepy - The language doesn't add any substantial value to PL theory or programming methodology compared to say, Python - The future of computer-human interaction is not in programming. Python will be good enough until we reach that point where we can use neural networks/AI to do most of the business tasks.
- dragonwriter 8y ago
  > Naming a PL "Julia" is sexist and creepy How? (I kind of assume that a big reason computer scientists would pull out that name without a specific referent in mind is the influence of the Julia set, named for Gaston Julia.) > The language doesn't add any substantial value to PL theory or programming methodology compared to say, Python Maybe; not all practical benefits in programming come from advances in methodology or PL theory. > The future of computer-human interaction is not in programming. I've been hearing that since the early 80s. When someone makes that future reality, we can discuss what it requires, until then programming is what we have and I'm glad it wasn't neglected for the last four decades, and I hope it won't be for the next however many it takes, either.
  - mattkrause 8y ago
    I also thought it was related to Gaston Julia or his sets, but apparently not: it was just chosen since it sounds nice (https://www.infoworld.com/article/2616709/application-development/new-julia-language-seeks-to-be-the-c-for-scientists.html https://www.infoworld.com/article/2616709/application-develo...)
- mattkrause 8y ago
  Out of curiosity, what's wrong with the name? Using a human name doesn't seem much stranger than using the name of (say) a comedy troupe or fungus.
- ychen306 8y ago
  I don't even know or use Julia and find this confusing. - I don't think Python added anything to PL theory or methodology either. At least Julia introduced multiple dispatch to a new audience. - How is the name sexist or creepy?
emmanueloga_ 8y ago
I'm always looking for good computer tools to assist with learning Math with computers. I found this: [1]. Are there any other resources like this to learn fundamentals of Math with Julia? ([Linear] Algebra, Calculus, Geometry, Basic Physics, Discrete Math). 1: https://calculuswithjulia.github.io/ https://calculuswithjulia.github.io/
- byt143 8y ago
  https://discourse.julialang.org/t/new-linear-algebra-textbook-downloadable-has-julia-companion/18665 https://discourse.julialang.org/t/new-linear-algebra-textboo...
  - emmanueloga_ 8y ago
    This course looks fantastic! Thanks for sharing :-)
    - byt143 8y ago
      Sure!
- byt143 8y ago
  There's also this: https://www.youtube.com/playlist?list=PL7RZyOlq_Xnw3B5per3IUyuE3Uhp4LjNZ https://www.youtube.com/playlist?list=PL7RZyOlq_Xnw3B5per3IU...
guessmyname 8y ago
HackerNews’ traffic broke this website’s database: --- 500 - Internal server error. SQL Exception Error Details File Error Index #: 0 Source: .Net SqlClient Data Provider Class: 17 Number: 1105 Procedure: AddEventLog Message: System.Data.SqlClient.SqlException (0x80131904): Could not allocate space for object 'dbo.EventLog'.'PK_EventLogMaster' in database 'DNN-PROD' because the 'PRIMARY' filegroup is full. Create disk space by deleting unneeded files, dropping objects in the filegroup, adding additional files to the filegroup, or setting autogrowth on for existing files in the filegroup. at System.Data.SqlClient.SqlConnection.OnError(SqlException exception, Boolean breakConnection, Action`1 wrapCloseInAction) at System.Data.SqlClient.SqlInternalConnection.OnError(SqlException exception, Boolean breakConnection, Action`1 wrapCloseInAction) at System.Data.SqlClient.TdsParser.ThrowExceptionAndWarning(TdsParserStateObject stateObj, Boolean callerHasConnectionLock, Boolean asyncClose) at System.Data.SqlClient.TdsParser.TryRun(RunBehavior runBehavior, SqlCommand cmdHandler, SqlDataReader dataStream, BulkCopySimpleResultSet bulkCopyHandler, TdsParserStateObject stateObj, Boolean& dataReady) at System.Data.SqlClient.SqlCommand.FinishExecuteReader(SqlDataReader ds, RunBehavior runBehavior, String resetOptionsString, Boolean isInternal, Boolean forDescribeParameterEncryption, Boolean shouldCacheForAlwaysEncrypted) at System.Data.SqlClient.SqlCommand.RunExecuteReaderTds(CommandBehavior cmdBehavior, RunBehavior runBehavior, Boolean returnStream, Boolean async, Int32 timeout, Task& task, Boolean asyncWrite, Boolean inRetry, SqlDataReader ds, Boolean describeParameterEncryptionRequest) at System.Data.SqlClient.SqlCommand.RunExecuteReader(CommandBehavior cmdBehavior, RunBehavior runBehavior, Boolean returnStream, String method, TaskCompletionSource`1 completion, Int32 timeout, Task& task, Boolean& usedCache, Boolean asyncWrite, Boolean inRetry) at System.Data.SqlClient.SqlCommand.InternalExecuteNonQuery(TaskCompletionSource`1 completion, String methodName, Boolean sendToPipe, Int32 timeout, Boolean& usedCache, Boolean asyncWrite, Boolean inRetry) at System.Data.SqlClient.SqlCommand.ExecuteNonQuery() at PetaPoco.Database.Execute(String sql, Object[] args) at DotNetNuke.Data.PetaPoco.PetaPocoHelper.ExecuteNonQuery(String connectionString, CommandType type, Int32 timeout, String sql, Object[] args) at DotNetNuke.Data.SqlDataProvider.ExecuteNonQuery(String procedureName, Object[] commandParameters) at DotNetNuke.Data.DataProvider.AddLog(String logGUID, String logTypeKey, Int32 logUserID, String logUserName, Int32 logPortalID, String logPortalName, DateTime logCreateDate, String logServerName, String logProperties, Int32 logConfigID) at DotNetNuke.Services.Log.EventLog.DBLoggingProvider.WriteLog(LogQueueItem logQueueItem) ClientConnectionId:84098483-739c-4cd8-bf62-38ff4b256361 Error Number:1105,State:2,Class:17

335 points by yarapavan 8y ago

deleted 8y ago

[deleted]

asimpletune 8y ago

Wow, congratulations to the Julia team!

azhenley 8y ago

From the interview with the award recipients: “A programming language cannot be derived from first principles alone. Language design is applied psychology—the computer program is the ultimate human-computer interface. Sometimes you have to try a design out and see how people interact with it and iterate based on that real-world feedback.” I wish more people viewed PL like this.

sephoric 8y ago
That's why C is the way it is, for all the hate it gets. I've been teaching my son the beginnings of C now that he's proficient in JavaScript and Lua, but making sure that every step of the way, we jump from a concept he already understands, to a new but related concept, and how they're connected. For example, when I explained signed and unsigned to him, since we already covered the concepts of groups of bits having 2^n possible values, he quickly understood that signed has just as many values as unsigned, but the upper half just become negative inverse of the lower half. C evolved from actual needs, and the fact that it's still widely used today shows how incredibly well designed it was for practical but relatively general problem solving. The C committee's job is mostly just a matter of saying "no" to every new feature request, because C has proven to be versatile enough to work in an extremely diverse array of situations. We've been using Lua's C API and the Win32 API[1] to make cool things, such as a primitive Love2d clone, and just last night he said "Wait, you're telling me this is the old way of programming Windows? It just makes so much sense and seems so well designed!" C isn't perfect, but if you start from where C started, and trace it until now, you'll learn all the reasons behind its decisions, and they make sense in practical situations. Kind of like the difference between metric and imperial measurement systems. Metric makes sense in an isolated mathematical world (i.e. science), bu imperial units make sense when you're working with real physical objects (e.g. construction). [1] http://laurencejackson.com/win32/ http://laurencejackson.com/win32/
- renox 8y ago
  Well designed.. I'm not so sure, once you're used to something you're 'blind' to its defaults.. Big: signed/unsigned automatic conversion? Minor: conflating unsigned and modulo arithmetic (why not allowing signed modulo int?)? Huge: no way to pass an array but just a pointer? ...
IA21 8y ago
> I wish more people viewed PL like this. I wish less people abbreviated "programming language" to PL.

spot 8y ago

what good is philosophy if you choose arrays based on 1? https://groups.google.com/forum/?hl=en#!topic/julia-dev/tNN72FnYbYQ https://groups.google.com/forum/?hl=en#!topic/julia-dev/tNN7...

baldfat 8y ago
So does: APL, AWK, COBOL, Fortran, Lua, Mathematica, MATLAB, R, Smalltalk, Wolfram Because it is Mathmatics and have 1 be based on 0 makes no sense, you then have to switch between the two and it is easy to make a mistake. This is why I don't use Python and Pandas. I got burnt once and that was enough and switched to R. Sadly we are stuck with 0 based array in programming and due to a historical issue.
- pjmlp 8y ago
  You have forgotten Algol, PL/I, Pascal, Oberon, Oberon-2, Active Oberon, Component Pascal, Mesa, Mesa/Cedar, Modula-2+, Modula-3, Eiffel, Basic,... Although in Wirth inspired languages, actually the indexes are flexible, but by convention 1 gets used.
- nadam 8y ago
  0 based arrays is objectively the preferred way for me and not for historical reasons. I write a lot of low level graphics algorithm stuff, and 1-based arrays would complicate index arithmetic. like now with everything 0 based having something like: arr[offset1 * 32 + offset2] would be the following if all my offsets would be 1-based and arrays would be 1-based: arr[(offset1 -1) * 32 + offset2] which is pretty arbitrary...
  - syockit 8y ago
    You could reshape it (https://docs.julialang.org/en/v1/base/arrays/#Base.reshape https://docs.julialang.org/en/v1/base/arrays/#Base.reshape). But if you're interfacing with libraries written with C interface you'd still have to subtract for both offset1 and offset2.
  - baldfat 8y ago

linkingday 8y ago

Can't wait for the language to be as widely used as Python or R. Been playing around with it at home since the 1.0 release and it really is a joy to use.

pjmlp 8y ago
I wish that Python feels a bit of Julia's heat, as that might be the only way for more PyPy love.
- Stubb 8y ago
  Python without GIL to provide real shared-memory threading would address 90% of my issues with the language.
  - civility 8y ago
    In my experience, CPython is 100 to 1000 times slower than C (or C++, Rust, Fortran, etc...). CPython would be better off fixing the speed (perhaps by embracing PyPy) and staying single threaded than removing the GIL. At least if you're choosing threads for performance gains. Think of it this way: A single threaded C++ or Rust program can do more work per second than a hypothetical GIL-free CPython with 64 cores...
    - viraptor 8y ago
      > CPython is 100 to 1000 times slower than C That's very context dependant. With annotations, typical calculations compile to C code roughly equivalent to native. The more of the actual runtime you use, the more you call into cpython which can't be sped up this way. Cython compiled code will be somewhere between C and cpython in terms of speed, but putting a single number to it will be always misleading.
      - weberc2 8y ago
        >> CPython is 100 to 1000 times slower than C > That's very context dependant. With annotations, typical calculations compile to C code roughly equivalent to native. The more of the actual runtime you use, the more you call into cpython which can't be sped up this way. Cython compiled code will be somewhere between C and cpython in terms of speed, but putting a single number to it will be always misleading. OP said "CPython", not "Cython". CPython is pretty reliably 100X to 1000X slower than C.

make3 8y ago

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

pjmlp 8y ago
Multi-methods are much more powerfull than instance methods, but yeah lets agree to disagree. :)
- veddox 8y ago
  Sorry to continue, but could you elaborate on that? I understand both concepts, but not their relative merits...
  - pjmlp 8y ago
    Instance methods are bound to a specific object definition, thus they can only be applied to instances of that specific object or its descendants. Also in static languages, the set of available instance is closed and extending it requires approaches like extension methods now available in a couple of OOP languages. Whereas multi-methods are dynamically dispatched taking into consideration the whole set of parameters, and can be defined after the fact. Meaning that they aren't necessarily written in the same module that defines the respective data structures, which opens the door to more extensible designs. Taking the Alan Perlis' quote "It is better to have 100 functions operate on one data structure than 10 functions on 10 data structures." to the next level. Because not only can you define all those functions that operate on one data structure, they actually apply to the tuple made by the dynamic type of all parameters at call site. Naturally it also might make it harder to follow what actually happens with a given method dispatch. This is my insight from having gone through "The Art of the Metaobject Protocol" and dabbling with multi-methods in Clojure, so I might not be 100% correct here.
- yellowapple 8y ago
  I feel like they're a significant departure from the OO concept of sending a message to an object (for example, "Foo ! bar()" in Erlang or "Foo.bar()" in a more typical OO language would be interpreted as "send message bar() to object/actor/whatever Foo"). Julia's approach is more "call this function on this object", which is indeed perfectly useful, but is semantically different.

ArtWomb 8y ago

Congrats! JuliaCon 2019 registration also just opened (22 July, Baltimore) https://juliacon.org/2019/ https://juliacon.org/2019/

xvilka 8y ago

Julia needs something like IPython/Jupyter but without Python.

marviel 8y ago
I think this is what you're looking for: https://github.com/JuliaLang/IJulia.jl https://github.com/JuliaLang/IJulia.jl
SiempreViernes 8y ago
the "Ju" in Jupyter is for julia, do you mean you want Jupyter without the python support?
- maxmouchet 8y ago
  I was curious about this and it turns out you're (partially) right: https://github.com/jupyter/design/wiki/Jupyter-Logo#where-does-the-name-come-from https://github.com/jupyter/design/wiki/Jupyter-Logo#where-do...
- xvilka 8y ago
  Yes, this is why I said "without Python".
  - yellowapple 8y ago
    Wouldn't it be easier to just use Jupyter and not use the Python-supporting stuff? Just because Visual Studio supports Visual Basic doesn't mean I can't use it when I'm only interested in writing things in C#.
coldtea 8y ago
It already has it. Jupyter has been multi-language for ages...
ihnorton 8y ago
That might be possible with nteract (Javascript, not sure if pure) and the IJulia kernel.

amrrs 8y ago

With computational power becoming cheaper and cheaper - will we have two-language problem anymore?

mac01021 8y ago
Yes (if you're asking what I think you're asking). Computers are never fast enough. Even if they get 1000x faster, we'll want to squeeze every drop of performance out by using C or whatever.
- pjmlp 8y ago
  As someone that remembers when C compilers for home computers weren't able to compete with junior devs hand writing Assembly, it always feels interesting to see this kind of remarks. Thankfully the changes in modern hardware architectures have triggered many runtime devs to start having another look at their compiler backends, improving vector instructions support and access to GPGPU features, instead of sticking with just good enough for CRUD apps.
JustFinishedBSG 8y ago
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
- dnautics 8y ago
  Sometimes the wait isn't the computational time wait, but the developer time wait, too.
  - xiaodai 8y ago
    Truth. See http://www.stochasticlifestyle.com/the-nonlinear-effect-of-code-speed-on-productivity/ http://www.stochasticlifestyle.com/the-nonlinear-effect-of-c...

marviel 8y ago

If anyone is interested, I was snooping around and found one of the co-creator's PHD thesis that explains in detailed terms some of the ideology behind Julia: https://dspace.mit.edu/handle/1721.1/99811#files-area https://dspace.mit.edu/handle/1721.1/99811#files-area

StefanKarpinski 8y ago
Can be downloaded here (PDF): https://github.com/JeffBezanson/phdthesis/raw/master/main.pdf https://github.com/JeffBezanson/phdthesis/raw/master/main.pd... For a shorter read with many of the same highlights, this is a paper about the design and implementation of Julia (PDF): https://julialang.org/publications/julia-fresh-approach-BEKS.pdf https://julialang.org/publications/julia-fresh-approach-BEKS...
- gfodor 8y ago
  congrats Stefan :)
- marviel 8y ago
  Thanks! Awesome work on Julia!
chappi42 8y ago
Or its forerunner, the master thesis: https://dspace.mit.edu/handle/1721.1/74897 https://dspace.mit.edu/handle/1721.1/74897.

ForHackernews 8y ago

Julia deserves way more attention than it's currently getting. I'm hoping now that it's past 1.0, a few big-name companies will start using it and raise its profile.

agumonkey 8y ago
Attention is better in small doses, I think it's clear to many that Julia is a strong project, let it grow peacefully.

xiphias2 8y ago

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.

vanderZwan 8y ago
I thought Tim Holy's Trait Tick was considered the de facto way to use traits in Julia? https://github.com/mauro3/SimpleTraits.jl https://github.com/mauro3/SimpleTraits.jl
- xiphias2 8y ago
  Maybe it works great, but the syntax doesn't feel native to me, and I don't see it used in the standard library, which means that it's not embraced by the language developers.
  - deleted 8y ago
    [deleted]
  - StefanKarpinski 8y ago
    Holy Traits are used extensively in the standard library (for iteration and collections among other things).
  - 3JPLW 8y ago
    Not many folks use the macros that those macro-trait packages define, but the technique itself is in widespread use throughout the core language and standard library. That's where it was first posited and implemented, in fact: https://github.com/JuliaLang/julia/pull/8432 https://github.com/JuliaLang/julia/pull/8432 (and see the link to the "trait trick")
    - xiphias2 8y ago
      Great, thanks!

tombert 8y ago

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 the language. Not trying to start a war here, but I'm curious what more-seasoned Julia vet might have seen that someone with only ~12 hours with the language wouldn't.

montalbano 8y ago
To name a few: beautiful type system, optional typing, multiple dispatch... edit: as another comment mentioned, metaprogramming is also great!
lenticular 8y ago
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 seamlessly with existing linear algebra types. I've done a lot of work in both Python with Scipy/Numpy, and Julia. Python is painfully inexpressive in comparison. Not only this, but Julia has excellent type inference. Combined with the JIT, this makes it very fast. Inner numerical loops can be nearly as fast as C/Fortran. Expanding on the macro system, this has allowed things like libraries that give easy support for GPU programming, fast automatic differentiation, seamless Python interop, etc.
- tombert 8y ago
  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.

you_owe_me 8y ago

The authors claim Julia is a general programming language, but after a few tries I am not totally sure about that. Yes, it's a nice programming language for scientific computing but I am afraid its usefulness stops there. Matlab is (was?) the default tool for computational science, and Julia borrows lots from it. I'd say it's safe to put Julia in the same category with Matlab and Mathematica

montalbano 8y ago
https://discourse.julialang.org/t/not-only-for-technical-computing-changing-the-narrative-around-the-usecase-for-julia/19784 https://discourse.julialang.org/t/not-only-for-technical-com...
krull10 8y ago
What about the Julia 1.0 language design do you find prevents general purpose programming?
- xiaodai 8y ago
  I think he's just trolling...
h8hawk 8y ago
People are using Javascript or python for real production. How those are general purpose and Julia is not?
xiaodai 8y ago
Conceivably you can see a backen server being built in Julia e.g. https://github.com/JuliaWeb/Mux.jl https://github.com/JuliaWeb/Mux.jl But I can't imagine anyone would choose Matlab or Mathematica to build a backend...
- Recurecur 8y ago
  >Conceivably you can see a backen server being built in Julia e.g. https://github.com/JuliaWeb/Mux.jl https://github.com/JuliaWeb/Mux.jl >But I can't imagine anyone would choose Matlab or Mathematica to build a backend... Julia is a clean, concise language that has so far mainly been focused on numerics. People are looking at using it in many other areas, for instance real-time robotic control: http://www.juliarobotics.org/ http://www.juliarobotics.org/ This means that at least some Julia folk are looking at ways of avoiding garbage collection during critical code sections... Data center efficiency is a concern, and there is real interest in better languages for web applications. Rust and Swift both have projects exploring this area. Julia would fit well in that space, and in my opinion its syntax is much cleaner than either.

mruts 8y ago

Julia is interesting, but the block syntax is a little off-putting. I'm not sure why someone would design a language that uses 'end' to delineate a block. Curly brackets make sense. Tabs make sense. But 'end'? All it does is make code harder to read and harder to write.

jampekka 8y ago
Because MATLAB. And I don't think that's a very compelling argument.
chappi42 8y ago
Because Pascal. And as Pascal was used as a teaching language, I don't think your 'make code harder to read and harder to write' argument holds. But certainly nowadays 'end's are not seen often; maybe this has an influence in your statement?
- mruts 8y ago
  Why do you think that "end" is superior to more lightweight syntax? One might argue that using "end" doesn't really matter, but I am extremely skeptical one could argue it is superior to a curly bracket or a tab in any way at all. PS: And in regards to your last statement, maybe "end"s aren't seen very much anymore is because language designers' agree with me, not that somehow my opinion is influenced by the syntax of modern languages. If you just think about it, that is much more likely than what you are proposing.
  - StefanKarpinski 8y ago
    Given the historical precedent of Pascal, Ruby, Matlab and others, using `end` to close blocks is not exactly controversial or uncommon. 5 of the current top 20 languages on the Tiobe Index use `end` to close blocks versus 11/20 for curly braces and 1/20 for indentation. Most of the `{}` languages are C descendants: using `{}` for blocks is popular because C has been wildly successful, not the other way around. Using `{}` for blocks wasn't some brilliant language design choice that caused the success of C—it was a fairly mundane choice that happened to be made by a language that succeeded for entirely unrelated reasons and the syntax spread from there. As to the benefits of not using `{}` for blocks, pairs of ASCII brackets are one of the most precious commodities in programming language syntax design. Wasting them on blocks is not ideal. For example, C++ was out of brackets to use for template parameters, and had to use `<>` instead—despite the syntactic clash with their meaning as less than and greater than operators. This has caused no end of parsing problems and irregularities in C++ and related languages and has only been made to work because they're all static languages with separate "expression context" and "type context" and inequality operators don't make sense in type contexts. In a dynamic language, there's only one context and you can't distinguish the use of `<>` as brackets from its use as inequality operators based on that. Julia uses `()` for function calls (pretty important), `[]` for array indexing (also pretty crucial), and `{}` for type parameters. Using indentation is a fairly clever choice but not without its drawbacks. It causes lots of problems with cutting and pasting code. It means that your IDE cannot generally autoformat or autoindent your code for you. There are also many people who find the "trailing off into space" visual appearance of Python code unsettling and prefer the symmetry and closure provided by `end` or other block delimiters.

francasso 8y ago

I'll say only one thing: 1 based indexing. Jokes asides, congratulations to Jeff Bezanson, Stefan Karpinski, and Viral B. Shah, well deserved!

coldtea 8y ago
>I'll say only one thing: 1 based indexing. You mean you'll say only zero thing?
xiaodai 8y ago
Oh well, can't let this pass... Introducing TwoBasedIndexing.jl (https://github.com/simonster/TwoBasedIndexing.jl https://github.com/simonster/TwoBasedIndexing.jl) The point is, n-based indexing isn't really that big a deal.

uptownfunk 8y ago

Want to drive adoption? Introduce it in schools.

deleted 8y ago
[deleted]
giornogiovanna 8y ago
Evil but true. I think the easiest way in would be to rally up some university students into starting a "Julia Club" or maybe even a "Julia Evangelism Strike Force".
- uptownfunk 8y ago
  Even further than that, you need faculty to teach with it. I know I use R a lot primarily because that's what I learnt at Cal, it was easy, and it worked. Things are probably shifting towards Python in schools now, but I think that's the best way you're going to get a lot of users using it persistently in their careers.

Iwan-Zotow 8y ago

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?!

maxmouchet 8y ago
What do you mean by closed ranges composition ?
- Iwan-Zotow 8y ago
  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 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
  - mcabbott 8y ago
    But why should you have to care, why not just sum(range)? Or @threads for i in eachindex(object) and let the details about how many cores be written once, correctly, elsewhere?
    - Iwan-Zotow 8y ago
      > But why should you have to care, why not just sum(range)? Sure, if you have single infinitely fast CPU. In real life, we have to decompose problem, run it in parallel and compose it back. > Or @threads for i in eachindex(object) & let the details about how many cores be written once, correctly, elsewhere? Here I'm explicitly talking about details, how it should be done, importance of composition, monoids etc. I understand, that if someone did it for you, you might not care - well, more power to you then. But some basics rules about Pyton ranges are pretty good: 1. [0...K) + [K...N) = [0...N) 2. Given range [K...N), number of elements in the range is N-K, in case of [0...N) number of elements is N-0=N. Simple, elegant, composable. I can't say the same about Julia

make3 8y ago

The fact that you have numpy like matrix manipulation directly out of the box is really cool, and it's even better than numpy because if the dot operator for element wise operation, which is just awesome

kkylin 8y ago

The prize lecture will be given at the SIAM Computational Science & Engineering conference in a little over a month (https://www.siam.org/conferences/CM/Main/cse19 https://www.siam.org/conferences/CM/Main/cse19). SIAM hasn't been doing live streams, but does sometimes put up video or audio+synchronized slides a little (a couple months?) after the conference, in case anyone is interested.

WhompingWindows 8y ago

As a current R user, and former SAS user, can someone give me an elevator pitch as to why Julia is worth my time? I use a lot of the tidyverse and some more niche epidemiology/stats packages in R, I'm also pulling in datasets on the order of 1-10 million rows from MS SQL.

byt143 8y ago
One usecase: Do you want to do interesting cutting edge modeling of disease propagation dynamics or other complex systems simulation? Then check this out: https://julialang.org/blog/2019/01/fluxdiffeq https://julialang.org/blog/2019/01/fluxdiffeq Here's context : https://jontysinai.github.io/jekyll/update/2019/01/18/understanding-neural-odes.html https://jontysinai.github.io/jekyll/update/2019/01/18/unders... There's nothing else like it. Also here's the julia equiv to dplyr: https://github.com/queryverse/Query.jl https://github.com/queryverse/Query.jl
currymj 8y ago
the elevator pitch is, it's an easy to use language, you can vectorize things if you want, but also if you hand-write loops it will be very fast. Whereas in R, hand-writing loops brings you to the 3rd circle of hell [1]. the more general version of the elevator pitch is that being in an environment where all the code is written in one high-level language that is still fast is qualitatively different. you can combine things in all kinds of strange ways with surprisingly little work. I.e. the DiffEqFlux package takes about a hundred lines of code to glue together a GPU neural network library and some very advanced differential equation solvers. realistically, it sounds like you are hitting all of R's strongest points currently, though. I suspect right now you would be pretty dissatisfied with Julia. 1: https://www.burns-stat.com/pages/Tutor/R_inferno.pdf https://www.burns-stat.com/pages/Tutor/R_inferno.pdf
vanderZwan 8y ago
On top of what else has been said: you can call R from within Julia with almost negligible overhead via RCall.jl[0], so you can still use code you have already written. https://github.com/JuliaInterop/RCall.jl https://github.com/JuliaInterop/RCall.jl

antpls 8y ago

I'm ready to burn a part of my karma to say the following : - Naming a PL "Julia" is sexist and creepy - The language doesn't add any substantial value to PL theory or programming methodology compared to say, Python - The future of computer-human interaction is not in programming. Python will be good enough until we reach that point where we can use neural networks/AI to do most of the business tasks.

dragonwriter 8y ago
> Naming a PL "Julia" is sexist and creepy How? (I kind of assume that a big reason computer scientists would pull out that name without a specific referent in mind is the influence of the Julia set, named for Gaston Julia.) > The language doesn't add any substantial value to PL theory or programming methodology compared to say, Python Maybe; not all practical benefits in programming come from advances in methodology or PL theory. > The future of computer-human interaction is not in programming. I've been hearing that since the early 80s. When someone makes that future reality, we can discuss what it requires, until then programming is what we have and I'm glad it wasn't neglected for the last four decades, and I hope it won't be for the next however many it takes, either.
- mattkrause 8y ago
  I also thought it was related to Gaston Julia or his sets, but apparently not: it was just chosen since it sounds nice (https://www.infoworld.com/article/2616709/application-development/new-julia-language-seeks-to-be-the-c-for-scientists.html https://www.infoworld.com/article/2616709/application-develo...)
mattkrause 8y ago
Out of curiosity, what's wrong with the name? Using a human name doesn't seem much stranger than using the name of (say) a comedy troupe or fungus.
ychen306 8y ago
I don't even know or use Julia and find this confusing. - I don't think Python added anything to PL theory or methodology either. At least Julia introduced multiple dispatch to a new audience. - How is the name sexist or creepy?

emmanueloga_ 8y ago

I'm always looking for good computer tools to assist with learning Math with computers. I found this: [1]. Are there any other resources like this to learn fundamentals of Math with Julia? ([Linear] Algebra, Calculus, Geometry, Basic Physics, Discrete Math). 1: https://calculuswithjulia.github.io/ https://calculuswithjulia.github.io/

byt143 8y ago
https://discourse.julialang.org/t/new-linear-algebra-textbook-downloadable-has-julia-companion/18665 https://discourse.julialang.org/t/new-linear-algebra-textboo...
- emmanueloga_ 8y ago
  This course looks fantastic! Thanks for sharing :-)
  - byt143 8y ago
    Sure!
byt143 8y ago
There's also this: https://www.youtube.com/playlist?list=PL7RZyOlq_Xnw3B5per3IUyuE3Uhp4LjNZ https://www.youtube.com/playlist?list=PL7RZyOlq_Xnw3B5per3IU...

guessmyname 8y ago

HackerNews’ traffic broke this website’s database: --- 500 - Internal server error. SQL Exception Error Details File Error Index #: 0 Source: .Net SqlClient Data Provider Class: 17 Number: 1105 Procedure: AddEventLog Message: System.Data.SqlClient.SqlException (0x80131904): Could not allocate space for object 'dbo.EventLog'.'PK_EventLogMaster' in database 'DNN-PROD' because the 'PRIMARY' filegroup is full. Create disk space by deleting unneeded files, dropping objects in the filegroup, adding additional files to the filegroup, or setting autogrowth on for existing files in the filegroup. at System.Data.SqlClient.SqlConnection.OnError(SqlException exception, Boolean breakConnection, Action`1 wrapCloseInAction) at System.Data.SqlClient.SqlInternalConnection.OnError(SqlException exception, Boolean breakConnection, Action`1 wrapCloseInAction) at System.Data.SqlClient.TdsParser.ThrowExceptionAndWarning(TdsParserStateObject stateObj, Boolean callerHasConnectionLock, Boolean asyncClose) at System.Data.SqlClient.TdsParser.TryRun(RunBehavior runBehavior, SqlCommand cmdHandler, SqlDataReader dataStream, BulkCopySimpleResultSet bulkCopyHandler, TdsParserStateObject stateObj, Boolean& dataReady) at System.Data.SqlClient.SqlCommand.FinishExecuteReader(SqlDataReader ds, RunBehavior runBehavior, String resetOptionsString, Boolean isInternal, Boolean forDescribeParameterEncryption, Boolean shouldCacheForAlwaysEncrypted) at System.Data.SqlClient.SqlCommand.RunExecuteReaderTds(CommandBehavior cmdBehavior, RunBehavior runBehavior, Boolean returnStream, Boolean async, Int32 timeout, Task& task, Boolean asyncWrite, Boolean inRetry, SqlDataReader ds, Boolean describeParameterEncryptionRequest) at System.Data.SqlClient.SqlCommand.RunExecuteReader(CommandBehavior cmdBehavior, RunBehavior runBehavior, Boolean returnStream, String method, TaskCompletionSource`1 completion, Int32 timeout, Task& task, Boolean& usedCache, Boolean asyncWrite, Boolean inRetry) at System.Data.SqlClient.SqlCommand.InternalExecuteNonQuery(TaskCompletionSource`1 completion, String methodName, Boolean sendToPipe, Int32 timeout, Boolean& usedCache, Boolean asyncWrite, Boolean inRetry) at System.Data.SqlClient.SqlCommand.ExecuteNonQuery() at PetaPoco.Database.Execute(String sql, Object[] args) at DotNetNuke.Data.PetaPoco.PetaPocoHelper.ExecuteNonQuery(String connectionString, CommandType type, Int32 timeout, String sql, Object[] args) at DotNetNuke.Data.SqlDataProvider.ExecuteNonQuery(String procedureName, Object[] commandParameters) at DotNetNuke.Data.DataProvider.AddLog(String logGUID, String logTypeKey, Int32 logUserID, String logUserName, Int32 logPortalID, String logPortalName, DateTime logCreateDate, String logServerName, String logProperties, Int32 logConfigID) at DotNetNuke.Services.Log.EventLog.DBLoggingProvider.WriteLog(LogQueueItem logQueueItem) ClientConnectionId:84098483-739c-4cd8-bf62-38ff4b256361 Error Number:1105,State:2,Class:17