# What Python Creator Guido van Rossum Thinks of Rust, Go, Julia, and TypeScript

**URL:** <https://discourse.julialang.org/t/what-python-creator-guido-van-rossum-thinks-of-rust-go-julia-and-typescript/61689>\
**Category:** Offtopic\
**Created:** [May 23, 2021, 6:02pm UTC](https://discourse.julialang.org/t/what-python-creator-guido-van-rossum-thinks-of-rust-go-julia-and-typescript/61689 "2021-05-23T18:02:44Z")\
**Posts on this page:** 20\
**Page:** 4

<div class="post-metadata">

**Author:** ![jzr](https://avatars.discourse-cdn.com/v4/letter/j/eb9ed0/32.png) [@jzr](https://discourse.julialang.org/u/jzr)\
**Post date:** [May 24, 2021, 9:44pm UTC](https://discourse.julialang.org/t/what-python-creator-guido-van-rossum-thinks-of-rust-go-julia-and-typescript/61689/61 "2021-05-24T21:44:56Z")

</div>

> [@oheil](#):
>
> at the end, it’s all about taste and what people like more

Sounds good to me 🙂

---

<div class="post-metadata">

**Author:** ![jzr](https://avatars.discourse-cdn.com/v4/letter/j/eb9ed0/32.png) [@jzr](https://discourse.julialang.org/u/jzr)\
**Post date:** [May 24, 2021, 9:48pm UTC](https://discourse.julialang.org/t/what-python-creator-guido-van-rossum-thinks-of-rust-go-julia-and-typescript/61689/62 "2021-05-24T21:48:03Z")

</div>

> [@Oscar\_Smith](#):
>
> The 2 language problem is the ability to write fast high level code. Specifically, a common workflow is to write a prototype in a high level language like python or matlab, and then translate it into C++ or Fortran when you actually run it so it will be fast enough. The promise with Julia is that you can write code as quickly and easily as a high level language, but optimize it to perform as well as the low level language without completely rewriting everything.

Yeah that’s consistent with what I thought. Thanks.

---

<div class="post-metadata">

**Author:** ![EvoArt](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/evoart/32/25357_2.png) [@EvoArt](https://discourse.julialang.org/u/EvoArt)\
**Post date:** [May 24, 2021, 11:18pm UTC](https://discourse.julialang.org/t/what-python-creator-guido-van-rossum-thinks-of-rust-go-julia-and-typescript/61689/63 "2021-05-24T23:18:07Z")

</div>

> [@oheil](#):
>
> So people would like to have great startup times but slow motion code after a rocket like start up?

Yes! Most of my colleagues just use R to fit GLMs to smallish data sets. You wouldn’t notice whether the code is running fast or slow. But you would notice a long start up time, or time to first plot.

In fact I used R today, for consistency with earlier parts of a project. And it felt really quick.

---

<div class="post-metadata">

**Author:** ![jzr](https://avatars.discourse-cdn.com/v4/letter/j/eb9ed0/32.png) [@jzr](https://discourse.julialang.org/u/jzr)\
**Post date:** [May 24, 2021, 11:24pm UTC](https://discourse.julialang.org/t/what-python-creator-guido-van-rossum-thinks-of-rust-go-julia-and-typescript/61689/64 "2021-05-24T23:24:58Z")

</div>

Another example would be a frequently-run command-line tool like git (in C) or mercurial (in Python).

---

<div class="post-metadata">

**Author:** ![Ronis\_BR](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/ronis_br/32/50999_2.png) [@Ronis\_BR](https://discourse.julialang.org/u/Ronis_BR)\
**Post date:** [May 24, 2021, 11:29pm UTC](https://discourse.julialang.org/t/what-python-creator-guido-van-rossum-thinks-of-rust-go-julia-and-typescript/61689/65 "2021-05-24T23:29:54Z")

</div>

Well… niche or not, Julia is just solving all my problems 🙂 It is, at least, as niche as MATLAB with a big plus in performance.

DifferentialEquations.jl is the best ODE solver available for control systems high-fidelity simulation. Period. I tested a lot, I tried a lot, and it is just better 🙂 The AOCS simulator of Amazonia 1 is written entirely in Julia using DifferentialEquations.jl and the accuracy we obtained is just fantastic.

Julia is being used as a computational core for a mission operational concept simulator. Using this, we can have infinite capability to customize the simulated mission (the configuration files are .jl). Hence, we can use the same code to check the simulation on the fly, and also to perform multi-objective optimization.

I also use Julia as a scripting language, to fetch the satellite telemetry, process, and analyze it.

Conclusion: to do all those things together, I would probably need C/C++, Python, and possibly Bash, or C/C++ and MATLAB plus some extension.

I know that Julia was supposed to solve the two-language problem, and not to be one language to rule them all. However, the “niche” he is referring seems to be the entire numerical computing community! In this case, the only thing the separate Julia from Python is time. In 8 years, we have this amazing community, with these awesome packages. What would we have 20 years from now?

---

<div class="post-metadata">

**Author:** ![ToucheSir](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/touchesir/32/14411_2.png) [@ToucheSir](https://discourse.julialang.org/u/ToucheSir)\
**Post date:** [May 25, 2021, 12:29am UTC](https://discourse.julialang.org/t/what-python-creator-guido-van-rossum-thinks-of-rust-go-julia-and-typescript/61689/66 "2021-05-25T00:29:04Z")

</div>

Not to detract from your point, but there have [been](https://discourse.julialang.org/t/help-with-binary-trees-benchmark-games-example/37307) [a](https://discourse.julialang.org/t/lhe-biofast-benchmark-fastq-parsing-julia-nim-crystal-python/39747) [few](https://discourse.julialang.org/t/slow-gzip-streaming-in-julia-but-not-in-python/56346) [threads](https://discourse.julialang.org/t/bad-performance-of-eachline-on-stdin/55701) on not-so-competitive IO and string processing performance. From what I can tell, there aren’t any inherent trade-offs at play like you’d have with the compiler/GC and TTFP, just more development time/resources required.

---

<div class="post-metadata">

**Author:** ![jzr](https://avatars.discourse-cdn.com/v4/letter/j/eb9ed0/32.png) [@jzr](https://discourse.julialang.org/u/jzr)\
**Post date:** [May 25, 2021, 12:32am UTC](https://discourse.julialang.org/t/what-python-creator-guido-van-rossum-thinks-of-rust-go-julia-and-typescript/61689/67 "2021-05-25T00:32:15Z")

</div>

@oheil said they wanted to stop participating in this back-and-forth, I hope we can honor that.

---

<div class="post-metadata">

**Author:** ![Gnimuc](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/gnimuc/32/2194_2.png) [@Gnimuc](https://discourse.julialang.org/u/Gnimuc)\
**Post date:** [May 25, 2021, 5:04am UTC](https://discourse.julialang.org/t/what-python-creator-guido-van-rossum-thinks-of-rust-go-julia-and-typescript/61689/68 "2021-05-25T05:04:38Z")

</div>

> [@anon56330260](#):
>
> I do the claim because I have observed many quite negative responses in Chinese Julia community and on Zhihu

I guess you can observe a lot quite negative responses for **any topics** on that site. :troll:

---

<div class="post-metadata">

**Author:** ![DNF](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/dnf/32/10191_2.png) [@DNF](https://discourse.julialang.org/u/DNF)\
**Post date:** [May 25, 2021, 5:06am UTC](https://discourse.julialang.org/t/what-python-creator-guido-van-rossum-thinks-of-rust-go-julia-and-typescript/61689/69 "2021-05-25T05:06:35Z")

</div>

> [@jzr](#):
>
> @oheil said they wanted to stop participating in this back-and-forth, I hope we can honor that.

I fairness, one cannot both make a last point, _and_ declare the discussion over. One has to allow others to respond to that last point.

---

<div class="post-metadata">

**Author:** ![lungben](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/lungben/32/12314_2.png) [@lungben](https://discourse.julialang.org/u/lungben)\
**Post date:** [May 25, 2021, 7:14am UTC](https://discourse.julialang.org/t/what-python-creator-guido-van-rossum-thinks-of-rust-go-julia-and-typescript/61689/70 "2021-05-25T07:14:36Z")

</div>

These 2 statements look for me to be written by persons without deeper Julia knowledge because they cover mostly feelings / first impressions rather than concrete, valid points.

Every programming language has to make trade-offs which makes it better / worse suited for specific tasks.  
In Julia, the main tradeoffs are imho just-ahead-of-time compiler and dynamic typing. On one hand, they enable the great flexibility, composibility and performance of the language.  
On the other hand, they have some drawbacks compared to static compilers on one side and interpreted languages on the other:

1. time to first plot (although I think that many people are overstating the importance of this point)
2. it is difficult to compile to small portable libraries because the Julia runtime has to be included to deal with unexpected types
3. type errors are runtime errors, not (mostly) compile-time errors like in statically typed languages

Some points just need more time / resources:

- documentation / examples / online QAs
- performance improvements of specific components (like IO, string operations)
- most important: people who know Julia, both programmers and decision makes in management, so that choosing Julia for a task it is well suited is natural, not an uphill battle.

Julia is my favorite language and I think that these points will be mostly mitigated in the (not so far) future.

---

<div class="post-metadata">

**Author:** ![oheil](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/oheil/32/220745_2.png) [@oheil](https://discourse.julialang.org/u/oheil)\
**Post date:** [May 25, 2021, 7:44am UTC](https://discourse.julialang.org/t/what-python-creator-guido-van-rossum-thinks-of-rust-go-julia-and-typescript/61689/71 "2021-05-25T07:44:25Z")

</div>

> [@DNF](#):
>
> I fairness, one cannot both make a last point, _and_ declare the discussion over. One has to allow others to respond to that last point.

Of course, I am only talking about me to stop my part in this discussion!

---

<div class="post-metadata">

**Author:** ![StatisticalMouse](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/statisticalmouse/32/43370_2.png) [@StatisticalMouse](https://discourse.julialang.org/u/StatisticalMouse)\
**Post date:** [May 25, 2021, 8:23am UTC](https://discourse.julialang.org/t/what-python-creator-guido-van-rossum-thinks-of-rust-go-julia-and-typescript/61689/72 "2021-05-25T08:23:35Z")

</div>

> [@lungben](#):
>
> Julia is my favorite language and I think that these points will be mostly mitigated in the (not so far) future.

Juila is also my favorite language!

If I had a magic wand, it would enable static compilation of Juila to WASM.

( 🤣 )

---

<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:** [May 25, 2021, 8:47am UTC](https://discourse.julialang.org/t/what-python-creator-guido-van-rossum-thinks-of-rust-go-julia-and-typescript/61689/73 "2021-05-25T08:47:43Z")

</div>

> [@jzr](#):
>
> It offers some kinds of productivity (fill in your favorite example) but not others (eg automatic refactoring).

Automatic refactoring is usually a glorified text replacement engine with templates. The Julian solution to that problem is writing clean and small interfaces, at zero or near-zero cost.

This makes the boilerplate-management infrastructure that C++/Java programmers are used to unnecessary in Julia. Good riddance.

---

<div class="post-metadata">

**Author:** ![jonathanBieler](https://avatars.discourse-cdn.com/v4/letter/j/82dd89/32.png) [@jonathanBieler](https://discourse.julialang.org/u/jonathanBieler)\
**Post date:** [May 25, 2021, 11:37am UTC](https://discourse.julialang.org/t/what-python-creator-guido-van-rossum-thinks-of-rust-go-julia-and-typescript/61689/74 "2021-05-25T11:37:35Z")

</div>

An extract method functionality is very useful for Julia (speaking from experience), you can write and test your code in global space and then turn in into a function with a shortcut. It actually promotes writing more small functions since it’s easier to turn any block of code into a function, and it’s also less error prone (it’s easy to miss a variable and leave it as an unintended global).

---

<div class="post-metadata">

**Author:** ![StefanKarpinski](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/stefankarpinski/32/24_2.png) [@StefanKarpinski](https://discourse.julialang.org/u/StefanKarpinski)\
**Post date:** [May 25, 2021, 1:41pm UTC](https://discourse.julialang.org/t/what-python-creator-guido-van-rossum-thinks-of-rust-go-julia-and-typescript/61689/75 "2021-05-25T13:41:27Z")

</div>

![Julia_is_a_general_purpose_language](https://global.discourse-cdn.com/julialang/original/3X/d/7/d786bcff59838f3569b0cb544bf98684922cb791.jpeg)

---

<div class="post-metadata">

**Author:** ![paulmelis](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/paulmelis/32/35063_2.png) [@paulmelis](https://discourse.julialang.org/u/paulmelis)\
**Post date:** [May 25, 2021, 2:22pm UTC](https://discourse.julialang.org/t/what-python-creator-guido-van-rossum-thinks-of-rust-go-julia-and-typescript/61689/76 "2021-05-25T14:22:54Z")

</div>

![batman](https://global.discourse-cdn.com/julialang/original/3X/7/8/78199d67b7507048af794414929f2f0a65cf3000.png)

PS I like 0-based indexing more, but since we’re doing memes… 😉

---

<div class="post-metadata">

**Author:** ![lmiq](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/lmiq/32/18314_2.png) [@lmiq](https://discourse.julialang.org/u/lmiq)\
**Post date:** [May 25, 2021, 2:41pm UTC](https://discourse.julialang.org/t/what-python-creator-guido-van-rossum-thinks-of-rust-go-julia-and-typescript/61689/77 "2021-05-25T14:41:28Z")

</div>

Perhaps more representative then:

| 

 ![image](https://global.discourse-cdn.com/julialang/original/3X/2/6/26dcb00db60b98485b4a0399f34cad2da88b5f02.jpeg)

 | | | 

 ![image](https://global.discourse-cdn.com/julialang/original/3X/f/f/ff3677baa0de1ced1449e0fc6c122390355493be.jpeg)

 | |

(except that Python pretty much has world domination already 🙂 )

---

<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:** [May 25, 2021, 2:53pm UTC](https://discourse.julialang.org/t/what-python-creator-guido-van-rossum-thinks-of-rust-go-julia-and-typescript/61689/78 "2021-05-25T14:53:33Z")

</div>

> [@jonathanBieler](#):
>
> extract method functionality is very useful for Julia

Isn’t that just adding a `function(...)` and an `end` though?

I guess one could call that refactoring, but then at that point I will insist on tidying up my desk being refactoring.

---

<div class="post-metadata">

**Author:** ![StatisticalMouse](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/statisticalmouse/32/43370_2.png) [@StatisticalMouse](https://discourse.julialang.org/u/StatisticalMouse)\
**Post date:** [May 25, 2021, 3:19pm UTC](https://discourse.julialang.org/t/what-python-creator-guido-van-rossum-thinks-of-rust-go-julia-and-typescript/61689/79 "2021-05-25T15:19:20Z")

</div>

Maybe. It’s supposed to be a compilation delay. I was also contemplating some google-translate mistranslation instead, but I couldn’t think of a suitable one.  
It’s not perfect.

The third question for the Python et. al. could be “WHAT DO WE HAVE?”, and the answer “C++ AND FORTRAN”.

---

<div class="post-metadata">

**Author:** ![jonathanBieler](https://avatars.discourse-cdn.com/v4/letter/j/82dd89/32.png) [@jonathanBieler](https://discourse.julialang.org/u/jonathanBieler)\
**Post date:** [May 25, 2021, 3:51pm UTC](https://discourse.julialang.org/t/what-python-creator-guido-van-rossum-thinks-of-rust-go-julia-and-typescript/61689/80 "2021-05-25T15:51:31Z")

</div>

The interesting part is figuring out which variables needs to be in “…”. Try to list of the variables that needs to be in there in that piece of code and see how long it takes you. The computer can probably do it faster and more reliably.

```julia
    using Gadfly
    mu = K1
    const alpha = 1
    const beta = (alpha+1)*mu
    for i=1:10
        x = rand(100, f(K2)) 
    end
    plot(x = K3, y = pdf(InverseGamma(K4,beta),K5), Geom.line)
    ind, K7 = K6.asd
    x = [K8[K7] for i=1:K6]

```

[Previous page](https://discourse.julialang.org/t/what-python-creator-guido-van-rossum-thinks-of-rust-go-julia-and-typescript/61689.md?page=3)

[Next page](https://discourse.julialang.org/t/what-python-creator-guido-van-rossum-thinks-of-rust-go-julia-and-typescript/61689.md?page=5)