# Julia with respect to reliability, sustainability, critical application, dynamic/static typing, big data, HPC?

**URL:** <https://discourse.julialang.org/t/julia-with-respect-to-reliability-sustainability-critical-application-dynamic-static-typing-big-data-hpc/23135>\
**Category:** Performance\
**Created:** [April 14, 2019, 11:44am UTC](https://discourse.julialang.org/t/julia-with-respect-to-reliability-sustainability-critical-application-dynamic-static-typing-big-data-hpc/23135 "2019-04-14T11:44:03Z")\
**Posts on this page:** 20\
**Page:** 1

<div class="post-metadata">

**Author:** ![steph\_de\_paris](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/steph_de_paris/32/7780_2.png) [@steph\_de\_paris](https://discourse.julialang.org/u/steph_de_paris)\
**Post date:** [April 14, 2019, 11:44am UTC](https://discourse.julialang.org/t/julia-with-respect-to-reliability-sustainability-critical-application-dynamic-static-typing-big-data-hpc/23135/1 "2019-04-14T11:44:03Z")

</div>

Hello,

I am testing Julia langage for critical applications for which our codes do not have the right to bug. So, together with my practical tests, I would like to find some general informations coming from universities and national labs concerning the powerfull, robustness and durability of Julia langage for HPC and big data analysis.

For example, do you know if one of the teams who applied the Katie Bouman’s algorithm to construct a black hole image used Julia langage (see [Katie Bouman: 5 Fast Facts You Need to Know | Heavy.com](https://heavy.com/news/2019/04/katie-bouman/)) ?

If you know open web adresses with slides and papers about these questions, it would be great !

Thanks all !!!

---

<div class="post-metadata">

**Author:** ![Tamas\_Papp](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/tamas_papp/32/25949_2.png) [@Tamas\_Papp](https://discourse.julialang.org/u/Tamas_Papp)\
**Post date:** [April 14, 2019, 12:08pm UTC](https://discourse.julialang.org/t/julia-with-respect-to-reliability-sustainability-critical-application-dynamic-static-typing-big-data-hpc/23135/2 "2019-04-14T12:08:46Z")

</div>

> [@steph\_de\_paris](#):
>
> our codes do not have the right to bug

You mean you want 100% bug-free code? I am not sure that is practically feasible, regardless of the programming language.

> [@steph\_de\_paris](#):
>
> construct a black hole image used Julia langage

AFAICT the code was written in Python:

> **[GitHub - achael/eht-imaging: Imaging, analysis, and simulation software for...](https://github.com/achael/eht-imaging)**
>
> Imaging, analysis, and simulation software for radio interferometry - GitHub - achael/eht-imaging: Imaging, analysis, and simulation software for radio interferometry

A similar project in Julia would be Celeste:

[![](https://global.discourse-cdn.com/julialang/original/3X/2/0/2053b8046ca6a14c0e8e68db1a8a80471aae8cbf.jpeg "JuliaCon 2017 | Celeste.jl: Petascale Computing in Julia | Prabhat, Regier & Fischer") ](https://www.youtube.com/watch?v=uecdcADM3hY)

---

<div class="post-metadata">

**Author:** ![foobar\_lv2](https://avatars.discourse-cdn.com/v4/letter/f/ee59a6/32.png) [@foobar\_lv2](https://discourse.julialang.org/u/foobar_lv2)\
**Post date:** [April 14, 2019, 3:54pm UTC](https://discourse.julialang.org/t/julia-with-respect-to-reliability-sustainability-critical-application-dynamic-static-typing-big-data-hpc/23135/3 "2019-04-14T15:54:59Z")

</div>

Performance, “no right to bug” and high coding productivity are somewhat in conflict. Julia optimizes for performance and high coding productivity.

For “no right to bug critical applications”, I’d recommend to stay away from julia (“critical application” = crash/bugs kill people). You definitely want a far older (= battle-tested) and simpler compiler / runtime / language, probably want a lot of static analysis and static type-checking and possibly want proof-carrying code / formal verification.

After lurking on the julia bugtracker for some time, I would definitely refuse to bet lives on the julia runtime not crashing due to some missed gc root, subtle subtyping or subtle llvm bug triggered by whatever you are coding. Julia is far too complex, too new and too optimized for performance and programmer convenience for that. That being said, I never worked in high-reliability contexts, so I can’t comment on what tools are used in the industry.

---

<div class="post-metadata">

**Author:** ![chrisvwx](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/chrisvwx/32/45289_2.png) [@chrisvwx](https://discourse.julialang.org/u/chrisvwx)\
**Post date:** [April 14, 2019, 5:26pm UTC](https://discourse.julialang.org/t/julia-with-respect-to-reliability-sustainability-critical-application-dynamic-static-typing-big-data-hpc/23135/4 "2019-04-14T17:26:46Z")

</div>

> For “no right to bug critical applications”, I’d recommend to stay away from julia (“critical application” = crash/bugs kill people). You definitely want a far older…

I believe an early version of Julia is used for an [aircraft avoidance system](https://www.youtube.com/watch?reload=9&v=rj-WhTL_VXE); i.e. the advantages of Julia seemed to overcome concern about language maturity. Edit: More info [here](https://juliacomputing.com/case-studies/lincoln-labs.html).

> … and possibly want proof-carrying code / formal verification.

My understanding is that one could build a formal verification system on top of Julia. The lack of a tool such as [ACL2](https://en.wikipedia.org/wiki/ACL2) for Julia is not a problem with the language itself, rather with the lack of tools built on it.

---

<div class="post-metadata">

**Author:** ![foobar\_lv2](https://avatars.discourse-cdn.com/v4/letter/f/ee59a6/32.png) [@foobar\_lv2](https://discourse.julialang.org/u/foobar_lv2)\
**Post date:** [April 14, 2019, 6:34pm UTC](https://discourse.julialang.org/t/julia-with-respect-to-reliability-sustainability-critical-application-dynamic-static-typing-big-data-hpc/23135/5 "2019-04-14T18:34:47Z")

</div>

Cool project, thanks for the link!

Just noting that afaiu they use julia as a prototyping and pseudo-code specification language, and no critical application (like an actual aircraft) is intended to ever run julia code. Instead Airbus and Boing are supposed to re-implement and verify the (readable and performant to simulate) reference implementation using their favorite high-reliability development process and language that they use for their critical on-board aircraft systems.

This is responsible use, imo awesome, and not a “no bugs allowed critical application”: If the julia runtime crashes under weird circumstances, or you trigger bugs in it, then no actual aircraft falls from the sky; instead some engineer has a bad day bug-hunting during development and testing of the actually deployed critical system.

---

<div class="post-metadata">

**Author:** ![goretkin](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/goretkin/32/167_2.png) [@goretkin](https://discourse.julialang.org/u/goretkin)\
**Post date:** [April 14, 2019, 6:35pm UTC](https://discourse.julialang.org/t/julia-with-respect-to-reliability-sustainability-critical-application-dynamic-static-typing-big-data-hpc/23135/6 "2019-04-14T18:35:38Z")

</div>

I believe the Julia language is used in the specification of TCAS. That doesn’t mean there’s an airworthy TCAS implementation in Julia.

---

<div class="post-metadata">

**Author:** ![chrisvwx](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/chrisvwx/32/45289_2.png) [@chrisvwx](https://discourse.julialang.org/u/chrisvwx)\
**Post date:** [April 14, 2019, 10:04pm UTC](https://discourse.julialang.org/t/julia-with-respect-to-reliability-sustainability-critical-application-dynamic-static-typing-big-data-hpc/23135/7 "2019-04-14T22:04:54Z")

</div>

> [@goretkin](#):
>
> I believe the Julia language is used in the specification of TCAS. That doesn’t mean there’s an airworthy TCAS implementation in Julia.

> [@foobar\_lv2](#):
>
> Just noting that afaiu they use julia as a prototyping and pseudo-code specification language…

Good point, thanks.

Quoting [Robert Moss](https://www.youtube.com/watch?v=19zm1Fn0S9M&t=31m23s) from a talk about the next-gen TCAS: “There is some talk on this. The question is what about having Julia not just be the reference but to fly on the aircraft themselves. It’s not a crazy thought. I think Julia would have to go through a rigorous evaluation process, and there would have to be a stable release. Right now this is not what we’re pushing.  
I’d like to see that of course.”

It would be interesting to hear an update on this. Maybe an invited talk at JuliaCon?

---

<div class="post-metadata">

**Author:** ![Joshua\_Bowles](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/joshua_bowles/32/4515_2.png) [@Joshua\_Bowles](https://discourse.julialang.org/u/Joshua_Bowles)\
**Post date:** [April 15, 2019, 1:02am UTC](https://discourse.julialang.org/t/julia-with-respect-to-reliability-sustainability-critical-application-dynamic-static-typing-big-data-hpc/23135/8 "2019-04-15T01:02:39Z")

</div>

I hear Ada is used, and a buddy of mine who used to work oh fighter jets says he used to use Ada. There is also a subset of Ada called spark used for formal verification. There’s even a fairly active thread in rust discourse about Ada, tldr; Rust is not good enough to replace many of these high reliability environments…

---

<div class="post-metadata">

**Author:** ![Joshua\_Bowles](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/joshua_bowles/32/4515_2.png) [@Joshua\_Bowles](https://discourse.julialang.org/u/Joshua_Bowles)\
**Post date:** [April 15, 2019, 1:49am UTC](https://discourse.julialang.org/t/julia-with-respect-to-reliability-sustainability-critical-application-dynamic-static-typing-big-data-hpc/23135/9 "2019-04-15T01:49:40Z")

</div>

My point, vague as it is… New programming languages (and even many established ones like Ruby, JavaScript, python) are often not appropriate for life and death software. It’s no knock on what Julia offers. Instead, like all things in tech, it’s a balancing act between tradeoffs.  
Also, there’s a difference between life-death side effects bugs and losing lots of money or time due to bugs. I’d say if you literally cannot have bugs you’ll be looking at a very niche set of programming languages and/or a very select group of developers

---

<div class="post-metadata">

**Author:** ![xiaodai](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/xiaodai/32/15937_2.png) [@xiaodai](https://discourse.julialang.org/u/xiaodai)\
**Post date:** [April 15, 2019, 2:12am UTC](https://discourse.julialang.org/t/julia-with-respect-to-reliability-sustainability-critical-application-dynamic-static-typing-big-data-hpc/23135/10 "2019-04-15T02:12:55Z")

</div>

> [@steph\_de\_paris](#):
>
> do you know if one of the teams who applied the Katie Bouman’s algorithm to construct a black hole image used Julia langage (see [https://heavy.com/news/2019/04/katie-bouman/](https://heavy.com/news/2019/04/katie-bouman/)) ?

I read that it uses Python. I wonder how much faster the program will run if it was done in Julia?

---

<div class="post-metadata">

**Author:** ![Tamas\_Papp](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/tamas_papp/32/25949_2.png) [@Tamas\_Papp](https://discourse.julialang.org/u/Tamas_Papp)\
**Post date:** [April 15, 2019, 4:49am UTC](https://discourse.julialang.org/t/julia-with-respect-to-reliability-sustainability-critical-application-dynamic-static-typing-big-data-hpc/23135/11 "2019-04-15T04:49:31Z")

</div>

I agree with your assessment; but I think this discussion is developing from a question that the original poster did not fully understand.

No one wants to have bugs, but actually ensuring that with any reliability is extremely costly. An organization with that goal in mind would not send someone to find out how by asking fairly random and unrelated questions (data analysis in astrophysics is not required to be bug free in the sense of, say, TCAS) following a recent scientific discovery.

---

<div class="post-metadata">

**Author:** ![chakravala](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/chakravala/32/6832_2.png) [@chakravala](https://discourse.julialang.org/u/chakravala)\
**Post date:** [April 15, 2019, 5:05pm UTC](https://discourse.julialang.org/t/julia-with-respect-to-reliability-sustainability-critical-application-dynamic-static-typing-big-data-hpc/23135/12 "2019-04-15T17:05:45Z")

</div>

> [@Joshua\_Bowles](#):
>
> I hear Ada is used, and a buddy of mine who used to work oh fighter jets says he used to use Ada.

Is that what was used for the troublesome and glitchy F-35 jet? Yet a language with formal verification is still not going to fix problems with human error and bureaucrazy in the signal chain.

---

<div class="post-metadata">

**Author:** ![bpr](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/bpr/32/2710_2.png) [@bpr](https://discourse.julialang.org/u/bpr)\
**Post date:** [April 15, 2019, 7:03pm UTC](https://discourse.julialang.org/t/julia-with-respect-to-reliability-sustainability-critical-application-dynamic-static-typing-big-data-hpc/23135/13 "2019-04-15T19:03:56Z")

</div>

[Not that much Ada, mostly C and C++.](https://stackoverflow.com/questions/9827176/what-is-the-predominant-programming-language-used-for-the-f35-lightning-ii-aircr)

---

<div class="post-metadata">

**Author:** ![chakravala](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/chakravala/32/6832_2.png) [@chakravala](https://discourse.julialang.org/u/chakravala)\
**Post date:** [April 15, 2019, 8:49pm UTC](https://discourse.julialang.org/t/julia-with-respect-to-reliability-sustainability-critical-application-dynamic-static-typing-big-data-hpc/23135/14 "2019-04-15T20:49:15Z")

</div>

What is it about ada which makes it particularly useful for this purpose? Can the Julia language inherit those features too in the long run? Another formalistic language I want Julia to learn from is [agda](https://en.wikipedia.org/wiki/Agda_(programming_language)).

> Programming in pure type theory involves a lot of tedious and repetitive proofs, and Agda has no support for tactics. Instead, Agda has support for automation via [reflection](https://en.wikipedia.org/wiki/Reflection_(computer_programming)). The reflection mechanism allows one to quote program fragments into – or unquote them from – the abstract syntax tree. The way reflection is used is similar to the way Template Haskell works.[[8]](https://en.wikipedia.org/wiki/Agda_(programming_language)#cite_note-8)

Reflection is also what Julia metaprogramming is based on, so extend the type system of Julia?

---

<div class="post-metadata">

**Author:** ![longemen3000](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/longemen3000/32/7298_2.png) [@longemen3000](https://discourse.julialang.org/u/longemen3000)\
**Post date:** [April 15, 2019, 9:19pm UTC](https://discourse.julialang.org/t/julia-with-respect-to-reliability-sustainability-critical-application-dynamic-static-typing-big-data-hpc/23135/15 "2019-04-15T21:19:30Z")

</div>

> [@steph\_de\_paris](#):
>
> our codes do not have the right to bug

offtopic, but i love that quote

---

<div class="post-metadata">

**Author:** ![Tamas\_Papp](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/tamas_papp/32/25949_2.png) [@Tamas\_Papp](https://discourse.julialang.org/u/Tamas_Papp)\
**Post date:** [April 16, 2019, 6:11am UTC](https://discourse.julialang.org/t/julia-with-respect-to-reliability-sustainability-critical-application-dynamic-static-typing-big-data-hpc/23135/16 "2019-04-16T06:11:54Z")

</div>

> [@chakravala](#):
>
> What is it about ada which makes it particularly useful for this purpose? Can the Julia language inherit those features too in the long run?

No, and hopefully no one in their right mind is even thinking about this.

Imagine a spectrum where you trade off convenience and flexibility for catching errors at compile time. On this spectrum, Julia and Ada are very far away, and you will find languages like C++, C, and Fortran in between (and of course, more exotic ones too).

Julia was explicitly designed to be dynamic, convenient, and fast, with the compiler there to help you by making your code run fast if you cooperate with it, but rarely _enforcing_ anything at compile time. In fact, apart from trivial syntactic mistakes, the effort of “getting your program to compile” is mostly unknown to Julia users.

---

<div class="post-metadata">

**Author:** ![chakravala](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/chakravala/32/6832_2.png) [@chakravala](https://discourse.julialang.org/u/chakravala)\
**Post date:** [April 16, 2019, 8:20am UTC](https://discourse.julialang.org/t/julia-with-respect-to-reliability-sustainability-critical-application-dynamic-static-typing-big-data-hpc/23135/17 "2019-04-16T08:20:49Z")

</div>

> [@Tamas\_Papp](#):
>
> Imagine a spectrum where you trade off convenience and flexibility for catching errors at compile time.

Who said anything about making a trade-off? I wasn’t proposing to take anything away.

Also, I was talking about “agda” with an extra `g`, which is not the same as ada. It uses proof by reflection, which Julia might be able to do if it had some extra inductive type features.

The new features don’t have to exactly resemble a previous language, just learn from it.

Are [inductive types](https://en.m.wikipedia.org/wiki/Inductive_type) threatening to other aspects of the Julia language that would cause trade-off?

---

<div class="post-metadata">

**Author:** ![Tamas\_Papp](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/tamas_papp/32/25949_2.png) [@Tamas\_Papp](https://discourse.julialang.org/u/Tamas_Papp)\
**Post date:** [April 16, 2019, 8:33am UTC](https://discourse.julialang.org/t/julia-with-respect-to-reliability-sustainability-critical-application-dynamic-static-typing-big-data-hpc/23135/18 "2019-04-16T08:33:39Z")

</div>

> [@chakravala](#):
>
> I was talking about “agda” with an extra `g`

Not in the part I quoted.

> [@chakravala](#):
>
> Are [inductive types](https://en.m.wikipedia.org/wiki/Inductive_type) threatening to other aspects of the Julia language that would cause trade-off?

Hard to say without a concrete proposal. But it is also unclear what their benefit would be.

My understanding is that in Julia, types are mostly used for dispatch, and by the compiler, but not for enforcing anything. In fact, Julia relishes the fact that [not all expressions have a type at “compile time”](https://stackoverflow.com/a/28096079).

---

<div class="post-metadata">

**Author:** ![chakravala](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/chakravala/32/6832_2.png) [@chakravala](https://discourse.julialang.org/u/chakravala)\
**Post date:** [April 16, 2019, 8:38am UTC](https://discourse.julialang.org/t/julia-with-respect-to-reliability-sustainability-critical-application-dynamic-static-typing-big-data-hpc/23135/19 "2019-04-16T08:38:54Z")

</div>

> [@Tamas\_Papp](#):
>
> My understanding is that in Julia, types are mostly used for dispatch, and by the compiler, but not for enforcing anything.

A new keyword like `inductive type` could be used to generalize Julia from only type dispatch to make julia able of more general proofs.

---

<div class="post-metadata">

**Author:** ![bpr](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/bpr/32/2710_2.png) [@bpr](https://discourse.julialang.org/u/bpr)\
**Post date:** [April 16, 2019, 1:31pm UTC](https://discourse.julialang.org/t/julia-with-respect-to-reliability-sustainability-critical-application-dynamic-static-typing-big-data-hpc/23135/20 "2019-04-16T13:31:54Z")

</div>

> [@chakravala](#):
>
> What is it about ada which makes it particularly useful for this purpose? Can the Julia language inherit those features too in the long run? Another formalistic language I want Julia to learn from is [agda](https://en.wikipedia.org/wiki/Agda_(programming_language)).

IMO, a number of things, among them that Ada has been used in this domain for a while, and now has [SPARK](https://en.wikipedia.org/wiki/SPARK_(programming_language)).

I don’t think Julia is well suited for this domain, nor do I think it would be worth the effort to try to make it so. Julia already has a nice focus, scientific computing, and fairly broad scope outside of that focus. If the developers were looking for more challenges, then embedded systems would be my suggestion, since one would like to deploy trained machine learning models there and I suspect (but have not done the experiment) that Julia is currently not suited for tiny embedded systems. Of course, I’d love to be wrong about that.

[Next page](https://discourse.julialang.org/t/julia-with-respect-to-reliability-sustainability-critical-application-dynamic-static-typing-big-data-hpc/23135.md?page=2)