4 ms·

> out of the hands of the programmer see, and that's where these languages become really clunky for HPC purposes. A compiler/runtime with HPC support (and I th

> out of the hands of the programmer see, and that's where these languages become really clunky for HPC purposes. A compiler/runtime with HPC support (and I think also systems programming) should provide (a) performant defaults with safety as a second (but still high) priority and (b) the ability for programmers to go and set things a certain way when it is clear to them how things should be implemented on the machine. Otherwise, in large applications, there's just too many moving parts that the compiler (optimization) can mess up. As long as we have no AGI baked into compilers it's an illusion to think that compilers will do the job of HPC engineers, so if you take away these tools we just have to look elsewhere.

pjmlp 8y ago
Have you looked at Chapel?
- m_mueller 8y ago
  Not yet, thanks. How does it compare to Julia?
  - pjmlp 8y ago
    Different goals. Chapel is a strongly typed language designed from the ground up to replace C++ and Fortran for HPC programming in cluster environments, while removing the typical unsafe features from C and C++. Initially designed by Cray, Intel has also given an helping hand. My experience is only from language geek point of view, reading the papers. Chapel Implementers and Users Workshop 2018 papers https://chapel-lang.org/CHIUW2018.html https://chapel-lang.org/CHIUW2018.html
    - m_mueller 8y ago
      > strongly typed language designed from the ground up to replace C++ and Fortran for HPC programming ... sounds like Julia to me ... > ... in cluster environments this is where it may be differentiating itself, AFAIK Julia has not been very focused on clustering from start, but I'm assuming it's now getting better.
      - pjmlp 8y ago
        Hasn't Julia focus been MATLAB folks mostly? In any case, the more the merrier. :)
        m_mueller 8y ago
        I think the idea is for it to be both machine friendly and MATLAB/python users friendly, by bringing the best of Fortran into the modern world and with a good type system. The types are very machine oriented but with nice abstractions to easily allow polymorphism.
        ChrisRackauckas 8y ago
        A pure Julia program got >1 petaflop on Cori, so it's quite in the HPC realm. https://juliacomputing.com/case-studies/celeste.html https://juliacomputing.com/case-studies/celeste.html
      - deleted 8y ago
        [deleted]
      - ChrisRackauckas 8y ago
        Julia works great on clusters, I use it all the time. It's learning a lot from Chapel too. Chapel has an amazing parallelism model, and a lot of Julia's parallelism is learning from it, including the near future hierarchical task-based multithreading. Julia was designed for interactive usage that can generate fast code, while Chapel was designed for the more traditional HPC usage. With more and more people using interactive languages on the HPC to avoid the translation step of the two-language problem though, Julia seems to be eating into the domain where more hardcore people used to write C++ and Fortran with MPI (I was one of those for a bit!). But while "no need to rewrite code, just take your interactive script and throw it on the cluster" is right for some, other applications will want a statically compiled language with a strong parallelism model which is Chapel. The issue I see with Chapel though is that HPC is such a small community compared to larger scientific computing, and Julia has such a good design that it is very easy to improve (using Julia code!) with a large developer group (currently 736 contributors, that is quite a bit more than CPython has ever had and Julia is a lot younger), Julia is a lot more nimble. So when Chapel gets a good idea, sure enough there's an MIT programming languages or HPC fellow who proposes it in Julia, and so you get stuff like https://github.com/JuliaLang/julia/pull/22631 https://github.com/JuliaLang/julia/pull/22631 soon after. That doesn't mean Chapel is bad, but Julia already has the largest contributor base of any of the open source scientific computing languages still being developed, and that manpower is definitely useful for keeping up with the current research trends (working on Julia is a good way to get a math/CS PhD at MIT :) )

pjmlp 8y ago

Have you looked at Chapel?

m_mueller 8y ago
Not yet, thanks. How does it compare to Julia?
- pjmlp 8y ago
  Different goals. Chapel is a strongly typed language designed from the ground up to replace C++ and Fortran for HPC programming in cluster environments, while removing the typical unsafe features from C and C++. Initially designed by Cray, Intel has also given an helping hand. My experience is only from language geek point of view, reading the papers. Chapel Implementers and Users Workshop 2018 papers https://chapel-lang.org/CHIUW2018.html https://chapel-lang.org/CHIUW2018.html
  - m_mueller 8y ago
    > strongly typed language designed from the ground up to replace C++ and Fortran for HPC programming ... sounds like Julia to me ... > ... in cluster environments this is where it may be differentiating itself, AFAIK Julia has not been very focused on clustering from start, but I'm assuming it's now getting better.
    - pjmlp 8y ago
      Hasn't Julia focus been MATLAB folks mostly? In any case, the more the merrier. :)
      - m_mueller 8y ago
        I think the idea is for it to be both machine friendly and MATLAB/python users friendly, by bringing the best of Fortran into the modern world and with a good type system. The types are very machine oriented but with nice abstractions to easily allow polymorphism.
      - ChrisRackauckas 8y ago
        A pure Julia program got >1 petaflop on Cori, so it's quite in the HPC realm. https://juliacomputing.com/case-studies/celeste.html https://juliacomputing.com/case-studies/celeste.html
    - deleted 8y ago
      [deleted]
    - ChrisRackauckas 8y ago
      Julia works great on clusters, I use it all the time. It's learning a lot from Chapel too. Chapel has an amazing parallelism model, and a lot of Julia's parallelism is learning from it, including the near future hierarchical task-based multithreading. Julia was designed for interactive usage that can generate fast code, while Chapel was designed for the more traditional HPC usage. With more and more people using interactive languages on the HPC to avoid the translation step of the two-language problem though, Julia seems to be eating into the domain where more hardcore people used to write C++ and Fortran with MPI (I was one of those for a bit!). But while "no need to rewrite code, just take your interactive script and throw it on the cluster" is right for some, other applications will want a statically compiled language with a strong parallelism model which is Chapel. The issue I see with Chapel though is that HPC is such a small community compared to larger scientific computing, and Julia has such a good design that it is very easy to improve (using Julia code!) with a large developer group (currently 736 contributors, that is quite a bit more than CPython has ever had and Julia is a lot younger), Julia is a lot more nimble. So when Chapel gets a good idea, sure enough there's an MIT programming languages or HPC fellow who proposes it in Julia, and so you get stuff like https://github.com/JuliaLang/julia/pull/22631 https://github.com/JuliaLang/julia/pull/22631 soon after. That doesn't mean Chapel is bad, but Julia already has the largest contributor base of any of the open source scientific computing languages still being developed, and that manpower is definitely useful for keeping up with the current research trends (working on Julia is a good way to get a math/CS PhD at MIT :) )